NI-DAQmx-wait-changes: move wait monitor error checking to compilation time, and ensure that

start_order and stop_order of separate wait monitor timeout and acquisition
devices are configured as required to ensure that the subprocess otherwise
belonging to the acquisition device will be able to control the timeout device
without contention from tasks in the other process.

Author: chrisjbillington

NI_DAQmx/blacs_tabs.py

@@ -158,20 +158,14 @@ def initialise_GUI(self):
         if wait_acq_device == self.device_name:
             if wait_timeout_device:
                 wait_timeout_device = connection_table.find_by_name(wait_timeout_device)
-                if not hasattr(models, wait_timeout_device.device_class):
-                    msg = """If using an NI DAQmx device as a wait monitor input, then
-                        the wait monitor timeout device must also be an NI DAQmx device,
-                        not {}.""".format(
-                        wait_timeout_device.device_class
-                    )
-                    raise RuntimeError(dedent(msg))
                 wait_timeout_MAX_name = wait_timeout_device.properties['MAX_name']
             else:
                 wait_timeout_MAX_name = None
 
             if num_CI == 0:
-                msg = "Device cannot be a wait monitor as it has no counter inputs"
-                raise RuntimeError(msg)
+                msg = """Device cannot be the wait monitor acquisiiton device as it has
+                    no counter inputs"""
+                raise RuntimeError(dedent(msg))
 
             self.create_worker(
                 "wait_monitor_worker",

NI_DAQmx/labscript_devices.py

@@ -404,6 +404,49 @@ def _make_analog_input_table(self, inputs):
 
         return acquisition_table
 
+    def _check_wait_monitor_timeout_device_config(self):
+        """Check that if we are the wait monitor acquisition device and another device
+        is the wait monitor timeout device, that a) the other device is a DAQmx device
+        and b) the other device has a start_order lower than us and a stop_order higher
+        than us."""
+        acquisition_device = compiler.wait_monitor.acquisition_device
+        timeout_device = compiler.wait_monitor.timeout_device
+        if acquisition_device is not self or timeout_device is None:
+            return
+        if timeout_device is self:
+            return
+        if not isinstance(timeout_device, NI_DAQmx):
+            msg = """If using an NI DAQmx device as a wait monitor acquisition device,
+                then the wait monitor timeout device must also be an NI DAQmx device,
+                not {}."""
+            raise TypeError(dedent(msg).format(type(timeout_device)))
+        timeout_start = timeout_device.start_order
+        if timeout_start is None:
+            timeout_start = 0
+        timeout_stop = timeout_device.stop_order
+        if timeout_stop is None:
+            timeout_stop = 0
+        self_start = self.start_order
+        if self_start is None:
+            self_start = 0
+        self_stop = self.stop_order
+        if self_stop is None:
+            self_stop = 0
+        if timeout_start >= self_start or timeout_stop <= self_stop:
+            msg = """If using different DAQmx devices as the wait monitor acquisition
+                and timeout devices, the timeout device must transition_to_buffered
+                before the acquisition device, and transition_to_manual after it, in
+                order to ensure the output port for timeout pulses is not in use (by the
+                manual mode DO task) when the wait monitor subprocess attempts to use
+                it. To achieve this, pass the start_order and stop_order keyword
+                arguments to the devices in your connection table, ensuring that the
+                timeout device has a lower start_order and a higher stop_order than the
+                acquisition device. The default start_order and stop_order is zero, so
+                if you are not otherwise controlling the order that devices are
+                programmed, you can set start_order=-1, stop_order=1 on the timeout
+                device only."""
+            raise RuntimeError(dedent(msg))
+
     def generate_code(self, hdf5_file):
         IntermediateDevice.generate_code(self, hdf5_file)
         analogs = {}
@@ -438,6 +481,7 @@ def generate_code(self, hdf5_file):
         AI_table = self._make_analog_input_table(inputs)
 
         self._check_AI_not_too_fast(AI_table)
+        self._check_wait_monitor_timeout_device_config()
 
         grp = self.init_device_group(hdf5_file)
         if AO_table is not None: