Add WriteDigitalWaveforms to NiDAQmxService (#1216)

mikeprosserni · Mike Prosser · web-flow · commit c1676375f382 · 2025-11-05T18:11:12.000-06:00
* Enhance NIDAQmx API with waveform support and additional metadata

- Added ReadAnalogWaveforms method stub to NiDAQmxService for reading analog waveforms.
- Updated metadata validation to include CustomCodeNoLibrary.
- Introduced new waveform attributes and functions in metadata.
- Enhanced CMake configuration for new protobuf files.
- Improved CONTRIBUTING.md with Ninja build instructions.

* fix lint

* fix validate_examples

* ReadAnalogWaveforms implementation (untested, but compiles)

* add tests

* Add support for creating two AI voltage channels in tests

* cleanup

* cleanup CMakeLists.txt

* attempt fix for ubuntu build

* more verbose build output

* Try some different build settings

* add quotes to fix cmake flags

* add sampsPerChanRead to ReadAnalogWaveforms response

* revert changes in build_cmake.yml and do -fno-var-tracking-assignments instead

* use GCC push_options

* use -fno-var-tracking-assignments globally for gcc

* fix timing conversion

* add ReadDigitalWaveforms RPC with stub implementation

* implementation and tests for single channel

* test multi channel and multi line

* add copilot instructions for how to build with ninja, and do some cleanup

* fix data layout

* brad's feedback

* copy protobuf types protos to heirarchical location

* fix merge and templatize the SetWfmAttrCallback

* copilot-build.ps1

* handle epoch difference (note - SecondsFrom0001EpochTo1904Epoch value is off by 5ish months)

* convert_dot_net_daqmx_ticks_to_btf_precision_timestamp

* fixes and cleanup

* cleanup and more test cases

* PrecisionTimestampConverterLiteralTests

* fix merge

* remove copilot instructions (will be added in separate PR)

* use correct logic for NI-BTF

* test cleanup

* fillMode: 1 = GROUP_BY_SCAN_NUMBER (interleaved)

* cleanup merge

* cleanup

* use waveform-&gt;mutable_y_data();

* test cleanup

* Brad's feedback

* cleanup

* implement WriteDigitalWaveforms

* memcpy optimization

* fix merge

* test cleanup

* Brad's feedback

* trailing metadata

* added tests to verify the trailing metadata in error cases

* fix asserts

* fix crash in ReadAnalogWaveforms

* EXPECT_THROW_DRIVER_ERROR

* guard against negative-overflow array_size in ReadDigitalWaveforms

---------

Co-authored-by: Mike Prosser &lt;Mike.Prosser@emerson.com&gt;
diff --git a/generated/nidaqmx/nidaqmx.proto b/generated/nidaqmx/nidaqmx.proto
@@ -469,6 +469,7 @@ service NiDAQmx {
   rpc ReadAnalogWaveforms(ReadAnalogWaveformsRequest) returns (ReadAnalogWaveformsResponse);
   rpc ReadDigitalWaveforms(ReadDigitalWaveformsRequest) returns (ReadDigitalWaveformsResponse);
   rpc WriteAnalogWaveforms(WriteAnalogWaveformsRequest) returns (WriteAnalogWaveformsResponse);
+  rpc WriteDigitalWaveforms(WriteDigitalWaveformsRequest) returns (WriteDigitalWaveformsResponse);
 }
 
 enum BufferUInt32Attribute {
@@ -11565,3 +11566,15 @@ message WriteAnalogWaveformsResponse {
   int32 samps_per_chan_written = 2;
 }
 
+message WriteDigitalWaveformsRequest {
+  nidevice_grpc.Session task = 1;
+  bool auto_start = 2;
+  double timeout = 3;
+  repeated ni.protobuf.types.DigitalWaveform waveforms = 4;
+}
+
+message WriteDigitalWaveformsResponse {
+  int32 status = 1;
+  int32 samps_per_chan_written = 2;
+}
+
diff --git a/generated/nidaqmx/nidaqmx_client.cpp b/generated/nidaqmx/nidaqmx_client.cpp
@@ -12488,5 +12488,25 @@ write_analog_waveforms(const StubPtr& stub, const nidevice_grpc::Session& task,
   return response;
 }
 
+WriteDigitalWaveformsResponse
+write_digital_waveforms(const StubPtr& stub, const nidevice_grpc::Session& task, const bool& auto_start, const double& timeout, const std::vector<ni::protobuf::types::DigitalWaveform>& waveforms)
+{
+  ::grpc::ClientContext context;
+
+  auto request = WriteDigitalWaveformsRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_auto_start(auto_start);
+  request.set_timeout(timeout);
+  copy_array(waveforms, request.mutable_waveforms());
+
+  auto response = WriteDigitalWaveformsResponse{};
+
+  raise_if_error(
+      stub->WriteDigitalWaveforms(&context, request, &response),
+      context);
+
+  return response;
+}
+
 
 } // namespace nidaqmx_grpc::experimental::client
diff --git a/generated/nidaqmx/nidaqmx_client.h b/generated/nidaqmx/nidaqmx_client.h
@@ -471,6 +471,7 @@ WriteToTEDSFromFileResponse write_to_teds_from_file(const StubPtr& stub, const s
 ReadAnalogWaveformsResponse read_analog_waveforms(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<WaveformAttributeMode, pb::int32>& waveform_attribute_mode);
 ReadDigitalWaveformsResponse read_digital_waveforms(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<WaveformAttributeMode, pb::int32>& waveform_attribute_mode);
 WriteAnalogWaveformsResponse write_analog_waveforms(const StubPtr& stub, const nidevice_grpc::Session& task, const bool& auto_start, const double& timeout, const std::vector<ni::protobuf::types::DoubleAnalogWaveform>& waveforms);
+WriteDigitalWaveformsResponse write_digital_waveforms(const StubPtr& stub, const nidevice_grpc::Session& task, const bool& auto_start, const double& timeout, const std::vector<ni::protobuf::types::DigitalWaveform>& waveforms);
 
 } // namespace nidaqmx_grpc::experimental::client
 
diff --git a/generated/nidaqmx/nidaqmx_service.h b/generated/nidaqmx/nidaqmx_service.h
@@ -541,6 +541,7 @@ class NiDAQmxService final : public NiDAQmx::WithCallbackMethod_RegisterSignalEv
   ::grpc::Status ReadAnalogWaveforms(::grpc::ServerContext* context, const ReadAnalogWaveformsRequest* request, ReadAnalogWaveformsResponse* response) override;
   ::grpc::Status ReadDigitalWaveforms(::grpc::ServerContext* context, const ReadDigitalWaveformsRequest* request, ReadDigitalWaveformsResponse* response) override;
   ::grpc::Status WriteAnalogWaveforms(::grpc::ServerContext* context, const WriteAnalogWaveformsRequest* request, WriteAnalogWaveformsResponse* response) override;
+  ::grpc::Status WriteDigitalWaveforms(::grpc::ServerContext* context, const WriteDigitalWaveformsRequest* request, WriteDigitalWaveformsResponse* response) override;
 private:
   LibrarySharedPtr library_;
   ResourceRepositorySharedPtr session_repository_;
diff --git a/source/codegen/metadata/nidaqmx/functions_addon.py b/source/codegen/metadata/nidaqmx/functions_addon.py
@@ -197,6 +197,65 @@
                 'type': 'int32'
             }
         ]
