microeye 2.3.2__py3-none-any.whl

microEye/hardware/stages/elliptec/deviceID.py

@@ -0,0 +1,212 @@
+import struct
+from enum import Enum
+
+
+class DeviceID:
+    class DeviceTypes(Enum):
+        '''Values that represent Elliptec Device Types.'''
+
+        Paddle = 3
+        '''OBSOLETE (ELL3)'''
+        Rotator = 4
+        '''OBSOLETE (ELL4)'''
+        Actuator = 5
+        '''OBSOLETE (ELL5)'''
+        Shutter2 = 6
+        '''An Elliptec Shutter/Slider SM1 x 2 (ELL6).'''
+        LinearStage25mm = 7
+        '''OBSOLETE: An Elliptec Linear Stage (ELL7).'''
+        RotaryStage8 = 8
+        '''OBSOLETE: An Elliptec Rotary Stage (ELL8).'''
+        Shutter4 = 9
+        '''An Elliptec Shutter/Slider SM1 x 4 (ELL9).'''
+        LinearStage60mm_10 = 10
+        '''OBSOLETE: An Elliptec Linear Stage (ELL10).'''
+        Shutter6 = 12
+        '''An Elliptec Shutter/Slider SM05 x 6 (ELL12).'''
+        OpticsRotator = 14
+        '''An Elliptec Optics Rotator (ELL14).'''
+        MotorizedIris = 15
+        '''An Elliptec Motorized Iris (ELL15).'''
+        LinearStage28mm = 17
+        '''An Elliptec 28mm Linear Stage (ELL17).'''
+        RotaryStage18 = 18
+        '''An Elliptec Rotary Stage (ELL18).'''
+        LinearStage60mm = 20
+        '''An Elliptec 60mm Linear Stage (ELL20).'''
+
+        @property
+        def string_value(self):
+            values = {
+                3: 'Paddle (OBSOLETE)',
+                4: 'Rotator (OBSOLETE)',
+                5: 'Actuator (OBSOLETE)',
+                6: 'Slider SM1 x 2',
+                7: 'Linear Stage 25mm (OBSOLETE)',
+                8: 'Rotary Stage (OBSOLETE)',
+                9: 'Slider SM1 x 4',
+                10: 'Linear Stage 60mm (OBSOLETE)',
+                12: 'Slider SM05 x 6',
+                14: 'Optics Rotator',
+                15: 'Motorized Iris',
+                17: 'Linear Stage 28mm',
+                18: 'Rotary Stage',
+                20: 'Linear Stage 60mm',
+            }
+            return values[self.value]
+
+    class UnitTypes(Enum):
+        '''Values that represent units in the Elliptec devices.'''
+
+        MM = 'mm'
+        '''An enum constant representing the millimetres option.'''
+        Inches = 'in'
+        '''An enum constant representing the inches option.'''
+        Degrees = 'deg'
+        '''An enum constant representing the degrees option.'''
+
+    def __init__(self, id_string=None):
+        self._unit_factor = 0
+        self._unit_type = None
+        self.FormatStr = ''
+        self.Units = ''
+
+        if id_string:
+            self._deserialize(id_string)
+
+    def _deserialize(self, id_string):
+        device_info_format = 'c2s2s8s4s2s2s4s8s'
+        device_info = struct.unpack(device_info_format, id_string.encode())
+
+        self.Address = device_info[0].decode()
+        self.SerialNo = device_info[3].decode()
+        self.Year = int(device_info[4])
+        self.Firmware = float('.'.join(device_info[5].decode()))
+        hw = int(device_info[6], 16)
+        self.Hardware = hw & 0x7F
+        self.Imperial = bool((hw >> 7) & 1)
+        self.Travel = int(device_info[7], 16)
+        self.PulsePerPosition = int(device_info[8], 16)
+        self.DeviceType = DeviceID.DeviceTypes(int(device_info[2], 16))
+
+        self._set_motor_count()
+        self._set_unit_info()
+
+    def _set_motor_count(self):
+        device_type = self.DeviceType
+        if device_type in {
+            DeviceID.DeviceTypes.Shutter2,
+            DeviceID.DeviceTypes.Actuator,
+        }:
+            self.MotorCount = 1
+        elif device_type in {
+            DeviceID.DeviceTypes.Shutter4,
+            DeviceID.DeviceTypes.Shutter6,
+            DeviceID.DeviceTypes.Rotator,
+            DeviceID.DeviceTypes.RotaryStage8,
+            DeviceID.DeviceTypes.LinearStage25mm,
+            DeviceID.DeviceTypes.LinearStage28mm,
+            DeviceID.DeviceTypes.OpticsRotator,
+            DeviceID.DeviceTypes.MotorizedIris,
+            DeviceID.DeviceTypes.RotaryStage18,
+            DeviceID.DeviceTypes.LinearStage60mm_10,
+            DeviceID.DeviceTypes.LinearStage60mm,
+        }:
+            self.MotorCount = 2
+        elif device_type == DeviceID.DeviceTypes.Paddle:
+            self.MotorCount = 3
+        else:
+            self.MotorCount = 1
+
+    def _set_unit_info(self):
+        device_type = self.DeviceType
+        if device_type == DeviceID.DeviceTypes.Paddle:
+            self._unit_factor = (self.PulsePerPosition - 1) / self.Travel
+            self._unit_type = DeviceID.UnitTypes.Degrees
+            self.FormatStr = '{:.3f}'
+        elif device_type in {
+            DeviceID.DeviceTypes.Rotator,
+            DeviceID.DeviceTypes.OpticsRotator,
+            DeviceID.DeviceTypes.RotaryStage8,
+            DeviceID.DeviceTypes.RotaryStage18,
+        }:
+            self._unit_factor = self.PulsePerPosition / 360.0
+            self._unit_type = DeviceID.UnitTypes.Degrees
+            self.FormatStr = '{:.3f}'
+        elif device_type == DeviceID.DeviceTypes.MotorizedIris:
+            if self.Imperial:
+                self.Travel = self._micron_to_mm(self.Travel)
+                self._unit_type = DeviceID.UnitTypes.Inches
+                self._unit_factor = 25.4 * self.PulsePerPosition
+                self.FormatStr = '{:.4f}'
+            else:
+                self.Travel = self._micron_to_mm(self.Travel)
+                self._unit_type = DeviceID.UnitTypes.MM
+                self._unit_factor = self.PulsePerPosition
+                self.FormatStr = '{:.2f}'
+        else:
+            if self.Imperial:
+                self._unit_type = DeviceID.UnitTypes.Inches
+                self._unit_factor = 25.4 * self.PulsePerPosition
+                self.FormatStr = '{:.4f}'
+            else:
+                self._unit_type = DeviceID.UnitTypes.MM
+                self._unit_factor = self.PulsePerPosition
+                self.FormatStr = '{:.3f}'
+
+        self.Units = self._unit_type.value
+
+    def pulse_to_unit(self, pulses):
+        if self._unit_factor == 0:
+            return pulses
+        return pulses / self._unit_factor
+
+    def unit_to_pulse(self, units):
+        if self._unit_factor == 0:
+            return int(units)
+        return int(round(units * self._unit_factor))
+
+    def _micron_to_mm(self, micron):
+        return micron / 1000.0
+
+    def format_position(self, position, show_units=False, show_space=False):
+        output = self.FormatStr.format(position)
+        if show_units:
+            if show_space:
+                output += ' '
+            output += self.Units
+        return output
+
+    def format_specific_position(
+        self, position, decimals, show_units=False, show_space=False
+    ):
+        format_str = '{:.' + str(decimals) + 'f}'
+        output = format_str.format(position)
+        if show_units:
+            if show_space:
+                output += ' '
+            output += self.Units
+        return output
+
+    def description(self):
+        desc = [
+            f'Address: {self.Address}',
+            f'Serial Number: {self.SerialNo}',
+            f'Device Type: {self.DeviceType.name}',
+            f'Motors: {self.MotorCount}',
+            f'Firmware: {self.Firmware}',
+            f'Hardware: {self.Hardware}',
+            f"Variant: {'Imperial' if self.Imperial else 'Metric'}",
+            f'Year: {self.Year}',
+        ]
+        if self._unit_type == DeviceID.UnitTypes.MM:
+            desc.append(f'Travel: {self.Travel} {self.Units}')
+            desc.append(f'Pulses Per {self.Units}: {self.unit_to_pulse(1.0)}')
+        elif self._unit_type == DeviceID.UnitTypes.Inches:
+            desc.append(f'Travel: {self._micron_to_mm(self.Travel):.3f} {self.Units}')
+            desc.append(f'Pulses Per {self.Units}: {self.unit_to_pulse(1.0)}')
+        elif self._unit_type == DeviceID.UnitTypes.Degrees:
+            desc.append(f'Travel: {self.Travel} {self.Units}')
+            desc.append(f'Pulses Per {self.Units}: {self.unit_to_pulse(1.0)}')
+
+        return desc

