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

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

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

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

@@ -7,6 +7,7 @@ UC2_REST.egg-info/dependency_links.txt
 UC2_REST.egg-info/not-zip-safe
 UC2_REST.egg-info/requires.txt
 UC2_REST.egg-info/top_level.txt
+uc2rest/MockSerial.py
 uc2rest/UC2Client.py
 uc2rest/__init__.py
 uc2rest/__version__.py

uc2_rest-0.2.0.21/uc2rest/MockSerial.py

@@ -0,0 +1,74 @@
+import random
+from threading import Thread
+import time
+
+class MockSerial:
+    def __init__(self, port, baudrate, timeout=1):
+        self.port = port
+        self.baudrate = baudrate
+        self.timeout = timeout
+        self.is_open = False
+        self.data_buffer = []
+        self.thread = Thread(target=self._simulate_data)
+        self.thread.daemon = True
+        self.thread.start()
+        self.is_open = True
+        self.manufacturer = "UC2Mock"
+        self.BAUDRATES = -1
+
+    def flush(self):
+        pass
+
+    def isOpen(self):
+        return self.is_open
+
+    def open(self):
+        self.is_open = True
+
+    def close(self):
+        self.is_open = False
+
+    def readline(self, timeout=1):
+        if not self.is_open:
+            raise Exception("Device not connected")
+        if len(self.data_buffer) == 0:
+            return b''
+        data = self.data_buffer
+        self.data_buffer = self.data_buffer
+        time.sleep(.05)
+        return bytes(data)
+
+    def read(self, num_bytes):
+        if not self.is_open:
+            raise Exception("Device not connected")
+        if len(self.data_buffer) == 0:
+            return b''
+        data = self.data_buffer[:num_bytes]
+        self.data_buffer = self.data_buffer[num_bytes:]
+        return bytes(data)
+
+    def write(self, data):
+        if not self.is_open:
+            raise Exception("Device not connected")
+        pass  # Do nothing, as it's a mock
+
+    def _simulate_data(self):
+        while self.is_open:
+            if random.random() < 0.2:  # Simulate occasional data availability
+                self.data_buffer.extend([random.randint(0, 255) for _ in range(10)])
+            time.sleep(0.1)
+
+    def __enter__(self):
+        self.open()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+if __name__ == '__main__':
+    with MockSerial("COM1", 9600) as ser:
+        while True:
+            data = ser.readline()
+            print(data)
+            time.sleep(1)

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/UC2Client.py

@@ -39,7 +39,7 @@ class UC2Client(object):
     is_serial = False
 
     # BAUDRATE = 500000
-    BAUDRATE = 115200
+    BAUDRATE = 500000
 
     def __init__(self, host=None, port=31950, serialport=None, identity="UC2_Feather", baudrate=BAUDRATE, NLeds=64, SerialManager=None, DEBUG=False, logger=None):
         '''

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

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/galvo.py

@@ -1,3 +1,4 @@
+import numpy as np
 class Galvo(object):
     def __init__(self, parent=None):
         '''
@@ -15,16 +16,18 @@ class Galvo(object):
         self._parent = parent
 
     
-    def set_dac(self, channel=1, frequency=1, offset=0, amplitude=1/2, clk_div=0, timeout=1):
-        
+    def set_dac(self, channel=1, frequency=1, offset=0, amplitude=1, clk_div=0, phase=0, invert=1, timeout=1):
+        # {"task":"/dac_act", "dac_channel":1, "frequency":10, "offset":1, "amplitude":1, "divider":0, "phase":0, "invert":1, "qid":2}
         path = "/dac_act"
         payload = {
             "task": path,
             "dac_channel": channel, # 1 or 2
             "frequency": frequency,
             "offset": offset,
-            "amplitude":amplitude,
-            "clk_div": clk_div
+            "divider": clk_div,
+            "amplitude":amplitude, 
+            "phase":phase,
+            "invert":invert
         }
                         
         self._parent.post_json(path, payload, timeout=timeout, getReturn=False)

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/laser.py

@@ -6,7 +6,6 @@ class Laser(object):
         self.filter_pos_2 = 0
         self.filter_pos_3 = 0
         self.filter_pos_LED = 0