+    },
+    'WriteDigitalWaveforms': {
+        'returns': 'int32',
+        'codegen_method': 'CustomCodeNoLibrary',
+        'parameters': [
+            {
+                'ctypes_data_type': 'ctypes.TaskHandle',
+                'direction': 'in',
+                'is_optional_in_python': False,
+                'name': 'task',
+                'python_data_type': 'TaskHandle',
+                'python_description': '',
+                'python_type_annotation': 'TaskHandle',
+                'type': 'TaskHandle'
+            },
+            {
+                'ctypes_data_type': 'ctypes.c_bool',
+                'direction': 'in',
+                'is_optional_in_python': True,
+                'name': 'autoStart',
+                'python_data_type': 'bool',
+                'python_default_value': 'False',
+                'python_description': 'Specifies whether to start the task automatically.',
+                'python_type_annotation': 'Optional[bool]',
+                'type': 'bool32'
+            },
+            {
+                'ctypes_data_type': 'ctypes.c_double',
+                'direction': 'in',
+                'is_optional_in_python': True,
+                'name': 'timeout',
+                'python_data_type': 'float',
+                'python_default_value': '10.0',
+                'python_description': 'Specifies the time in seconds to wait for the device to respond before timing out.',
+                'python_type_annotation': 'Optional[float]',
+                'type': 'float64'
+            },
+            {
+                'direction': 'in',
+                'is_optional_in_python': False,
+                'name': 'waveforms',
+                'python_data_type': 'object',
+                'python_description': 'The waveforms to write to the specified channels.',
+                'python_type_annotation': 'List[object]',
+                'type': 'repeated ni.protobuf.types.DigitalWaveform'
+            },
+            {
+                'ctypes_data_type': 'ctypes.c_int',
+                'direction': 'out',
+                'is_optional_in_python': False,
+                'is_streaming_type': True,
+                'name': 'sampsPerChanWritten',
+                'python_data_type': 'int',
+                'python_description': '',
+                'python_type_annotation': 'int',
+                'return_on_error_key': 'ni-samps-per-chan-written',
+                'type': 'int32'
+            }
+        ]
     }
 }
 
