SoftwareDevice: merge

Author: chrisjbillington

FlyCapture2Camera/blacs_tabs.py

@@ -14,6 +14,10 @@
 from labscript_devices.IMAQdxCamera.blacs_tabs import IMAQdxCameraTab
 
 class FlyCapture2CameraTab(IMAQdxCameraTab):
+    """Thin sub-class of obj:`IMAQdxCameraTab`.
+    
+    This sub-class only defines :obj:`worker_class` to point to the correct
+    :obj:`FlyCapture2CameraWorker`."""
 
     # override worker class
     worker_class = 'labscript_devices.FlyCapture2Camera.blacs_workers.FlyCapture2CameraWorker'

FlyCapture2Camera/blacs_workers.py

@@ -14,5 +14,7 @@
 from labscript_devices.IMAQdxCamera.labscript_devices import IMAQdxCamera
 
 class FlyCapture2Camera(IMAQdxCamera):
+    """Thin sub-class of :obj:`IMAQdxCamera`."""
+    
     description = 'FlyCapture2 Camera'
 

FlyCapture2Camera/labscript_devices.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_tabs.py

@@ -31,6 +31,7 @@
 from PyDAQmx.DAQmxCallBack import *
 
 import numpy as np
+from numpy.lib.recfunctions import structured_to_unstructured
 import labscript_utils.h5_lock
 import h5py
 from zprocess import Event
@@ -196,32 +197,32 @@ def program_buffered_DO(self, DO_table):
                 line_final_value = bool((1 << line) & port_final_value)
                 final_values['%s/line%d' % (port_str, line)] = int(line_final_value)
 
+        # Convert DO table to a regular array and ensure it is C continguous:
+        DO_table = np.ascontiguousarray(
+            structured_to_unstructured(DO_table, dtype=np.uint32)
+        )
+
         # Check if DOs are all zero for the whole shot. If they are this triggers a
         # bug in NI-DAQmx that throws a cryptic error for buffered output. In this
         # case, run it as a non-buffered task.
-        self.DO_all_zero = all(
-            DO_table[port].sum() == 0 for port in DO_table.dtype.names
-        )
+        self.DO_all_zero = not np.any(DO_table)
         if self.DO_all_zero:
             DO_table = DO_table[0:1]
 
         if self.static_DO or self.DO_all_zero:
             # Static DO. Start the task and write data, no timing configuration.
             self.DO_task.StartTask()
-            # Write data for each port:
-            for port_str in ports:
-                # See the comment in self.program_manual as to why we are using uint32
-                # instead of the native size of the port
-                data = DO_table[port_str].astype(np.uint32, order='C')
-                self.DO_task.WriteDigitalU32(
-                    1,  # npts
-                    False,  # autostart
-                    10.0,  # timeout
-                    DAQmx_Val_GroupByChannel,
-                    data,
-                    written,
-                    None,
-                )
+            # Write data. See the comment in self.program_manual as to why we are using
+            # uint32 instead of the native size of each port
+            self.DO_task.WriteDigitalU32(
+                1,  # npts
+                False,  # autostart
+                10.0,  # timeout
+                DAQmx_Val_GroupByScanNumber,
+                DO_table,
+                written,
+                None,
+            )
         else:
             # We use all but the last sample (which is identical to the second last
             # sample) in order to ensure there is one more clock tick than there are
@@ -237,23 +238,18 @@ def program_buffered_DO(self, DO_table):
                 DAQmx_Val_FiniteSamps,
                 npts,
             )
-            self.DO_task.CfgOutputBuffer(npts)
-
-            # Write data for each port:
-            for port_str in ports:
-                # Use all but the last sample as mentioned above. See the comment in
-                # self.program_manual as to why we are using uint32 instead of the native
-                # size of the port.
-                data = DO_table[port_str][:-1].astype(np.uint32, order='C')
-                self.DO_task.WriteDigitalU32(
-                    npts,
-                    False,  # autostart
-                    10.0,  # timeout
-                    DAQmx_Val_GroupByChannel,
-                    data,
-                    written,
-                    None,
-                )
+
+            # Write data. See the comment in self.program_manual as to why we are using
+            # uint32 instead of the native size of each port.
+            self.DO_task.WriteDigitalU32(
+                npts,
+                False,  # autostart
+                10.0,  # timeout
+                DAQmx_Val_GroupByScanNumber,
+                DO_table[:-1], # All but the last sample as mentioned above
+                written,
+                None,
+            )
 
             # Go!
             self.DO_task.StartTask()