microEye/hardware/stages/elliptec/devicePort.py

@@ -0,0 +1,379 @@
+import logging
+import struct
+from collections import deque
+from datetime import datetime
+from typing import Optional, Union
+
+from microEye.qt import QDateTime, QtCore, QtSerialPort, Signal
+
+
+class ELLException(Exception):
+    pass
+
+
+class DevicePort(QtCore.QObject):
+    _instance = None
+    '''Class variable to hold the single instance'''
+    _responses: Optional[deque[str]] = None
+    '''Class variable to hold the responses'''
+
+    dataSent = Signal(str)
+    '''Signal emitted when data is sent'''
+    dataReceived = Signal(str)
+    '''Signal emitted when data is received'''
+    logUpdated = Signal(str)
+    '''Signal to notify when the TX/RX log is updated'''
+    errorOccurred = Signal(str)
+    '''Signal for error reporting'''
+
+    COMMAND_RESPONSE_LENGTHS = {
+        'GS': 5,  # Example: GetStatus command
+        'PO': 11,  # Example: Position command
+        'IN': 33,  # Example: Identify command
+        'BS': 5,  # Button status
+        'BO': 11,  # Button position
+        'I1': 25,
+        'I2': 25,
+        'I3': 25,
+        'HO': 11,
+        'GJ': 11,
+        'GV': 5,
+        'C1': 525,
+        'C2': 525,
+        # Add more commands as needed
+    }
+    '''A dictionary mapping commands to their expected response lengths'''
+
+    @classmethod
+    def instance(cls, port_name='COM1', baud_rate=9600, max_log_entries=1000):
+        '''Class method to get the singleton instance'''
+        if cls._instance is None:
+            cls._instance = cls(port_name, baud_rate, max_log_entries)
+        return cls._instance
+
+    def __init__(self, port_name='COM1', baud_rate=9600, max_entries=1000):
+        """
+        Initialize the Elliptec Communication Layer.
+
+        Parameters
+        ----------
+        port_name : str, optional
+            The name of the serial port to use (default is 'COM1').
+        baud_rate : int, optional
+            The baud rate for the serial port (default is 9600).
+        max_entries : int, optional
+            The maximum number of entries to keep (default is 1000).
+        """
+        if DevicePort._instance is not None:
+            raise Exception('This class is a singleton!')
+        super().__init__()
+
+        self.serial = QtSerialPort.QSerialPort(None, readyRead=self.rx_piezo)
+        self.serial.setBaudRate(baud_rate)
+        self.serial.setPortName(port_name)
+        self.serial.setParity(QtSerialPort.QSerialPort.Parity.NoParity)
+        self.serial.setStopBits(QtSerialPort.QSerialPort.StopBits.OneStop)
+        self.serial.setDataBits(QtSerialPort.QSerialPort.DataBits.Data8)
+        self.serial.setFlowControl(QtSerialPort.QSerialPort.FlowControl.NoFlowControl)
+        self.buffer = ''
+
+        # New attributes for logging
+        DevicePort._responses = deque(maxlen=max_entries)
+
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.DEBUG)
+
+    @classmethod
+    def open(cls, portName: str = None):
+        '''
+        Open the serial port.
+        '''
+        if portName:
+            cls.instance().serial.setPortName(portName)
+
+        if not cls.instance().isOpen():
+            cls.instance().serial.open(QtCore.QIODevice.OpenModeFlag.ReadWrite)
+
+        return cls.instance().isOpen()
+
+    @classmethod
+    def close(cls):
+        '''
+        Close the serial port.
+        '''
+        if cls.instance().isOpen():
+            cls.instance().serial.close()
+
+    @classmethod
+    def isOpen(cls):
+        '''
+        Check if the serial port is open.
+
+        Returns
+        -------
+        bool
+            True if the serial port is open, False otherwise.
+        '''
+        return cls.instance().serial.isOpen()
+
+    @classmethod
+    def portName(cls) -> str:
+        '''
+        Get the name of the serial port.
+
+        Returns
+        -------
+        str
+            The name of the serial port.
+        '''
+        return cls.instance().serial.portName()
+
+    @classmethod
+    def setPortName(cls, name: str):
+        '''
+        Set the name of the serial port.
+
+        Parameters
+        ----------
+        name : str
+            The new port name.
+        '''
+        if not cls.instance().isOpen():
+            cls.instance().serial.setPortName(name)
+
+    @classmethod
+    def baudRate(cls) -> int:
+        '''
+        Get the current baud rate.
+
+        Returns
+        -------
+        int
+            The current baud rate.
+        '''
+        return cls.instance().serial.baudRate()
+
+    @classmethod
+    def setBaudRate(cls, baudRate: int):
+        '''
+        Set the baud rate for the serial port.
+
+        Parameters
+        ----------
+        baudRate : int
+            The new baud rate.
+        '''
+        if not cls.instance().isOpen():
+            cls.instance().serial.setBaudRate(baudRate)
+
+    @classmethod
+    def log_communication(cls, direction, message):
+        """
+        Log a communication event.
+
+        Parameters:
+        direction (str): Either 'TX' for transmitted or 'RX' for received.
+        message (str): The content of the message.
+        """
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
+        log_entry = f'{timestamp} - {direction}: {message}'
+        cls.instance().logUpdated.emit(log_entry)
+
+    @classmethod
+    def write(cls, value: str):
+        '''
+        Write a value to the serial port.
+
+        Parameters
+        ----------
+        value : bytes
+            The value to write.
+        '''
+        if cls.instance().isOpen():
+            cls.instance().serial.write(value.encode('utf-8'))
+            cls.instance().dataSent.emit(value)
+            cls.instance().log_communication('TX', value)
+
+    @classmethod
+    def addResponse(cls, response: str):
+        '''
+        Add a response to the response buffer.
+
+        Parameters
+        ----------
+        response : str
+            The response to add.
+        '''
+        cls._responses.append(response)
+
+    @classmethod
+    def hasResponse(cls, addresses: Optional[list[str]] = None):
+        '''
+        Check if there is a response in the buffer.
+
+        Returns
+        -------
+        bool
+            True if there is a response, False otherwise.
+        '''
+        if (
+            addresses is not None
+            and isinstance(addresses, list)
+            and all(isinstance(address, str) for address in addresses)
+        ):
+            return any(response[0] in addresses for response in cls._responses)
+        else:
+            return len(cls._responses) > 0
+
+    @classmethod
+    def getNextResponse(cls, address: Optional[Union[str, list[str]]] = None):
+        '''
+        Get the next response from the buffer.
+
+        Parameters
+        ----------
+        address : str or list[str], optional
+            The address of the response to get
+            (default is None, which gets the next response).
+
+        Returns
+        -------
+        str
+            The next response from the buffer.
+        '''
+        if address is not None:
+            if isinstance(address, str):
+                address = [address]
+
+        if not cls.hasResponse(address):
+            raise ELLException('No Responses available')
+
+        if address is None:
+            return cls._responses.popleft()
+        elif isinstance(address, list) and all(isinstance(add, str) for add in address):
+            for i, response in enumerate(cls._responses):
+                if response[0] in address:
+                    result = cls._responses[i]
+                    del cls._responses[i]
+                    return result
+
+            raise ELLException('No Responses available for the given address')
+        else:
+            raise ELLException('Invalid address')
+
+    @classmethod
+    def clearResponses(cls, address: Optional[Union[str, list[str]]] = None):
+        '''
+        Clear the response buffer.
+
+        Parameters
+        ----------
+        address : str or list[str], optional
+            The address of the response to clear
+            (default is None, which clears all responses).
+        '''
+        if address is not None:
+            if isinstance(address, str):
+                address = [address]
+
+        if address is None:
+            cls._responses.clear()
+        elif isinstance(address, list) and all(isinstance(add, str) for add in address):
+            cls._responses = deque(
+                response for response in cls._responses if response[0] not in address
+            )
+        else:
+            raise ELLException('Invalid address')
+
+    def rx_piezo(self):
+        '''
+        Handle incoming data from the serial port.
+        '''
+        try:
+            self.buffer += str(self.serial.readAll(), encoding='utf8')
+
+            eol = self.buffer.find('\n')
+            while eol >= 0:
+                message = self.buffer[: eol + 1].strip(' \r\n')
+                self.buffer = self.buffer[eol + 1 :]
+                eol = self.buffer.find('\n')
+
+                if message:
+                    self.log_communication('RX', message)
+                    DevicePort.addResponse(message)
+                    self.dataReceived.emit(message)
+        except Exception as e:
+            self.logger.error(f'Error in rx_piezo: {str(e)}')
+            self.errorOccurred.emit(str(e))
+
+    @classmethod
+    def wait_for_response(
+        cls,
+        addresses: Union[str, list[str]],
+        responses: Union[str, list[str]],
+        timeout: int,
+    ):
+        if isinstance(responses, str):
+            responses = [responses]
+        if isinstance(addresses, str):
+            addresses = [addresses]
+
+        headers = [
+            f'{address}{response}' for address in addresses for response in responses
+        ]
+
+        loop = QtCore.QEventLoop()
+        QtCore.QTimer.singleShot(timeout, loop.quit)
+        cls.instance().dataReceived.connect(loop.quit)
+        loop.exec()
+        cls.instance().dataReceived.disconnect(loop.quit)
+
+        if cls.hasResponse(addresses):
+            message = cls.getNextResponse(addresses)
+            if message[:3] in headers:
+                return message
+
+        raise ELLException('Response timeout')
+
+    @classmethod
+    def send_command(
+        cls, address: str, command: str, param: str = '', clearResponses=True
+    ) -> Optional[str]:
+        '''
+        Send a command to the stage.
+
+        Parameters
+        ----------
+        address : str
+            The stage address 0-F.
+        command : str
+            The command to send.
+        param : str, optional
+            The parameter to send (default is "").
+        '''
+        try:
+            full_command = f'{address}{command}{param}'
+
+            if clearResponses:
+                cls.clearResponses(address)
+
+            cls.instance().write(full_command)
+        except Exception as e:
+            cls.instance().logger.error(f'Error in send_command: {str(e)}')
+            cls.instance().errorOccurred.emit(str(e))
+
+    @classmethod
+    def sendFreeString(cls, text: str):
+        cls.instance().send_command(text, '')
+
+    @classmethod
+    def send_string_i16(cls, address: str, command: str, i: int):
+        cls.instance().send_command(address, command, f'{i:04X}')
+
+    @classmethod
+    def send_string_i32(cls, address: str, command: str, i: int):
+        cls.instance().send_command(address, command, f'{i:08X}')
+
+    @classmethod
+    def send_string_b(cls, address: str, command: str, b: int):
+        cls.instance().send_command(address, command, f'{chr(b)}')

