UC2-REST 0.2.0.31__tar.gz → 0.2.0.32__tar.gz

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.31
+Version: 0.2.0.32
 Summary: This pacage will help you to drive the ESP32-driven microscopy control modules from UC2
 Home-page: https://github.com/openUC2/UC2-REST
 Author: Benedict Diederich

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/UC2_REST.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.31
+Version: 0.2.0.32
 Summary: This pacage will help you to drive the ESP32-driven microscopy control modules from UC2
 Home-page: https://github.com/openUC2/UC2-REST
 Author: Benedict Diederich

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/UC2_REST.egg-info/SOURCES.txt

@@ -13,9 +13,11 @@ uc2rest/__init__.py
 uc2rest/__version__.py
 uc2rest/analog.py
 uc2rest/camera.py
+uc2rest/camera_trigger.py
 uc2rest/can.py
 uc2rest/canota.py
 uc2rest/cmdrecorder.py
+uc2rest/digitalin.py
 uc2rest/digitalout.py
 uc2rest/galvo.py
 uc2rest/gripper.py
@@ -27,6 +29,7 @@ uc2rest/logger.py
 uc2rest/message.py
 uc2rest/modules.py
 uc2rest/motor.py
+uc2rest/motor_config.py
 uc2rest/mserial.py
 uc2rest/objective.py
 uc2rest/pid.py

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/uc2rest/UC2Client.py

@@ -21,6 +21,7 @@ from .camera import Camera
 from .analog import Analog
 from .modules import Modules
 from .digitalout import DigitalOut
+from .digitalin import DigitalIn
 from .rotator import Rotator
 from .logger import Logger
 from .cmdrecorder import cmdRecorder
@@ -28,6 +29,7 @@ from .temperature import Temperature
 from .message import Message
 from .can import CAN
 from .canota import CANOTA
+from .camera_trigger import CameraTrigger
 try:
     import requests
 except:
@@ -149,8 +151,14 @@ class UC2Client(object):
         # initialize digital out
         self.digitalout = DigitalOut(self)
         
+        # initialize digital in
+        self.digitalin = DigitalIn(self)
+        
         # initialize messaging
         self.message = Message(self)
+        
+        # initialize camera trigger callback handler
+        self.camera_trigger = CameraTrigger(self)
 
         # initialize module controller
         self.modules = Modules(parent=self)

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/uc2rest/__version__.py

@@ -6,7 +6,7 @@ __version__.py
 
 __title__ = 'UC2-REST'
 __description__ = 'This pacage will help you to drive the ESP32-driven microscopy control modules from UC2'
-__version__ = "v0.2.0.31"
+__version__ = "v0.2.0.32"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

uc2_rest-0.2.0.32/uc2rest/camera_trigger.py

