Build to codegen

Signed-off-by: Jun Ying Tan <9677893+tjying95@users.noreply.github.com>
ni · Feb 28, 2025 · 2cc75d3 · 2cc75d3
1 parent 40e798b
commit 2cc75d3
Show file tree

Hide file tree

Showing 10 changed files with 175 additions and 0 deletions.
diff --git a/generated/nidaqmx/nidaqmx.proto b/generated/nidaqmx/nidaqmx.proto
@@ -310,6 +310,7 @@ service NiDAQmx {
   rpc BeginReadDigitalU32(BeginReadDigitalU32Request) returns (BeginReadDigitalU32Response);
   rpc ReadDigitalU8(ReadDigitalU8Request) returns (ReadDigitalU8Response);
   rpc BeginReadDigitalU8(BeginReadDigitalU8Request) returns (BeginReadDigitalU8Response);
+  rpc ReadIDPinMemory(ReadIDPinMemoryRequest) returns (ReadIDPinMemoryResponse);
   rpc ReadPowerBinaryI16(ReadPowerBinaryI16Request) returns (ReadPowerBinaryI16Response);
   rpc BeginReadPowerBinaryI16(BeginReadPowerBinaryI16Request) returns (BeginReadPowerBinaryI16Response);
   rpc ReadPowerF64(ReadPowerF64Request) returns (ReadPowerF64Response);
@@ -459,6 +460,7 @@ service NiDAQmx {
   rpc BeginWriteDigitalU32(BeginWriteDigitalU32Request) returns (BeginWriteDigitalU32Response);
   rpc WriteDigitalU8(WriteDigitalU8Request) returns (WriteDigitalU8Response);
   rpc BeginWriteDigitalU8(BeginWriteDigitalU8Request) returns (BeginWriteDigitalU8Response);
+  rpc WriteIDPinMemory(WriteIDPinMemoryRequest) returns (WriteIDPinMemoryResponse);
   rpc WriteRaw(WriteRawRequest) returns (WriteRawResponse);
   rpc BeginWriteRaw(BeginWriteRawRequest) returns (BeginWriteRawResponse);
   rpc WriteToTEDSFromArray(WriteToTEDSFromArrayRequest) returns (WriteToTEDSFromArrayResponse);
@@ -1708,6 +1710,8 @@ enum DeviceStringAttribute {
   DEVICE_ATTRIBUTE_COMPACT_RIO_CHASSIS_DEV_NAME = 12641;
   DEVICE_ATTRIBUTE_FIELD_DAQ_DEV_NAME = 12657;
   DEVICE_ATTRIBUTE_FIELD_DAQ_BANK_DEV_NAMES = 12664;
+  DEVICE_ATTRIBUTE_ID_PIN_PIN_NAMES = 12785;
+  DEVICE_ATTRIBUTE_ID_PIN_MEM_SERIAL_NUMS = 12788;
 }
 
 enum DeviceUInt32Attribute {
@@ -1816,6 +1820,8 @@ enum DeviceUInt32ArrayAttribute {
   DEVICE_UINT32_ARRAY_ATTRIBUTE_UNSPECIFIED = 0;
   DEVICE_ATTRIBUTE_ACCESSORY_PRODUCT_NUMS = 12142;
   DEVICE_ATTRIBUTE_ACCESSORY_SERIAL_NUMS = 12143;
+  DEVICE_ATTRIBUTE_ID_PIN_MEM_FAMILY_CODES = 12787;
+  DEVICE_ATTRIBUTE_ID_PIN_MEM_SIZES = 12789;
 }
 
 enum DeviceInt32ArrayAttribute {
@@ -1831,6 +1837,7 @@ enum DeviceInt32ArrayAttribute {
   DEVICE_ATTRIBUTE_NAV_SUPPORTED_MEAS_TYPES = 12323;
   DEVICE_ATTRIBUTE_NAV_TRIG_USAGE = 12324;
   DEVICE_ATTRIBUTE_AI_DIG_FLTR_TYPES = 12551;
+  DEVICE_ATTRIBUTE_ID_PIN_PIN_STATUSES = 12786;
 }
 
 enum ExportSignalDoubleAttribute {
@@ -3592,6 +3599,7 @@ enum ChannelInt32AttributeValues {
   CHANNEL_INT32_AI_MEASUREMENT_TYPE_TEDS_SENSOR = 12531;
   CHANNEL_INT32_AI_MEASUREMENT_TYPE_CHARGE = 16105;
   CHANNEL_INT32_AI_MEASUREMENT_TYPE_POWER = 16201;
+  CHANNEL_INT32_AI_MEASUREMENT_TYPE_CALCULATED_POWER = 16204;
   CHANNEL_INT32_AO_IDLE_OUTPUT_BEHAVIOR_ZERO_VOLTS = 12526;
   CHANNEL_INT32_AO_IDLE_OUTPUT_BEHAVIOR_HIGH_IMPEDANCE = 12527;
   CHANNEL_INT32_AO_IDLE_OUTPUT_BEHAVIOR_MAINTAIN_EXISTING_VALUE = 12528;
@@ -3966,6 +3974,7 @@ enum DeviceInt32AttributeValues {
   DEVICE_INT32_AI_MEASUREMENT_TYPE_TEDS_SENSOR = 12531;
   DEVICE_INT32_AI_MEASUREMENT_TYPE_CHARGE = 16105;
   DEVICE_INT32_AI_MEASUREMENT_TYPE_POWER = 16201;
+  DEVICE_INT32_AI_MEASUREMENT_TYPE_CALCULATED_POWER = 16204;
   DEVICE_INT32_AO_OUTPUT_CHANNEL_TYPE_VOLTAGE = 10322;
   DEVICE_INT32_AO_OUTPUT_CHANNEL_TYPE_CURRENT = 10134;
   DEVICE_INT32_AO_OUTPUT_CHANNEL_TYPE_FUNC_GEN = 14750;
@@ -4020,6 +4029,8 @@ enum DeviceInt32AttributeValues {
   DEVICE_INT32_FILTER_TYPE2_BANDPASS = 16073;
   DEVICE_INT32_FILTER_TYPE2_NOTCH = 16074;
   DEVICE_INT32_FILTER_TYPE2_CUSTOM = 10137;
+  DEVICE_INT32_ID_PIN_STATUS_MEMORY_NOT_PRESENT = 16205;
+  DEVICE_INT32_ID_PIN_STATUS_MEMORY_PRESENT = 16206;
   DEVICE_INT32_NAV_MEASUREMENT_TYPE_ALTITUDE = 15997;
   DEVICE_INT32_NAV_MEASUREMENT_TYPE_LONGITUDE = 15998;
   DEVICE_INT32_NAV_MEASUREMENT_TYPE_LATITUDE = 15999;
@@ -4127,6 +4138,7 @@ enum PhysicalChannelInt32AttributeValues {
   PHYSICALCHANNEL_INT32_AI_MEASUREMENT_TYPE_TEDS_SENSOR = 12531;
   PHYSICALCHANNEL_INT32_AI_MEASUREMENT_TYPE_CHARGE = 16105;
   PHYSICALCHANNEL_INT32_AI_MEASUREMENT_TYPE_POWER = 16201;
+  PHYSICALCHANNEL_INT32_AI_MEASUREMENT_TYPE_CALCULATED_POWER = 16204;
   PHYSICALCHANNEL_INT32_AO_OUTPUT_CHANNEL_TYPE_VOLTAGE = 10322;
   PHYSICALCHANNEL_INT32_AO_OUTPUT_CHANNEL_TYPE_CURRENT = 10134;
   PHYSICALCHANNEL_INT32_AO_OUTPUT_CHANNEL_TYPE_FUNC_GEN = 14750;
@@ -9269,6 +9281,19 @@ message MonikerReadDigitalU8Response {
   int32 samps_per_chan_read = 3;
 }
 
+message ReadIDPinMemoryRequest {
+  string device_name = 1;
+  string id_pin_name = 2;
+  uint32 array_size = 3;
+}
+
+message ReadIDPinMemoryResponse {
+  int32 status = 1;
+  bytes data = 2;
+  uint32 data_length_read = 3;
+  uint32 format_code = 4;
+}
+
 message ReadPowerBinaryI16Request {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;
@@ -11415,6 +11440,17 @@ message MonikerWriteDigitalU8Response {
   int32 samps_per_chan_written = 2;
 }
 
+message WriteIDPinMemoryRequest {
+  string device_name = 1;
+  string id_pin_name = 2;
+  bytes data = 3;
+  uint32 format_code = 4;
+}
+
+message WriteIDPinMemoryResponse {
+  int32 status = 1;
+}
+
 message WriteRawRequest {
   nidevice_grpc.Session task = 1;
   int32 num_samps = 2;

diff --git a/generated/nidaqmx/nidaqmx_client.cpp b/generated/nidaqmx/nidaqmx_client.cpp
@@ -8580,6 +8580,25 @@ begin_read_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, c
   return response;
 }
 
+ReadIDPinMemoryResponse
+read_id_pin_memory(const StubPtr& stub, const std::string& device_name, const std::string& id_pin_name, const pb::uint32& array_size)
+{
+  ::grpc::ClientContext context;
+
+  auto request = ReadIDPinMemoryRequest{};
+  request.set_device_name(device_name);
+  request.set_id_pin_name(id_pin_name);
+  request.set_array_size(array_size);
+
+  auto response = ReadIDPinMemoryResponse{};
+
+  raise_if_error(
+      stub->ReadIDPinMemory(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadPowerBinaryI16Response
 read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps)
 {
@@ -12282,6 +12301,26 @@ begin_write_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task,
   return response;
 }
 
+WriteIDPinMemoryResponse
+write_id_pin_memory(const StubPtr& stub, const std::string& device_name, const std::string& id_pin_name, const std::string& data, const pb::uint32& format_code)
+{
+  ::grpc::ClientContext context;
+
+  auto request = WriteIDPinMemoryRequest{};
+  request.set_device_name(device_name);
+  request.set_id_pin_name(id_pin_name);
+  request.set_data(data);
+  request.set_format_code(format_code);
+
+  auto response = WriteIDPinMemoryResponse{};
+
+  raise_if_error(
+      stub->WriteIDPinMemory(&context, request, &response),
+      context);
+
+  return response;
+}
+
 WriteRawResponse
 write_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps, const bool& auto_start, const double& timeout, const std::string& write_array)
 {

diff --git a/generated/nidaqmx/nidaqmx_client.h b/generated/nidaqmx/nidaqmx_client.h
@@ -313,6 +313,7 @@ ReadDigitalU32Response read_digital_u32(const StubPtr& stub, const nidevice_grpc
 BeginReadDigitalU32Response begin_read_digital_u32(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadDigitalU8Response read_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 BeginReadDigitalU8Response begin_read_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
+ReadIDPinMemoryResponse read_id_pin_memory(const StubPtr& stub, const std::string& device_name, const std::string& id_pin_name, const pb::uint32& array_size);
 ReadPowerBinaryI16Response read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 BeginReadPowerBinaryI16Response begin_read_power_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadPowerF64Response read_power_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
@@ -462,6 +463,7 @@ WriteDigitalU32Response write_digital_u32(const StubPtr& stub, const nidevice_gr
 BeginWriteDigitalU32Response begin_write_digital_u32(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const bool& auto_start, const double& timeout, const simple_variant<GroupBy, pb::int32>& data_layout);
 WriteDigitalU8Response write_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const bool& auto_start, const double& timeout, const simple_variant<GroupBy, pb::int32>& data_layout, const std::string& write_array);
 BeginWriteDigitalU8Response begin_write_digital_u8(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const bool& auto_start, const double& timeout, const simple_variant<GroupBy, pb::int32>& data_layout);
+WriteIDPinMemoryResponse write_id_pin_memory(const StubPtr& stub, const std::string& device_name, const std::string& id_pin_name, const std::string& data, const pb::uint32& format_code);
 WriteRawResponse write_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps, const bool& auto_start, const double& timeout, const std::string& write_array);
 BeginWriteRawResponse begin_write_raw(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps, const bool& auto_start, const double& timeout);
 WriteToTEDSFromArrayResponse write_to_teds_from_array(const StubPtr& stub, const std::string& physical_channel, const std::string& bit_stream, const simple_variant<WriteBasicTEDSOptions, pb::int32>& basic_teds_options);

diff --git a/generated/nidaqmx/nidaqmx_compilation_test.cpp b/generated/nidaqmx/nidaqmx_compilation_test.cpp
@@ -1347,6 +1347,11 @@ int32 ReadDigitalU8(TaskHandle task, int32 numSampsPerChan, float64 timeout, int
   return DAQmxReadDigitalU8(task, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved);
 }
 
+int32 ReadIDPinMemory(const char deviceName[], const char idPinName[], uInt8 data[], uInt32 arraySize, uInt32* dataLengthRead, uInt32* formatCode)
+{
+  return DAQmxReadIDPinMemory(deviceName, idPinName, data, arraySize, dataLengthRead, formatCode);
+}
+
 int32 ReadPowerBinaryI16(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, int16 readArrayVoltage[], int16 readArrayCurrent[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved)
 {
   return DAQmxReadPowerBinaryI16(task, numSampsPerChan, timeout, fillMode, readArrayVoltage, readArrayCurrent, arraySizeInSamps, sampsPerChanRead, reserved);
@@ -1982,6 +1987,11 @@ int32 WriteDigitalU8(TaskHandle task, int32 numSampsPerChan, bool32 autoStart, f
   return DAQmxWriteDigitalU8(task, numSampsPerChan, autoStart, timeout, dataLayout, writeArray, sampsPerChanWritten, reserved);
 }
 
+int32 WriteIDPinMemory(const char deviceName[], const char idPinName[], const uInt8 data[], uInt32 arraySize, uInt32 formatCode)
+{
+  return DAQmxWriteIDPinMemory(deviceName, idPinName, data, arraySize, formatCode);
+}
+
 int32 WriteRaw(TaskHandle task, int32 numSamps, bool32 autoStart, float64 timeout, const uInt8 writeArray[], int32* sampsPerChanWritten, bool32* reserved)
 {
   return DAQmxWriteRaw(task, numSamps, autoStart, timeout, writeArray, sampsPerChanWritten, reserved);

diff --git a/generated/nidaqmx/nidaqmx_library.cpp b/generated/nidaqmx/nidaqmx_library.cpp
@@ -297,6 +297,7 @@ NiDAQmxLibrary::NiDAQmxLibrary(std::shared_ptr<nidevice_grpc::SharedLibraryInter
   function_pointers_.ReadDigitalU16 = reinterpret_cast<ReadDigitalU16Ptr>(shared_library_->get_function_pointer("DAQmxReadDigitalU16"));
   function_pointers_.ReadDigitalU32 = reinterpret_cast<ReadDigitalU32Ptr>(shared_library_->get_function_pointer("DAQmxReadDigitalU32"));
   function_pointers_.ReadDigitalU8 = reinterpret_cast<ReadDigitalU8Ptr>(shared_library_->get_function_pointer("DAQmxReadDigitalU8"));
+  function_pointers_.ReadIDPinMemory = reinterpret_cast<ReadIDPinMemoryPtr>(shared_library_->get_function_pointer("DAQmxReadIDPinMemory"));
   function_pointers_.ReadPowerBinaryI16 = reinterpret_cast<ReadPowerBinaryI16Ptr>(shared_library_->get_function_pointer("DAQmxReadPowerBinaryI16"));
   function_pointers_.ReadPowerF64 = reinterpret_cast<ReadPowerF64Ptr>(shared_library_->get_function_pointer("DAQmxReadPowerF64"));
   function_pointers_.ReadPowerScalarF64 = reinterpret_cast<ReadPowerScalarF64Ptr>(shared_library_->get_function_pointer("DAQmxReadPowerScalarF64"));
@@ -425,6 +426,7 @@ NiDAQmxLibrary::NiDAQmxLibrary(std::shared_ptr<nidevice_grpc::SharedLibraryInter
   function_pointers_.WriteDigitalU16 = reinterpret_cast<WriteDigitalU16Ptr>(shared_library_->get_function_pointer("DAQmxWriteDigitalU16"));
   function_pointers_.WriteDigitalU32 = reinterpret_cast<WriteDigitalU32Ptr>(shared_library_->get_function_pointer("DAQmxWriteDigitalU32"));
   function_pointers_.WriteDigitalU8 = reinterpret_cast<WriteDigitalU8Ptr>(shared_library_->get_function_pointer("DAQmxWriteDigitalU8"));
+  function_pointers_.WriteIDPinMemory = reinterpret_cast<WriteIDPinMemoryPtr>(shared_library_->get_function_pointer("DAQmxWriteIDPinMemory"));
   function_pointers_.WriteRaw = reinterpret_cast<WriteRawPtr>(shared_library_->get_function_pointer("DAQmxWriteRaw"));
   function_pointers_.WriteToTEDSFromArray = reinterpret_cast<WriteToTEDSFromArrayPtr>(shared_library_->get_function_pointer("DAQmxWriteToTEDSFromArray"));
   function_pointers_.WriteToTEDSFromFile = reinterpret_cast<WriteToTEDSFromFilePtr>(shared_library_->get_function_pointer("DAQmxWriteToTEDSFromFile"));
@@ -2598,6 +2600,14 @@ int32 NiDAQmxLibrary::ReadDigitalU8(TaskHandle task, int32 numSampsPerChan, floa
   return function_pointers_.ReadDigitalU8(task, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved);
 }
 
+int32 NiDAQmxLibrary::ReadIDPinMemory(const char deviceName[], const char idPinName[], uInt8 data[], uInt32 arraySize, uInt32* dataLengthRead, uInt32* formatCode)
+{
+  if (!function_pointers_.ReadIDPinMemory) {
+    throw nidevice_grpc::LibraryLoadException("Could not find DAQmxReadIDPinMemory.");
+  }
+  return function_pointers_.ReadIDPinMemory(deviceName, idPinName, data, arraySize, dataLengthRead, formatCode);
+}
+
 int32 NiDAQmxLibrary::ReadPowerBinaryI16(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, int16 readArrayVoltage[], int16 readArrayCurrent[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved)
 {
   if (!function_pointers_.ReadPowerBinaryI16) {
@@ -3622,6 +3632,14 @@ int32 NiDAQmxLibrary::WriteDigitalU8(TaskHandle task, int32 numSampsPerChan, boo
   return function_pointers_.WriteDigitalU8(task, numSampsPerChan, autoStart, timeout, dataLayout, writeArray, sampsPerChanWritten, reserved);
 }
 
+int32 NiDAQmxLibrary::WriteIDPinMemory(const char deviceName[], const char idPinName[], const uInt8 data[], uInt32 arraySize, uInt32 formatCode)
+{
+  if (!function_pointers_.WriteIDPinMemory) {
+    throw nidevice_grpc::LibraryLoadException("Could not find DAQmxWriteIDPinMemory.");
+  }
+  return function_pointers_.WriteIDPinMemory(deviceName, idPinName, data, arraySize, formatCode);
+}
+
 int32 NiDAQmxLibrary::WriteRaw(TaskHandle task, int32 numSamps, bool32 autoStart, float64 timeout, const uInt8 writeArray[], int32* sampsPerChanWritten, bool32* reserved)
 {
   if (!function_pointers_.WriteRaw) {

diff --git a/generated/nidaqmx/nidaqmx_library.h b/generated/nidaqmx/nidaqmx_library.h
@@ -290,6 +290,7 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
   int32 ReadDigitalU16(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, uInt16 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) override;
   int32 ReadDigitalU32(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, uInt32 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) override;
   int32 ReadDigitalU8(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, uInt8 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) override;
+  int32 ReadIDPinMemory(const char deviceName[], const char idPinName[], uInt8 data[], uInt32 arraySize, uInt32* dataLengthRead, uInt32* formatCode) override;
   int32 ReadPowerBinaryI16(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, int16 readArrayVoltage[], int16 readArrayCurrent[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) override;
   int32 ReadPowerF64(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, float64 readArrayVoltage[], float64 readArrayCurrent[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) override;
   int32 ReadPowerScalarF64(TaskHandle task, float64 timeout, float64* voltage, float64* current, bool32* reserved) override;
@@ -418,6 +419,7 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
   int32 WriteDigitalU16(TaskHandle task, int32 numSampsPerChan, bool32 autoStart, float64 timeout, int32 dataLayout, const uInt16 writeArray[], int32* sampsPerChanWritten, bool32* reserved) override;
   int32 WriteDigitalU32(TaskHandle task, int32 numSampsPerChan, bool32 autoStart, float64 timeout, int32 dataLayout, const uInt32 writeArray[], int32* sampsPerChanWritten, bool32* reserved) override;
   int32 WriteDigitalU8(TaskHandle task, int32 numSampsPerChan, bool32 autoStart, float64 timeout, int32 dataLayout, const uInt8 writeArray[], int32* sampsPerChanWritten, bool32* reserved) override;
+  int32 WriteIDPinMemory(const char deviceName[], const char idPinName[], const uInt8 data[], uInt32 arraySize, uInt32 formatCode) override;
   int32 WriteRaw(TaskHandle task, int32 numSamps, bool32 autoStart, float64 timeout, const uInt8 writeArray[], int32* sampsPerChanWritten, bool32* reserved) override;
   int32 WriteToTEDSFromArray(const char physicalChannel[], const uInt8 bitStream[], uInt32 arraySize, int32 basicTEDSOptions) override;
   int32 WriteToTEDSFromFile(const char physicalChannel[], const char filePath[], int32 basicTEDSOptions) override;
@@ -693,6 +695,7 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
   using ReadDigitalU16Ptr = decltype(&DAQmxReadDigitalU16);
   using ReadDigitalU32Ptr = decltype(&DAQmxReadDigitalU32);
   using ReadDigitalU8Ptr = decltype(&DAQmxReadDigitalU8);
+  using ReadIDPinMemoryPtr = decltype(&DAQmxReadIDPinMemory);
   using ReadPowerBinaryI16Ptr = decltype(&DAQmxReadPowerBinaryI16);
   using ReadPowerF64Ptr = decltype(&DAQmxReadPowerF64);
   using ReadPowerScalarF64Ptr = decltype(&DAQmxReadPowerScalarF64);
@@ -821,6 +824,7 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
   using WriteDigitalU16Ptr = decltype(&DAQmxWriteDigitalU16);
   using WriteDigitalU32Ptr = decltype(&DAQmxWriteDigitalU32);
   using WriteDigitalU8Ptr = decltype(&DAQmxWriteDigitalU8);
+  using WriteIDPinMemoryPtr = decltype(&DAQmxWriteIDPinMemory);
   using WriteRawPtr = decltype(&DAQmxWriteRaw);
   using WriteToTEDSFromArrayPtr = decltype(&DAQmxWriteToTEDSFromArray);
   using WriteToTEDSFromFilePtr = decltype(&DAQmxWriteToTEDSFromFile);
@@ -1095,6 +1099,7 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
     ReadDigitalU16Ptr ReadDigitalU16;
     ReadDigitalU32Ptr ReadDigitalU32;
     ReadDigitalU8Ptr ReadDigitalU8;
+    ReadIDPinMemoryPtr ReadIDPinMemory;
     ReadPowerBinaryI16Ptr ReadPowerBinaryI16;
     ReadPowerF64Ptr ReadPowerF64;
     ReadPowerScalarF64Ptr ReadPowerScalarF64;
@@ -1223,6 +1228,7 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
     WriteDigitalU16Ptr WriteDigitalU16;
     WriteDigitalU32Ptr WriteDigitalU32;
     WriteDigitalU8Ptr WriteDigitalU8;
+    WriteIDPinMemoryPtr WriteIDPinMemory;
     WriteRawPtr WriteRaw;
     WriteToTEDSFromArrayPtr WriteToTEDSFromArray;
     WriteToTEDSFromFilePtr WriteToTEDSFromFile;