microeye 2.3.2__py3-none-any.whl

microEye/hardware/misc/temp.py

@@ -0,0 +1,188 @@
+from os import name
+
+import numpy as np
+from pyqtgraph.widgets.PlotWidget import PlotWidget
+
+from microEye.hardware.port_config import port_config
+from microEye.qt import (
+    QApplication,
+    QDateTime,
+    QMainWindow,
+    QtCore,
+    QtSerialPort,
+    QtWidgets,
+    Slot,
+)
+from microEye.utils import StartGUI
+
+
+class temperature_monitor(QMainWindow):
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+
+        # Define main window layout
+        self.main_widget = QtWidgets.QWidget()
+        self.main_layout = QtWidgets.QHBoxLayout()
+        self.main_widget.setLayout(self.main_layout)
+        self.setCentralWidget(self.main_widget)
+
+        self.temp_log_X = np.arange(100)
+        self.temp_log = np.array([20.0] * 100)
+
+        self.serial = QtSerialPort.QSerialPort(None, readyRead=self.receive)
+        self.serial.setBaudRate(115200)
+        self.serial.setPortName('COM4')
+
+        self.labelStyle = {'color': '#FFF', 'font-size': '10pt'}
+        self.temp_log_graph = PlotWidget()
+        self.temp_log_graph.setLabel('bottom', 'Frame', **self.labelStyle)
+        self.temp_log_graph.setLabel('left', 'Temperature [C]', **self.labelStyle)
+        self.temp_log_graph_ref = None
+
+        self.buttons_layout = QtWidgets.QHBoxLayout()
+        self.connect_btn = QtWidgets.QPushButton(
+            'Connect', clicked=lambda: self.OpenCOM()
+        )
+        self.disconnect_btn = QtWidgets.QPushButton(
+            'Disconnect', clicked=lambda: self.CloseCOM()
+        )
+        self.config_btn = QtWidgets.QPushButton(
+            'Config.', clicked=lambda: self.open_dialog(self.serial)
+        )
+
+        self.buttons_layout.addWidget(self.connect_btn)
+        self.buttons_layout.addWidget(self.disconnect_btn)
+        self.buttons_layout.addWidget(self.config_btn)
+
+        self.settings_group = QtWidgets.QGroupBox('Settings')
+        self.settings_layout = QtWidgets.QFormLayout()
+        self.settings_group.setLayout(self.settings_layout)
+        self.settings_group.setMinimumWidth(250)
+
+        self.setT = QtWidgets.QDoubleSpinBox()
+        self.setT.setMinimum(-2000)
+        self.setT.setMaximum(10000)
+        self.setT.setValue(10)
+
+        self.kP = QtWidgets.QDoubleSpinBox()
+        self.kP.setMinimum(-2000)
+        self.kP.setMaximum(10000)
+        self.kP.setValue(90)
+        self.kI = QtWidgets.QDoubleSpinBox()
+        self.kI.setMinimum(-2000)
+        self.kI.setMaximum(10000)
+        self.kI.setValue(0)
+        self.kD = QtWidgets.QDoubleSpinBox()
+        self.kD.setMinimum(-2000)
+        self.kD.setMaximum(10000)
+        self.kD.setValue(0)
+
+        self.send_btn = QtWidgets.QPushButton(
+            'Send Settings', clicked=lambda: self.SendCommand()
+        )
+
+        self.settings_layout.addRow(self.connect_btn)
+        self.settings_layout.addRow(self.disconnect_btn)
+        self.settings_layout.addRow(self.config_btn)
+        self.settings_layout.addRow('Set T [C]:', self.setT)
+        self.settings_layout.addRow('kP:', self.kP)
+        self.settings_layout.addRow('kI:', self.kI)
+        self.settings_layout.addRow('kD:', self.kD)
+        self.settings_layout.addRow(self.send_btn)
+
+        self.main_layout.addWidget(self.settings_group)
+        self.main_layout.addWidget(self.temp_log_graph, 3)
+
+        # Statues Bar Timer
+        self.timer = QtCore.QTimer()
+        self.timer.setInterval(10)
+        self.timer.timeout.connect(self.update)
+        self.timer.start()
+
+        self.show()
+        self.center()
+
+    def center(self):
+        '''Centers the window within the screen.'''
+        qtRectangle = self.frameGeometry()
+        centerPoint = QApplication.primaryScreen().availableGeometry().center()
+        qtRectangle.moveCenter(centerPoint)
+        self.move(qtRectangle.topLeft())
+
+    def receive(self):
+        while self.serial.canReadLine():
+            line = self.serial.readLine().data().decode('utf-8')
+            temp = line.rstrip('\r\n')
+            try:
+                temp = float(temp)
+                self.temp_log = np.roll(self.temp_log, -1)
+                self.temp_log[-1] = temp
+            except ValueError:
+                return
+
+    def update(self):
+        self.statusBar().showMessage(
+            'Time: ' + QDateTime.currentDateTime().toString('hh:mm:ss,zzz')
+        )
+
+        if self.temp_log_graph_ref is None:
+            # create plot reference when None
+            self.temp_log_graph_ref = self.temp_log_graph.plot(
+                self.temp_log_X, self.temp_log
+            )
+        else:
+            # use the plot reference to update the data for that line.
+            self.temp_log_graph_ref.setData(self.temp_log_X, self.temp_log)
+
+    @Slot()
+    def open_dialog(self, serial: QtSerialPort.QSerialPort):
+        '''Opens a port config dialog for the provided serial port.
+
+        Parameters
+        ----------
+        serial : QSerialPort
+            the serial port to be configured.
+        '''
+        dialog = port_config()
+        if not serial.isOpen():
+            if dialog.exec():
+                portname, baudrate = dialog.get_results()
+                serial.setPortName(portname)
+                serial.setBaudRate(baudrate)
+
+    def OpenCOM(self):
+        '''Opens the serial port and initializes the combiner.'''
+        if not self.serial.isOpen():
+            self.serial.open(
+                QtCore.QIODevice.OpenModeFlag.ReadWrite)
+            self.serial.flush()
+
+    def CloseCOM(self):
+        '''Closes the serial port.'''
+        self.serial.close()
+
+    def SendCommand(self):
+        if self.serial.isOpen():
+            data = dict()
+            data['P'] = self.kP.value()
+            data['I'] = self.kI.value()
+            data['D'] = self.kD.value()
+            data['T'] = self.setT.value()
+            command = str(data) + '\r'
+            self.serial.write(command.encode('utf-8'))
+
+    def StartGUI():
+        '''Initializes a new QApplication and temperature_monitor.
+
+        Use
+        -------
+        app, window = temperature_monitor.StartGUI()
+
+        app.exec()
+
+        Returns
+        -------
+        tuple (QApplication, temperature_monitor)
+            Returns a tuple with QApp and temperature_monitor main window.
+        '''
+        return StartGUI(temperature_monitor)