microEye/hardware/stages/elliptec/deviceStatus.py

@@ -0,0 +1,65 @@
+import struct
+from enum import Enum
+
+
+class DeviceStatusValues(Enum):
+    '''Values that represent Device Status.'''
+
+    OK = 0
+    CommunicationError = 1
+    MechanicalTimeOut = 2
+    CommandError = 3
+    ValueOutOfRange = 4
+    ModuleIsolated = 5
+    ModuleOutOfIsolation = 6
+    InitializationError = 7
+    ThermalError = 8
+    Busy = 9
+    SensorError = 10
+    MotorError = 11
+    OutOfRangeError = 12
+    OverCurrentError = 13
+    GeneralError = 14
+
+    def __str__(self):
+        return {
+            0: 'Ok',
+            1: 'Communication Error',
+            2: 'Mechanical Time Out',
+            3: 'Command Error',
+            4: 'Value Out Of Range',
+            5: 'Module Isolated',
+            6: 'Module Out Of Isolation',
+            7: 'Initialization Error',
+            8: 'Thermal Error',
+            9: 'Busy',
+            10: 'Sensor Error',
+            11: 'Motor Error',
+            12: 'Out of range Error',
+            13: 'Over current Error',
+            14: 'General Error',
+        }[self.value]
+
+
+class DeviceStatusStruct:
+    '''Structure containing device stage axis parameters.'''
+
+    FORMAT = 'c2s2s'
+
+    def __init__(self, address, command, status):
+        self.address: str = address
+        self.command: str = command
+        self.status: int = status
+
+    @classmethod
+    def from_bytes(cls, data):
+        address, command, status = struct.unpack(cls.FORMAT, data)
+        return cls(address.decode('utf-8'), command.decode('utf-8'), int(status, 16))
+
+class DeviceStatus:
+    def __init__(self, message: str = None) -> None:
+        if message is None:
+            self.Status = DeviceStatusValues.OK
+        else:
+            ds = DeviceStatusStruct.from_bytes(message.encode('utf-8'))
+            self.Status = DeviceStatusValues(ds.status)