NI-DAQmx-wait-changes: Bugfixes. Error checking for DAQmx analog input was in the wrong function

instead denying analog *output*. Fixed that.

PulseBlasters were unable to detect the end of a shot without a wait monitor.
Now they can, but only if they have programming_scheme='pb_stop_programming/STOP'.
Otherwise the WAIT instruction at the end of a shot(used when
programming_scheme='pb_start()/BRANCH') cannot be distinguished from a
intra-shot wait, and so there is no way to detect end-of-shot.

Author: RbChip

NI_DAQmx/labscript_devices.py

@@ -320,12 +320,6 @@ 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]
@@ -384,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

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