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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UC2-REST
-Version: 0.2.0.17
+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.17 → 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.17
+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.17 → 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.17 → 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)
@@ -160,6 +163,7 @@ class UC2Client(object):
             # FIXME: this is not working
             url = f"http://{self.host}:{self.port}{path}"
             try:
+                if timeout==0: timeout=.2
                 r = requests.post(url, json=payload, headers=self.headers,  timeout=timeout)
                 returnMessage = r.json()
                 returnMessage["success"] = r.status_code==200
@@ -172,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, 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.17 → 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.17"
+__version__ = "v0.2.0.19"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

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

@@ -78,9 +78,9 @@ class Home(object):
                 {
                  "stepperid": axis,
                  "timeout":timeout*1000,
-                 "speed":speed,
+                 "speed":direction*abs(speed),
                  "direction":direction,
-                 "endposrelease":endposrelease, 
+                 "endposrelease":endposrelease,
                  "endstoppolarity":endstoppolarity
                  }]
             }}

{UC2-REST-0.2.0.17 → 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
@@ -46,7 +46,7 @@ class Laser(object):
 
         }
         #self._parent.logger.debug("Setting Laser "+str(channel)+", value: "+str(value))
-        r = self._parent.post_json(path, payload, getReturn=is_blocking)
+        r = self._parent.post_json(path, payload, getReturn=is_blocking, timeout=.5)
         return r
 
     def set_laserpin(self, laserid=1, laserpin=0):
@@ -61,33 +61,3 @@ class Laser(object):
         r = self._parent.post_json(path, payload)
         return r
 
-    def get_laserpins(self):
-        path = '/laser_get'
-        
-        r = self._parent.get_json(path)
-        
-        if type(r) is dict:
-            # cast laser pins
-            if "LASER1pin" in r: r["LASER1pin"] = int(r["LASER1pin"])
-            else: r["LASER1pin"] = 0
-            if r.__contains__("LASER2pin"): r["LASER2pin"] = int(r["LASER2pin"])
-            else: r["LASER2pin"] = 0
-            if r.__contains__("LASER3pin"): r["LASER3pin"] = int(r["LASER3pin"])
-            else: r["LASER3pin"] = 0
-        else:
-            r={}
-            r["LASER1pin"] = 0
-            r["LASER2pin"] = 0
-            r["LASER3pin"] = 0
-        
-        return r
-    
-    def get_laserpin(self, laserid=1):
-        path = '/laser_get'
-        
-        payload = {
-            "task": path,
-        }
-        
-        r = self._parent.post_json(path, payload,timeout=2)
-        return r["LASER"+str(laserid)+"pin"]

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.17 → 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
 
@@ -48,14 +38,17 @@ class Motor(object):
         self.stepSizeZ =  1
         self.stepSizeA =  1
 
+        self.DEFAULT_ACCELERATION = 10000
+
         self.motorAxisOrder = [0,1,2,3] # motor axis is 1,2,3,0 => X,Y,Z,T # FIXME: Hardcoded
 
         # register a callback function for the motor status on the serial loop
-        self._parent.serial.register_callback(self._callback_motor_status, pattern="steppers")
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_motor_status, pattern="steppers")
 
         # 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))
