UC2-REST 0.2.0.18__tar.gz → 0.2.0.19__tar.gz

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UC2-REST
-Version: 0.2.0.18
+Version: 0.2.0.19
 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.18 → uc2_rest-0.2.0.19}/UC2_REST.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UC2-REST
-Version: 0.2.0.18
+Version: 0.2.0.19
 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.18 → uc2_rest-0.2.0.19}/UC2_REST.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ uc2rest/home.py
 uc2rest/laser.py
 uc2rest/ledmatrix.py
 uc2rest/logger.py
+uc2rest/message.py
 uc2rest/modules.py
 uc2rest/motor.py
 uc2rest/mserial.py

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.19}/uc2rest/UC2Client.py

@@ -23,7 +23,7 @@ from .rotator import Rotator
 from .logger import Logger
 from .cmdrecorder import cmdRecorder
 from .temperature import Temperature
-
+from .message import Message
 try:
     import requests
 except:
@@ -141,6 +141,9 @@ class UC2Client(object):
         # initialize digital out
         self.digitalout = DigitalOut(self)
         
+        # initialize messaging
+        self.message = Message(self)
+        
         # initialize config
         if False: # not self.isPyScript: 
             self.config = config(self)
@@ -173,7 +176,7 @@ class UC2Client(object):
         elif self.is_serial or self.isPyScript:
             if timeout <=0:
                 getReturn = False
-            return self.serial.post_json(path, payload, getReturn=getReturn, timeout=timeout, nResponses=nResponses)
+            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

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.19}/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.18"
+__version__ = "v0.2.0.19"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.19}/uc2rest/home.py

@@ -80,7 +80,7 @@ class Home(object):
                  "timeout":timeout*1000,
                  "speed":direction*abs(speed),
                  "direction":direction,
-                 "endposrelease":endposrelease, 
+                 "endposrelease":endposrelease,
                  "endstoppolarity":endstoppolarity
                  }]
             }}

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.19}/uc2rest/laser.py

@@ -11,7 +11,7 @@ class Laser(object):
     def set_laser(self, channel=1, value=0, auto_filterswitch=False,
                         filter_axis=-1, filter_position = None,
                         despeckleAmplitude = 0.,
-                        despecklePeriod=10, timeout=20, is_blocking = True):
+                        despecklePeriod=10, timeout=20, is_blocking = False):
         if channel not in (0,1,2,3):
             if channel=="R":
                 channel = 1

uc2_rest-0.2.0.19/uc2rest/message.py

@@ -0,0 +1,85 @@
+import numpy as np
+import time
+import json
+
+
+gTIMEOUT = 1 # seconds to wait for a response from the ESP32
+class Message(object):
+    ''' 
+    This class only parses incoming messages from the ESP32 that can be used e.g. for triggering events such as taking an image
+    or converting hardware inputs such as button presses to software events
+    '''
+    def __init__(self, parent=None):
+        self._parent = parent
+        
+        # create a dictionary of callback functions that can be triggered by incoming messages
+        self._callbackPerKey = {}
+        self.NCallBacks = 10
+        for i in range(self.NCallBacks):
+            self._callbackPerKey[i] = None
+
+        # register a callback function for the motor status on the serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_message, pattern="message")
+
+    def _callback_message(self, data):
+        ''' cast the json in the form:
+        {
+            "message":      {
+                    "key":  1,
+                    "data": 1
+            }
+        }       
+        into seperated actions that follow this pattern:
+        data lookup:
+		{
+			key 	|	 meaning 		|	value
+			--------------------------------
+			1		|	snap image		|	0
+			2		|	exposure time	|	0....1000000
+			3		|	gain			|	0...100
+            ...
+            
+        Example:
+            #%%
+            import uc2rest
+            import time
+            
+            port = "unknown"
+            port = "/dev/cu.SLAB_USBtoUART"
+            ESP32 = uc2rest.UC2Client(serialport=port, baudrate=500000, DEBUG=True)
+
+            # register callback function for key/value pair 
+            def my_callback_key1(value):
+                print("Callback: ", value)
+            ESP32.message.register_callback(1, my_callback_key1)
+
+            while True:
+                time.sleep(.1)
+		*/
+  
+        '''
+        try:
+            # parse the message
+            key = data["message"]["key"]
+            value = data["message"]["data"]
+            # trigger the action
+            if self._callbackPerKey[key] is not None:
+                self._callbackPerKey[key](value) # we call the function with the value
+        except Exception as e:
+            print("Error in _callback_message: ", e)
+
+    def register_callback(self, key, callback):
+        ''' register a callback function for a specific key '''
+        self._callbackPerKey[key] = callback
+        
+    def trigger_message(self, key:int=1, value:int=1):
+        # {"task": "/message_act", "message": 1, "key":1, "value":1}
+        path = "/heat_act"
+        payload = {
+            "task": path,
+            "key": key,
+            "value": value
+            }
+        r = self._parent.post_json(path, payload, getReturn=False)
+        return r

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.19}/uc2rest/motor.py

