microeye 2.3.2__py3-none-any.whl

microEye/hardware/stages/elliptec/ellDevices.py

@@ -0,0 +1,134 @@
+from typing import Optional
+
+from microEye.hardware.stages.elliptec.baseDevice import BaseDevice
+from microEye.hardware.stages.elliptec.device import SHUTTER_POSITION_FACTOR, EllDevice
+from microEye.hardware.stages.elliptec.deviceID import DeviceID
+from microEye.hardware.stages.elliptec.devicePort import DevicePort, ELLException
+from microEye.hardware.stages.elliptec.messageUpdater import MessageUpdater
+from microEye.qt import QtCore
+
+
+class ELLDevices(QtCore.QObject):
+    def __init__(self):
+        super().__init__()
+        self._selected_device: Optional[EllDevice] = None
+        self._devices: dict[str, EllDevice] = {}
+        self._message_updater = MessageUpdater()
+
+    @property
+    def IsOpen(self) -> bool:
+        return DevicePort.isOpen()
+
+    def SendFreeCommand(self, free_command: str) -> bool:
+        self._message_updater.update_output('Sending free command...')
+        DevicePort.sendFreeString(free_command)
+        return True
+
+    def scanAddresses(
+        self, min_device_address: str, max_device_address: str
+    ) -> list[str]:
+        connections = []
+        if not DevicePort.isOpen():
+            return connections
+
+        self._message_updater.update_output('Scanning for devices')
+        for address in [
+            a
+            for a in BaseDevice.VALID_ADDRESSES
+            if min_device_address <= a <= max_device_address
+        ]:
+            DevicePort.send_command(address, 'in')
+            try:
+                msg = DevicePort.wait_for_response(
+                    address, 'IN', BaseDevice.STATUS_TIMEOUT
+                )
+                if msg:
+                    connections.append(msg)
+            except ELLException as e:
+                DevicePort.instance().logger.error(f'Error in scanAddresses: {str(e)}')
+                DevicePort.instance().errorOccurred.emit(str(e))
+                # device address not used
+
+        count = len(connections)
+        self._message_updater.update_output(
+            f"{count} device{'s' if count != 1 else ''} found"
+        )
+        return connections
+
+    def ClearDevices(self):
+        self._devices.clear()
+
+    def configure(self, device_id: str) -> bool:
+        if not device_id:
+            return False
+
+        address = device_id[0]
+        if address in BaseDevice.VALID_ADDRESSES:
+            di = BaseDevice.configure(device_id, self._message_updater)
+            if di.DeviceType == DeviceID.DeviceTypes.Paddle:
+                return False
+                # self._devices[address] = ELLPaddlePolariser(di, self._message_updater)
+            elif di.DeviceType == DeviceID.DeviceTypes.Actuator:
+                self._devices[address] = EllDevice(di, 1, self._message_updater)
+            else:
+                self._devices[address] = EllDevice(di, 2, self._message_updater)
+            self._selected_device = self._devices[address]
+        return True
+
+    @property
+    def SelectedDevice(self):
+        return self._selected_device
+
+    def ReaddressDevice(self, old_address: str, new_address: str) -> bool:
+        device = self.addressedDevice(old_address)
+        if not device:
+            return False
+        if not device.set_address(new_address):
+            return False
+        self._devices[new_address] = self._devices.pop(old_address)
+        return True
+
+    def addressedDevice(self, address: str):
+        return self._devices.get(address)
+
+    def ValidAddresses(self, addresses: list[str]) -> list[str]:
+        return [addr for addr in addresses if addr in self._devices]
+
+    @property
+    def MessageUpdates(self) -> MessageUpdater:
+        return self._message_updater
+
+    def open(self) -> bool:
+        DevicePort.open()
+
+    def close(self) -> bool:
+        DevicePort.close()
+
+    def baudrate(self) -> int:
+        return DevicePort.baudRate()
+
+    def set_baudrate(self, baudrate: int) -> bool:
+        return DevicePort.setBaudRate(baudrate)
+
+    def portname(self) -> str:
+        return DevicePort.portName()
+
+    def set_portname(self, portname: str) -> bool:
+        return DevicePort.setPortName(portname)
+
+    def get_config(self) -> dict:
+        return {
+            'port': DevicePort.portName(),
+            'baudrate': DevicePort.baudRate(),
+        }
+
+    def load_config(self, config: dict) -> bool:
+        if 'port' in config:
+            self.set_portname(config['port'])
+        if 'baudrate' in config:
+            self.set_baudrate(config['baudrate'])
+        return True
+
+    @property
+    def ValidAddress(self) -> list[str]:
+        return BaseDevice.VALID_ADDRESSES

