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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UC2-REST
-Version: 0.2.0.18
+Version: 0.2.0.20
 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.20}/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.20
 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.20}/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
@@ -21,6 +22,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.20/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.18 → uc2_rest-0.2.0.20}/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:
@@ -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):
         '''
@@ -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.20}/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.20"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

{UC2-REST-0.2.0.18 → uc2_rest-0.2.0.20}/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.20}/uc2rest/laser.py

@@ -6,12 +6,11 @@ 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,
                         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.18 → uc2_rest-0.2.0.20}/uc2rest/ledmatrix.py

@@ -1,7 +1,7 @@
 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 +73,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 +168,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 +179,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.20/uc2rest/message.py

@@ -0,0 +1,90 @@
+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, nCallbacks = 10):
+        self._parent = parent
+        self.nCallbacks = nCallbacks
+        # initialize the callback functions
+        self.init_callback_functions(self.nCallbacks)
+        
+        # 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 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 = "/message_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.20}/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
 
@@ -55,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:
         {
@@ -77,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:
@@ -99,8 +108,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 +124,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):
@@ -522,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.18 → uc2_rest-0.2.0.20}/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):
@@ -14,7 +15,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 +27,20 @@ class Serial:
         self.identity = identity
         self.DEBUG = DEBUG
         self.is_connected = False
-        self.write_timeout = 0.02
+        self.write_timeout = 1
         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()
-
+        self.serialLock = threading.Lock()
+        
+        # setup callback list for parent modules
         self.callBackList = []
 
         # initialize serial connection
@@ -52,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:
@@ -101,6 +106,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):
@@ -110,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"]
 
@@ -119,12 +129,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):
@@ -157,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
@@ -168,6 +181,32 @@ 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
+            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)
+            
     def _process_commands(self):
         buffer = ""
         reading_json = False
@@ -175,10 +214,9 @@ class Serial:
         nLineCountTimeout = 50 # maximum number of lines read before timeout
         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:
@@ -189,13 +227,12 @@ class Serial:
 
             # 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
@@ -219,15 +256,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,29 +333,33 @@ 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 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)
+            
         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":
+            time.sleep(0.1)
             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:
                 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:
@@ -315,6 +367,14 @@ 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.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
@@ -328,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.18 → uc2_rest-0.2.0.20}/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

uc2_rest-0.2.0.20/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()