@@ -0,0 +1,197 @@
+"""
+Camera trigger callback module for UC2-REST.
+
+This module handles camera trigger signals from the firmware ({"cam":1})
+to enable software triggering based on hardware events during stage scanning.
+"""
+
+import numpy as np
+import time
+import json
+
+
+gTIMEOUT = 1  # seconds to wait for a response from the ESP32
+
+
+class CameraTrigger(object):
+    """
+    This class parses incoming camera trigger signals from the ESP32 firmware.
+    
+    When the firmware sends {"cam":1}, this module triggers registered callbacks
+    which can be used for software-triggered image acquisition during stage scanning.
+    
+    Example usage:
+        import uc2rest
+        
+        ESP32 = uc2rest.UC2Client(serialport=port, baudrate=500000)
+        
+        # Register callback for camera trigger
+        def my_camera_callback(data):
+            print(f"Camera trigger received: {data}")
+            # Trigger image acquisition here
+            
+        ESP32.camera_trigger.register_callback(0, my_camera_callback)
+    """
+    
+    def __init__(self, parent=None, nCallbacks=10):
+        """
+        Initialize camera trigger handler.
+        
+        Args:
+            parent: Parent UC2Client instance
+            nCallbacks: Maximum number of callback functions to register
+        """
+        self._parent = parent
+        self.nCallbacks = nCallbacks
+        
+        # Track trigger count for diagnostics
+        self._trigger_count = 0
+        self._last_trigger_time = None
+        
+        # Initialize callback functions
+        self._callbackPerKey = {}
+        self.init_callback_functions(self.nCallbacks)
+        
+        # Register callback for camera trigger on serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_camera_trigger, pattern="cam")
+
+    def _callback_camera_trigger(self, data):
+        """
+        Parse camera trigger message from firmware.
+        
+        Expected JSON format:
+        {
+            "cam": 1  # Trigger signal
+        }
+        
+        or with additional data:
+        {
+            "cam": {
+                "trigger": 1,
+                "frame_id": 123,
+                "illumination": 0
+            }
+        }
+        
+        Args:
+            data: JSON data dictionary from firmware
+        """
+        try:
+            # Update trigger statistics
+            self._trigger_count += 1
+            self._last_trigger_time = time.time()
+            
+            # Extract trigger information
+            cam_data = data.get("cam", {})
+            
+            # Handle simple trigger ({"cam": 1})
+            if isinstance(cam_data, (int, float)):
+                trigger_info = {
+                    "trigger": int(cam_data),
+                    "frame_id": self._trigger_count,
+                    "timestamp": self._last_trigger_time
+                }
+                self._parent.logger.debug(f"Camera trigger received: {trigger_info}")
+            else:
+                # Handle extended trigger data
+                trigger_info = {
+                    "trigger": cam_data.get("trigger", 1),
+                    "frame_id": cam_data.get("frame_id", self._trigger_count),
+                    "illumination": cam_data.get("illumination", -1),
+                    "timestamp": self._last_trigger_time
+                }
+                self._parent.logger.debug(f"Camera trigger with data received: {trigger_info}") 
+            
+            # Call all registered callbacks
+            for key, callback in self._callbackPerKey.items():
+                if callback is not None and callable(callback):
+                    try:
+                        callback(trigger_info)
+                    except Exception as callback_error:
+                        print(f"Error in camera trigger callback {key}: {callback_error}")
+                        
+        except Exception as e:
+            print(f"Error in _callback_camera_trigger: {e}")
+
+    def init_callback_functions(self, nCallbacks=10):
+        """
+        Initialize callback function dictionary.
+        
+        Args:
+            nCallbacks: Number of callback slots to create
+        """
+        self._callbackPerKey = {}
+        self.nCallbacks = nCallbacks
+        for i in range(nCallbacks):
+            self._callbackPerKey[i] = None
+
+    def register_callback(self, key, callback):
+        """
+        Register a callback function for camera trigger events.
+        
+        Args:
+            key: Integer key (0 to nCallbacks-1) for this callback
+            callback: Function to call when trigger is received.
+                     Function signature: callback(trigger_info: dict)
+                     
+        Example:
+            def on_camera_trigger(info):
+                print(f"Frame {info['frame_id']} triggered at {info['timestamp']}")
+                camera.snap_image()
+                
+            ESP32.camera_trigger.register_callback(0, on_camera_trigger)
+        """
+        if key < 0 or key >= self.nCallbacks:
+            raise ValueError(f"Callback key must be between 0 and {self.nCallbacks-1}")
+        self._callbackPerKey[key] = callback
+
+    def unregister_callback(self, key):
+        """
+        Remove a registered callback.
+        
+        Args:
+            key: Integer key of callback to remove
+        """
+        if key in self._callbackPerKey:
+            self._callbackPerKey[key] = None
+
+    def clear_all_callbacks(self):
+        """Remove all registered callbacks."""
+        self.init_callback_functions(self.nCallbacks)
+
+    def get_trigger_count(self):
+        """
+        Get the total number of triggers received since initialization.
+        
+        Returns:
+            int: Number of camera triggers received
+        """
+        return self._trigger_count
+
+    def get_last_trigger_time(self):
+        """
+        Get the timestamp of the last trigger received.
+        
+        Returns:
+            float or None: Unix timestamp of last trigger, or None if no triggers received
+        """
+        return self._last_trigger_time
+
+    def reset_trigger_count(self):
+        """Reset the trigger counter to zero."""
+        self._trigger_count = 0
+        self._last_trigger_time = None
+
+    def get_trigger_stats(self):
+        """
+        Get statistics about trigger events.
+        
+        Returns:
+            dict: Dictionary with trigger statistics
+        """
+        return {
+            "total_triggers": self._trigger_count,
+            "last_trigger_time": self._last_trigger_time,
+            "callbacks_registered": sum(1 for cb in self._callbackPerKey.values() if cb is not None)
+        }

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/uc2rest/can.py

