UC2-REST 0.2.0.21__tar.gz → 0.2.0.23__tar.gz

{uc2_rest-0.2.0.21 → uc2_rest-0.2.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.21
+Version: 0.2.0.23
 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
@@ -16,9 +16,18 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: requests
 Requires-Dist: pyserial
-Requires-Dist: esptool
-Requires-Dist: progressbar2
-Requires-Dist: pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 <p align="left">

{uc2_rest-0.2.0.21 → uc2_rest-0.2.0.23}/UC2_REST.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.21
+Version: 0.2.0.23
 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
@@ -16,9 +16,18 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: requests
 Requires-Dist: pyserial
-Requires-Dist: esptool
-Requires-Dist: progressbar2
-Requires-Dist: pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 <p align="left">

{uc2_rest-0.2.0.21 → uc2_rest-0.2.0.23}/UC2_REST.egg-info/SOURCES.txt

@@ -18,19 +18,21 @@ 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
 uc2rest/state.py
 uc2rest/temperature.py
-uc2rest/updater.py
 uc2rest/utils.py
 uc2rest/wifi.py

uc2_rest-0.2.0.23/UC2_REST.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+requests
+pyserial

{uc2_rest-0.2.0.21 → uc2_rest-0.2.0.23}/setup.py

@@ -27,7 +27,7 @@ setup(
     packages=['uc2rest'],
     include_package_data=True,
     python_requires='>=3.7',
-    install_requires=['numpy', 'requests', 'pyserial', "esptool", "progressbar2", "pillow"],
+    install_requires=['numpy', 'requests', 'pyserial'],
     license=about['__license__'],
     zip_safe=False,
     entry_points={

{uc2_rest-0.2.0.21 → uc2_rest-0.2.0.23}/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
@@ -84,9 +86,7 @@ class UC2Client(object):
         else:
             self.logger.error("No ESP32 device is connected - check IP or Serial port!")
         
-                
-        if not self.isPyScript: from .updater import updater
-        
+                        
         # import libraries depending on API version
         self.logger.debug("Using API version 2")        
 
@@ -111,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)
 
@@ -150,11 +156,7 @@ class UC2Client(object):
             try: self.pinConfig = self.config.loadConfigDevice()
             except: self.pinConfig = None
         
-        # initialize updater 
-        if not self.isPyScript: 
-            try: self.updater = updater(parent=self)
-            except: self.updater = None
-        
+
         # initialize module controller
         self.modules = Modules(parent=self)
     
@@ -192,7 +194,7 @@ class UC2Client(object):
             if timeout <=0:
                 getReturn = False
             return self.serial.post_json(path, payload=None, getReturn=getReturn, nResponses=1, timeout=timeout)
-            #return self.serial.read_json()
+            #return self.serial.read_json()<
         else:
             self.logger.error("No ESP32 device is connected - check IP or Serial port!")
             return None
@@ -202,4 +204,4 @@ class UC2Client(object):
         self.serial.DEBUG = debug
         
     def close(self):
-        self.serial.closeSerial()
+        self.serial.close()

uc2_rest-0.2.0.23/uc2rest/__init__.py

@@ -0,0 +1,2 @@
+from .config import *
+from .UC2Client import *

{uc2_rest-0.2.0.21 → uc2_rest-0.2.0.23}/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.21"
+__version__ = "v0.2.0.23"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

uc2_rest-0.2.0.23/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.21 → uc2_rest-0.2.0.23}/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,14 +37,25 @@ class Home(object):
         # axisa = 3 corresponds to 'Z'
         axis = 3
         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_a(self, speed = None, direction = None, endposrelease = None, endstoppolarity=None, timeout=None, isBlocking=False):
+        # axis = 0 corresponds to 'A'
+        axis = 0
+        self.home(axis=axis,
+                  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, 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)
@@ -77,10 +88,9 @@ class Home(object):
                 "steppers": [
                 {
                  "stepperid": axis,
-                 "timeout":timeout*1000,
-                 "speed":direction*abs(speed),
+                 "timeout":endstoptimeout,
+                 "speed":abs(speed),
                  "direction":direction,
-                 "endposrelease":endposrelease,
                  "endstoppolarity":endstoppolarity
                  }]
             }}

uc2_rest-0.2.0.23/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