microEye/hardware/port_config.py

@@ -0,0 +1,59 @@
+from microEye.qt import Qt, QtSerialPort, QtWidgets
+
+
+class port_config(QtWidgets.QDialog):
+    '''A dialog for setting the serial port config | Inherits QDialog'''
+
+    def __init__(self, parent=None, title='Serial Port Config.', **kwargs):
+        super().__init__(parent)
+
+        self.setWindowTitle(title)
+        self.portname_comboBox = QtWidgets.QComboBox()  # port name combobox
+        self.baudrate_comboBox = QtWidgets.QComboBox()  # baudrate combobox
+
+        # adding available serial ports
+        for info in QtSerialPort.QSerialPortInfo.availablePorts():
+            self.portname_comboBox.addItem(info.portName())
+
+        self.portname_comboBox.setCurrentText(
+            kwargs.get(
+                'portname', QtSerialPort.QSerialPortInfo.availablePorts()[0].portName()
+            )
+        )
+
+        # adding default baudrates (default 115200)
+        for baudrate in QtSerialPort.QSerialPortInfo.standardBaudRates():
+            # if baudrate == 115200:
+            self.baudrate_comboBox.addItem(str(baudrate), baudrate)
+
+        self.baudrate_comboBox.setCurrentText(kwargs.get('baudrate', '115200'))
+
+        # dialog buttons
+        buttonBox = QtWidgets.QDialogButtonBox()
+        buttonBox.setOrientation(Qt.Orientation.Horizontal)
+        buttonBox.setStandardButtons(
+            QtWidgets.QDialogButtonBox.Cancel | QtWidgets.QDialogButtonBox.Ok
+        )
+        buttonBox.accepted.connect(self.accept)
+        buttonBox.rejected.connect(self.reject)
+
+        # dialog layout
+        lay = QtWidgets.QFormLayout(self)
+        lay.addRow('Port Name:', self.portname_comboBox)
+        lay.addRow('BaudRate:', self.baudrate_comboBox)
+        lay.addRow(buttonBox)
+        self.setFixedSize(self.sizeHint().width() + 50, self.sizeHint().height())
+        self.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
+
+    def get_results(self):
+        '''Get the selected serial port config.
+
+        Returns
+        -------
+        tuple (str, int)
+            the selected port and baudrate respectively.
+        '''
+        return (
+            self.portname_comboBox.currentText(),
+            self.baudrate_comboBox.currentData(),
+        )

