Merged in NI-DAQmx-wait-changes (pull request #76)

More flexible NI DAQmx wait monitor functionality.

Author: chrisjbillington

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,21 +156,24 @@ 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)
+                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",
                 'labscript_devices.NI_DAQmx.blacs_workers.NI_DAQmxWaitMonitorWorker',
                 {
                     '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

@@ -759,13 +759,20 @@ 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:
+                        # 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.debug('Waiting for pulse indicating end of wait')
                         semiperiods = self.read_edges(2, timeout=None)
                     # Alright, now we're at the end of the wait.
@@ -815,7 +822,8 @@ def stop_tasks(self, abort):
             if not abort:
                 # Don't want errors about incomplete task to be raised if we are aborting:
                 self.CI_task.StopTask()
-            self.DO_task.StopTask()
+            if self.DO_task is not None:
+                self.DO_task.StopTask()
         if self.CI_task is not None:
             self.CI_task.ClearTask()
             self.CI_task = None
@@ -849,15 +857,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,
 )
@@ -377,6 +378,13 @@ def _make_analog_input_table(self, inputs):
                         acq['units'],
                     )
                 )
+        if acquisitions and 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))
+
         # The 'a256' dtype below limits the string fields to 256
         # characters. Can't imagine this would be an issue, but to not
         # specify the string length (using dtype=str) causes the strings
@@ -396,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 = {}
@@ -430,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:

PulseBlaster.py

@@ -16,8 +16,23 @@
     str = unicode
 
 from labscript_devices import BLACS_tab, runviewer_parser
+from labscript_utils import dedent
 
-from labscript import Device, PseudoclockDevice, Pseudoclock, ClockLine, IntermediateDevice, DigitalQuantity, DigitalOut, DDS, DDSQuantity, config, LabscriptError, set_passed_properties
+from labscript import (
+    Device,
+    PseudoclockDevice,
+    Pseudoclock,
+    ClockLine,
+    IntermediateDevice,
+    DigitalQuantity,
+    DigitalOut,
+    DDS,
+    DDSQuantity,
+    config,
+    LabscriptError,
+    set_passed_properties,
+    compiler,
+)
 
 import numpy as np
 
@@ -603,14 +618,30 @@ def write_pb_inst_to_h5(self, pb_inst, hdf5_file):
         group.create_dataset('PULSE_PROGRAM', compression=config.compression,data = pb_inst_table)   
         self.set_property('stop_time', self.stop_time, location='device_properties')
 
-        
+
+    def _check_wait_monitor_ok(self):
+        if (
+            compiler.master_pseudoclock is self
+            and compiler.wait_table
+            and compiler.wait_monitor is None
+            and self.programming_scheme != 'pb_stop_programming/STOP'
+        ):
+            msg = """If using waits without a wait monitor, the PulseBlaster used as a
+                master pseudoclock must have
+                programming_scheme='pb_stop_programming/STOP'. Otherwise there is no way
+                for BLACS to distinguish between a wait, and the end of a shot. Either
+                use a wait monitor (see labscript.WaitMonitor for details) or set
+                programming_scheme='pb_stop_programming/STOP for %s."""
+            raise LabscriptError(dedent(msg) % self.name)
+
     def generate_code(self, hdf5_file):
         # Generate the hardware instructions
-        hdf5_file.create_group('/devices/'+self.name)
+        hdf5_file.create_group('/devices/' + self.name)
         PseudoclockDevice.generate_code(self, hdf5_file)
         dig_outputs, dds_outputs = self.get_direct_outputs()
         freqs, amps, phases = self.generate_registers(hdf5_file, dds_outputs)
         pb_inst = self.convert_to_pb_inst(dig_outputs, dds_outputs, freqs, amps, phases)
+        self._check_wait_monitor_ok()
         self.write_pb_inst_to_h5(pb_inst, hdf5_file)
 
 
@@ -1042,10 +1073,17 @@ def transition_to_buffered(self,device_name,h5file,initial_values,fresh):
             else:
                 raise ValueError('invalid programming_scheme %s'%str(self.programming_scheme))
 
-            # Are there waits in use in this experiment? The monitor waiting for the end of
-            # the experiment will need to know:
-            self.waits_pending =  bool(len(hdf5_file['waits']))
-            
+            # Are there waits in use in this experiment? The monitor waiting for the end
+            # of the experiment will need to know:
+            wait_monitor_exists = bool(hdf5_file['waits'].attrs['wait_monitor_acquisition_device'])
+            waits_in_use = bool(len(hdf5_file['waits']))
+            self.waits_pending = wait_monitor_exists and waits_in_use
+            if waits_in_use and not wait_monitor_exists:
+                # This should be caught during labscript compilation, but just in case.
+                # Having waits but not a wait monitor means we can't tell when the shot
+                # is over unless the shot ends in a STOP instruction:
+                assert self.programming_scheme == 'pb_stop_programming/STOP'
+
             # Now we build a dictionary of the final state to send back to the GUI:
             return_values = {'dds 0':{'freq':finalfreq0, 'amp':finalamp0, 'phase':finalphase0, 'gate':en0},
                              'dds 1':{'freq':finalfreq1, 'amp':finalamp1, 'phase':finalphase1, 'gate':en1},
@@ -1077,7 +1115,7 @@ def transition_to_manual(self):
         if self.programming_scheme == 'pb_start/BRANCH':
             done_condition = status['waiting']
         elif self.programming_scheme == 'pb_stop_programming/STOP':
-            done_condition = True # status['stopped']
+            done_condition = status['stopped']
 
         if time_based_shot_over is not None:
             done_condition = time_based_shot_over

PulseBlaster_No_DDS.py

@@ -54,6 +54,7 @@ def generate_code(self, hdf5_file):
         PseudoclockDevice.generate_code(self, hdf5_file)
         dig_outputs, ignore = self.get_direct_outputs()
         pb_inst = self.convert_to_pb_inst(dig_outputs, [], {}, {}, {})
+        self._check_wait_monitor_ok()
         self.write_pb_inst_to_h5(pb_inst, hdf5_file) 
 
 
@@ -403,9 +404,16 @@ def transition_to_buffered(self,device_name,h5file,initial_values,fresh):
             else:
                 raise ValueError('invalid programming_scheme %s'%str(self.programming_scheme))
 
-            # Are there waits in use in this experiment? The monitor waiting for the end of
-            # the experiment will need to know:
-            self.waits_pending =  bool(len(hdf5_file['waits']))
+            # Are there waits in use in this experiment? The monitor waiting for the end
+            # of the experiment will need to know:
+            wait_monitor_exists = bool(hdf5_file['waits'].attrs['wait_monitor_acquisition_device'])
+            waits_in_use = bool(len(hdf5_file['waits']))
+            self.waits_pending = wait_monitor_exists and waits_in_use
+            if waits_in_use and not wait_monitor_exists:
+                # This should be caught during labscript compilation, but just in case.
+                # having waits but not a wait monitor means we can't tell when the shot
+                # is over unless the shot ends in a STOP instruction:
+                assert self.programming_scheme == 'pb_stop_programming/STOP'
 
             # Now we build a dictionary of the final state to send back to the GUI:
             return_values = {}
@@ -436,7 +444,7 @@ def transition_to_manual(self):
         if self.programming_scheme == 'pb_start/BRANCH':
             done_condition = status['waiting']
         elif self.programming_scheme == 'pb_stop_programming/STOP':
-            done_condition = True # status['stopped']
+            done_condition = status['stopped']
 
         if time_based_shot_over is not None:
             done_condition = time_based_shot_over