NI-DAQmx-wait-changes: More flexible NI DAQmx wait monitor functionality.

- In the case that there are waits, analog input, but no wait monitor,
  raise an exception.

- Allow the wait monitor timeout device to de a different NI DAQmx device.

- Allow there to be no timeout device.

These changes are to be compatible with labscript changes that make wait monitors
and wait timeouts optional. The timeout device being allowed to be a different
device allows for the case where one device has counters but no unbuffered DO
ports, whereas another one has unbuffered DO ports but no counters. I am not
sure if the latter exists, but this was motivated by an NI DAQmx device with
unreliable counter input. We were not able to figure out what made the counter
input unreliable, but switching to a different device fixed the problem (though
the device we switched to lacks unbuffered DO ports, so we cannot use it as
the timeout device).

Author: RbChip

NI_DAQmx/blacs_tabs.py

@@ -22,6 +22,7 @@
 
 from blacs.device_base_class import DeviceTab
 from .utils import split_conn_AO, split_conn_DO
+from . import models
 
 
 class NI_DAQmxTab(DeviceTab):
@@ -155,10 +156,18 @@ def initialise_GUI(self):
         self.primary_worker = "main_worker"
 
         if wait_acq_device == self.device_name:
-            if wait_timeout_device != self.device_name:
-                msg = """The wait monitor acquisition device must be the same as the
-                    wait timeout device."""
-                raise RuntimeError(msg)
+            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"
@@ -170,6 +179,7 @@ def initialise_GUI(self):
                 {
                     'MAX_name': self.MAX_name,
                     'wait_acq_connection': wait_acq_connection,
+                    'wait_timeout_MAX_name': wait_timeout_MAX_name,
                     'wait_timeout_connection': wait_timeout_connection,
                     'timeout_trigger_type': timeout_trigger_type,
                     'min_semiperiod_measurement': min_semiperiod_measurement,

NI_DAQmx/blacs_workers.py

@@ -763,14 +763,21 @@ def wait_monitor(self):
                     semiperiods = self.read_edges(2, timeout)
                     # Did the wait finish of its own accord, or time out?
                     if semiperiods is None:
-                        # It timed out. Better trigger the clock to resume!
-                        msg = """Wait timed out; retriggering clock with {:.3e} s pulse
-                            ({} edge)"""
-                        msg = dedent(msg).format(pulse_width, self.timeout_trigger_type)
-                        self.logger.debug(msg)
-                        self.send_resume_trigger(pulse_width)
-                        # Wait for it to respond to that:
-                        self.logger.debug('Waiting for pulse indicating end of wait')
+                        # It timed out. If there is a timeout device, send a trigger to
+                        # resume the clock!
+                        if self.DO_task is not None:
+                            msg = """Wait timed out; retriggering clock with {:.3e} s
+                                pulse ({} edge)"""
+                            msg = msg.format(pulse_width, self.timeout_trigger_type)
+                            self.logger.debug(dedent(msg))
+                            self.send_resume_trigger(pulse_width)
+                        else:
+                            msg = """Specified wait timeout exceeded, but there is no
+                                timeout device with which to resume the experiment.
+                                Continuing to wait."""
+                            self.logger.warning(dedent(msg))
+                        # Keep waiting for the clock to resume:
+                        self.logger.info('Waiting for pulse indicating end of wait')
                         semiperiods = self.read_edges(2, timeout=None)
                     # Alright, now we're at the end of the wait.
                     self.semiperiods.extend(semiperiods)
@@ -853,15 +860,16 @@ def start_tasks(self):
         self.CI_task.StartTask()
 
         # The timeout task:
-        self.DO_task = Task()
-        DO_chan = self.MAX_name + '/' + self.wait_timeout_connection
-        self.DO_task.CreateDOChan(DO_chan, "", DAQmx_Val_ChanForAllLines)
-        # Ensure timeout trigger is armed:
-        written = int32()
-        # Writing autostarts the task:
-        self.DO_task.WriteDigitalLines(
-            1, True, 1, DAQmx_Val_GroupByChannel, self.timeout_rearm, written, None
-        )
+        if self.wait_timeout_MAX_name is not None:
+            self.DO_task = Task()
+            DO_chan = self.wait_timeout_MAX_name + '/' + self.wait_timeout_connection
+            self.DO_task.CreateDOChan(DO_chan, "", DAQmx_Val_ChanForAllLines)
+            # Ensure timeout trigger is armed:
+            written = int32()
+            # Writing autostarts the task:
+            self.DO_task.WriteDigitalLines(
+                1, True, 1, DAQmx_Val_GroupByChannel, self.timeout_rearm, written, None
+            )
 
     def transition_to_buffered(self, device_name, h5file, initial_values, fresh):
         self.logger.debug('transition_to_buffered')

NI_DAQmx/labscript_devices.py

@@ -31,6 +31,7 @@
     AnalogIn,
     bitfield,
     config,
+    compiler,
     LabscriptError,
     set_passed_properties,
 )
@@ -319,6 +320,12 @@ def _make_analog_out_table(self, analogs, times):
         """Collect analog output data and create the output array"""
         if not analogs:
             return None
+        if compiler.wait_table and compiler.wait_monitor is None:
+            msg = """Cannot do analog input on an NI DAQmx device in an experiment that
+                uses waits without a wait monitor. This is because input data cannot be
+                'chunked' into requested segments without knowledge of the durations of
+                the waits. See labscript.WaitMonitor for details."""
+            raise LabscriptError(dedent(msg))
         n_timepoints = 1 if self.static_AO else len(times)
         connections = sorted(analogs, key=split_conn_AO)
         dtypes = [(c, np.float32) for c in connections]