SY-3096: Automate Driver QA - NI (#2071)

SY-3096: Automate Driver QA - NI (#2071)

Author: sy-nico

.github/PULL_REQUEST_TEMPLATE/rc.md

@@ -319,65 +319,12 @@ I can successfully:
 I can successfully:
 
 - [ ] Enable and disable NI integration when starting the server.
-- [x] Recognize and connect to an NI device locally. (driver_ni_digital_write.py)
-- [ ] Recognize and connect to NI devices over the network.
-- [x] Recognize and connect to physical and simulated devices. (driver_ni_digital_write.py)
-- [ ] Disconnect a physical device while a task is running without causing faults.
-- [ ] Ignore chassis and view devices connected to it.
-- [ ] Run the Driver without NI-DAQmx and System Configuration libraries installed.
-- [ ] Receive feedback when trying to create an NI task on a machine lacking the necessary libraries.
-- **Handle invalid device configurations and receive meaningful feedback:**
-  - [ ] Invalid ports.
-  - [ ] Incorrect task type for devices.
-  - [ ] Out-of-range values.
-  - [ ] Multiple tasks using the same channel.
+- [ ] View a chassis and it's child devices.
 - [ ] Shut down the driver without errors during embedded operation.
-- [ ] Run various tasks on a single device.
-- [ ] Run multiple tasks across multiple devices concurrently.
-- **Reliable data streaming at the following sample rates:**
-  - [ ] 1 Hz
-  - [ ] 10 Hz
-  - [ ] 100 Hz
-  - [ ] 1 kHz
-  - [ ] 5 kHz
-- **Configure the following stream rates:**
-  - [ ] 1 Hz
-  - [ ] 10 Hz
-  - [ ] 30 Hz
-- **Analog Read Task**
-  - [ ] Plot live data.
-  - [ ] Tare data.
-  - [ ] Handle device disconnection during active tasks with appropriate feedback.
-  - [ ] Start multiple tasks at different times and view live data.
-  - [ ] Enable and disable data saving.
-  - [ ] Enabled auto-start, and ensure that the task automatically starts after configuration.
-  - [ ] Ensure no lag between sensor input and Core data recording.
-  - [ ] Configure and run an analog read task for the following channels:
-    - [ ] Current (NI-9203)
-    - [ ] Resistance (NI-9219)
-    - [ ] RTD (NI-9217)
-      - [ ] All RTD types and resistance configurations.
-    - [ ] Built-in temperature sensor (USB-6289)
-    - [ ] Thermocouple (NI-9211A)
-      - [ ] All thermocouple types and CJC options.
-    - [ ] Voltage (USB-6000)
-      - **Terminal configurations:**
-        - [ ] Default (USB-6000)
-        - [ ] Reference Single-Ended (USB-6000)
-        - [ ] Non-Referenced Single-Ended (NI-9206)
-        - [ ] Differential (NI-9206)
-        - [ ] Pseudo-Differential (NI-9234)
-  - **Apply the following scales:**
-    - [ ] Linear
-    - [ ] Map
 - **Digital Read Task**
   - [ ] Plot live data.
-  - [ ] Stop, start, and reconfigure tasks.
-  - [ ] Enable and disable data saving.
 - **Digital Write Task**
   - [ ] Perform control actions using a schematic.
-  - [ ] Stop, start, and reconfigure tasks.
-  - [ ] Handle device disconnection during active tasks with appropriate feedback.
   - **Configure response time for specified state rates:**
     - [ ] 1 Hz (visible delay)
     - [ ] 20 Hz (near-instant response)

client/py/examples/ni/analog_read_task.py

@@ -8,119 +8,106 @@
 #  included in the file licenses/APL.txt.
 
 import synnax as sy
+from synnax import ni
 
 """
-This examples demonstrates how to configure and start an Analog Read Task on a National
-Instruments USB-6289 device.
+This example demonstrates how to configure and start a multi-device Analog Read Task
+on National Instruments hardware. The task reads voltage from one device, current from
+another, and temperature (thermocouple) from a third — all in a single task.
 
 To run this example, you'll need to have your Synnax cluster properly configured to
-detect National Instruments devices: https://docs.synnaxlabs.com/reference/driver/ni/get-started
+detect National Instruments devices:
+https://docs.synnaxlabs.com/reference/driver/ni/get-started
 
-You'll also need to have either a physical USB-6289 device or create a simulated device
-via the NI-MAX software.
+You'll also need physical NI devices or simulated devices via NI-MAX.
 """
 
 # We've logged in via the CLI, so there's no need to provide credentials here.
 # See https://docs.synnaxlabs.com/reference/client/quick-start for more information.
 client = sy.Synnax()
 
-dev = client.devices.retrieve(model="USB-6289")
+# Retrieve devices — each module is a separate device in Synnax.
+v_dev = client.devices.retrieve(name="Mod1_Voltage")
+c_dev = client.devices.retrieve(name="Mod2_Current")
+tc_dev = client.devices.retrieve(name="Mod1_TC")
 
-# Create an index channel that will be used to store the timestamps
-# for the analog read data.
+# Create an index channel for timestamps.
 ai_time = client.channels.create(
     name="ai_time",
     is_index=True,
     data_type=sy.DataType.TIMESTAMP,
     retrieve_if_name_exists=True,
 )
 
-# Create two synnax channels that will be used to store the input data. Notice
-# how these channels aren't specifically bound to the device. You'll do that in a
-# later step when you create the Analog Read Task.
-ai_0 = client.channels.create(
-    name="ai_0",
-    # Pass in the index key here to associate the channel with the index channel.
+# Create data channels — one per physical input.
+voltage_chan = client.channels.create(
+    name="voltage_chan",
     index=ai_time.key,
     data_type=sy.DataType.FLOAT32,
     retrieve_if_name_exists=True,
 )
-ai_1 = client.channels.create(
-    name="ai_1",
-    # Pass in the index key here to associate the channel with the index channel.
+current_chan = client.channels.create(
+    name="current_chan",
+    index=ai_time.key,
+    data_type=sy.DataType.FLOAT32,
+    retrieve_if_name_exists=True,
+)
+temp_chan = client.channels.create(
+    name="temp_chan",
     index=ai_time.key,
     data_type=sy.DataType.FLOAT32,
     retrieve_if_name_exists=True,
 )
 
-# Instantiate the task. A task is a background process that can be used to acquire data
-# from, or write commands to a device. Tasks are the primary method for interacting with
-# hardware in Synnax.
-tsk = sy.ni.AnalogReadTask(
-    # A name to find and monitor the task via the Synnax Console.
-    name="Basic Analog Read",
-    # The rate at which the task will sample data from the device.
+# Create and configure the task. Each channel specifies its own device, allowing
+# a single task to read from multiple NI modules simultaneously.
+task = ni.AnalogReadTask(
+    name="Analog Read Task",
     sample_rate=sy.Rate.HZ * 100,
-    # The rate at which data will be streamed from the device into Synnax.
-    # Since we're sampling at 100hz and streaming at 25hz, we'll get 4 samples at a
-    # time.
-    # It's generally best to keep the stream rate under 100Hz.
     stream_rate=sy.Rate.HZ * 25,
-    # Whether to save data acquired by the task to disk. If set to False, the data
-    # will be streamed into Synnax for real-time consumption but not saved to disk.
     data_saving=True,
-    # The list of physical channels we'd like to acquire data from.
     channels=[
-        sy.ni.AIVoltageChan(
-            # The key of the Synnax channel we're acquiring data for.
-            channel=ai_0.key,
-            # The key of the device on which the channel is located.
-            device=dev.key,
-            # The port on the device the channel is connected to.
+        ni.AIVoltageChan(
+            channel=voltage_chan.key,
+            device=v_dev.key,
             port=0,
-            # A custom scale to apply to the data. This is optional, but can be useful
-            # for converting raw data into meaningful units.
-            custom_scale=sy.ni.LinScale(
-                slope=2e4,
-                y_intercept=50,
-                pre_scaled_units="Volts",
-                scaled_units="Volts",
-            ),
+            min_val=-10.0,
+            max_val=10.0,
+            terminal_config="Diff",
         ),
-        sy.ni.AIVoltageChan(
-            channel=ai_1.key,
-            device=dev.key,
-            port=1,
-            custom_scale=sy.ni.MapScale(
-                pre_scaled_min=0,
-                pre_scaled_max=10,
-                scaled_min=0,
-                scaled_max=200,
-                pre_scaled_units="Volts",
-                scaled_units="Degrees",
-            ),
+        ni.AICurrentChan(
+            channel=current_chan.key,
+            device=c_dev.key,
+            port=0,
+            min_val=0.004,
+            max_val=0.02,
+        ),
+        ni.AIThermoChan(
+            channel=temp_chan.key,
+            device=tc_dev.key,
+            port=0,
+            units="DegC",
+            thermocouple_type="J",
+            cjc_source="BuiltIn",
         ),
     ],
 )
 
 # This will create the task in Synnax and wait for the driver to validate that the
 # configuration is correct.
-client.tasks.configure(tsk)
+client.tasks.configure(task)
 
 # Stream 100 reads, which will accumulate a total of 400 samples
 # for each channel over a period of 4 seconds.
 total_reads = 100
 
-# Create a synnax frame to accumulate data.
 frame = sy.Frame()
 
-# Start the task under a context manager, which ensures the task gets stopped
-# when the block exits.
-with tsk.run():
-    # Open a streamer on the analog input channels.
-    with client.open_streamer(["ai_0", "ai_1"]) as streamer:
+with task.run():
+    with client.open_streamer(
+        ["voltage_chan", "current_chan", "temp_chan"]
+    ) as streamer:
         for i in range(total_reads):
             frame.append(streamer.read())
 
-# Save the data to a CSV file.
 frame.to_df().to_csv("analog_read_result.csv")

client/py/examples/simulators/device_sim.py

@@ -109,6 +109,8 @@ def _subprocess_entry(self) -> None:
         os.dup2(devnull_fd, 1)
         os.dup2(devnull_fd, 2)
         os.close(devnull_fd)
+        sys.stdout = open(os.devnull, "w")
+        sys.stderr = open(os.devnull, "w")
         signal.signal(signal.SIGINT, signal.SIG_DFL)
         if sys.platform != "win32":
             signal.signal(signal.SIGTERM, signal.SIG_DFL)

client/py/synnax/ni/types.py

@@ -1875,6 +1875,7 @@ class DIChan(BaseModel):
 class BaseCIChan(BaseChan):
     device: str = ""
     port: int
+    channel: int
 
 
 class CIFrequencyChan(BaseCIChan, MinMaxVal):
@@ -2416,11 +2417,17 @@ class AnalogReadTaskConfig(task.BaseReadConfig):
 
     @field_validator("channels")
     def validate_channel_ports(cls, v: list[AIChan], values: Any) -> list[AIChan]:
-        ports = {c.port for c in v}
-        if len(ports) < len(v):
-            used_ports = [c.port for c in v]
-            duplicate_ports = [port for port in ports if used_ports.count(port) > 1]
-            raise ValueError(f"Port {duplicate_ports[0]} has already been used")
+        device_ports = {(c.device, c.port) for c in v}
+        if len(device_ports) < len(v):
+            seen: set[tuple[str, int]] = set()
+            for c in v:
+                key = (c.device, c.port)
+                if key in seen:
+                    raise ValueError(
+                        f"Port {c.port} has already been used on device"
+                        f" '{c.device}'"
+                    )
+                seen.add(key)
         return v
 
 
@@ -2454,11 +2461,17 @@ class CounterReadConfig(task.BaseReadConfig):
 
     @field_validator("channels")
     def validate_channel_ports(cls, v: list[CIChan]) -> list[CIChan]:
-        ports = {c.port for c in v}
-        if len(ports) < len(v):
-            used_ports = [c.port for c in v]
-            duplicate_ports = [port for port in ports if used_ports.count(port) > 1]
-            raise ValueError(f"Port {duplicate_ports[0]} has already been used")
+        device_ports = {(c.device, c.port) for c in v}
+        if len(device_ports) < len(v):
+            seen: set[tuple[str, int]] = set()
+            for c in v:
+                key = (c.device, c.port)
+                if key in seen:
+                    raise ValueError(
+                        f"Port {c.port} has already been used on device"
+                        f" '{c.device}'"
+                    )
+                seen.add(key)
         return v
 
 

client/py/tests/test_ni.py

@@ -797,6 +797,71 @@ def test_digital_read_sample_rate_bounds(self):
                 ],
             )
 
+    def test_multi_device_duplicate_ports_allowed(self):
+        """Channels on different devices can reuse the same port number."""
+        sy.ni.AnalogReadTaskConfig(
+            sample_rate=100,
+            stream_rate=25,
+            data_saving=False,
+            channels=[
+                sy.ni.AIVoltageChan(
+                    key="test1",
+                    device="device-a",
+                    terminal_config="Cfg_Default",
+                    channel=1,
+                    port=0,
+                    enabled=True,
+                    min_val=-10,
+                    max_val=10,
+                    units="Volts",
+                ),
+                sy.ni.AIVoltageChan(
+                    key="test2",
+                    device="device-b",
+                    terminal_config="Cfg_Default",
+                    channel=2,
+                    port=0,
+                    enabled=True,
+                    min_val=-10,
+                    max_val=10,
+                    units="Volts",
+                ),
+            ],
+        )
+
+    def test_same_device_duplicate_ports_rejected(self):
+        """Channels on the same device cannot reuse the same port number."""
+        with pytest.raises(ValidationError):
+            sy.ni.AnalogReadTaskConfig(
+                sample_rate=100,
+                stream_rate=25,
+                data_saving=False,
+                channels=[
+                    sy.ni.AIVoltageChan(
+                        key="test1",
+                        device="device-a",
+                        terminal_config="Cfg_Default",
+                        channel=1,
+                        port=0,
+                        enabled=True,
+                        min_val=-10,
+                        max_val=10,
+                        units="Volts",
+                    ),
+                    sy.ni.AIVoltageChan(
+                        key="test2",
+                        device="device-a",
+                        terminal_config="Cfg_Default",
+                        channel=2,
+                        port=0,
+                        enabled=True,
+                        min_val=-10,
+                        max_val=10,
+                        units="Volts",
+                    ),
+                ],
+            )
+
 
 @pytest.mark.ni
 class TestNIDeviceHelpers: