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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.30
+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.30 → 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.30
+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.30 → uc2_rest-0.2.0.32}/UC2_REST.egg-info/SOURCES.txt

@@ -13,8 +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
@@ -26,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.30 → uc2_rest-0.2.0.32}/uc2rest/UC2Client.py

@@ -21,12 +21,15 @@ 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
 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:
@@ -109,6 +112,9 @@ class UC2Client(object):
         # initialize CAN
         self.can = CAN(self)
         
+        # initialize CAN OTA
+        self.canota = CANOTA(self)
+        
         # initialize gripper
         self.gripper = Gripper(self)
         
@@ -145,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.30 → 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.30"
+__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.32/uc2rest/can.py

@@ -0,0 +1,143 @@
+class CAN(object):
+    def __init__(self, parent):
+        """
+        CANController handles sending commands to a remote CAN device via the parent post_json interface.
+
+        :param parent: Parent object with post_json(path, payload, getReturn, timeout, nResponses)
+        """
+        self._parent = parent
+        
+        # Store latest scan results
+        self.scanResults = []
+        self.deviceCount = 0
+        
+        # Register a callback function for the CAN status on the serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_can_status, pattern="scan")
+        
+        # Announce a function that is called when we receive a CAN scan 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."""
+        _callbackPerKey = {}
+        self.nCallbacks = nCallbacks
+        for i in range(nCallbacks):
+            _callbackPerKey[i] = []
+        return _callbackPerKey
+    
+    def _callback_can_status(self, data):
+        """
+        Cast the json in the form:
+        {
+            "scan": [
+                {"canId": 20, "deviceType": 1, "status": 0, "deviceTypeStr": "laser", "statusStr": "idle"},
+                {"canId": 10, "deviceType": 0, "status": 0, "deviceTypeStr": "motor", "statusStr": "idle"}
+            ],
+            "qid": 2,
+            "count": 1
+        }
+        into the scan results array.
+        """
+        try:
+            if "scan" in data:
+                self.scanResults = data["scan"]
+                self.deviceCount = data.get("count", len(self.scanResults))
+                
+                # Call registered callback function with scan results
+                if callable(self._callbackPerKey[0]):
+                    self._callbackPerKey[0](self.scanResults)
+        except Exception as e:
+            print("Error in _callback_can_status: ", e)
+    
+    def register_callback(self, key, callbackfct):
+        """Register a callback function for a specific key."""
+        self._callbackPerKey[key] = callbackfct
+
+    def reboot_remote(self, qid=1, can_address=0, isBlocking=False, timeout=2):
+        """
+        Send a reboot signal to the remote CAN device.
+
+        :param qid: Query ID for the CAN command (default: 1)
+        :param isBlocking: If True, wait for response
+        :param timeout: Timeout for the command in seconds
+        :param can_address: Address of the CAN device to reboot (0 is master)
+        :return: Response from the device
+        """
+        path = "/can_act"
+        payload = {
+            "task": path,
+            "restart": int(can_address)
+        }
+        nResponses = 1 if isBlocking else 0
+        # Send the payload to the parent, which handles the actual communication
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=isBlocking,
+            timeout=timeout if isBlocking else 0,
+            nResponses=nResponses
+        )
+
+    def scan(self, qid=1, timeout=5):
+        """
+        Scan the CAN bus for connected devices.
+
+        :param qid: Query ID for the CAN command (default: 1)
+        :param timeout: Timeout for the scan in seconds (default: 5)
+        :return: Response containing scan results with device information
+                 Example: {
+                     "scan": [
+                         {"canId": 10, "deviceType": 0, "deviceTypeStr": "motor", "status": 0, "statusStr": "idle"},
+                         {"canId": 20, "deviceType": 1, "deviceTypeStr": "laser", "status": 0, "statusStr": "idle"}
+                     ],
+                     "qid": 1,
+                     "count": 2
+                 }
+        """
+        path = "/can_act"
+        payload = {
+            "task": path,
+            "scan": True,
+            "qid": qid
+        }
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=True,
+            timeout=timeout,
+            nResponses=2
+        )
+
+    def get_available_devices(self, timeout=2):
+        """
+        Get list of available CAN devices.
+
+        :param timeout: Timeout for the command in seconds (default: 2)
+        :return: Response containing available CAN IDs and other bus information
+                 Example: {
+                     "input": {"task": "/can_get"},
+                     "address": 1,
+                     "addresspref": 1,
+                     "addressgetcan": 1,
+                     "nonworking": [0,0,0,...],
+                     "available": [20,0,0,...],
+                     "rx": 18,
+                     "tx": 17
+                 }
+        """
+        path = "/can_act"
+        payload = {
+            "task": path,
+            "scan": True
+        }
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=True,
+            timeout=timeout,
+            nResponses=2
+        )