microEye/hardware/stages/elliptec/messageUpdater.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import Any, Union
+
+from microEye.qt import QtCore, Signal
+
+
+class MessageUpdater(QtCore.QObject):
+    class UpdateTypes(Enum):
+        Status = 1
+        MotorInfo = 2
+        DeviceInfo = 3
+        Position = 4
+        HomeOffset = 5
+        JogstepSize = 6
+        PolarizerPositions = 7
+        PaddlePosition = 8
+
+    outputUpdated = Signal(list, bool)
+    parameterUpdated = Signal(UpdateTypes, str, object)
+
+    def __init__(self):
+        super().__init__()
+
+    def update_output(self, message: Union[str, list[str]], error: bool = False):
+        if isinstance(message, str):
+            message = [message]
+        self.outputUpdated.emit(message, error)
+
+    def update_parameter(self, update_type: UpdateTypes, address: str, data: Any):
+        self.parameterUpdated.emit(update_type, address, data)
+
+    def update_output_with_list(self, message: str, list_data: list[str]):
+        output_list = [message] + list_data
+        self.outputUpdated.emit(output_list, False)

microEye/hardware/stages/elliptec/motorInfo.py

@@ -0,0 +1,153 @@
+import struct
+from enum import Enum
+
+
+class SwitchState(Enum):
+    ON = '1'
+    OFF = '0'
+
+
+class MotorInfoStruct:
+    '''Structure containing stage axis parameters.'''
+
+    FORMAT = 'c2scc4s4s4s4s4s'
+    SIZE = struct.calcsize(FORMAT)
+
+    def __init__(
+        self,
+        address: bytes,
+        command: bytes,
+        loop_state: bytes,
+        motor_state: bytes,
+        current: bytes,
+        ramp_up: bytes,
+        ramp_down: bytes,
+        fwd_period: bytes,
+        rev_period: bytes,
+    ):
+        self.address = address.decode('utf-8')
+        self.command = command.decode('utf-8')
+        self.motor_id = command.decode('utf-8')[1]
+        self.loop_state = SwitchState(loop_state.decode('utf-8'))
+        self.motor_state = SwitchState(motor_state.decode('utf-8'))
+        self.current = int(current, 16) / 1866
+        self.ramp_up = int(ramp_up, 16)
+        self.ramp_down = int(ramp_down, 16)
+        self.fwd_period = int(fwd_period, 16)
+        self.rev_period = int(rev_period, 16)
+
+    @classmethod
+    def from_bytes(cls, data):
+        return cls(*struct.unpack(MotorInfoStruct.FORMAT, data))
+
+class MotorInfo:
+    def __init__(self, motor_id: str = None):
+        self.motor_id = motor_id
+        self.motor_state = SwitchState.OFF
+        self.is_valid = False
+
+        self.loop_state = None
+        self.current = 0.0
+        self.ramp_up = 0
+        self.ramp_down = 0
+        self.fwd_freq = 0
+        self.rev_freq = 0
+
+    @classmethod
+    def from_string(cls, id_string: str):
+        motor_info_struct = MotorInfoStruct.from_bytes(id_string.encode('ascii'))
+        motor_info = cls('')
+        motor_info.motor_id = motor_info_struct.motor_id
+        motor_info.motor_state = motor_info_struct.motor_state
+        motor_info.loop_state = motor_info_struct.loop_state
+        motor_info.current = motor_info_struct.current
+        motor_info.ramp_up = motor_info_struct.ramp_up
+        motor_info.ramp_down = motor_info_struct.ramp_down
+        motor_info.fwd_freq = 14740 / motor_info_struct.fwd_period
+        motor_info.rev_freq = 14740 / motor_info_struct.rev_period
+        motor_info.is_valid = True
+        return motor_info
+
+    @property
+    def is_valid(self) -> bool:
+        return self._is_valid
+
+    @is_valid.setter
+    def is_valid(self, value: bool):
+        self._is_valid = value
+
+    @property
+    def loop_state(self) -> SwitchState:
+        return self._loop_state
+
+    @loop_state.setter
+    def loop_state(self, value: SwitchState):
+        self._loop_state = value
+
+    @property
+    def motor_state(self) -> SwitchState:
+        return self._motor_state
+
+    @motor_state.setter
+    def motor_state(self, value: SwitchState):
+        self._motor_state = value
+
+    @property
+    def current(self) -> float:
+        return self._current
+
+    @current.setter
+    def current(self, value: float):
+        self._current = value
+
+    @property
+    def ramp_up(self) -> int:
+        return self._ramp_up
+
+    @ramp_up.setter
+    def ramp_up(self, value: int):
+        self._ramp_up = value
+
+    @property
+    def ramp_down(self) -> int:
+        return self._ramp_down
+
+    @ramp_down.setter
+    def ramp_down(self, value: int):
+        self._ramp_down = value
+
+    @property
+    def fwd_freq(self) -> float:
+        return self._fwd_freq
+
+    @fwd_freq.setter
+    def fwd_freq(self, value: float):
+        self._fwd_freq = value
+
+    @property
+    def rev_freq(self) -> float:
+        return self._rev_freq
+
+    @rev_freq.setter
+    def rev_freq(self, value: float):
+        self._rev_freq = value
+
+    @property
+    def motor_id(self) -> str:
+        return self._motor_id
+
+    @motor_id.setter
+    def motor_id(self, value: str):
+        self._motor_id = value
+
+    def description(self) -> list:
+        return [
+            f'Motor ID {self.motor_id}',
+            f'Loop State {self.loop_state}',
+            f'Motor State {self.motor_state}',
+            f'Current {self.current:.2f}A',
+            f'Fwd Frequency {self.fwd_freq:.1f}kHz',
+            f'Rev Frequency {self.rev_freq:.1f}kHz',
+            f'RampUp {self.ramp_up}',
+            f'RampDown {self.ramp_down}',
+        ]

