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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.31
+Version: 0.2.0.33
 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.33}/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.33
 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.33}/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.33}/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,18 +29,20 @@ from .temperature import Temperature
 from .message import Message
 from .can import CAN
 from .canota import CANOTA
+from .camera_trigger import CameraTrigger
+
+# requests is no longer used for direct ESP communication (serial-only).
+# Kept as optional import for other modules that may need HTTP (e.g. firmware downloads).
 try:
     import requests
-except:
-    print("No requests available - running on pyscript?")
+except Exception:
+    requests = None
 
 class UC2Client(object):
-    # headers = {'ESP32-version': '*'}
     headers={"Content-Type":"application/json"}
     getmessage = ""
     is_connected = False
 
-    is_wifi = False
     is_serial = False
     BAUDRATE = 115200
 
@@ -50,12 +53,13 @@ class UC2Client(object):
         This client connects to the UC2-REST microcontroller that can be found here
         https://github.com/openUC2/UC2-REST
 
+        Communication is via USB/serial only.
+        The host/port parameters are deprecated and will be ignored.
+
         generally speaking you send/receive JSON documents that will cause an:
         1. action => "/XXX_act"
         2. getting => "/XXX_get"
         3. setting => "/XXX_set"
-
-        you can send commands through wifi/http or usb/serial
         '''
         if True: #logger is None:
             self.logger = Logger()
@@ -65,28 +69,27 @@ class UC2Client(object):
         # perhaps we are in the browser?
         self.isPyScript = isPyScript
 
-        # initialize communication channel (# connect to wifi or usb)
+        # Deprecation notice for WiFi mode
+        if host is not None and serialport is None and SerialManager is None:
+            self.logger.warning(
+                "WiFi/HTTP communication has been removed. "
+                "Please use serialport= instead. Ignoring host parameter."
+            )
+
+        # initialize communication channel (serial only)
         if serialport is not None:
             # use USB connection
             self.serial = Serial(serialport, baudrate, parent=self, identity=identity, DEBUG=DEBUG, skipFirmwareCheck=skipFirmwareCheck)
             self.is_serial = True
             self.is_connected = self.serial.is_connected
             self.serial.DEBUG = DEBUG
-        elif host is not None:
-            # use client in wireless mode
-            self.is_wifi = True
-            self.host = host
-            self.port = port
-
-            # check if host is up
-            self.logger.debug(f"Connecting to microscope {self.host}:{self.port}")
-            #self.is_connected = self.isConnected()
         elif SerialManager is not None:
-            # we are trying to access the controller from .a web browser
+            # we are trying to access the controller from a web browser
             self.serial = SerialManagerWrapper(SerialManager, parent=self)
             self.isPyScript = True
+            self.is_serial = True
         else:
-            self.logger.error("No ESP32 device is connected - check IP or Serial port!")
+            self.logger.error("No ESP32 device is connected - please provide a serialport!")
         
                         
         # import libraries depending on API version
@@ -149,49 +152,30 @@ 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)
     
     def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=1):
-        if self.is_wifi:
-            # FIXME: this is not working
-            url = f"http://{self.host}:{self.port}{path}"
-            try:
-                if timeout==0: timeout=.2
-                r = requests.post(url, json=payload, headers=self.headers,  timeout=timeout)
-                returnMessage = r.json()
-                returnMessage["success"] = r.status_code==200
-            except Exception as e:
-                print(e)
-                returnMessage = {}
-                returnMessage["error"] = str(e)
-                returnMessage["success"] = 0
-            return returnMessage
-        elif self.is_serial or self.isPyScript:
-            if timeout <=0:
-                getReturn = False
-            return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout)
-        else:
-            self.logger.error("No ESP32 device is connected - check IP or Serial port!")
-            return None
+        if timeout <=0:
+            getReturn = False
+        return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout)
 
     def get_json(self, path, getReturn=True, timeout=1):
-        if self.is_wifi:
-            # FIXME: this is not working
-            url = f"http://{self.host}:{self.port}{path}"
-            r = requests.get(url, headers=self.headers, timeout=timeout)
-            return r.json()
-        elif self.is_serial or self.isPyScript:
-            # timeout is not used anymore
-            if timeout <=0:
+        if self.is_serial or self.isPyScript:
+            if timeout <= 0:
                 getReturn = False
             return self.serial.post_json(path, payload=None, getReturn=getReturn, nResponses=1, timeout=timeout)
-            #return self.serial.read_json()<
         else:
-            self.logger.error("No ESP32 device is connected - check IP or Serial port!")
+            self.logger.error("No ESP32 device is connected - serial not initialized!")
             return None
 
     def setDebugging(self, debug=False):

{uc2_rest-0.2.0.31 → uc2_rest-0.2.0.33}/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.33"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

uc2_rest-0.2.0.33/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.33}/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,