@@ -129,9 +129,10 @@ class CAN(object):
                      "tx": 17
                  }
         """
-        path = "/can_get"
+        path = "/can_act"
         payload = {
-            "task": path
+            "task": path,
+            "scan": True
         }
         return self._parent.post_json(
             path,

uc2_rest-0.2.0.32/uc2rest/digitalin.py

@@ -0,0 +1,122 @@
+import numpy as np
+
+class DigitalIn(object):
+    ## DigitalIn
+    def __init__(self, parent):
+        self._parent = parent
+        self.nDigitalIns = 3
+        self.digitalInValues = np.zeros((self.nDigitalIns), dtype=int)
+                
+        # register a callback function for the digitalin status on the serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_digitalin_status, pattern="digitalin")
+        
+        # announce a function that is called when we receive a digitalin update through the callback
+        self._callbackPerKey = {}
+        self.nCallbacks = 10
+        self._callbackPerKey = self.init_callback_functions(nCallbacks=self.nCallbacks)
+        print(self._callbackPerKey)
+        
+      
+    def init_callback_functions(self, nCallbacks=10):
+        ''' initialize the callback functions - each key holds a list of callbacks '''
+        _callbackPerKey = {}
+        self.nCallbacks = nCallbacks
+        for i in range(nCallbacks):
+            _callbackPerKey[i] = []  # Initialize as list to support multiple callbacks
+        return _callbackPerKey
+            
+    def _callback_digitalin_status(self, data):
+        ''' cast the json in the form:
+        ++
+        {"digitalin":{"digitalinid":1,"digitalinval":1,"isDone":1},"qid":2}
+        --
+        into the digitalin values array '''
+        try:
+            digitalin_data = data["digitalin"]
+            # Handle both single digitalin and multiple digitalins
+            if isinstance(digitalin_data, dict):
+                # Single digitalin format: {"digitalinid":1,"digitalinval":1}
+                digitalin_id = digitalin_data.get("digitalinid", 0)
+                digitalin_val = digitalin_data.get("digitalinval", 0)
+                if 0 < digitalin_id <= self.nDigitalIns:
+                    self.digitalInValues[digitalin_id - 1] = digitalin_val
+            elif isinstance(digitalin_data, list):
+                # Multiple digitalins format: [{"digitalinid":1,"digitalinval":1}, ...]
+                for digitalin in digitalin_data:
+                    digitalin_id = digitalin.get("digitalinid", 0)
+                    digitalin_val = digitalin.get("digitalinval", 0)
+                    if 0 < digitalin_id <= self.nDigitalIns:
+                        self.digitalInValues[digitalin_id - 1] = digitalin_val
+            
+            # Call all registered callbacks for key 0
+            for callback in self._callbackPerKey[0]:
+                if callable(callback):
+                    try:
+                        callback(self.digitalInValues)
+                    except Exception as callback_error:
+                        print(f"Error in callback execution: {callback_error}")
+        except Exception as e:
+            print("Error in _callback_digitalin_status: ", e)
+
+    def register_callback(self, key, callbackfct):
+        ''' register a callback function for a specific key - supports multiple callbacks per key '''
+        if key not in self._callbackPerKey:
+            self._callbackPerKey[key] = []
+        if callbackfct not in self._callbackPerKey[key]:  # Avoid duplicate registrations
+            self._callbackPerKey[key].append(callbackfct)
+            print(f"Registered callback for key {key}. Total callbacks for this key: {len(self._callbackPerKey[key])}")
+        
+
+    def get_digitalin(self, digitalinid=1, timeout=1, is_blocking=True):
+        """
+        Get the current value of a digital input.
+        
+        Parameters:
+        -----------
+        digitalinid : int
+            ID of the digital input (1, 2, or 3)
+        timeout : float
+            Timeout for the request in seconds
+        is_blocking : bool
+            Whether to wait for a response
+            
+        Returns:
+        --------
+        dict or None
+            Response from the device containing digitalin status
+        """
+        path = '/digitalin_get'
+        
+        payload = {
+            "task": path,
+            "digitalinid": digitalinid
+        }
+        
+        r = self._parent.post_json(path, payload, getReturn=is_blocking, timeout=timeout)
+        return r
+
+    def act_digitalin(self, timeout=1, is_blocking=False):
+        """
+        Trigger the digitalin act function.
+        
+        Parameters:
+        -----------
+        timeout : float
+            Timeout for the request in seconds
+        is_blocking : bool
+            Whether to wait for a response
+            
+        Returns:
+        --------
+        dict or None
+            Response from the device
+        """
+        path = '/digitalin_act'
+        
+        payload = {
+            "task": path
+        }
+        
+        r = self._parent.post_json(path, payload, getReturn=is_blocking, timeout=timeout)
+        return r

uc2_rest-0.2.0.32/uc2rest/digitalout.py

@@ -0,0 +1,187 @@
+import numpy as np
+
+class DigitalOut(object):
+    ## DigitalOut
+    def __init__(self, parent):
+        self._parent = parent
+        self._logger = parent.logger
+        self.nDigitalOuts = 3
+        self.digitalOutValues = np.zeros((self.nDigitalOuts), dtype=int)
+                
+        # register a callback function for the digitalout status on the serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_digitalout_status, pattern="digitalout")
+        
+        # announce a function that is called when we receive a digitalout update through the callback
+        self._callbackPerKey = {}
+        self.nCallbacks = 10
+        self._callbackPerKey = self.init_callback_functions(nCallbacks=self.nCallbacks)
+        print(self._callbackPerKey)
+        
+      
+    def init_callback_functions(self, nCallbacks=10):
+        ''' initialize the callback functions - each key holds a list of callbacks '''
+        _callbackPerKey = {}
+        self.nCallbacks = nCallbacks
+        for i in range(nCallbacks):
+            _callbackPerKey[i] = []  # Initialize as list to support multiple callbacks
+        return _callbackPerKey
+            
+    def _callback_digitalout_status(self, data):
+        ''' cast the json in the form:
+        ++
+        {"digitalout":{"digitaloutid":1,"digitaloutval":1,"digitaloutpin":4,"isDone":1},"qid":2}
+        --
+        into the digitalout values array '''
+        try:
+            digitalout_data = data["digitalout"]
+            # Handle both single digitalout and multiple digitalouts
+            if isinstance(digitalout_data, dict):
+                # Single digitalout format: {"digitaloutid":1,"digitaloutval":1,"digitaloutpin":4}
+                digitalout_id = digitalout_data.get("digitaloutid", 0)
+                digitalout_val = digitalout_data.get("digitaloutval", 0)
+                if 0 < digitalout_id <= self.nDigitalOuts:
+                    self.digitalOutValues[digitalout_id - 1] = digitalout_val
+            elif isinstance(digitalout_data, list):
+                # Multiple digitalouts format: [{"digitaloutid":1,"digitaloutval":1}, ...]
+                for digitalout in digitalout_data:
+                    digitalout_id = digitalout.get("digitaloutid", 0)
+                    digitalout_val = digitalout.get("digitaloutval", 0)
+                    if 0 < digitalout_id <= self.nDigitalOuts:
+                        self.digitalOutValues[digitalout_id - 1] = digitalout_val
+            
+            # Call all registered callbacks for key 0
+            for callback in self._callbackPerKey[0]:
+                if callable(callback):
+                    try:
+                        callback(self.digitalOutValues)
+                    except Exception as callback_error:
+                        print(f"Error in callback execution: {callback_error}")
+        except Exception as e:
+            print("Error in _callback_digitalout_status: ", e)
+
+    def register_callback(self, key, callbackfct):
+        ''' register a callback function for a specific key - supports multiple callbacks per key '''
+        if key not in self._callbackPerKey:
+            self._callbackPerKey[key] = []
+        if callbackfct not in self._callbackPerKey[key]:  # Avoid duplicate registrations
+            self._callbackPerKey[key].append(callbackfct)
+            print(f"Registered callback for key {key}. Total callbacks for this key: {len(self._callbackPerKey[key])}")
+    
+    def setup_digitaloutpin(self, id=1, pin=4):
+        path = '/digitalout_set'
+        payload = {
+            "task": path,
+            "digitaloutid": id,
+            "digitaloutpin": pin,
+        }
+        r = self._parent.post_json(path, payload)
+        return r
+    
+    def reset_triggertable(self):
+        path = '/digitalout_act'
+        payload = {
+            "task": path,
+            "digitaloutistriggerreset": 1,
+        }
+        r = self._parent.post_json(path, payload)
+        return r
+    
+    def set_trigger(self, trigger1=False, delayOn1=0, delayOff1=0, trigger2=False, delayOn2=0, delayOff2=0, trigger3=False, delayOn3=0, delayOff3=0):
+        '''
+        this stats a trigger table with 3 triggers
+        
+        Parameters:
+        
+        '''
+        path = '/digitalout_act'
+        
+        payload = {
+            "task":path,
+            "digitalout1TriggerDelayOn":delayOn1,
+            "digitalout1TriggerDelayOff":delayOff1,
+            "digitalout1IsTrigger":trigger1,
+            "digitalout2TriggerDelayOn":delayOn2,
+            "digitalout2TriggerDelayOff":delayOff2,
+            "digitalout2IsTrigger":trigger2, 
+            "digitalout3TriggerDelayOn":delayOn3,
+            "digitalout3TriggerDelayOff":delayOff3,
+            "digitalout3IsTrigger":trigger3,
+        }
+        
+        r = self._parent.post_json(path, payload)
+        return r
+    
+        
+
+
+    def sendTrigger(self, triggerId=0):
+        path = '/digital_act'
+
+        payload = {
+            "task": path,
+            "digitalid": triggerId,
+            "digitalval": -1,
+        }
+
+        r = self._parent.post_json(path, payload)
+        return r
+
+    def get_digitalout(self, digitaloutid=1, timeout=1, is_blocking=True):
+        """
+        Get the current value and pin of a digital output.
+        
+        Parameters:
+        -----------
+        digitaloutid : int
+            ID of the digital output (1, 2, or 3)
+        timeout : float
+            Timeout for the request in seconds
+        is_blocking : bool
+            Whether to wait for a response
+            
+        Returns:
+        --------
+        dict or None
+            Response from the device containing digitalout status (id, val, pin)
+        """
+        path = '/digitalout_get'
+        
+        payload = {
+            "task": path,
+            "digitaloutid": digitaloutid
+        }
+        
+        r = self._parent.post_json(path, payload, getReturn=is_blocking, timeout=timeout)
+        return r
+
+    def set_digitalout(self, digitaloutid=1, digitaloutval=0, timeout=1, is_blocking=False):
+        """
+        Set the value of a digital output. Use digitaloutval=-1 to trigger a pulse (HIGH->LOW).
+        
+        Parameters:
+        -----------
+        digitaloutid : int
+            ID of the digital output (1, 2, or 3)
+        digitaloutval : int
+            Value to set (0=LOW, 1=HIGH, -1=pulse/trigger)
+        timeout : float
+            Timeout for the request in seconds
+        is_blocking : bool
+            Whether to wait for a response
+            
+        Returns:
+        --------
+        dict or None
+            Response from the device
+        """
+        path = '/digitalout_act'
+        
+        payload = {
+            "task": path,
+            "digitaloutid": digitaloutid,
+            "digitaloutval": digitaloutval
+        }
+        
+        r = self._parent.post_json(path, payload, getReturn=is_blocking, timeout=timeout)
+        return r

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/uc2rest/home.py

@@ -14,7 +14,8 @@ class Home(object):
         
         self.nMotors = 4
         self.isHomed = np.zeros((self.nMotors))
-                
+        
+
         # register a callback function for the motor status on the serial loop
         if hasattr(self._parent, "serial"):
             self._parent.serial.register_callback(self._callback_home_status, pattern="home")
@@ -132,13 +133,17 @@ class Home(object):
             )
         """
         # Convert axes to stepper IDs