@@ -273,15 +269,15 @@ def program_buffered_AO(self, AO_table):
         # Collect the final values of the analog outs:
         final_values = dict(zip(AO_table.dtype.names, AO_table[-1]))
 
-        # Obtain a view that is a regular array:
-        AO_table = AO_table.view((AO_table.dtype[0], len(AO_table.dtype.names)))
-        # And convert to 64 bit floats:
-        AO_table = AO_table.astype(np.float64)
+        # Convert AO table to a regular array and ensure it is C continguous:
+        AO_table = np.ascontiguousarray(
+            structured_to_unstructured(AO_table, dtype=np.float64)
+        )
 
         # Check if AOs are all zero for the whole shot. If they are this triggers a
         # bug in NI-DAQmx that throws a cryptic error for buffered output. In this
         # case, run it as a non-buffered task.
-        self.AO_all_zero = all(AO_table.flatten() == 0)
+        self.AO_all_zero = not np.any(AO_table)
         if self.AO_all_zero:
             AO_table = AO_table[0:1]
 
@@ -763,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.
@@ -819,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
@@ -853,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/blacs_workers.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,51 @@ 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."""
+        if compiler.wait_monitor is None:
+            return
+        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 +483,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:

NI_DAQmx/labscript_devices.py

@@ -0,0 +1,64 @@
+#####################################################################
+#                                                                   #
+# /NI_DAQmx/models/_subclass_template.py                            #
+#                                                                   #
+# Copyright 2018, Christopher Billington                            #
+#                                                                   #
+# This file is part of the module labscript_devices, in the         #
+# labscript suite (see http://labscriptsuite.org), and is           #
+# licensed under the Simplified BSD License. See the license.txt    #
+# file in the root of the project for the full license.             #
+#                                                                   #
+#####################################################################
+
+#####################################################################
+#     WARNING                                                       #
+#                                                                   #
+# This file is auto-generated, any modifications may be             #
+# overwritten. See README.txt in this folder for details            #
+#                                                                   #
+#####################################################################
+
+
+from __future__ import division, unicode_literals, print_function, absolute_import
+from labscript_utils import PY2
+
+if PY2:
+    str = unicode
+
+from labscript_devices.NI_DAQmx.labscript_devices import NI_DAQmx
+
+CAPABILITIES = {
+    'AI_range': None,
+    'AI_start_delay': None,
+    'AO_range': None,
+    'max_AI_multi_chan_rate': None,
+    'max_AI_single_chan_rate': None,
+    'max_AO_sample_rate': None,
+    'max_DO_sample_rate': 20000000.0,
+    'min_semiperiod_measurement': None,
+    'num_AI': 0,
+    'num_AO': 0,
+    'num_CI': 0,
+    'ports': {
+        'port0': {'num_lines': 8, 'supports_buffered': True},
+        'port1': {'num_lines': 8, 'supports_buffered': True},
+        'port2': {'num_lines': 8, 'supports_buffered': True},
+        'port3': {'num_lines': 8, 'supports_buffered': True},
+        'port4': {'num_lines': 0, 'supports_buffered': False},
+        'port5': {'num_lines': 4, 'supports_buffered': False},
+    },
+    'supports_buffered_AO': False,
+    'supports_buffered_DO': True,
+    'supports_semiperiod_measurement': False,
+}
+
+
+class NI_PCI_DIO_32HS(NI_DAQmx):
+    description = 'NI-PCI-DIO-32HS'
+
+    def __init__(self, *args, **kwargs):
+        # Any provided kwargs take precedent over capabilities
+        combined_kwargs = CAPABILITIES.copy()
+        combined_kwargs.update(kwargs)
+        NI_DAQmx.__init__(self, *args, **combined_kwargs)