@@ -245,6 +304,12 @@
             # size is determined by the Write.NumChans property
             'waveforms': ['ARRAY_PARAMETER_NEEDS_SIZE']
         }
+    },
+    'WriteDigitalWaveforms': {
+        'parameters': {
+            # size is determined by the Write.NumChans property
+            'waveforms': ['ARRAY_PARAMETER_NEEDS_SIZE']
+        }
     }
 }
 
diff --git a/source/custom/nidaqmx_service.custom.cpp b/source/custom/nidaqmx_service.custom.cpp
@@ -2,6 +2,7 @@
 #include <vector>
 #include <memory>
 #include <cstdint>
+#include <cstring>
 #include <server/converters.h>
 #include "NIDAQmxInternalWaveform.h"
 
@@ -180,8 +181,9 @@ ::grpc::Status NiDAQmxService::ReadAnalogWaveforms(::grpc::ServerContext* contex
     std::vector<std::vector<float64>> read_arrays(num_channels);
     std::vector<float64*> read_array_ptrs(num_channels);
     
+    const uInt32 size = (number_of_samples_per_channel > 0) ? number_of_samples_per_channel : 1;
     for (uInt32 i = 0; i < num_channels; ++i) {
-      read_arrays[i].resize(number_of_samples_per_channel);
+      read_arrays[i].resize(size);
       read_array_ptrs[i] = read_arrays[i].data();
     }
 
@@ -218,6 +220,7 @@ ::grpc::Status NiDAQmxService::ReadAnalogWaveforms(::grpc::ServerContext* contex
         nullptr
     );
 
+    context->AddTrailingMetadata("ni-samps-per-chan-read", std::to_string(samples_per_chan_read));
     if (!status_ok(status)) {
       return ConvertApiErrorStatusForTaskHandle(context, status, task);
     }
@@ -276,7 +279,8 @@ ::grpc::Status NiDAQmxService::ReadDigitalWaveforms(::grpc::ServerContext* conte
     }
 
     // Calculate total array size needed (samples * channels * max_bytes_per_chan)
-    const uInt32 array_size = number_of_samples_per_channel * num_channels * max_bytes_per_chan;
+    const uInt32 num_samples = (number_of_samples_per_channel > 0) ? number_of_samples_per_channel : 1;
+    const uInt32 array_size = num_samples * num_channels * max_bytes_per_chan;
     std::vector<uInt8> read_array(array_size);
 
     response->mutable_waveforms()->Reserve(num_channels);
@@ -318,6 +322,7 @@ ::grpc::Status NiDAQmxService::ReadDigitalWaveforms(::grpc::ServerContext* conte
         nullptr
     );
 
+    context->AddTrailingMetadata("ni-samps-per-chan-read", std::to_string(samples_per_chan_read));
     if (!status_ok(status)) {
       return ConvertApiErrorStatusForTaskHandle(context, status, task);
     }
@@ -404,6 +409,93 @@ ::grpc::Status NiDAQmxService::WriteAnalogWaveforms(::grpc::ServerContext* conte
         nullptr
     );
 
+    context->AddTrailingMetadata("ni-samps-per-chan-written", std::to_string(samples_per_chan_written));
+    if (!status_ok(status)) {
+      return ConvertApiErrorStatusForTaskHandle(context, status, task);
+    }
+
+    response->set_samps_per_chan_written(samples_per_chan_written);
+    response->set_status(status);
+    return ::grpc::Status::OK;
+  }
+  catch (nidevice_grpc::NonDriverException& ex) {
+    return ex.GetStatus();
+  }
+}
+
+::grpc::Status NiDAQmxService::WriteDigitalWaveforms(::grpc::ServerContext* context, const WriteDigitalWaveformsRequest* request, WriteDigitalWaveformsResponse* response)
+{
+  if (context->IsCancelled()) {
+    return ::grpc::Status::CANCELLED;
+  }
+  try {
+    auto task_grpc_session = request->task();
+    TaskHandle task = session_repository_->access_session(task_grpc_session.name());
+
+    const auto auto_start = request->auto_start();
+    const auto timeout = request->timeout();
+    const auto& waveforms = request->waveforms();
+    
+    if (waveforms.empty()) {
+      return ::grpc::Status(::grpc::INVALID_ARGUMENT, "No waveforms provided");
+    }
+
+    const uInt32 num_channels = static_cast<uInt32>(waveforms.size());
+    const int32 number_of_samples_per_channel = static_cast<int32>(waveforms[0].y_data().size() / waveforms[0].signal_count());
+
+    uInt32 max_bytes_per_chan = 0;
+    for (const auto& waveform : waveforms) {
+      const auto signal_count = waveform.signal_count();
+      max_bytes_per_chan = std::max(max_bytes_per_chan, static_cast<uInt32>(signal_count));
+    }
+
+    std::vector<uInt32> bytes_per_chan_array(num_channels);
+    for (uInt32 channel = 0; channel < num_channels; ++channel) {
+      const auto& waveform = waveforms[channel];
+      const auto signal_count = waveform.signal_count();
+      const auto& y_data = waveform.y_data();
+      
+      if (y_data.size() != number_of_samples_per_channel * signal_count) {
+        return ::grpc::Status(::grpc::INVALID_ARGUMENT, "The waveforms must all have the same sample count.");
+      }
+      
+      bytes_per_chan_array[channel] = static_cast<uInt32>(signal_count);
+    }
+
+    const uInt32 array_size = number_of_samples_per_channel * num_channels * max_bytes_per_chan;
+    std::vector<uInt8> write_array(array_size, 0);
+
+    for (uInt32 channel = 0; channel < num_channels; ++channel) {
+      const auto& waveform = waveforms[channel];
+      const auto signal_count = waveform.signal_count();
+      const auto& y_data = waveform.y_data();
+
+      // Data layout: grouped by scan number (interleaved)
+      // Sample 0: Channel 0 signals, Channel 1 signals, Channel 2 signals, ...
+      // Sample 1: Channel 0 signals, Channel 1 signals, Channel 2 signals, ...
+      // Within each channel's data in a sample, signals are sequential: Signal0, Signal1, Signal2, ...
+      for (int32 sample = 0; sample < number_of_samples_per_channel; ++sample) {
+        const uInt32 dest_index = sample * num_channels * max_bytes_per_chan + channel * max_bytes_per_chan;
+        const uInt32 src_index = sample * signal_count;
+        std::memcpy(&write_array[dest_index], &y_data[src_index], signal_count);
+      }
+    }
+
+    int32 samples_per_chan_written = 0;
+    auto status = library_->InternalWriteDigitalWaveform(
+        task,
+        number_of_samples_per_channel,
+        auto_start,
+        timeout,
+        GROUP_BY_GROUP_BY_SCAN_NUMBER,
+        write_array.data(),
+        bytes_per_chan_array.data(),
+        num_channels,
+        &samples_per_chan_written,
+        nullptr
+    );
+
+    context->AddTrailingMetadata("ni-samps-per-chan-written", std::to_string(samples_per_chan_written));
     if (!status_ok(status)) {
       return ConvertApiErrorStatusForTaskHandle(context, status, task);
     }
@@ -417,4 +509,4 @@ ::grpc::Status NiDAQmxService::WriteAnalogWaveforms(::grpc::ServerContext* conte
   }
 }
 
-}  // namespace nidaqmx_grpc
+}  // namespace nidaqmx_grpc
diff --git a/source/tests/system/nidaqmx_driver_api_tests.cpp b/source/tests/system/nidaqmx_driver_api_tests.cpp