@@ -9,16 +9,6 @@ class Motor(object):
     # indicate if there is any motion happening
     isRunning = False
 
-    # a dictionary that stores all motor parameters for each dxis
-    settingsdict = {"motor": {"steppers":
-        [{"stepperid":0,"dir":0,"step":0,"enable":0,"dir_inverted":False,"step_inverted":False,"enable_inverted":False,"speed":0,"speedmax":200000,"max_pos":100000,"min_pos":-100000},
-         {"stepperid":1,"dir":0,"step":0,"enable":0,"dir_inverted":False,"step_inverted":False,"enable_inverted":False,"speed":0,"speedmax":200000,"max_pos":100000,"min_pos":-100000},
-         {"stepperid":2,"dir":0,"step":0,"enable":0,"dir_inverted":False,"step_inverted":False,"enable_inverted":False,"speed":0,"speedmax":200000,"max_pos":100000,"min_pos":-100000},
-         {"stepperid":3,"dir":0,"step":0,"enable":0,"dir_inverted":False,"step_inverted":False,"enable_inverted":False,"speed":0,"speedmax":200000,"max_pos":100000,"min_pos":-100000}]
-        }}
-
-
-
     def __init__(self, parent=None):
         self._parent = parent
 
@@ -99,8 +89,8 @@ class Motor(object):
         r = self._parent.post_json(path, payload)
         return r
 
-    # {"task": "/motor_act", "stagescan": {"nStepsLine": 100, "dStepsLine": 1, "nTriggerLine": 1, "nStepsPixel": 100, "dStepsPixel": 1, "nTriggerPixel": 1, "delayTimeStep": 10, "stopped": 0, "nFrames": 5}}"}}
-    def startStageScanning(self, nStepsLine=100, dStepsLine=1, nTriggerLine=1, nStepsPixel=100, dStepsPixel=1, nTriggerPixel=1, delayTimeStep=10, nFrames=5):
+    # {"task": "/motor_act", "stagescan": {"nStepsLine": 50, "dStepsLine": 1, "nTriggerLine": 1, "nStepsPixel": 50, "dStepsPixel": 1, "nTriggerPixel": 1, "delayTimeStep": 10, "stopped": 0, "nFrames": 50}}"}}
+    def startStageScanning(self, nStepsLine=100, dStepsLine=1, nTriggerLine=1, nStepsPixel=100, dStepsPixel=1, nTriggerPixel=1, delayTimeStep=10, nFrames=5, isBlocking = False):
         path = "/motor_act"
         payload = {
             "task": path,
@@ -115,7 +105,7 @@ class Motor(object):
                 "stopped": 0,
                 "nFrames": nFrames
             }}