microEye/hardware/stages/elliptec/stage.py

@@ -0,0 +1,62 @@
+from enum import Enum
+
+from microEye.qt import QtCore, Signal
+
+
+class ThreadType(Enum):
+    Imperial = 1
+    Metric = 0
+
+class ElliptecStage(QtCore.QObject):
+    positionChanged = Signal(int)
+    '''Signal emitted when position is updated'''
+    statusChanged = Signal(int, str)
+    '''Signal emitted when status is updated'''
+
+    def __init__(self, address: str, **kwargs):
+        super().__init__()
+        self.address = str(address)
+        # self.type = ElliptecType(kwargs.get('Model'))
+        self.serial_number = kwargs.get('Serial_number', 'N/A')
+        self.year = kwargs.get('Year', 'N/A')
+        self.firmware_release = kwargs.get('Firmware_release', 'N/A')
+        self.hardware_release = kwargs.get('Hardware_release', -1)
+        self.thread_type = ThreadType(kwargs.get('Thread_type', 0))
+        self.travel = kwargs.get('Travel', -1)
+        self.pulses_per_mu = kwargs.get('Pulses_per_mu', -1)
+        self._position = 0
+
+        self.last_response = None
+        self.last_status = None
+
+    @property
+    def position(self):
+        return self._position / self.pulses_per_unit()
+
+    @position.setter
+    def position(self, value: int):
+        if isinstance(value, int):
+            self._position = value
+            self.positionChanged.emit(self.position)
+
+    def update_status(self, status_code: int, status_message: str):
+        self.last_status = status_message
+        self.statusChanged.emit(status_code, status_message)
+
+    def pulses_per_unit(self):
+        return self.pulses_per_mu / self.travel
+
+    def __str__(self):
+        return (
+            f'ElliptecStage(address={self.address}, '
+            f'type={self.type.name}, '
+            # f'serial_number={self.serial_number}, '
+            # f'year={self.year}, '
+            # f'firmware_release={self.firmware_release}, '
+            # f'hardware_release={self.hardware_release}, '
+            # f'thread_type={self.thread_type.name}, '
+            # f'travel={self.travel}, '
+            # f'pulses_per_mu={self.pulses_per_mu}, '
+            f'position={self.position / self.pulses_per_unit()}, '
+            f'last_status={self.last_status})'
+        )

microEye/hardware/stages/elliptec/test.py