uc2_rest-0.2.0.32/uc2rest/canota.py

@@ -0,0 +1,256 @@
+import time
+import json
+
+
+gTIMEOUT = 10  # seconds to wait for a response from the ESP32
+
+
+class CANOTA(object):
+    """
+    CAN OTA (Over-The-Air) update controller for UC2 satellite devices.
+    
+    This class handles sending OTA commands to CAN slave devices and processing
+    the responses through callbacks. It manages the WiFi connection setup and
+    OTA server initialization on remote devices.
+    
+    The OTA process involves:
+    1. Sending OTA command with WiFi credentials to a specific CAN device
+    2. Device connects to WiFi and starts ArduinoOTA server
+    3. Device sends back acknowledgment and IP address via serial
+    4. Device becomes available as UC2-CAN-<HEXID>.local for firmware upload
+    """
+    
+    def __init__(self, parent=None, nCallbacks=10):
+        """
+        Initialize the CAN OTA controller.
+        
+        :param parent: Parent UC2Client object with post_json and serial interfaces
+        :param nCallbacks: Number of callback slots to initialize (default: 10)
+        """
+        self._parent = parent
+        self.nCallbacks = nCallbacks
+        
+        # Initialize callback functions for different types of OTA events
+        self.init_callback_functions(self.nCallbacks)
+        
+        # Register callback function for OTA status messages on the serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_ota_status, pattern="ota")
+    
+    def init_callback_functions(self, nCallbacks=10):
+        """
+        Initialize the callback function dictionary.
+        
+        :param nCallbacks: Number of callback slots to create
+        """
+        self._callbackPerKey = {}
+        self.nCallbacks = nCallbacks
+        for i in range(nCallbacks):
+            self._callbackPerKey[i] = None
+    
+    def _callback_ota_status(self, data):
+        """
+        Process incoming OTA status messages from CAN devices.
+        
+        Expected message format:
+        {
+            "ota": {
+                "canId": 20,
+                "status": 0,
+                "statusMsg": "Success",
+                "ip": "192.168.2.137",
+                "hostname": "UC2-CAN-14.local"
+            }
+        }
+        
+        Status codes:
+        - 0: Success (WiFi connected, OTA server started)
+        - 1: WiFi connection failed
+        - 2: OTA start failed
+        
+        :param data: JSON data containing OTA status information
+        """
+        try:
+            ota_data = data["ota"]
+            can_id = ota_data.get("canId")
+            status = ota_data.get("status")
+            status_msg = ota_data.get("statusMsg", "")
+            ip_address = ota_data.get("ip", "")
+            hostname = ota_data.get("hostname", "")
+            
+            # Create a structured response for callbacks
+            ota_response = {
+                "canId": can_id,
+                "status": status,
+                "statusMsg": status_msg,
+                "ip": ip_address,
+                "hostname": hostname,
+                "success": status == 0
+            }
+            
+            # Trigger callbacks for different events
+            # Key 0: General OTA status updates
+            if callable(self._callbackPerKey[0]):
+                self._callbackPerKey[0](ota_response)
+            
+            # Key for specific CAN ID (use can_id % nCallbacks to avoid overflow)
+            if can_id is not None:
+                callback_key = (can_id % (self.nCallbacks - 1)) + 1  # Reserve key 0 for general
+                if callable(self._callbackPerKey[callback_key]):
+                    self._callbackPerKey[callback_key](ota_response)
+                    
+        except Exception as e:
+            print(f"Error in _callback_ota_status: {e}")
+    
+    def register_callback(self, key, callback_function):
+        """
+        Register a callback function for OTA events.
+        
+        :param key: Callback key (0 for general events, 1-9 for specific CAN IDs)
+        :param callback_function: Function to call when OTA event occurs
+                                Function should accept one parameter: ota_response dict
+        
+        Example:
+            def my_ota_callback(ota_response):
+                if ota_response["success"]:
+                    print(f"Device {ota_response['canId']} ready at {ota_response['ip']}")
+                else:
+                    print(f"OTA failed for device {ota_response['canId']}: {ota_response['statusMsg']}")
+            
+            ESP32.canota.register_callback(0, my_ota_callback)
+        """
+        if 0 <= key < self.nCallbacks:
+            self._callbackPerKey[key] = callback_function
+        else:
+            raise ValueError(f"Callback key must be between 0 and {self.nCallbacks-1}")
+    
+    def start_ota_update(self, can_id, ssid, password, timeout=300000, is_blocking=False, 
+                        response_timeout=gTIMEOUT):
+        """
+        Send OTA command to a specific CAN slave device.
+        
+        This tells the slave to connect to WiFi and start an OTA server.
+        The device will become available as UC2-CAN-<HEXID>.local for firmware upload.
+        
+        :param can_id: CAN ID of the target device (e.g., 11 for Motor X, 20 for Laser)
+        :param ssid: WiFi network name
+        :param password: WiFi password
+        :param timeout: OTA timeout in milliseconds (default: 300000 = 5 minutes)
+        :param is_blocking: If True, wait for acknowledgment response
+        :param response_timeout: Timeout for response in seconds
+        :return: Response from the device (if blocking)
+        
+        Examples:
+            # Motor X (CAN ID 11)
+            ESP32.canota.start_ota_update(11, "WiFi", "pass123")
+            
+            # Laser (CAN ID 20) with custom timeout
+            ESP32.canota.start_ota_update(20, "WiFi", "pass123", timeout=600000)
+        """
+        path = "/can_act"
+        payload = {
+            "task": path,
+            "ota": {
+                "canid": can_id,
+                "ssid": ssid,
+                "password": password,
+                "timeout": timeout
+            }
+        }
+        
+        # Send the payload to the parent, which handles the actual communication
+        nResponses = 1 if is_blocking else 0
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=is_blocking,
+            timeout=response_timeout if is_blocking else 0,
+            nResponses=nResponses
+        )
+    
+    def start_motor_ota(self, motor_axis, ssid, password, timeout=300000, is_blocking=False):
+        """
+        Convenience method for starting OTA on motor controllers.
+        
+        :param motor_axis: Motor axis ("X", "Y", "Z") or CAN ID (11, 12, 13)
+        :param ssid: WiFi network name
+        :param password: WiFi password
+        :param timeout: OTA timeout in milliseconds
+        :param is_blocking: If True, wait for acknowledgment response
+        :return: Response from the device
+        
+        Examples:
+            ESP32.canota.start_motor_ota("X", "WiFi", "pass123")
+            ESP32.canota.start_motor_ota(11, "WiFi", "pass123")  # Same as above
+        """
+        # Map motor axes to CAN IDs
+        motor_can_ids = {
+            "X": 11,
+            "Y": 12, 
+            "Z": 13
+        }
+        
+        if isinstance(motor_axis, str):
+            motor_axis = motor_axis.upper()
+            if motor_axis not in motor_can_ids:
+                raise ValueError(f"Invalid motor axis '{motor_axis}'. Use 'X', 'Y', or 'Z'")
+            can_id = motor_can_ids[motor_axis]
+        else:
+            can_id = motor_axis
+        
+        return self.start_ota_update(can_id, ssid, password, timeout, is_blocking)
+    
+    def start_led_ota(self, ssid, password, timeout=300000, is_blocking=False):
+        """
+        Convenience method for starting OTA on LED controller (CAN ID 30).
+        
+        :param ssid: WiFi network name
+        :param password: WiFi password
+        :param timeout: OTA timeout in milliseconds
+        :param is_blocking: If True, wait for acknowledgment response
+        :return: Response from the device
+        """
+        return self.start_ota_update(30, ssid, password, timeout, is_blocking)
+    
+    def start_laser_ota(self, laser_id=0, ssid="", password="", timeout=300000, is_blocking=False):
+        """
+        Convenience method for starting OTA on laser controller.
+        
+        :param laser_id: Laser ID (0 for main laser, maps to CAN ID 20)
+        :param ssid: WiFi network name
+        :param password: WiFi password
+        :param timeout: OTA timeout in milliseconds
+        :param is_blocking: If True, wait for acknowledgment response
+        :return: Response from the device
+        """
+        # Map laser ID to CAN ID (for now, laser 0 = CAN ID 20)
+        can_id = 20 + laser_id
+        return self.start_ota_update(can_id, ssid, password, timeout, is_blocking)
+    
+    def get_ota_hostname(self, can_id):
+        """
+        Generate the expected hostname for a CAN device in OTA mode.
+        
+        :param can_id: CAN ID of the device
+        :return: Expected hostname (e.g., "UC2-CAN-14.local" for CAN ID 20)
+        """
+        hex_id = format(can_id, 'X')  # Convert to hexadecimal
+        return f"UC2-CAN-{hex_id}.local"
+    
+    def get_platformio_upload_command(self, can_id, project_path="."):
+        """
+        Generate the PlatformIO upload command for OTA firmware update.
+        
+        :param can_id: CAN ID of the target device
+        :param project_path: Path to the PlatformIO project (default: current directory)
+        :return: PlatformIO upload command string
+        
+        Example:
+            cmd = ESP32.canota.get_platformio_upload_command(20)
+            # Returns: "platformio run -t upload --upload-port UC2-CAN-14.local"
+        """
+        hostname = self.get_ota_hostname(can_id)
+        if project_path != ".":
+            return f"platformio run -t upload --upload-port {hostname} -d {project_path}"
+        else:
+            return f"platformio run -t upload --upload-port {hostname}"