UC2-REST 0.2.0.22__tar.gz → 0.2.0.24__tar.gz

{uc2_rest-0.2.0.22 → uc2_rest-0.2.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.22
+Version: 0.2.0.24
 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
@@ -24,6 +24,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{uc2_rest-0.2.0.22 → uc2_rest-0.2.0.24}/UC2_REST.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.22
+Version: 0.2.0.24
 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
@@ -24,6 +24,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{uc2_rest-0.2.0.22 → uc2_rest-0.2.0.24}/UC2_REST.egg-info/SOURCES.txt

@@ -18,14 +18,17 @@ uc2rest/config.py
 uc2rest/config_.py
 uc2rest/digitalout.py
 uc2rest/galvo.py
+uc2rest/gripper.py
 uc2rest/home.py
 uc2rest/laser.py
 uc2rest/ledmatrix.py
+uc2rest/ledmatrix_.py
 uc2rest/logger.py
 uc2rest/message.py
 uc2rest/modules.py
 uc2rest/motor.py
 uc2rest/mserial.py
+uc2rest/objective.py
 uc2rest/pid.py
 uc2rest/rotator.py
 uc2rest/slm.py

{uc2_rest-0.2.0.22 → uc2_rest-0.2.0.24}/uc2rest/UC2Client.py

@@ -11,7 +11,9 @@ from .galvo import Galvo
 from .config import config
 from .ledmatrix import LedMatrix
 from .motor import Motor
+from .gripper import Gripper
 from .home import Home
+from .objective import Objective
 from .state import State
 from .laser import Laser
 from .wifi import Wifi
@@ -41,7 +43,7 @@ class UC2Client(object):
     # BAUDRATE = 500000
     BAUDRATE = 500000
 
-    def __init__(self, host=None, port=31950, serialport=None, identity="UC2_Feather", baudrate=BAUDRATE, NLeds=64, SerialManager=None, DEBUG=False, logger=None):
+    def __init__(self, host=None, port=31950, serialport=None, identity="UC2_Feather", baudrate=BAUDRATE, NLeds=64, SerialManager=None, DEBUG=False, logger=None, skipFirmwareCheck=False):
         '''
         This client connects to the UC2-REST microcontroller that can be found here
         https://github.com/openUC2/UC2-REST
@@ -64,7 +66,7 @@ class UC2Client(object):
         # initialize communication channel (# connect to wifi or usb)
         if serialport is not None:
             # use USB connection
-            self.serial = Serial(serialport, baudrate, parent=self, identity=identity, DEBUG=DEBUG)
+            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
@@ -109,12 +111,18 @@ class UC2Client(object):
         # initilize motor
         self.motor = Motor(self)
         
+        # initialize gripper
+        self.gripper = Gripper(self)
+        
         # initialize rotator
         self.rotator = Rotator(self)
         
         # initiliaze homing
         self.home = Home(self)
         
+        # initialize objective
+        self.objective = Objective(self)
+        
         # initialize temperature
         self.temperature = Temperature(self)
 

{uc2_rest-0.2.0.22 → uc2_rest-0.2.0.24}/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.22"
+__version__ = "v0.2.0.24"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

uc2_rest-0.2.0.24/uc2rest/gripper.py

@@ -0,0 +1,107 @@
+import time
+import json
+
+class Gripper(object):
+    """
+    Example Python class for controlling a gripper servo via JSON commands
+    to the MCU, similar in style to the Objective class provided.
+    """
+
+    def __init__(self, parent):
+        """
+        parent: an object that handles the low-level post_json(path, payload, getReturn, timeout, nResponses)
+                similar to the 'Home' or 'Objective' parent in the template.
+        """
+        self._parent = parent
+        self.timeout = 10  # default timeout for blocking commands
+        # Default angles
+        self.close_angle = 0
+        self.open_angle  = 180
+
+    def close(self, isBlocking=False):
+        """
+        Closes the gripper to close_angle (0° by default).
+        Sends {"task":"/gripper_act","action":"close"} over Serial/JSON.
+        """
+        path = "/gripper_act"
+        payload = {
+            "task": path,
+            "action": "close"
+        }
+        # Possibly wait for the MCU response
+        nResponses = 1 if isBlocking else 0
+        r = self._parent.post_json(
+            path,
+            payload,
+            getReturn=isBlocking,
+            timeout=self.timeout if isBlocking else 0,
+            nResponses=nResponses
+        )
+        return r
+
+    def open(self, isBlocking=False):
+        """
+        Opens the gripper to open_angle (180° by default).
+        Sends {"task":"/gripper_act","action":"open"}.
+        """
+        path = "/gripper_act"
+        payload = {
+            "task": path,
+            "action": "open"
+        }
+        nResponses = 1 if isBlocking else 0
+        r = self._parent.post_json(
+            path,
+            payload,
+            getReturn=isBlocking,
+            timeout=self.timeout if isBlocking else 0,
+            nResponses=nResponses
+        )
+        return r
+
+    def setAngle(self, angle, isBlocking=False):
+        """
+        Moves the gripper servo to an arbitrary angle (0–180).
+        Sends {"task":"/gripper_act","action":"degree","value":<angle>}.
+        """
+        path = "/gripper_act"
+        payload = {
+            "task": path,
+            "action": "degree",
+            "value": angle
+        }
+        nResponses = 1 if isBlocking else 0
+        r = self._parent.post_json(
+            path,
+            payload,
+            getReturn=isBlocking,
+            timeout=self.timeout if isBlocking else 0,
+            nResponses=nResponses
+        )
+        return r
+
+    def getstatus(self):
+        """
+        Query the current gripper status.
+        Expects MCU to return something like:
+          {
+            "gripper":{
+              "pos": 90,
+              "isOpen": 0 or 1,
+              "state": 1,
+              "isRunning": 0
+            }
+          }
+        """
+        path = "/gripper_get"
+        payload = {"task": path}
+        r = self._parent.post_json(path, payload, timeout=1)
+
+        try:
+            # The last item in r is assumed to contain the "gripper" field
+            status = r[-1]["gripper"]
+        except:
+            # Fallback if parsing fails
+            status = {"pos": 0, "isOpen": None, "state": 0, "isRunning": 0}
+
+        return status

{uc2_rest-0.2.0.22 → uc2_rest-0.2.0.24}/uc2rest/home.py

@@ -15,7 +15,7 @@ class Home(object):
         # axis = 1 corresponds to 'X'
         axis = 1
         self.home(axis=axis, 
-                  timeout=timeout, 
+                  endstoptimeout=timeout, 
                   speed = speed, 
                   direction = direction, 
                   endposrelease=endposrelease,
@@ -26,7 +26,7 @@ class Home(object):
         # axis = 2 corresponds to 'Y'
         axis = 2
         self.home(axis=axis, 
-                  timeout=timeout, 
+                  endstoptimeout=timeout, 
                   speed = speed, 
                   direction = direction, 
                   endposrelease=endposrelease, 
@@ -37,7 +37,7 @@ class Home(object):
         # axisa = 3 corresponds to 'Z'
         axis = 3
         self.home(axis=axis, 
-                  timeout=timeout, 
+                  endstoptimeout=timeout, 
                   speed = speed, 
                   direction = direction, 
                   endposrelease=endposrelease, 
@@ -48,14 +48,14 @@ class Home(object):
         # axis = 0 corresponds to 'A'
         axis = 0
         self.home(axis=axis,
-                  timeout=timeout, 
+                  endstoptimeout=timeout, 
                   speed = speed, 
                   direction = direction, 
                   endposrelease=endposrelease, 
                   endstoppolarity=endstoppolarity,
                   isBlocking=isBlocking)    
     
-    def home(self, axis=None, timeout=None, speed=None, direction=None, endposrelease=None, endstoppolarity=None, isBlocking=False):
+    def home(self, axis=None, timeout=None, speed=None, direction=None, endposrelease=None, endstoppolarity=None, endstoptimeout=10000, isBlocking=False):
         '''
         axis = 0,1,2,3 or 'A, 'X','Y','Z'
         timeout => when to stop homing (it's a while loop on the MCU)
@@ -88,7 +88,7 @@ class Home(object):
                 "steppers": [
                 {
                  "stepperid": axis,
-                 "timeout":timeout,
+                 "timeout":endstoptimeout,
                  "speed":abs(speed),
                  "direction":direction,
                  "endstoppolarity":endstoppolarity

uc2_rest-0.2.0.24/uc2rest/ledmatrix.py

@@ -0,0 +1,324 @@
+import numpy as np
+
+gTimeout = 2
+
+class LedMatrix(object):
+    def __init__(self, parent, NLeds=64):
+        """
+        This class handles sending JSON commands for controlling a NeoPixel or LED matrix device.
+        The 'parent' is assumed to be an object providing post_json(...) and get_json(...) methods.
+        """
+        self.NLeds = NLeds
+        self.Nx = self.Ny = int(np.sqrt(NLeds)) if NLeds > 0 else 8
+
+        # We assume the pattern is binary (0 or 1) for an NxN grid, stored in ledpattern NxN or flattened.
+        # We store an RGB for each LED if needed. -1 indicates "unset" or no color assigned.
+        self.ledpattern = np.ones((self.NLeds, 3)) * -1
+
+        self._parent = parent  # must have post_json() etc.
+        self.timeout = 1
+        self.intensity = (255, 255, 255)
+
+        # Maps textual modes to an integer, used for backward compatibility
+        self.ledArrayModes = {
+            "array": 0,
+            "full": 1,
+            "single": 2,
+            "off": 3,
+            "left": 4,
+            "right": 5,
+            "top": 6,
+            "bottom": 7,
+            "multi": 8
+        }
+
+        self.currentLedArrayMode = "full"
+
+    ######################################################################################################
+    # BASE / LEGACY METHODS
+    ######################################################################################################
+
+    def send_LEDMatrix_array(self, led_pattern, getReturn=True, timeout=gTimeout):
+        """
+        Send an LED array pattern e.g. a list of { id, r, g, b } or a NumPy array shape (N,3).
+        Produces JSON:
+        {
+          "task": "/ledarr_act",
+          "led": {
+            "action": "array",
+            "LEDArrMode": 0,
+            "led_array": [
+               {"id":0,"r":...,"g":...,"b":...},
+               ...
+            ]
+          }
+        }
+        """
+        path = "/ledarr_act"
+
+        # If led_pattern is a NumPy array, convert it to a list of dict
+        if not isinstance(led_pattern, list):
+            if len(led_pattern.shape) == 3:
+                # flatten 3D into 2D
+                led_pattern = np.reshape(led_pattern, (led_pattern.shape[0]*led_pattern.shape[1], led_pattern.shape[2]))
+
+            pattern_list = []
+            for i in range(led_pattern.shape[0]):
+                pattern_list.append({
+                    "id": i,
+                    "r": int(led_pattern[i, 0]),
+                    "g": int(led_pattern[i, 1]),
+                    "b": int(led_pattern[i, 2])
+                })
+        else:
+            pattern_list = led_pattern
+
+        payload = {
+            "task": path,
+            "qid": 0,  # or fill in dynamically if you like
+            "led": {
+                "action": "array",
+                "LEDArrMode": self.ledArrayModes["array"],
+                "led_array": pattern_list
+            }
+        }
+
+        r = self._parent.post_json(path, payload, getReturn=getReturn, timeout=timeout)
+        if not getReturn or timeout == 0:
+            r = {"success": 1}
+        self.currentLedArrayMode = "array"
+        return r
+
+    def send_LEDMatrix_full(self, intensity=(255, 255, 255), getReturn=True, timeout=gTimeout):
+        """
+        Fill all LEDs with the same (r,g,b). 
+        Creates JSON with: "action": "fill"
+        """
+        path = "/ledarr_act"
+        payload = {
+            "task": path,
+            "qid": 0,
+            "led": {
+                "action": "fill",
+                "LEDArrMode": self.ledArrayModes["full"],
+                "r": int(intensity[0]),
+                "g": int(intensity[1]),
+                "b": int(intensity[2])
+            }
+        }
+
+        r = self._parent.post_json(path, payload, getReturn=getReturn, timeout=timeout)
+        if not getReturn or timeout == 0:
+            r = {"success": 1}
+        self.currentLedArrayMode = "full"
+        return r
+
+    def send_LEDMatrix_single(self, indexled=0, intensity=(255, 255, 255), getReturn=True, timeout=gTimeout):
+        """
+        Update only a single LED with color (r,g,b).
+        Creates JSON: "action":"single"
+        """
+        path = "/ledarr_act"
+        payload = {
+            "task": path,
+            "qid": 0,
+            "led": {
+                "action": "single",
+                "LEDArrMode": self.ledArrayModes["single"],
+                "ledIndex": int(indexled),
+                "r": int(intensity[0]),
+                "g": int(intensity[1]),
+                "b": int(intensity[2])
+            }
+        }
+
+        r = self._parent.post_json(path, payload, getReturn=getReturn, timeout=timeout)
+        if not getReturn or timeout == 0:
+            r = {"success": 1}
+        self.currentLedArrayMode = "single"
+        return r
+
+    def get_LEDMatrix(self, timeout=gTimeout):
+        """
+        Request info from the device about pin/LED count, etc.
+        Usually the device responds with JSON containing these details.
+        """
+        path = "/ledarr_get"
+        payload = {"task": path}
+        r = self._parent.post_json(path, payload, getReturn=True, timeout=timeout)
+        return r
+
+    def setSingle(self, indexled, state):
+        """
+        High-level usage: set a single LED's "state" (0 or 1), then send it with intensity scaling.
+        """
+        ix = indexled // self.Nx
+        iy = indexled % self.Nx
+        self.ledpattern[indexled] = (state, state, state)
+        # If your wiring is zig-zag or reversed, you may need to adapt index
+        if ix % 2 != 0:
+            indexled = (ix * self.Nx) + (self.Ny - iy - 1)
+
+        intensityScaled = np.array(state) * np.array(self.intensity)
+        self.send_LEDMatrix_single(indexled=indexled, intensity=intensityScaled, timeout=self.timeout)
+        return self.ledpattern
+
+    def setAll(self, state: int, intensity:int =None, getReturn=True):
+        """
+        Turn on or off all LEDs at a certain intensity. 
+        If state is a boolean array or a single boolean, we set them all.
+        """
+        onval = np.sum(state) > 0
+        if intensity is not None:
+            self.intensity = intensity
+        intensity2display = np.array(self.intensity) * onval
+        self.send_LEDMatrix_full(intensity=intensity2display, getReturn=getReturn)
+        self.ledpattern = onval * np.ones((self.NLeds, 3))
+        return self.ledpattern
+
+    def setIntensity(self, intensity:int, getReturn:bool=True):
+        self.intensity = intensity
+        self.setPattern(getReturn=getReturn)
+
+    def setPattern(self, getReturn:bool=True, ledpattern=None):
+        """
+        If ledpattern is provided, store it, then send to device.
+        If the entire pattern is "on", we do a 'full' fill for speed,
+        otherwise we do 'array' updates for each LED.
+        """
+        if ledpattern is not None:
+            self.ledpattern = ledpattern
+        pattern2send = (self.ledpattern >= 1) * self.intensity
+
+        if np.sum(self.ledpattern, 0)[0] == self.ledpattern.shape[0]:
+            # All on => just do a fill
+            self.send_LEDMatrix_full(pattern2send[0, :], getReturn=getReturn)
+        else:
+            # partial => send an array of per-LED
+            self.send_LEDMatrix_array(pattern2send, getReturn=getReturn)
+        return self.ledpattern
+
+    def getPattern(self):
+        return self.ledpattern
+
+    def set_led(self, colour=(0, 0, 0)):
+        """
+        (Legacy) Possibly sets a single color. 
+        Demo only - not used in the new command style.
+        """
+        path = "/led"
+        payload = {"r": colour[0], "g": colour[1], "b": colour[2]}
+        r = self._parent.post_json(path, payload)
+        return r
+
+    def get_ledpin(self):
+        """
+        Another legacy method that might do a GET request.
+        """
+        path = "/ledarr_get"
+        r = self._parent.get_json(path, getReturn=True, timeout=1)
+        return r
+
+    ######################################################################################################
+    # NEW METHODS FOR "OFF", "RINGS", "CIRCLES", "HALVES", etc.
+    ######################################################################################################
+    def send_LEDMatrix_off(self, getReturn=True, timeout=gTimeout):
+        """
+        Turn all LEDs off.
+        JSON: "action":"off"
+        """
+        path = "/ledarr_act"
+        payload = {
+            "task": path,
+            "qid": 0,
+            "led": {
+                "action": "off"
+            }
+        }
+        r = self._parent.post_json(path, payload, getReturn=getReturn, timeout=timeout)
+        return r
+
+    def send_LEDMatrix_halves(self, region="left", intensity=(255,255,255), getReturn=True, timeout=gTimeout):
+        """
+        Light only "left"/"right"/"top"/"bottom" half in color, rest is dark.
+        JSON: "action":"halves", "region": <string>
+        """
+        if type(intensity)==int:
+            intensity = (intensity, intensity, intensity)        
+        path = "/ledarr_act"
+        payload = {
+            "task": path,
+            "qid": 0,
+            "led": {
+                "action": "halves",
+                "region": region,
+                "r": int(intensity[0]),
+                "g": int(intensity[1]),
+                "b": int(intensity[2])
+            }
+        }
+        r = self._parent.post_json(path, payload, getReturn=getReturn, timeout=timeout)
+        return r
+
+    def send_LEDMatrix_rings(self, radius=4, intensity=(255,255,255), getReturn=True, timeout=gTimeout):
+        """
+        Draw a ring of radius N. Often done by filling the circle and carving out center to make it hollow.
+        JSON: "action":"rings", "radius": <int>
+        """
+        if type(intensity)==int:
+            intensity = (intensity, intensity, intensity)
+        path = "/ledarr_act"
+        payload = {
+            "task": path,
+            "qid": 0,
+            "led": {
+                "action": "rings",
+                "radius": radius,
+                "r": int(intensity[0]),
+                "g": int(intensity[1]),
+                "b": int(intensity[2])
+            }
+        }
+        r = self._parent.post_json(path, payload, getReturn=getReturn, timeout=timeout)
+        return r
+
+    def send_LEDMatrix_circles(self, radius=4, intensity=(255,255,255), getReturn=True, timeout=gTimeout):
+        """
+        Draw a filled circle of radius N in color.
+        JSON: "action":"circles", "radius": <int>
+        """
+        if type(intensity)==int:
+            intensity = (intensity, intensity, intensity)
+        path = "/ledarr_act"
+        payload = {
+            "task": path,
+            "qid": 0,
+            "led": {
+                "action": "circles",
+                "radius": radius,
+                "r": int(intensity[0]),
+                "g": int(intensity[1]),
+                "b": int(intensity[2])
+            }
+        }
+        r = self._parent.post_json(path, payload, getReturn=getReturn, timeout=timeout)
+        return r
+
+    def send_LEDMatrix_status(self, status="idle"):
+        """
+        Set the status of the LED matrix to "idle" or "busy".
+        JSON: "action":"status", "status": <string>
+        """
+        if status not in ["error", "idle", "warn", "success", "busy", "rainbow"]:
+            status = "idle"
+        path = "/ledarr_act"
+        payload = {
+            "task": path,
+            "qid": 0,
+            "led": {
+                "action": "status",
+                "status": status
+            }
+        }
+        r = self._parent.post_json(path, payload)
+        return r