Inheritance diagram for microscope.controllers.zaber.ZaberDaisyChain:

Public Member Functions
None	__init__ (self, str port, typing.Mapping[int, ZaberDeviceType] address2type, **kwargs)

typing.Dict[str, microscope.abc.Device]	devices (self)

typing.Mapping[str, Device]	devices (self)

Public Member Functions inherited from microscope.abc.Device
None	__init__ (self)

None	__del__ (self)

bool	get_is_enabled (self)

None	disable (self)

None	enable (self)

None	initialize (self)

None	shutdown (self)

None	add_setting (self, name, dtype, get_func, set_func, values, typing.Optional[typing.Callable[[], bool]] readonly=None)

def	get_setting (self, str name)

def	get_all_settings (self)

None	set_setting (self, str name, value)

def	describe_setting (self, str name)

def	describe_settings (self)

def	update_settings (self, incoming, bool init=False)

Additional Inherited Members
Public Attributes inherited from microscope.abc.Device
	enabled

Detailed Description

A daisy chain of Zaber devices.

Args:
    port: the port name to connect to.  For example, `COM1`,
        `/dev/ttyUSB0`, or `/dev/cuad1`.
    address2type: a map of device addresses to the corresponding
        :class:`ZaberDeviceType`.

Zaber devices can be daisy-chained, i.e., a set of Zaber devices
can be connected in a sequence so that each device is only wired
to the previous and next device in the sequence, and only the
first device in the sequence is connected to the computer.  Even
if there is only Zaber device, this is modelled as a one element
daisy-chain.  If there are multiple devices, all connected
directly to the computer, i.e., not chained, then each device is
its own one-element daisy-chain.

.. code-block:: python

    from microscope.controllers.zaber import ZaberDaisyChain, ZaberDeviceType
    zaber = ZaberDaisyChain("/dev/ttyUSB0",
                            {2: ZaberDeviceType.STAGE,
                             3: ZaberDeviceType.LED_CONTROLLER,
                             4: ZaberDeviceType.FILTER_WHEEL})

    # Device names are strings, not int.
    filterwheel = zaber.devices['4']

    # LEDs are not devices of the zaber daisy chain, they are
    # devices of the LED controller.
    led_controller = zaber.devices['3']
    led1 = led_controller.devices['LED1']

    # Stage axis names are the string of the axis number.
    xy_stage = zaber.devices['2']
    motor1 = xy_stage.axes['1']

Each device on a chain is identified by a device address which is
an integer between 1 and 99.  By default, the addresses start at 1
and are sorted by distance to the computer, but this can be
changed.

For an LED controller device, the names of its devices are "LED1",
"LED2", etc, the same as the labels on the LED controller itself.

Because there is no method to correctly guess a device type, a map
of device addresses to device types is required.

.. note::

   Zaber devices need to be homed before they can be moved.  A
   stage will be homed during `enable` but a filter wheel will be
   homed during the object construction.

Definition at line 531 of file zaber.py.

Constructor & Destructor Documentation

◆ init()

None microscope.controllers.zaber.ZaberDaisyChain.__init__	(		self,
		str	port,
		typing.Mapping[int, ZaberDeviceType]	address2type,
		**	kwargs
	)

Reimplemented from microscope.abc.Device.

Definition at line 588 of file zaber.py.

    ) -> None:
        super().__init__(**kwargs)
        self._conn = _ZaberConnection(port, baudrate=115200, timeout=0.5)
        self._devices: typing.Dict[str, microscope.abc.Device] = {}
 
        for address, device_type in address2type.items():
            if address < 1 or address > 99:
                raise ValueError("address must be an integer between 1-99")
            dev_cls = device_type.value
            self._devices[str(address)] = dev_cls(self._conn, address)
 