zaberstage: Remote value check, and docstrings for labscript_devices classes.

Author: chrisjbillington

ZaberStageController/blacs_tabs.py

@@ -38,8 +38,9 @@ def initialise_GUI(self):
                 'step': self.base_step,
                 'decimals': self.base_decimals,
             }
-        # Sort by stage number:
+        # Sort by device number:
         ao_prop = {c: ao_prop[c] for c in sorted(ao_prop, key=get_device_number)}
+        self.child_connections = list(ao_prop.keys())
         # Create the output objects
         self.create_analog_outputs(ao_prop)
         # Create widgets for output objects
@@ -48,14 +49,18 @@ def initialise_GUI(self):
         self.auto_place_widgets(("Zaber Stages", ao_widgets))
 
         # Set the capabilities of this device
-        self.supports_remote_value_check(False) # TODO: Implement
-        self.supports_smart_programming(False) #TODO: Implement
+        self.supports_remote_value_check(True)
+        self.supports_smart_programming(False) #TODO: Implement?
 
     def initialise_workers(self):
         # Create and set the primary worker
         self.create_worker(
             "main_worker",
             "labscript_devices.ZaberStageController.blacs_workers.ZaberWorker",
-            {'com_port': self.com_port, 'mock': self.mock},
+            {
+                'com_port': self.com_port,
+                'mock': self.mock,
+                'child_connections': self.child_connections,
+            },
         )
         self.primary_worker = "main_worker"

ZaberStageController/blacs_workers.py

@@ -18,19 +18,27 @@
 
 from .utils import get_device_number
 
+
+zaber = None
+
+TIMEOUT = 60
+
+
 class MockZaberInterface(object):
-    def __init__(self, port):
-        pass
+    def __init__(self, com_port):
+        from collections import defaultdict
+        self.positions = defaultdict(int)
+
+    def move(self, device_number, position):
+        print(f"Mock move device {device_number} to position {position}")
+        self.positions[device_number] = position
 
-    def move(self, stage_number, position):
-        print(f"Mock move stage {stage_number} to position {position}")
+    def get_position(self, device_number):
+        return self.positions[device_number]
 
     def close(self):
         print(f"mock close")
 
-zaber = None
-
-TIMEOUT = 60
 
 class ZaberInterface(object):
     def __init__(self, com_port):
@@ -44,33 +52,42 @@ def __init__(self, com_port):
 
         self.port = zaber.BinarySerial(com_port)
 
-    def move(self, stage_number, position):
-        device = zaber.BinaryDevice(self.port, stage_number)
+    def move(self, device_number, position):
+        device = zaber.BinaryDevice(self.port, device_number)
         device.move_abs(position)
         deadline = monotonic() + TIMEOUT
         while device.get_position() != position:
             if monotonic() > deadline:
                 msg = "Device did not move to requested position within timeout"
                 raise TimeoutError(msg)
 
+    def get_position(self, device_number):
+        device = zaber.BinaryDevice(self.port, device_number)
+        return device.get_position()
+
     def close(self):
         self.port.close()
 
+
 class ZaberWorker(Worker):
     def init(self):
         if self.mock:
             self.controller = MockZaberInterface(self.com_port)
         else:
             self.controller = ZaberInterface(self.com_port)
 
+    def check_remote_values(self):
+        remote_values = {} 
+        for connection in self.child_connections:
+            device_number = get_device_number(connection)
+            remote_values[connection] = self.controller.get_position(device_number)
+        return remote_values
+
     def program_manual(self, values):
         for connection, value in values.items():
-            stage_number = get_device_number(connection)
-            self.controller.move(stage_number, int(round(value)))
-        #TODO: return actual position of the zaber stage. Are they readable? Check API
-        return values
-
-    # TODO: home stage function?
+            device_number = get_device_number(connection)
+            self.controller.move(device_number, int(round(value)))
+        return self.check_remote_values()
 
     def transition_to_buffered(self, device_name, h5file, initial_values, fresh):
         with h5py.File(h5file) as hdf5_file:
@@ -80,7 +97,6 @@ def transition_to_buffered(self, device_name, h5file, initial_values, fresh):
                 values = {name: data[0][name] for name in data.dtype.names}
             else:
                 values = {}
-
         return self.program_manual(values)
 
     def transition_to_manual(self):

ZaberStageController/labscript_devices.py

@@ -17,12 +17,36 @@
 
 # Base class for stages:
 class ZaberStage(StaticAnalogQuantity):
-    limits = (-np.inf, np.inf)
+    limits = (0, np.inf)
     description = "Zaber Stage"
     @set_passed_properties(
         property_names={"connection_table_properties": ["limits"]}
     )
     def __init__(self, *args, limits=None, **kwargs):
+        """Static Analog output device for controlling the position of a Zaber stage.
+        Can be added as a child device of `ZaberStageController`. Subclasses for
+        specific models already have model-specific limits set for their values, but you
+        may further restrict these by setting the keyword argument limits=
+
+        Args:
+            *args:
+                Arguments to be passed to the  `__init__` method of the parent class
+                (StaticAnalogQuantity).
+
+            limits (tuple), default `None`
+                a two-tuple (min, max) for the minimum and maximum allowed positions, in
+                steps, that the device may be instructed to move to via a labscript
+                experiment or the BLACS front panel. If None, the limits set as a class
+                attribute will be used, which are set to the maximal positions allowed
+                by the device if using one of the model-specific subclasses defined in
+                this module, or is (0, inf) otherwise.
+
+            **kwargs:
+                Further keyword arguments to be passed to the `__init__` method of the
+                parent class (StaticAnalogQuantity).
+
+        """
+
         if limits is None:
             limits = self.limits
         StaticAnalogQuantity.__init__(self, *args, limits=limits, **kwargs)
@@ -47,13 +71,33 @@ class ZaberStageTLS28M(ZaberStage):
 
 class ZaberStageController(IntermediateDevice):
     allowed_children = [ZaberStage]
-    generation = 0
 
     @set_passed_properties(
         property_names={"connection_table_properties": ["com_port", "mock"]}
     )
-    def __init__(self, name, com_port="", mock=False):
-        IntermediateDevice.__init__(self, name, None)
+    def __init__(self, name, com_port="COM1", mock=False, **kwargs):
+        """Device for controlling a number of Zaber stages connected to a serial port.
+        Add stages as child devices, either by using one of them model-specific classes
+        in this module, or the generic `ZaberStage` class.
+
+        Args:
+            name (str)
+                device name
+
+            com_port (str), default: `'COM1'`
+                Serial port for communication, i.e. `'COM1' etc on Windows or
+                `'/dev/USBtty0'` or similar on unix.
+
+            mock (bool, optional), default: False
+                For testing purpses, simulate a device instead of communicating with
+                actual hardware.
+
+            **kwargs: Further keyword arguments to be passed to the `__init__` method of
+                the parent class (IntermediateDevice).
+
+        """
+
+        IntermediateDevice.__init__(self, name, None, **kwargs)
         self.BLACS_connection = com_port
 
     def add_device(self, device):

ZaberStageController/testing/test.py

@@ -5,15 +5,14 @@
 # labscript_init('test.h5', new=True, overwrite=True)
 
 from labscript_devices.ZaberStageController.labscript_devices import (
-    ZaberStageTLS28M,
+    ZaberStage,
     ZaberStageController,
 )
 from labscript import start, stop
 
 DummyPseudoclock()
 ZaberStageController('controller', com_port='COM1', mock=MOCK)
-ZaberStageTLS28M('stage', controller, 'stage 1', limits=(0, 30000))
-# ZaberStageTLS28M('stage2', controller, 'stage 2')
+ZaberStage('stage', controller, 'device 1', limits=(0, 30000))
 
 start()