-        self._parent.logger.debug("Attention, lasers are on channels 1,2,3")
         
     def set_laser(self, channel=1, value=0, auto_filterswitch=False,
                         filter_axis=-1, filter_position = None,
@@ -61,3 +60,18 @@ class Laser(object):
         r = self._parent.post_json(path, payload)
         return r
 
+
+
+    def set_servo(self, channel=1, value=0, is_blocking=False):
+        #{"task":"/laser_act", "LASERid":1 ,"LASERval":99, "servo":1, "qid":1}
+        path = '/laser_act'
+        
+        payload = {
+            "task": path,
+            "LASERid": channel,
+            "LASERval": value, 
+            "servo": 1
+        }
+        
+        r = self._parent.post_json(path, payload, getReturn=is_blocking)
+        return r

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/ledmatrix.py

@@ -1,7 +1,6 @@
 import numpy as np
-import json
-import time 
-gTimeout = 1
+
+gTimeout = 2
 class LedMatrix(object):
     def __init__(self, parent, NLeds=64):
         #TOOD: This is for the LED matrix only!
@@ -73,7 +72,7 @@ class LedMatrix(object):
         self.currentLedArrayMode = "array"            
         return r
 
-    def send_LEDMatrix_full(self, intensity = (255,255,255), getReturn=False, timeout=gTimeout):
+    def send_LEDMatrix_full(self, intensity = (255,255,255), getReturn=True, timeout=gTimeout):
         '''
         set all LEDs with te same RGB value: intensity=(255,255,255)
         '''
@@ -168,7 +167,7 @@ class LedMatrix(object):
 
         return self.ledpattern
     
-    def setAll(self, state, intensity=None, getReturn=False):
+    def setAll(self, state, intensity=None, getReturn=True):
         # fast addressing
         # turns on all LEDs at a certain intensity
         state = np.sum(state)>0
@@ -179,7 +178,7 @@ class LedMatrix(object):
         self.ledpattern = state*np.ones((self.NLeds, 3))
         return self.ledpattern
     
-    def setIntensity(self, intensity, getReturn=False):
+    def setIntensity(self, intensity, getReturn=True):
         self.intensity = intensity
         self.setPattern(getReturn=getReturn)
     

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/message.py

@@ -9,19 +9,17 @@ 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):
+    def __init__(self, parent=None, nCallbacks = 10):
         self._parent = parent
+        self.nCallbacks = nCallbacks
+        # initialize the callback functions
+        self.init_callback_functions(self.nCallbacks)
         
-        # 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:
         {
@@ -69,13 +67,20 @@ class Message(object):
         except Exception as e:
             print("Error in _callback_message: ", e)
 
+    def init_callback_functions(self, nCallbacks=10):
+        ''' initialize the callback functions '''
+        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 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"
+        path = "/message_act"
         payload = {
             "task": path,
             "key": key,

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/motor.py

@@ -45,11 +45,23 @@ class Motor(object):
         # register a callback function for the motor status on the serial loop
         if hasattr(self._parent, "serial"):
             self._parent.serial.register_callback(self._callback_motor_status, pattern="steppers")
-
+        # announce a function that is called when we receive a position update through the callback
+        self._callbackPerKey = {}
+        self.nCallbacks = 10
+        self._callbackPerKey = self.init_callback_functions(nCallbacks=self.nCallbacks) # only one is used for now
+        print(self._callbackPerKey)
         # move motor to wake them up #FIXME: Should not be necessary!
         #self.move_stepper(steps=(1,1,1,1), speed=(1000,1000,1000,1000), is_absolute=(False,False,False,False))
         #self.move_stepper(steps=(-1,-1,-1,-1), speed=(1000,1000,1000,1000), is_absolute=(False,False,False,False))
 
+    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_motor_status(self, data):
         ''' cast the json in the form:
         {
@@ -67,9 +79,16 @@ class Motor(object):
                 stepperID = data["steppers"][iMotor]["stepperid"]
                 # smart to re-update this variable? Will be updated by motor-sender too
                 self._position[stepperID] = data["steppers"][iMotor]["position"]
+            if  callable(self._callbackPerKey[0]):
+                self._callbackPerKey[0](self._position) # we call the function with the value
         except Exception as e:
             print("Error in _callback_motor_status: ", e)
 
+    def register_callback(self, key, callbackfct):
+        ''' register a callback function for a specific key '''
+        self._callbackPerKey[key] = callbackfct
+        
+        
     def setTrigger(self, axis="X", pin=1, offset=0, period=1):
         # {"task": "/motor_act", "setTrig": {"steppers": [{"stepperid": 1, "trigPin": 1, "trigOff":0, "trigPer":1}]}}
         if type(axis) is not int:
@@ -512,7 +531,7 @@ class Motor(object):
         r = self._parent.post_json(path, payload)
         return r
 
-    def get_position(self, axis=None, timeout=.2):
+    def get_position(self, axis=None, timeout=1):
         # pulls all current positions from the stepper controller
         path = "/motor_get"
         payload = {

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/mserial.py

@@ -1,10 +1,11 @@
 import serial
+from serial.tools  import list_ports
 import json
 import queue
 import threading
 import time
 
-T_SERIAL_WARMUP = 1.5
+T_SERIAL_WARMUP = 2.5
 class Serial:
     def __init__(self, port, baudrate=115200, timeout=5,
                  identity="UC2_Feather", parent=None, DEBUG=False):
@@ -26,7 +27,7 @@ class Serial:
         self.identity = identity
         self.DEBUG = DEBUG
         self.is_connected = False
-        self.write_timeout = 0.05
+        self.write_timeout = 1
         self.read_timeout = 0.02
 
         self.cmdCallBackFct = None
@@ -37,6 +38,7 @@ class Serial:
         self.responses = {}
         self.commands = {}
         self.lock = threading.Lock()
+        self.serialLock = threading.Lock()
         
         # setup callback list for parent modules
         self.callBackList = []
@@ -53,8 +55,10 @@ class Serial:
         # free up any old data
         while True:
             try:
-                readLine = ser.readline().decode('utf-8').strip()
-                if self.DEBUG: self._logger.debug(readLine)
+                readLineRaw = ser.readline()
+                readLine = readLineRaw.decode('utf-8').strip()
+                if self.DEBUG and readLine != "": 
+                    self._logger.debug(readLine)
                 if readLine == "" and time.time()-t0 > timeMinimum:
                     break
             except Exception as e:
@@ -116,7 +120,7 @@ class Serial:
         It may be that - depending on the OS - the response may be corrupted
         If this is the case try to hard-code the COM port into the config JSON file
         '''
-        _available_ports = serial.tools.list_ports.comports(include_links=False)
+        _available_ports = list_ports.comports(include_links=False)
         ports_to_check = ["COM", "/dev/tt", "/dev/a", "/dev/cu.SLA", "/dev/cu.wchusb"]
         descriptions_to_check = ["CH340", "CP2102"]
 
@@ -165,7 +169,8 @@ class Serial:
         for i in range(500):
             # if we just want to send but not even wait for a response
             mReadline = ser.readline()
-            if self.DEBUG: self._logger.debug("[checkFirmware]: "+str(mReadline))
+            if self.DEBUG and mReadline != "" and mReadline != "\n" and mReadline != b'' and mReadline != b'\n': 
+                self._logger.debug("[checkFirmware]: "+str(mReadline))
             if mReadline.decode('utf-8').strip() == "++":
                 self._freeSerialBuffer(ser)
                 return True
@@ -188,14 +193,17 @@ class Serial:
             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))