+        # First get logical motor index, then map through motorAxisOrder to get physical stepper ID
         stepper_ids = []
+        motorAxisOrder = self._parent.motor.motorAxisOrder if hasattr(self._parent.motor   , 'motorAxisOrder') else [0, 1, 2, 3]
         for axis in axes:
             if isinstance(axis, str):
-                axis_id = self.xyztTo1230(axis)
+                logical_motor_index = self.xyztTo1230(axis)
             else:
-                axis_id = axis
-            stepper_ids.append(axis_id)
+                logical_motor_index = axis
+            # Map logical motor index to physical stepper ID
+            stepper_id = motorAxisOrder[logical_motor_index]
+            stepper_ids.append(stepper_id)
         
         num_motors = len(stepper_ids)
         
@@ -171,7 +176,7 @@ class Home(object):
             for i, stepper_id in enumerate(stepper_ids):
                 # Move in opposite direction
                 preMoveDirection = -directions[i]
-                preMoveDistanceSteps = 1000  # steps to move away from endstop
+                preMoveDistanceSteps = 100  # steps to move away from endstop
                 
                 # Move away from endstop using the motor controller
                 if stepper_id == 1:  # X
@@ -265,7 +270,7 @@ class Home(object):
                 preMoveDirection = -1
             else:
                 preMoveDirection = 1