microEye/hardware/protocols/__init__.py

@@ -0,0 +1,2 @@
+from microEye.hardware.protocols.actions import WeakObjects
+from microEye.hardware.protocols.designer import ExperimentDesigner

microEye/hardware/protocols/actions.py

@@ -0,0 +1,402 @@
+import ast
+import re
+import threading
+import time
+import weakref
+from typing import Any, Callable
+
+from pyqtgraph.parametertree import Parameter
+from pyqtgraph.parametertree.parameterTypes import ActionParameter
+
+from microEye.hardware.cams import Camera_Panel
+from microEye.utils.parameter_tree import Tree
+
+
+class WeakObjects:
+    OBJECTS = weakref.WeakSet()
+
+    @classmethod
+    def addObject(cls, object):
+        cls.OBJECTS.add(object)
+
+    @classmethod
+    def removeObject(cls, object):
+        cls.OBJECTS.discard(object)
+
+    @classmethod
+    def getObject(cls, name: str):
+        for ref in cls.OBJECTS:
+            if str(ref) == name:
+                return ref
+        return None
+
+    @classmethod
+    def getObjectNames(cls):
+        return [str(obj) for obj in cls.OBJECTS]
+
+
+class BaseAction:
+    '''
+    Base class for all actions in the editor.
+
+    Attributes
+    ----------
+    id_counter : int
+        Global counter for action IDs.
+    NAME : str
+        The name of the action type.
+    id : int
+        The unique identifier for each action instance.
+    name : str
+        The name of the action instance.
+    '''
+
+    id_counter = 1  # Global counter for action IDs
+    NAME = 'Base Action'
+
+    def __init__(self):
+        '''
+        Initialize a new BaseAction instance.
+        '''
+        self.id = BaseAction.id_counter
+        BaseAction.id_counter += 1
+        self.name = self.__class__.__name__
+
+    def output(self, text: str, **kwargs):
+        output = kwargs.get('output', None)
+        if output is not None:
+            output.emit(text, kwargs.get('level', 0))
+
+    def execute(self, **kwargs):
+        '''
+        Execute the action. To be implemented by subclasses.
+
+        Raises
+        ------
+        NotImplementedError
+            If subclasses do not implement the execute method.
+        '''
+        raise NotImplementedError('Subclasses must implement the execute method')
+
+    def __str__(self) -> str:
+        '''Return a string representation of the action.'''
+        return f'{self.name} {self.id}'
+
+    def toHTML(self) -> str:
+        '''Return an HTML representation of the action.'''
+        return '<span style="color:#0f0;">' + f'<b>{self.name} {self.id}</b></span>'
+
+
+class FunctionCall(BaseAction):
+    NAME = 'Function Call'
+
+    def __init__(self, function: Callable = None, Args: tuple = ()):
+        '''
+        Initialize a new FunctionCall instance.
+
+        Parameters
+        ----------
+        function : Callable, optional
+            The function to be called, by default None.
+        Args : tuple, optional
+            The arguments to be passed to the function, by default ().
+
+        Raises
+        ------
+        TypeError
+            If the provided function is not callable.
+        '''
+        super().__init__()
+        self.function = function
+        self.function_args = Args
+
+    def execute(self, **kwargs):
+        event: threading.Event = kwargs.get('event')
+        if event and event.is_set():
+            self.output(f'{str(self)}: Execution stopped.', **kwargs)
+            return
+
+        self.output(f'{str(self)}: Executing...', **kwargs)
+        if self.function is not None:
+            self.function(*self.function_args, **kwargs)
+
+
+class ActionGroup(BaseAction):
+    '''
+    Action that groups multiple child actions.
+
+    Subclass of BaseAction.
+
+    Attributes
+    ----------
+    NAME : str
+        The name of the action type.
+    child_actions : list
+        List of child actions.
+    '''
+
+    NAME = 'Action Group'
+
+    def __init__(self):
+        '''
+        Initialize a new ActionGroup instance.
+        '''
+        super().__init__()
+        self.child_actions: list[BaseAction] = []
+
+    def execute(self, **kwargs):
+        '''
+        Execute the action group by executing all child actions.
+        '''
+        event: threading.Event = kwargs.get('event')
+        if event and event.is_set():
+            self.output(f'{str(self)}: Execution stopped.', **kwargs)
+            return
+
+        self.output(f'{str(self)}: Executing...', **kwargs)
+        kwargs['level'] = kwargs.get('level', 0) + 1
+        for child_action in self.child_actions:
+            if event and event.is_set():
+                break
+            child_action.execute(**kwargs)
+
+
+class ForLoop(ActionGroup):
+    '''
+    Action that repeats the execution of its child actions.
+
+    Subclass of ActionGroup.
+
+    Attributes
+    ----------
+    NAME : str
+        The name of the action type.
+    repeat_count : int
+        The number of times to repeat the child actions.
+    '''
+
+    NAME = 'For Loop'
+
+    def __init__(self, repeat_count=3):
+        '''
+        Initialize a new ForLoop instance.
+
+        Parameters
+        ----------
+        repeat_count : int, optional
+            The number of times to repeat the child actions, by default 3.
+        '''
+        super().__init__()
+        self.repeat_count = repeat_count
+
+    def setRepeatCount(self, repeat_count):
+        '''
+        Set the number of times to repeat the child actions.
+
+        Parameters
+        ----------
+        repeat_count : int
+            The number of times to repeat the child actions.
+        '''
+        self.repeat_count = repeat_count
+
+    def execute(self, **kwargs):
+        '''
+        Execute the for loop by repeating the child actions.
+
+        Notes
+        -----
+        Overrides the execute method in ActionGroup.
+        '''
+        event: threading.Event = kwargs.get('event')
+        if event and event.is_set():
+            self.output(f'{str(self)}: Execution stopped.', **kwargs)
+            return
+
+        new_kwargs = kwargs.copy()
+        new_kwargs['level'] = kwargs.get('level', 0) + 1
+        for i in range(self.repeat_count):
+            if event and event.is_set():
+                break
+            self.output(f'{str(self)} ({i+1})', **kwargs)
+            new_kwargs[f'i{self.id}'] = i
+            for child_action in self.child_actions:
+                if event and event.is_set():
+                    break
+                child_action.execute(**new_kwargs)
+
+    def __str__(self) -> str:
+        '''
+        Return a string representation of the for loop.
+        '''
+        return f'{self.__class__.NAME} {self.id}: range({self.repeat_count})'
+
+    def toHTML(self) -> str:
+        '''
+        Return a string representation of the for loop.
+
+        Returns
+        -------
+        str
+            String representation of the for loop.
+        '''
+        return (
+            f'<span style="color:#c586c0;">for</span> '
+            f'<span style="color:#9cdcfe;">i{self.id}</span> '
+            f'<span style="color:#c586c0;">in</span> '
+            f'<span style="color:#4ec9b0;">range</span>'
+            '<span style="color:#cccccc;">(</span>'
+            f'<span style="color:#9cdcfe;">{self.repeat_count}</span>'
+            '<span style="color:#cccccc;">)</span>'
+            '<span style="color:#cccccc;">:</span>'
+        )
+
+
+class ParameterAdjustmentAction(BaseAction):
+    NAME = 'Parameter'
+
+    def __init__(
+        self,
+        target_object: Tree = None,
+        parameter_name: str = 'N/A',
+        parameter_value: Any = None,
+        delay: float = 0.0,
+        is_expression: bool = False,
+    ):
+        super().__init__()
+        self.target_object = target_object
+        self.parameter_name = parameter_name
+        self.parameter_value = parameter_value
+        self.delay = delay
+        self.is_expression = is_expression
+
+    def get_paramtree(self):
+        target_object = WeakObjects.getObject(self.target_object)
+
+        if target_object is None:
+            return None
+
+        if isinstance(target_object, Tree):
+            return target_object
+        if isinstance(target_object, Camera_Panel):
+            return target_object.camera_options
+        for attr_name in dir(target_object):
+            attr = getattr(target_object, attr_name)
+            if isinstance(attr, Tree):
+                return attr
+
+    def get_event(self, attr: str):
+        target_object = WeakObjects.getObject(self.target_object)
+
+        if hasattr(target_object, attr):
+            event = getattr(target_object, attr)
+            if isinstance(event, threading.Event):
+                return event
+            else:
+                return None
+
+    def safe_eval(self, expr: str, variables: dict) -> Any:
+        # Basic safety check: ensure the expression is a valid Python expression
+        try:
+            ast.parse(expr, mode='eval')
+        except SyntaxError:
+            raise
+
+        # Evaluate the expression with only the provided variables
+        return eval(expr, {'__builtins__': {}}, variables)
+
+    def execute(self, **kwargs):
+        target_object = self.get_paramtree()
+        if target_object is None:
+            self.output(f'{str(self)}: object not found ...', **kwargs)
+            return
+
+        event: threading.Event = kwargs.get('event')
+        if event and event.is_set():
+            self.output(f'{str(self)}: Execution stopped.', **kwargs)
+            return
+
+        self.output(f'{str(self)}: Executing...', **kwargs)
+        param = target_object.get_param(self.parameter_name)
+        if param is not None:
+            if isinstance(param, ActionParameter):
+                param.activate()
+                if self.parameter_value and 'event' in param.opts:  # Wait for event
+                    time.sleep(0.5)
+                    param_event = self.get_event(param.opts['event'])
+                    if param_event is not None:  # Wait for event
+                        param_event.wait()
+                        time.sleep(0.2)
+            elif isinstance(param, Parameter):
+                if self.is_expression:
+                    try:
+                        value = self.safe_eval(self.parameter_value, kwargs)
+                    except Exception as e:
+                        self.output(
+                            f'{str(self)}: Expression evaluation failed: {str(e)}',
+                            **kwargs,
+                        )
+                        event.set()
+                        return
+                else:
+                    value = self.parameter_value
+                param.setValue(value)
+        if self.delay > 0:
+            self.output(f'{str(self)}: waiting {self.delay:.3f} secs ...', **kwargs)
+            # time.sleep(self.delay)
+            start_time = time.time()
+            while time.time() - start_time < self.delay:
+                if event and event.is_set():
+                    self.output(
+                        f'{str(self)}: Execution stopped during delay.', **kwargs
+                    )
+                    return
+                time.sleep(0.001)  # Short sleep to prevent busy waiting
+
+    def __str__(self) -> str:
+        return f'{self.__class__.NAME} {self.id}'
+
+    def toHTML(self) -> str:
+        param_name = self.parameter_name.replace('.', ' → ')
+        target_object = self.get_paramtree()
+        param_type = (
+            target_object.get_param(self.parameter_name).type()
+            if target_object
+            else None
+        )
+        param_suffix = (
+            target_object.get_param(self.parameter_name).opts.get('suffix', '')
+            if target_object
+            else ''
+        )
+        if param_type == 'action':
+            value_label = '(<span style="color: #0f0">' + (
+                'wait</span>)' if self.parameter_value else 'no wait</span>)'
+            )
+        else:
+            value = (
+                f'"{self.parameter_value}"'
+                if not isinstance(self.parameter_value, (int, float, bool))
+                and not self.is_expression
+                else f'{self.parameter_value}'
+            )
+            value_label = (
+                '= <span style="color: #0f0">'
+                + f'{"expr: " if self.is_expression else ""}'
+                + value
+                + f'</span> {param_suffix}'
+                if self.parameter_value is not None
+                else ''
+            )
+        return (
+            # '<span style="color:#0f0;">'
+            # f'<b>{self.__class__.NAME} {self.id}</b></span>:<br>'
+            '<span style="color:#9cdcfe;">'
+            f'<i>{target_object.__class__.__name__}</i> {self.id}</span>:<br>'
+            f'<span style="font-size: 0.8em; color:#4ec9b0;">{param_name}</span> '
+            + value_label
+            + f'<br><span style="font-size: 0.8em; color:#9cdcfe;">Type</span>'
+            f': <span style="color: #0f0">{param_type}</span><br>'
+            f'<span style="font-size: 0.8em; color:#9cdcfe;">Delay</span>'
+            f': <span style="color: #0f0">{self.delay}</span> Seconds'
+        )