-        r = self._parent.post_json(path, payload)
+        r = self._parent.post_json(path, payload, getReturn=isBlocking)
         return r
 
     def stopStageScanning(self):

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.19}/uc2rest/mserial.py

@@ -14,7 +14,7 @@ class Serial:
         self.baudrate = baudrate
         self.timeout = timeout
         self._parent = parent
-
+        self.manufacturer = ""
         if self._parent is None:
             import logging
             self._logger = logging.getLogger(__name__)
@@ -26,18 +26,19 @@ class Serial:
         self.identity = identity
         self.DEBUG = DEBUG
         self.is_connected = False
-        self.write_timeout = 0.02
+        self.write_timeout = 0.05
         self.read_timeout = 0.02
 
         self.cmdCallBackFct = None
 
         # setup command queue
         self.resetLastCommand = False
-        self.command_queue = queue.Queue()
+        self.sender_queue = queue.Queue()
         self.responses = {}
         self.commands = {}
         self.lock = threading.Lock()
-
+        
+        # setup callback list for parent modules
         self.callBackList = []
 
         # initialize serial connection
@@ -101,6 +102,11 @@ class Serial:
         self.identifier_counter = 0 # Counter for generating unique identifiers
         self.thread = threading.Thread(target=self._process_commands)
         self.thread.start()
+        
+        # setup sender queue
+        self.sender_worker_thread = threading.Thread(target=self._sending_commands)
+        self.sender_worker_thread.daemon = True  # Ensure the thread exits when the main program does
+        self.sender_worker_thread.start()  
         return ser
 
     def findCorrectSerialDevice(self):
@@ -119,12 +125,14 @@ class Serial:
                any(port.description.startswith(allowed_description) for allowed_description in descriptions_to_check):
                 if self.tryToConnect(port.device):
                     self.is_connected = True
+                    self.manufacturer = port.manufacturer
                     return self.serialdevice
 
         self.is_connected = False
         self.serialport = "NotConnected"
         self.serialdevice = None
         self._logger.debug("No USB device connected! Using DUMMY!")
+        self.manufacturer = "UC2Mock"
         return None
 
     def tryToConnect(self, port):
@@ -168,6 +176,29 @@ class Serial:
         self.identifier_counter += 1
         return self.identifier_counter
 
+    def _enqueue_command(self, json_command):
+        """Add a command to the queue."""
+        self.sender_queue.put(json_command)
+
+    def _sending_commands(self):
+        """Sending commands from the queue with a 1s delay between them."""
+        while self.running:
+            
+            # Wait for the next command
+            json_command = self.sender_queue.get()
+            
+            # Process the command
+            try:
+                self.serialdevice.write(json_command.encode('utf-8'))
+            except Exception as e:
+                self._logger.error("Failed to write the line in serial: "+str(e))
+            
+            # Signal that the command has been processed
+            self.sender_queue.task_done()
+            
+            # Wait for .05 second before processing the next command
+            time.sleep(0.05)
+            
     def _process_commands(self):
         buffer = ""
         reading_json = False
@@ -176,9 +207,9 @@ class Serial:
         lineCounter = 0
         while self.running:
 
-            # Check if the last command went through successfully
-            #if not self.command_queue.empty() and not reading_json:
-            #    currentIdentifier, command = self.command_queue.get()
+            if self.manufacturer == "UC2Mock": 
+                self.running = False
+                return
 
             # device not ready yet
             if self.serialdevice is None:
@@ -188,6 +219,7 @@ class Serial:
                 self.is_connected = True
 
             # if we just want to send but not even wait for a response
+        
             try:
                 mReadline = self.serialdevice.readline()
             except Exception as e:
@@ -219,15 +251,26 @@ class Serial:
                     self._logger.error("Error: %s" % str(e))
                     json_response = {}
 
+                try: currentIdentifier = json_response["qid"]
+                except: pass
+
                 with self.lock:
-                    try: currentIdentifier = json_response["qid"]
-                    except: pass
                     try:
                         self.responses[currentIdentifier].append(json_response.copy())
                     except:
                         self.responses[currentIdentifier] = list()
                         self.responses[currentIdentifier].append(json_response.copy())
-                buffer = ""     # reset buffer
+                    buffer = ""      # reset buffer
+
+            # detect a reboot of the device and return the current QIDs
+            elif line == "reboot":
+                self._logger.warning("Device rebooted")
+                self.resetLastCommand = True
+                buffer = ""
+                lineCounter = 0
+                reading_json = False
+                self.responses[currentIdentifier].append({"reboot": 1})
+                self.responses[currentIdentifier].append({"qid": currentIdentifier})
 
             if reading_json:
                 buffer += line
@@ -285,24 +328,25 @@ class Serial:
         If nResponses is 1, then the command is sent and the response is returned.
         If nResponses is >1, then the command is sent and a list of responses is returned.
         '''
-        t0 = time.time()
         if type(command) == str:
             command = json.loads(command)
         identifier = self._generate_identifier()
         command["qid"] = identifier
-        self.command_queue.put((identifier, command))
         try:
             json_command = json.dumps(command)+"\n"
-            with self.lock:
-                self.serialdevice.flush()
-                self._logger.debug("[SendMessage]: "+str(json_command))
-                self.serialdevice.write(json_command.encode('utf-8') )
+            self.serialdevice.flush()
+            if self.DEBUG: self._logger.debug("[SendMessage]: "+str(json_command))
+            # we have to queue the commands and give it some time to process
+            self._enqueue_command(json_command)
+            
         except Exception as e:
             if self.DEBUG: self._logger.error(e)
             return "Failed to Send"
-        self.commands[identifier]=command
-        if nResponses <= 0 or not self.is_connected or not type(self.serialdevice.BAUDRATES) is tuple:
+        self.commands[identifier]=command # FIXME: Need to clear this after the response is received
+        if nResponses <= 0 or not self.is_connected or self.manufacturer=="UC2Mock":
             return identifier
+        t0 = time.time()
+        timeReturnReceived = 0.3
         while self.running:
             time.sleep(0.002)
             if self.resetLastCommand or time.time()-t0>timeout or not self.is_connected:
@@ -315,6 +359,15 @@ class Serial:
                 if -identifier in self.responses:
                     self._logger.debug("You have sent the wrong command!")
                     return "Wrong Command"
+            if time.time()-t0>timeReturnReceived and not (identifier in self.responses and len(self.responses[identifier]) > 0):
+                self._logger.debug("It takes too long to get a response, we will resend the last command")
+                try:
+                    self.DEBUG=1
+                    self.serialdevice.write(json.dumps(self.commands[identifier]).encode('utf-8'))
+                    time.sleep(0.1)
+                except Exception as e:
+                    self._logger.error("Failed to write the line in serial: "+str(e))
+            
 
     def interruptCurrentSerialCommunication(self):
         self.resetLastCommand = True

uc2_rest-0.2.0.19/uc2rest/temperature.py

@@ -0,0 +1,93 @@
+import time
+import threading
+class Temperature(object):
+
+    def __init__(self, parent):
+        self._parent = parent
+        self._temperature = -273.15
+        
+        self.is_temperature_polling = False
+        
+        # register a callback function for the motor status on the serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_temperature_status, pattern="heat")
+        
+
+    '''
+    ##############################################################################################################################
+    Temperature Controllers
+    ##############################################################################################################################
+    '''
+    
+    def start_temperature_polling(self, period=5):
+        self.is_temperature_polling = True
+        def _poll_temperature():
+            while self.is_temperature_polling:
+                path = "/heat_get"
+                r = self._parent.get_json(path, timeout=0)
+                time.sleep(period)
+        threading.Thread(target=_poll_temperature).start()
+        
+    def stop_temperature_polling(self):
+        self.is_temperature_polling = False
+        
+        
+    def _callback_temperature_status(self, data):
+        ''' cast the json in the form:
+        {
+        "qid":	0,
+        "heat":	37.0
+        }
+        into the position array of the motors '''
+        try:
+            self._temperature = data["heat"]
+        except Exception as e:
+            print("Error in _callback_temperature_status: ", e)
+
+
+    def stop_heating(self):
+        r = self.set_temperature(active=0)
+        return r
+
+    def set_temperature(self, active=1, Kp=1000, Ki=0.1, Kd=0.1, target=37, timeout=600000000, updaterate=1000):
+        # {"task": "/heat_act", "active":1, "Kp":1000, "Ki":0.1, "Kd":0.1, "target":37, "timeout":60000000, "updaterate":1000}
+        path = "/heat_act"
+        payload = {
+            "task": path,
+            "active": int(active),
+            "Kp": Kp,
+            "Ki": Ki,
+            "Kd": Kd,
+            "target": target,
+            "timeout": timeout,
+            "updaterate": updaterate
+            }
+        r = self._parent.post_json(path, payload, getReturn=False)
+        return r
+
+    def get_temperature(self, timeout=0.5, isBlocking=False):
+        # {"task": "/heat_get"}
+        if isBlocking:
+            path = "/heat_get"
+            r = self._parent.get_json(path, timeout=timeout)
+            try:
+                r = r["heat"]
+            except:
+                r = -273.15
+            return r
+        else:
+            return self._temperature
+
+if __name__ == "__main__":
+
+    #%%
+    import uc2rest
+    import time
+    port = "/dev/cu.SLAB_USBtoUART"
+    ESP32 = uc2rest.UC2Client(serialport=port, DEBUG=True)
+    ESP32.temperature.set_temperature(active=1, Kp=1000, Ki=0.1, Kd=0.1, target=37, timeout=600000, updaterate=1000)
+    for i in range(10):
+        print(ESP32.temperature.get_temperature())
+        time.sleep(1)
+    ESP32.temperature.stop_heating()
+    ESP32.close()

UC2-REST-0.2.0.18/uc2rest/temperature.py

@@ -1,54 +0,0 @@
-class Temperature(object):
-
-    def __init__(self, parent):
-        self._parent = parent
-
-    '''
-    ##############################################################################################################################
-    Temperature Controllers
-    ##############################################################################################################################
-    '''
-
-    def stop_heating(self):
-        r = self.set_temperature(active=0)
-        return r
-
-    def set_temperature(self, active=1, Kp=1000, Ki=0.1, Kd=0.1, target=37, timeout=600000000, updaterate=1000):
-        # {"task": "/heat_act", "active":1, "Kp":1000, "Ki":0.1, "Kd":0.1, "target":37, "timeout":60000000, "updaterate":1000}
-        path = "/heat_act"
-        payload = {
-            "task": path,
-            "active": int(active),
-            "Kp": Kp,
-            "Ki": Ki,
-            "Kd": Kd,
-            "target": target,
-            "timeout": timeout,
-            "updaterate": updaterate
-            }
-        r = self._parent.post_json(path, payload, getReturn=False)
-        return r
-
-    def get_temperature(self, timeout=0.5):
-        path = "/heat_get"
-        r = self._parent.get_json(path, timeout=timeout)
-        try:
-            r = r["heat"]
-        except:
-            r = -273.15
-        return r
-
-
-if __name__ == "__main__":
-
-    #%%
-    import uc2rest
-    import time
-    port = "/dev/cu.SLAB_USBtoUART"
-    ESP32 = uc2rest.UC2Client(serialport=port, DEBUG=True)
-    ESP32.temperature.set_temperature(active=1, Kp=1000, Ki=0.1, Kd=0.1, target=37, timeout=600000, updaterate=1000)
-    for i in range(10):
-        print(ESP32.temperature.get_temperature())
-        time.sleep(1)
-    ESP32.temperature.stop_heating()
-    ESP32.close()