UC2-REST 0.2.0.9__tar.gz → 0.2.0.12__tar.gz

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/PKG-INFO

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

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

@@ -27,4 +27,5 @@ uc2rest/pid.py
 uc2rest/slm.py
 uc2rest/state.py
 uc2rest/updater.py
+uc2rest/utils.py
 uc2rest/wifi.py

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/uc2rest/UC2Client.py

@@ -6,15 +6,20 @@ Simple client code for the ESP32 in Python
 Copyright 2021 Benedict Diederich, released under LGPL 3.0 or later
 """
 from .mserial import Serial
+from .mserial import SerialManagerWrapper
+
 try:
-    from imswitch.imcommon.model import initLogger
+    from .imswitch.imcommon.model import initLogger
     IS_IMSWITCH = True
 except:
     print("No imswitch available")
     from .logger import Logger
     IS_IMSWITCH = False
 
-import requests
+try:
+    import requests
+except:
+    print("No requests available - running on pyscript?")
 
 class UC2Client(object):
     # headers = {'ESP32-version': '*'}
@@ -28,7 +33,7 @@ class UC2Client(object):
     # BAUDRATE = 500000
     BAUDRATE = 115200
 
-    def __init__(self, host=None, port=31950, serialport=None, identity="UC2_Feather", baudrate=BAUDRATE, NLeds=64, DEBUG=False):
+    def __init__(self, host=None, port=31950, serialport=None, identity="UC2_Feather", baudrate=BAUDRATE, NLeds=64, SerialManager=None, DEBUG=False):
         '''
         This client connects to the UC2-REST microcontroller that can be found here
         https://github.com/openUC2/UC2-REST
@@ -48,6 +53,7 @@ class UC2Client(object):
             self.logger = Logger()
         # set default APIVersion
         self.APIVersion = 2
+        self.isPyScript = False
 
         # initialize communication channel (# connect to wifi or usb)
         if serialport is not None:
@@ -64,10 +70,14 @@ class UC2Client(object):
 
             # check if host is up
             self.logger.debug(f"Connecting to microscope {self.host}:{self.port}")
-            self.is_connected = self.isConnected()
+            #self.is_connected = self.isConnected()
+        elif SerialManager is not None:
+            # we are trying to access the controller from .a web browser
+            self.serial = SerialManagerWrapper(SerialManager, parent=self)
+            self.isPyScript = True
         else:
             self.logger.error("No ESP32 device is connected - check IP or Serial port!")
-
+        
         # import libraries depending on API version
         if self.APIVersion == 1:
             self.logger.debug("Using API version 1")
@@ -93,7 +103,7 @@ class UC2Client(object):
             from .wifi import Wifi
             from .camera import Camera
             from .analog import Analog
-            from .updater import updater
+            if not self.isPyScript: from .updater import updater
             from .modules import Modules
             from .digitalout import DigitalOut
 
@@ -103,10 +113,12 @@ class UC2Client(object):
 
         # initialize state
         self.state = State(self)
-        self.state.get_state()
-
+        if not self.isPyScript: 
+            state = self.state.get_state()
+       
         # initialize config
-        self.config = config(self)
+        if not self.isPyScript: 
+            self.config = config(self)
 
         # initialize LED matrix
         self.led = LedMatrix(self, NLeds=NLeds)
@@ -139,11 +151,15 @@ class UC2Client(object):
         self.digitalout = DigitalOut(self)
         
         # initialize config
-        self.config = config(self)
-        self.pinConfig = self.config.loadConfigDevice()
+        if not self.isPyScript: 
+            self.config = config(self)
+            try: self.pinConfig = self.config.loadConfigDevice()
+            except: self.pinConfig = None
         
         # initialize updater 
-        self.updater = updater(parent=self)
+        if not self.isPyScript: 
+            try: self.updater = updater(parent=self)
+            except: self.updater = None
         
         # initialize module controller
         self.modules = Modules(parent=self)
@@ -152,23 +168,25 @@ class UC2Client(object):
         if self.is_wifi:
             # FIXME: this is not working
             url = f"http://{self.host}:{self.port}{path}"
-            r = requests.post(url, json=payload, headers=self.headers)
-            return r.json()
-        elif self.is_serial:
+            r = requests.post(url, json=payload, headers=self.headers,  timeout=timeout)
+            returnMessage = r.json()
+            returnMessage["success"] = r.status_code==200
+            return returnMessage
+        elif self.is_serial or self.isPyScript:
             return self.serial.post_json(path, payload, getReturn=getReturn, timeout=timeout)
         else:
             self.logger.error("No ESP32 device is connected - check IP or Serial port!")
             return None
 
-    def get_json(self, path, timeout=1):
+    def get_json(self, path, getReturn=False, timeout=1):
         if self.is_wifi:
             # FIXME: this is not working
             url = f"http://{self.host}:{self.port}{path}"
-            r = requests.get(url, headers=self.headers)
+            r = requests.get(url, headers=self.headers, timeout=timeout)
             return r.json()
-        elif self.is_serial:
-            self.serial.get_json(path)
-            return self.serial.read_json()
+        elif self.is_serial or self.isPyScript:
+            return self.serial.get_json(path)
+            #return self.serial.read_json()
         else:
             self.logger.error("No ESP32 device is connected - check IP or Serial port!")
             return None

UC2 REST-0.2.0.12/uc2rest/__init__.py

@@ -0,0 +1,6 @@
+from .config import *
+from .UC2Client import *
+try:
+    from .updater import *
+except:
+    print("Updater not available")

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/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.9"
+__version__ = "v0.2.0.12"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/uc2rest/laser.py

@@ -64,11 +64,7 @@ class Laser(object):
     def get_laserpins(self):
         path = '/laser_get'
         
-        payload = {
-            "task": path,
-        }
-        
-        r = self._parent.post_json(path, payload)
+        r = self._parent.get_json(path)
         
         if type(r) is dict:
             # cast laser pins

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/uc2rest/ledmatrix.py

@@ -10,7 +10,7 @@ class LedMatrix(object):
         self.Nx = self.Ny = int(np.sqrt(NLeds))
         
         # we assume the pattern is binary (e.g. 0 or 1)
-        self.ledpattern = np.zeros((self.NLeds, 3))
+        self.ledpattern = np.ones((self.NLeds, 3))*-1 # not set yet
         
         # this is a istance of the _parent32Client class
         self._parent = parent
@@ -165,6 +165,7 @@ class LedMatrix(object):
     def setAll(self, state, intensity=None):
         # fast addressing
         # turns on all LEDs at a certain intensity
+        state = np.sum(state)>0
         if intensity is not None:
             self.intensity = intensity
         intensity2display = np.array(self.intensity)*np.array(state)
@@ -217,10 +218,7 @@ class LedMatrix(object):
         
     def get_ledpin(self):
         path = "/ledarr_get"
-        payload = {
-            "task": path,
-        }
-        r = self._parent.post_json(path, payload, getReturn=True, timeout=1)
+        r = self._parent.get_json(path, getReturn=True, timeout=1)
         return r
             
     

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/uc2rest/modules.py

@@ -25,12 +25,10 @@ class Modules(object):
     def get_modules(self, timeout=1):
         # returns a list of available modules that are set or not set in the ESP
         path = '/modules_get'
-        
-        payload = {
-            "task": path,
-            }
-        r = self._parent.post_json(path, payload)["modules"]
-        
+        try:
+            r = self._parent.get_json(path)["modules"]
+        except:
+            r = None
         return r
 
     def set_modules(self, modules, timeout=1):

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/uc2rest/motor.py

@@ -3,7 +3,7 @@ import time
 import json
 
 
-gTIMEOUT = 10 # seconds to wait for a response from the ESP32
+gTIMEOUT = 100 # seconds to wait for a response from the ESP32
 class Motor(object):
 
     # indicate if there is any motion happening
@@ -21,6 +21,9 @@ class Motor(object):
 
     def __init__(self, parent=None):
         self._parent = parent
+        
+        # do we have a coreXY setup?
+        self.isCoreXY = False
 
         self.nMotors = 4
         self.steps_last = np.zeros((self.nMotors))
@@ -44,6 +47,9 @@ class Motor(object):
 
         self.motorAxisOrder = [0,1,2,3] # motor axis is 1,2,3,0 => X,Y,Z,T # FIXME: Hardcoded
 
+    def setIsCoreXY(self, isCoreXY = False):
+        self.isCoreXY = isCoreXY 
+
     def setMotorAxisOrder(self, order=[0,1,2,3]):
         self.motorAxisOrder = order
 
@@ -84,17 +90,34 @@ class Motor(object):
             axis = 0
         return axis
 
-    def move_x(self, steps=0, speed=1000, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
-        return self.move_axis_by_name(axis="X", steps=steps, speed=speed, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
+    def cartesian2corexy(self, x, y):
+        # convert cartesian coordinates to coreXY coordinates
+        # https://www.corexy.com/theory.html
+        x1 = (x+y)/np.sqrt(2)
+        y1 = (x-y)/np.sqrt(2)
+        return x1, y1
+    
+    def move_x(self, steps=0, speed=1000, acceleration=None, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
+        if self.isCoreXY:
+            # have to turn two motors to move in X direction
+            xTemp, yTemp =  self.cartesian2corexy(steps, 0)
+            return self.move_xy(steps=(xTemp, yTemp), speed=(speed,speed), is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
+        else:
+            return self.move_axis_by_name(axis="X", steps=steps, speed=speed, acceleration=acceleration, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
 
-    def move_y(self, steps=0, speed=1000, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
-        return self.move_axis_by_name(axis="Y", steps=steps, speed=speed, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
+    def move_y(self, steps=0, speed=1000, acceleration=None,  is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
+        if self.isCoreXY:
+            # have to turn two motors to move in Y direction
+            xTemp, yTemp =  self.cartesian2corexy(0,steps)
+            return self.move_xy(steps=(xTemp, yTemp), speed=(speed,speed), is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
+        else:
+            return self.move_axis_by_name(axis="Y", steps=steps, speed=speed, acceleration=acceleration, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
 
-    def move_z(self, steps=0, speed=1000, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
-        return self.move_axis_by_name(axis="Z", steps=steps, speed=speed, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
+    def move_z(self, steps=0, speed=1000, acceleration=None,  is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
+        return self.move_axis_by_name(axis="Z", steps=steps, speed=speed, acceleration=acceleration, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
 
-    def move_t(self, steps=0, speed=1000, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
-        return self.move_axis_by_name(axis="T", steps=steps, speed=speed, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
+    def move_t(self, steps=0, speed=1000, acceleration=None, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
+        return self.move_axis_by_name(axis="T", steps=steps, speed=speed, acceleration=acceleration, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
 
     def move_xyz(self, steps=(0,0,0), speed=(1000,1000,1000), is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
         if len(speed)!= 3:
@@ -105,12 +128,16 @@ class Motor(object):
         return r
 
     def move_xy(self, steps=(0,0), speed=(1000,1000), is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
-        if len(speed)!= 2:
-            speed = (speed,speed)
+        if self.isCoreXY:
+            # have to move only one motor to move in XY direction
+           return self.move_xyzt(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:
+                speed = (speed,speed)
 
-        # motor axis is 1,2,3,0 => X,Y,Z,T # FIXME: Hardcoded
-        r = self.move_xyzt(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)
-        return r
+            # motor axis is 1,2,3,0 => X,Y,Z,T # FIXME: Hardcoded
+            r = self.move_xyzt(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)
+            return r
 
     def move_xyzt(self, steps=(0,0,0,0), speed=(1000,1000,1000,1000), is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
         if type(speed)==int:
@@ -121,7 +148,7 @@ class Motor(object):
         r = self.move_stepper(steps=steps, speed=speed, backlash=(self.backlash[0],self.backlash[1],self.backlash[2],self.backlash[3]), is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled, timeout=timeout)
         return r
 
-    def move_axis_by_name(self, axis="X", steps=100, speed=1000, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
+    def move_axis_by_name(self, axis="X", steps=100, speed=1000, acceleration=None, is_blocking=False, is_absolute=False, is_enabled=True, timeout=gTIMEOUT):
         axis = self.xyztTo1230(axis)
         _speed=np.zeros(4)
         _speed[axis] = speed
@@ -129,7 +156,8 @@ class Motor(object):
         _steps[axis] = steps
         _backlash=np.zeros(4)
         _backlash[axis] = self.backlash[axis]
-        r = self.move_stepper(_steps, speed=_speed, timeout=timeout, backlash=_backlash, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled)
+        _acceleration=acceleration
+        r = self.move_stepper(_steps, speed=_speed, acceleration=_acceleration, timeout=timeout, backlash=_backlash, is_blocking=is_blocking, is_absolute=is_absolute, is_enabled=is_enabled)
         return r
 
     def move_forever(self, speed=(0,0,0,0), is_stop=False):
@@ -197,7 +225,7 @@ class Motor(object):
         return r
 
 
-    def move_stepper(self, steps=(0,0,0,0), speed=(1000,1000,1000,1000), is_absolute=(False,False,False,False), timeout=1, backlash=(0,0,0,0), is_blocking=True, is_enabled=True):
+    def move_stepper(self, steps=(0,0,0,0), speed=(1000,1000,1000,1000), is_absolute=(False,False,False,False), timeout=gTIMEOUT, backlash=(0,0,0,0), acceleration=(None, None, None, None), is_blocking=True, is_enabled=True):
         '''
         This tells the motor to run at a given speed for a specific number of steps; Multiple motors can run simultaneously
 
@@ -217,6 +245,10 @@ class Motor(object):
         if type(speed)!=list and type(speed)!=tuple and type(speed)!=np.ndarray:
             speed = np.array((speed,speed,speed,speed))
 
+        # convert single elements to array
+        if type(acceleration)!=list and type(acceleration)!=tuple and type(acceleration)!=np.ndarray:
+            acceleration = np.array((acceleration,acceleration,acceleration,acceleration))
+
         # make sure value is an array
         if type(steps)==tuple:
             steps = np.array(steps)
@@ -248,41 +280,19 @@ class Motor(object):
             steps_3 = 0
         '''
 
-        '''
-        {"task":"/motor_act",
-        "motor":{
-            "steppers":[
-                {
-                    "stepperid":1,
-                    "position":-1000,
-                    "speed":2000,
-                    "isabs":0,
-                    "isaccel":0
-                }
-            ]
-        }
-        }
-
-        {"task":"/motor_act",
-    "motor":
-    {
-        "steppers": [
-            { "stepperid": 1, "position": -100, "speed": 2000, "isabs": 0, "isaccel":0}
-        ]
-    }
-}
-        '''
 
         # only consider those actions that are necessary
         motorPropList = []
         for iMotor in range(4):
             if isAbsoluteArray[iMotor] or abs(steps[iMotor])>0:
                 motorProp = { "stepperid": self.motorAxisOrder[iMotor],
-                             "position": np.int(steps[iMotor]),
-                             "speed": speed[iMotor],
+                             "position": int(steps[iMotor]),
+                             "speed": int(speed[iMotor]),
                              "isabs": isAbsoluteArray[iMotor],
                              "isaccel":0, 
                              "isen": is_enabled}
+                if acceleration[iMotor] is not None:
+                    motorProp["accel"] = int(acceleration[iMotor])
                 motorPropList.append(motorProp)
 
         path = "/motor_act"
@@ -304,8 +314,11 @@ class Motor(object):
 
         # wait until job has been done        
         time0=time.time()
-        steppersRunning = np.abs(np.array(steps))>0
-        if is_blocking and self._parent.serial.is_connected:
+        if np.sum(isAbsoluteArray):
+            steppersRunning = isAbsoluteArray
+        else:
+            steppersRunning = np.abs(np.array(steps))>0
+        if not self._parent.is_wifi and is_blocking and self._parent.serial.is_connected:
             while True:
                 time.sleep(0.05) # don'T overwhelm the CPU
                 # see if already done
@@ -395,21 +408,40 @@ class Motor(object):
         r = self.set_motor(stepperid = axis, position = currentPosition)
         return r
 
-    def set_motor_acceleration(self, axis=0, acceleration=10000):
+    def set_motor_acceleration(self, axis=0, acceleration=40000):
         if type(axis)==str:
             axis = self.xyztTo1230(axis)
 
-        r = self.set_motor(stepperid = axis, acceleration=acceleration)
+        path = "/motor_act"
+        payload = {
+            "task": path,
+            "motor":
+            {
+            "steppers": [
+            { "stepperid":axis, "isaccel":1, "accel":acceleration}
+            ]
+            }
+            }
+        r = self._parent.post_json(path, payload)
         return r
 
-    def set_motor_enable(self, axis =0, is_enable=1):
-        if type(axis)==str:
-            axis = self.xyztTo1230(axis)
+
+    def set_motor_enable(self, is_enable=1):
+        self.set_motor_enable(enable=is_enable)
+
+    def set_motor_enable(self, enable=None, enableauto=None):
+        """
+        turns on/off enable pin overrides motor settings - god for cooling puproses
+        eanbaleauto  turns on/off timer of the accelstepper library
+        """
         path = "/motor_act"
         payload = {
-            "task": path,
-            "isen": is_enable
+            "task": path
         }
+        if enable is not None:
+            payload["isen"] = enable
+        if enableauto is not None:
+            payload["isenauto"] = enableauto
         r = self._parent.post_json(path, payload)
         return r
 
@@ -464,10 +496,8 @@ class Motor(object):
 
     def get_motors(self, timeout=1):
         path = "/motor_get"
-        payload = {
-            "task":path,
-        }
-        r = self._parent.post_json(path, payload, timeout=timeout)
+        
+        r = self._parent.get_json(path, timeout=timeout)
         try: return r["steppers"]
         except: return False
 

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/uc2rest/mserial.py

@@ -1,9 +1,12 @@
-import serial
-import serial.tools.list_ports
+try:
+    import serial
+    import serial.tools.list_ports
+except:
+    print("No serial available - running on pyscript?")
 import time
 import json
 
-T_SERIAL_WARMUP = 2 # the time to wait for the serial to warm up
+T_SERIAL_WARMUP = 3 # the time to wait for the serial to warm up
 
 class Serial(object):
     
@@ -208,6 +211,75 @@ class Serial(object):
             self.isSafetyBreak = False
         return _returnmessage
         
+class SerialManagerWrapper(object):
+    
+    def __init__(self, SerialManager, DEBUG = True, parent=None) -> None:
+        self._parent=parent
+        self._parent.logger.debug("SerialManagerWrapper init")
+        self.SerialManager = SerialManager
+        self.isSafetyBreak = False
+        self.DEBUG = DEBUG
+        
+    async def post_json(self, path, payload={}, getReturn=True, timeout=1):
+        if "task" not in payload:
+            payload["task"] = path
+        
+        if "isblock" in payload:
+            is_blocking = payload["isblock"]
+        else:
+            is_blocking = True
+
+        # write message to the serial
+        await self.writeSerial(payload)
+        return ''
+        print(3)
+        if getReturn:
+            # we read the return message
+            #self._parent.logger.debug(payload)
+            returnmessage = self.readSerial(is_blocking=is_blocking, timeout=timeout)
+        else:
+            returnmessage = False
+        return returnmessage
+    
+    async def writeSerial(self, payload):
+        """Write JSON document to serial device"""
+        if type(payload)==dict:
+            payload = json.dumps(payload)
+        try:
+            if self.DEBUG: self._parent.logger.debug(payload)
+            await self.SerialManager.write(payload)
+        except Exception as e:
+            self._parent.logger.error(e)
+
+    async def readSerial(self, is_blocking=True, timeout = 1): # TODO: hardcoded timeout - not code
+        """Receive and decode return message"""
+        returnmessage = ''
+        _returnmessage = ''
+        rmessage = ''
+        _time0 = time.time()
+        print("Reading serial")
+        if is_blocking:
+            while is_blocking and not self.isSafetyBreak:
+                try:
+                    rmessage = await self.SerialManager.read().decode()
+                    if self.DEBUG: self._parent.logger.debug(rmessage)
+                    returnmessage += rmessage
+                    if rmessage.find("--")==0:
+                        break
+                except:
+                    pass
+                if (time.time()-_time0)>timeout:
+                    break
+            # casting to dict
+            try:
+                # TODO: check if this is a valid JSON
+                _returnmessage = returnmessage.split("\n--")[0].split("\n++")[-1].replace("\r","").replace("\n", "").replace("'", '"')
+                if self.DEBUG: self._parent.logger.debug(returnmessage)
+                _returnmessage = json.loads(_returnmessage)
+            except Exception as e:
+                if self.DEBUG: self._parent.logger.debug("Casting json string from serial to Python dict failed")
+            self.isSafetyBreak = False
+        return _returnmessage
 class SerialDummy(object):
         
     def __init__(self, port, baudrate, timeout=1, parent=None):

{UC2 REST-0.2.0.9 → UC2 REST-0.2.0.12}/uc2rest/state.py

@@ -11,10 +11,7 @@ class State(object):
     def get_state(self, timeout=3):
         path = "/state_get"
 
-        payload = {
-            "task":path
-        }
-        r = self._parent.post_json(path, payload, timeout=timeout)
+        r = self._parent.get_json(path, timeout=timeout)
         return r
 
     def set_state(self, debug=False, timeout=1):

UC2 REST-0.2.0.12/uc2rest/utils.py

@@ -0,0 +1,17 @@
+from datetime import datetime as dt
+
+
+def format_date(dt_, fmt="%m/%d/%Y, %H:%M:%S"):
+    return dt_.strftime(fmt)
+
+
+def now(fmt="%m/%d/%Y, %H:%M:%S"):
+    return format_date(dt.now(), fmt)
+
+
+def remove_class(element, className):
+    element.element.classList.remove(className)
+
+
+def add_class(element, className):
+    element.element.classList.add(className)

UC2 REST-0.2.0.9/uc2rest/__init__.py

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