@@ -0,0 +1,139 @@
+import sys
+import time
+from enum import Enum, auto
+
+from microEye.hardware.stages.elliptec.baseDevice import BaseDevice, DeviceDirection
+from microEye.hardware.stages.elliptec.deviceID import DeviceID
+from microEye.hardware.stages.elliptec.devicePort import DevicePort
+from microEye.hardware.stages.elliptec.ellDevices import ELLDevices
+from microEye.qt import QApplication
+
+
+def data_sent_handler(message: str):
+    print(f'\033[96mTx: {message}\033[0m')  # Cyan color
+
+
+def data_received_handler(message: str):
+    print(f'\033[92mRx: {message}\033[0m')  # Green color
+
+
+def output_update_handler(messages: list[str], error: bool):
+    for message in messages:
+        print(f'\033[93mOutput-> {message}\033[0m')  # Yellow color
+
+
+def main(args: list[str]):
+    # Get the communication port
+    port = args[0] if len(args) > 0 else 'COM3'
+
+    # Get the range of addresses used (max range is '0' to 'F')
+    min_search_limit = (
+        args[1][0].upper()
+        if len(args) > 1 and BaseDevice.is_valid_address(args[1][0].upper())
+        else '0'
+    )
+    max_search_limit = (
+        args[2][0].upper()
+        if len(args) > 2 and BaseDevice.is_valid_address(args[2][0].upper())
+        else '3'
+    )
+
+    # Setup handlers
+    DevicePort.instance().dataSent.connect(data_sent_handler)
+    DevicePort.instance().dataReceived.connect(data_received_handler)
+
+    # Create ELLDevices class to maintain the collection of Elliptec devices
+    ell_devices = ELLDevices()
+    ell_devices.MessageUpdates.outputUpdated.connect(output_update_handler)
+
+    # Attempt to connect to the port
+    if DevicePort.open(port):
+        print('Discover devices')
+        print('================')
+        # Scan the port for connected devices using the given range of addresses
+        devices = ell_devices.scanAddresses(min_search_limit, max_search_limit)
+
+        for device in devices:
+            # Configure each device found
+            if ell_devices.configure(device):
+                # Test each device found
+                print(f'\nIdentify device {device[0]}')
+                print('=================')
+                addressed_device = ell_devices.addressedDevice(device[0])
+
+                if addressed_device:
+                    # Display the device information
+                    device_info = addressed_device.deviceInfo
+                    for info in device_info.description():
+                        print(info)
+
+                    # Test each device according to type
+                    print(f'\nTest device {device[0]}')
+                    print('=============')
+                    if device_info.DeviceType in [
+                        DeviceID.DeviceTypes.Shutter2,
+                        DeviceID.DeviceTypes.Shutter4,
+                    ]:
+                        # Test the shutter device
+                        addressed_device.home(DeviceDirection.Linear)
+                        time.sleep(0.25)
+                        addressed_device.jog_forward()
+                        time.sleep(0.25)
+                        if device_info.DeviceType == DeviceID.DeviceTypes.Shutter4:
+                            addressed_device.jog_forward()
+                            time.sleep(0.25)
+                            addressed_device.jog_forward()
+                            time.sleep(0.25)
+                        addressed_device.jog_backward()
+                        time.sleep(0.25)
+                        if device_info.DeviceType == DeviceID.DeviceTypes.Shutter4:
+                            addressed_device.jog_backward()
+                            time.sleep(0.25)
+                            addressed_device.jog_backward()
+                            time.sleep(0.25)
+                    elif device_info.DeviceType in [
+                        DeviceID.DeviceTypes.LinearStage25mm,
+                        DeviceID.DeviceTypes.LinearStage28mm,
+                        DeviceID.DeviceTypes.LinearStage60mm,
+                        DeviceID.DeviceTypes.LinearStage60mm_10,
+                    ]:
+                        # Test the Linear stage
+                        # For each motor ('1' and '2') get the motor information
+                        for c in ['1', '2']:
+                            if addressed_device.get_motor_info(c):
+                                motor_info = addressed_device._motor_info[c]
+                                for info in motor_info.description():
+                                    print(f'Output-> {info}')
+
+                        # Test the stage movement
+                        addressed_device.home(DeviceDirection.Linear)
+                        time.sleep(0.25)
+                        addressed_device.set_jogstep_size(1.0)
+                        for _ in range(10):
+                            addressed_device.jog_forward()
+                            time.sleep(0.1)
+                    elif device_info.DeviceType in [DeviceID.DeviceTypes.OpticsRotator]:
+                        for c in ['1', '2']:
+                            if addressed_device.get_motor_info(c):
+                                motor_info = addressed_device._motor_info[c]
+                                for info in motor_info.description():
+                                    print(f'Output-> {info}')
+                        # Test the stage movement
+                        addressed_device.home(DeviceDirection.Clockwise)
+                        time.sleep(0.25)
+                        addressed_device.set_jogstep_size(10.0)
+                        for _ in range(10):
+                            addressed_device.jog_forward()
+                            time.sleep(0.1)
+
+        DevicePort.close()
+    else:
+        print(f'\033[91mPort {port} unavailable\033[0m')  # Red color
+
+    print('Press Enter to exit')
+    input()
+
+
+if __name__ == '__main__':
+    app = QApplication([])
+    main(sys.argv[1:])

microEye/hardware/stages/kinesis/__init__.py

@@ -0,0 +1 @@
+from microEye.hardware.stages.kinesis.kinesis import KinesisView, KinesisXY

microEye/hardware/stages/kinesis/kdc101/__init__.py

@@ -0,0 +1 @@
+from microEye.hardware.stages.kinesis.kdc101.kdc101 import KDC101Controller