+        #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 _callback_motor_status(self, data):
         ''' cast the json in the form:
@@ -77,7 +70,46 @@ class Motor(object):
         except Exception as e:
             print("Error in _callback_motor_status: ", e)
 
+    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:
+            axis = self.xyztTo1230(axis)
+        path = "/motor_act"
+        payload = {
+            "task": path,
+            "setTrig":{
+                "steppers": [
+                {
+                 "stepperid": axis,
+                 "trigPin": pin,
+                 "trigOff": offset,
+                 "trigPer": period
+                 }]
+            }}
+        r = self._parent.post_json(path, payload)
+        return r
+
+    # {"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,
+            "stagescan":{
+                "nStepsLine": nStepsLine,
+                "dStepsLine": dStepsLine,
+                "nTriggerLine": nTriggerLine,
+                "nStepsPixel": nStepsPixel,
+                "dStepsPixel": dStepsPixel,
+                "nTriggerPixel": nTriggerPixel,
+                "delayTimeStep": delayTimeStep,
+                "stopped": 0,
+                "nFrames": nFrames
+            }}
+        r = self._parent.post_json(path, payload, getReturn=isBlocking)
+        return r
 
+    def stopStageScanning(self):
+        self.startStageScanning(stopped=1)
 
     def setIsCoreXY(self, isCoreXY = False):
         self.isCoreXY = isCoreXY
@@ -164,7 +196,7 @@ class Motor(object):
             # have to move only one motor to move in XY direction
            return self.move_xyza(steps=(0,steps[0], steps[1], 0), speed=(0,speed[0],speed[1],0), is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
         else:
-            if len(speed)!= 2:
+            if type(speed)==int or len(speed)!= 2:
                 speed = (speed,speed)
 
             if len(acceleration)!= 2:
@@ -339,10 +371,12 @@ class Motor(object):
                              "position": int(steps[iMotor]),
                              "speed": int(speed[iMotor]),
                              "isabs": isAbsoluteArray[iMotor],
-                             "isaccel":0,
+                             "isaccel":1,
                              "isen": is_enabled}
                 if acceleration[iMotor] is not None:
                     motorProp["accel"] = int(acceleration[iMotor])
+                else:
+                    motorProp["accel"] = self.DEFAULT_ACCELERATION
                 motorPropList.append(motorProp)
 
         path = "/motor_act"
@@ -478,7 +512,7 @@ class Motor(object):
         r = self._parent.post_json(path, payload)
         return r
 
-    def get_position(self, axis=None, timeout=1):
+    def get_position(self, axis=None, timeout=.2):
         # pulls all current positions from the stepper controller
         path = "/motor_get"
         payload = {
@@ -489,7 +523,7 @@ class Motor(object):
         _physicalStepSizes = np.array((self.stepSizeA, self.stepSizeX, self.stepSizeY, self.stepSizeZ))
 
         # this may be an asynchronous call.. #FIXME!
-        r = self._parent.post_json(path, payload, getReturn = True, nResponses=1)
+        r = self._parent.post_json(path, payload, getReturn = True, nResponses=1, timeout=timeout)
         if "motor" in r:
             for index, istepper in enumerate(r["motor"]["steppers"]):
                 _position[istepper["stepperid"]]=istepper["position"]*_physicalStepSizes[self.motorAxisOrder[index]]

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

@@ -9,12 +9,12 @@ class Serial:
     def __init__(self, port, baudrate=115200, timeout=5,
                  identity="UC2_Feather", parent=None, DEBUG=False):
 
-        self.ser = None
+        self.serialdevice = None
         self.serialport = port
         self.baudrate = baudrate
         self.timeout = timeout
         self._parent = parent
-
+        self.manufacturer = ""
         if self._parent is None:
             import logging
             self._logger = logging.getLogger(__name__)
@@ -26,23 +26,24 @@ 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
         self.thread = None
-        self.ser = self.openDevice(port, baudrate)
+        self.serialdevice= self.openDevice(port, baudrate)
 
     def breakCurrentCommunication(self):
         self.resetLastCommand = True
@@ -66,7 +67,7 @@ class Serial:
     def openDevice(self, port=None, baud_rate=115200):
         try: # try to close an eventually open serial connection
             if str(type(self.ser)) != "<class 'uc2rest.mserial.MockSerial'>":
-                self.ser.close()
+                self.serialdevice.close()
         except: pass
 
         try:
@@ -101,9 +102,20 @@ 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):
+        '''
+        This function tries to find the correct serial device from the list of available ports
+        It also checks if the firmware is correct by sending a command and checking for the correct response
+        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)
         ports_to_check = ["COM", "/dev/tt", "/dev/a", "/dev/cu.SLA", "/dev/cu.wchusb"]
         descriptions_to_check = ["CH340", "CP2102"]
@@ -113,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):
@@ -148,7 +162,7 @@ class Serial:
         ser.write(json.dumps(payload).encode('utf-8'))
         ser.write(b'\n')
         # iterate a few times in case the debug mode on the ESP32 is turned on and it sends additional lines
-        for i in range(100):
+        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))
@@ -162,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
@@ -170,24 +207,23 @@ 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.ser is None:
+            if self.serialdevice is None:
                 self.is_connected = False
                 continue
             else:
                 self.is_connected = True
 
             # if we just want to send but not even wait for a response
+        
             try:
-                mReadline = self.ser.readline()
+                mReadline = self.serialdevice.readline()
             except Exception as e:
                 self._logger.error("Failed to read the line in serial: "+str(e))
-                self.is_connected = False
-                break
             try:
                 line = mReadline.decode('utf-8').strip()
                 if self.DEBUG and line!="": self._logger.debug("[ProcessLines]:"+str(line))
@@ -212,18 +248,29 @@ class Serial:
 
                 except Exception as e:
                     self._logger.error("Failed to load the json from serial %s" % buffer)
-                    self._logger.error("Error: %s", e)
+                    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
@@ -235,7 +282,7 @@ class Serial:
         message = json.dumps(message)
         return self.sendMessage(message, nResponses=0, timeout=timeout)
 
-    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=1):
+    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=100):
         """Make an HTTP POST request and return the JSON response"""
         if payload is None:
             payload = {}
@@ -281,26 +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:
-                t0 = time.time()
-                self.ser.flush()
-                self._logger.debug("[SendMessage]: "+str(json_command))
-                self.ser.write(json_command.encode('utf-8') )
-                self._logger.debug("[SendMessage] took: "+str(time.time()-t0))
+            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.ser.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:
@@ -313,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
@@ -320,7 +375,7 @@ class Serial:
     def stop(self):
         self.running = False
         self.thread.join()
-        self.ser.close()
+        self.serialdevice.close()
 
     def closeSerial(self):
         self.stop()
@@ -329,7 +384,7 @@ class Serial:
     def reconnect(self):
         self.running = False
         try:
-            self.ser.close()
+            self.serialdevice.close()
         except:
             pass
         self.serialdevice = self.openDevice(port = self.serialport, baud_rate = self.baudrate)
@@ -388,6 +443,9 @@ class MockSerial:
         self.manufacturer = "UC2Mock"
         self.BAUDRATES = -1
 
+    def flush(self):
+        pass
+
     def isOpen(self):
         return self.is_open
 

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.17/uc2rest/temperature.py

@@ -1,56 +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=600000, updaterate=1000):
-        # {"task": "/heat_act", "active":1, "Kp":1000, "Ki":0.1, "Kd":0.1, "target":37, "timeout":600000, "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 = 9999
-        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()
-
-