-            preMoveDistanceSteps = 1000 # steps to move away from endstop
+            preMoveDistanceSteps = 100 # steps to move away from endstop
             
             # move away from endstop
             if axis == 1 or axis == "X":
@@ -279,6 +284,10 @@ class Home(object):
             else:   
                 raise ValueError("Invalid axis. Use 'X', 'Y', 'Z', or 'A'.")
             time.sleep(0.5)
+        
+        # Map logical motor index to physical stepper ID through motorAxisOrder
+        stepper_id = self._parent.motor.motorAxisOrder[axis]
+        
         # construct json string
         path = "/home_act"
 
@@ -287,7 +296,7 @@ class Home(object):
             "home":{
                 "steppers": [
                 {
-                 "stepperid": axis,
+                 "stepperid": stepper_id,
                  "timeout":endstoptimeout,
                  "speed":abs(speed),
                  "direction":direction,

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.32}/uc2rest/laser.py

@@ -111,7 +111,7 @@ class Laser(object):
 
         }
         #self._parent.logger.debug("Setting Laser "+str(channel)+", value: "+str(value))
-        r = self._parent.post_json(path, payload, getReturn=is_blocking, timeout=.5)
+        r = self._parent.post_json(path, payload, getReturn=is_blocking, timeout=0.5)
         return r
 
     def set_laserpin(self, laserid=1, laserpin=0):