+            with self.serialLock:
+                try:
+                    if self.DEBUG and json_command!="": self._logger.debug("[SendingCommands]:"+str(json_command))
+                    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()
-            
+            if self.DEBUG: self._logger.debug("[SendingCommands]: Task done")
+                        
             # Wait for .05 second before processing the next command
             time.sleep(0.05)
             
@@ -206,7 +214,6 @@ class Serial:
         nLineCountTimeout = 50 # maximum number of lines read before timeout
         lineCounter = 0
         while self.running:
-
             if self.manufacturer == "UC2Mock": 
                 self.running = False
                 return
@@ -219,15 +226,13 @@ class Serial:
                 self.is_connected = True
 
             # if we just want to send but not even wait for a response
-        
             try:
-                mReadline = self.serialdevice.readline()
+                with self.serialLock:
+                    mReadline = self.serialdevice.readline()
+                    line = mReadline.decode('utf-8').strip()
+                    if self.DEBUG and line!="": self._logger.debug("[ProcessLines]:"+str(line))
             except Exception as e:
                 self._logger.error("Failed to read the line in serial: "+str(e))
-            try:
-                line = mReadline.decode('utf-8').strip()
-                if self.DEBUG and line!="": self._logger.debug("[ProcessLines]:"+str(line))
-            except:
                 line = ""
             if line == "++":
                 reading_json = True
@@ -334,16 +339,19 @@ class Serial:
         command["qid"] = identifier
         try:
             json_command = json.dumps(command)+"\n"
-            self.serialdevice.flush()
-            if self.DEBUG: self._logger.debug("[SendMessage]: "+str(json_command))
+            #self.serialdevice.flush()
+            if self.DEBUG and json_command!="": self._logger.debug("[SendingCommands]:"+str(json_command))
+            self.serialdevice.write(json_command.encode('utf-8'))
+            #time.sleep(1)
             # we have to queue the commands and give it some time to process
-            self._enqueue_command(json_command)
+            #self._enqueue_command(json_command)
             
         except Exception as e:
             if self.DEBUG: self._logger.error(e)
             return "Failed to Send"
         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":
+            time.sleep(0.1)
             return identifier
         t0 = time.time()
         timeReturnReceived = 0.3
@@ -351,7 +359,7 @@ class Serial:
             time.sleep(0.002)
             if self.resetLastCommand or time.time()-t0>timeout or not self.is_connected:
                 self.resetLastCommand = False
-                return "communication interrupted"
+                return "communication interrupted by timeout or reset: "+str(identifier) + " and code:"+str(self.commands[identifier])
             with self.lock:
                 if identifier in self.responses:
                     if len(self.responses[identifier])==nResponses:
@@ -362,7 +370,6 @@ class Serial:
             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:
@@ -381,8 +388,10 @@ class Serial:
         self.stop()
         self.running = False
 
-    def reconnect(self):
+    def reconnect(self, baudrate=None):
         self.running = False
+        if baudrate is not None:
+            self.baudrate = baudrate
         try:
             self.serialdevice.close()
         except:

{uc2_rest-0.2.0.19 → uc2_rest-0.2.0.21}/uc2rest/state.py

@@ -84,3 +84,15 @@ class State(object):
         except:
             return r
 
+
+    def getHeap(self, timeout=1):
+        path = "/state_get"
+        payload = {
+            "task":path,
+            "heap": 1
+        }
+        r = self._parent.post_json(path, payload, timeout=timeout)
+        try:
+            return r["heap"]
+        except:
+            return r