python-selve-new 2.2.15__tar.gz → 2.2.17__tar.gz

{python_selve_new-2.2.15/python_selve_new.egg-info → python_selve_new-2.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-selve-new
-Version: 2.2.15
+Version: 2.2.17
 Summary: Python library for interfacing with selve devices using the USB-RF controller. Written completely new.
 Home-page: https://github.com/Kannix2005/python-selve-new
 Author: Stefan Altheimer

{python_selve_new-2.2.15 → python_selve_new-2.2.17/python_selve_new.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-selve-new
-Version: 2.2.15
+Version: 2.2.17
 Summary: Python library for interfacing with selve devices using the USB-RF controller. Written completely new.
 Home-page: https://github.com/Kannix2005/python-selve-new
 Author: Stefan Altheimer

{python_selve_new-2.2.15 → python_selve_new-2.2.17}/selve/__init__.py

@@ -9,6 +9,7 @@ from typing import Callable
 
 import serial
 from serial.tools import list_ports
+from serial import SerialException
 import untangle
 
 from selve.commands import param, service
@@ -42,6 +43,7 @@ class Selve:
     def __init__(self, port=None, discover=True, develop=False, logger=None):
         # Gateway state
         self._callbacks = set()
+        self._eventCallbacks = set()
         self.lastLogEvent = None
         self.state = None
 
@@ -74,9 +76,14 @@ class Selve:
         self._writeLock = asyncio.Lock()
         self._readLock = asyncio.Lock()
 
+        # Trasmit and Recieve Queue init
         self.txQ = None
         self.rxQ = None
 
+        #Options
+        self.reversedStopPosition = 0
+
+        #Logger
         self._LOGGER = logger
 
 
@@ -84,8 +91,9 @@ class Selve:
         # Infinite loop to collect all incoming data
         self._LOGGER.debug("(Selve Worker): " + "Worker started")
 
-        try:
-            while True:
+        
+        while True:
+            try:
                 if not self._pauseWorker.is_set():
                     if not self._serial.is_open:
                         self._serial.open()
@@ -98,6 +106,7 @@ class Selve:
                         async with self._writeLock:
                             async with self._readLock:
                                 if self._serial.in_waiting > 0:
+                                    self._LOGGER.debug(f'(Selve Worker): Recieved Serial Data')
                                     msg = ""
                                     while True:
                                         response = self._serial.readline().strip()
@@ -113,13 +122,22 @@ class Selve:
                 if self._stopThread.is_set():
                     self._LOGGER.debug("(Selve Worker): " + 'Exiting worker loop...')
                     break
+
                 await asyncio.sleep(0.1)
-            return True
-        # serial port exceptions, all of these notify that we are in some
-        # serious trouble
-        except serial.SerialException:
-            # log message
-            self._LOGGER.error("(Selve Worker): " + 'Serial Port RX error')
+
+            except serial.SerialException:
+                # log message
+                self._LOGGER.error("(Selve Worker): " + 'Serial Port RX error')
+                self._LOGGER.error("(Selve Worker): " + 'trying to reconnect...')
+                await self.recover()
+
+            #await asyncio.sleep(0.1)
+        return True
+    # serial port exceptions, all of these notify that we are in some
+    # serious trouble
+    
+
+
 
 
     async def setup(self, discover=False, fromConfigFlow=False):
@@ -194,6 +212,66 @@ class Selve:
             self._LOGGER.error("No gateway on comports found!")
             raise PortError
 
+    async def recover(self):
+        self._LOGGER.info("(Selve Worker): " + "Recover serial connection")
+        self._LOGGER.debug("(Selve Worker): " + "Waiting 5 seconds before trying...")
+        await asyncio.sleep(5)
+        self._LOGGER.debug("(Selve Worker): " + "Recovering")
+
+        if self._port is not None:
+            try:
+                self._serial = serial.Serial(
+                    port=self._port,
+                    baudrate=115200,
+                    bytesize=serial.EIGHTBITS,
+                    parity=serial.PARITY_NONE,
+                    stopbits=serial.STOPBITS_ONE,
+                    xonxoff=False,
+                    rtscts=False,
+                    dsrdtr=False)
+
+                if await self.pingGatewayFromWorker():
+                    return
+            except serial.SerialException as e:
+                self._LOGGER.debug("(Selve Worker): " + "Configured port not valid, maybe it has changed, trying other ports...")
+            except Exception as e:
+                self._LOGGER.error("(Selve Worker): " + "Unknown exception: " + str(e))
+
+
+        available_ports = list_ports.comports()
+        self._LOGGER.debug("(Selve Worker): " + "available comports: " + str(available_ports))
+
+        if len(available_ports) == 0:
+            self._LOGGER.error("(Selve Worker): " + "No available comports!")
+            return False
+
+        for p in available_ports:
+            try:
+                self._serial = serial.Serial(
+                    port=p.device,
+                    baudrate=115200,
+                    bytesize=serial.EIGHTBITS,
+                    parity=serial.PARITY_NONE,
+                    stopbits=serial.STOPBITS_ONE,
+                    xonxoff=False,
+                    rtscts=False,
+                    dsrdtr=False)
+            except Exception as e:
+                self._LOGGER.error("(Selve Worker): " + "Error at com port: " + str(e))
+                try:
+                    self._serial.close()
+                except:
+                    self._LOGGER.debug("(Selve Worker): " + "Cannot close com port")
+                pass
+            if await self.pingGatewayFromWorker():
+                self._port = p.device
+                return
+            else:
+                self._serial.close()
+                self._serial = None
+        else:
+            self._LOGGER.error("(Selve Worker): " + "No gateway on comports found!")
+            raise PortError
 
 
     async def startWorker(self):
@@ -246,6 +324,19 @@ class Selve:
         """Remove previously registered callback."""
         self._callbacks.discard(callback)
 
+    def register_event_callback(self, callback: Callable[[], None]) -> None:
+        """Register callback, called when other events take place."""
+        self._eventCallbacks.add(callback)
+
+    def remove_event_callback(self, callback: Callable[[], None]) -> None:
+        """Remove previously registered callback."""
+        self._eventCallbacks.discard(callback)
+
+
+    def updateOptions(self, reversedStopPosition = 0):
+        self.reversedStopPosition = reversedStopPosition
+
+
     async def _sendCommandToGateway(self, command: Command):
         commandstr = command.serializeToXML()
         self._LOGGER.debug('Gateway writing: ' + str(commandstr))
@@ -256,8 +347,25 @@ class Selve:
             self._serial.flush()
             #always sleep after writing
             await asyncio.sleep(0.5)
+
+        except SerialException as se:
+            self._LOGGER.info('Serial error, trying to reconnect once... ' + str(se))
+            await self.recover()
+
+            try:
+                self._LOGGER.debug('Trying again...')
+                if not self._serial.is_open:
+                    self._serial.open()
+                self._serial.write(commandstr)
+                self._serial.flush()
+                #always sleep after writing
+                await asyncio.sleep(0.5)
+            
+            except Exception as e:
+                self._LOGGER.error("error communicating: " + str(e) + " ; Please restart the integration!")
+
         except Exception as e:
-            self._LOGGER.error("error communicating: " + str(e))
+            self._LOGGER.error("error communicating: " + str(e) + " ; Please restart the integration!")
 
     async def processResponse(self, xmlstr):
         """Processes an XML String into a response object. Returns False if something went wrong or the gateway returned an error."""
@@ -627,8 +735,18 @@ class Selve:
                 self.addOrUpdateDevice(device, SelveTypes.DEVICE)
                 config: DeviceGetValuesResponse = await self.executeCommandSyncWithResponse(DeviceGetValues(i))
                 device.state = config.movementState
-                device.value = config.value
-                device.targetValue = config.targetValue
+
+                if self.reversedStopPosition is 0:
+                    device.value = config.value if config.value else 0
+                else:
+                    device.value = 100 - config.value if config.value else 0
+
+
+                if self.reversedStopPosition is 0:
+                    device.targetValue = config.targetValue if config.targetValue else 0
+                else:
+                    device.targetValue = 100 - config.targetValue if config.targetValue else 0
+
                 device.unreachable = config.unreachable
                 device.overload = config.overload
                 device.obstructed = config.obstructed
@@ -798,8 +916,18 @@ class Selve:
                 self._LOGGER.error("Id not found, creating")
 
             device.state = response.actorState
-            device.value = response.value
-            device.targetValue = response.targetValue
+
+            if self.reversedStopPosition is 0:
+                device.value = response.value if response.value else 0
+            else:
+                device.value = 100 - response.value if response.value else 0
+
+
+            if self.reversedStopPosition is 0:
+                device.targetValue = response.targetValue if response.targetValue else 0
+            else:
+                device.targetValue = 100 - response.targetValue if response.targetValue else 0
+
             device.unreachable = response.unreachable
             device.overload = response.overload
             device.obstructed = response.obstructed
@@ -845,6 +973,8 @@ class Selve:
             sender.lastEvent = response.event
             sender.name = response.senderName
             self.addOrUpdateDevice(sender, SelveTypes.SENSOR)
+            for callback in self._eventCallbacks:
+                callback(response)
 
         if isinstance(response, LogEventResponse):
             self.lastLogEvent = response
@@ -861,6 +991,9 @@ class Selve:
         if isinstance(response, DutyCycleResponse):
             self.sendingBlocked = response.mode
             self.utilization = response.traffic
+            
+            for callback in self._eventCallbacks:
+                callback(response)
 
 
     def commandResult(self, response: IveoResultResponse | CommandResultResponse):
@@ -897,6 +1030,19 @@ class Selve:
         self._LOGGER.debug("No ping")
         return False
 
+    async def pingGatewayFromWorker(self, fromConfigFlow=False):
+        cmd = ServicePing()
+        methodResponse = await self.executeCommandSyncWithResponsefromWorker(cmd)
+        try:
+            if hasattr(methodResponse, "name"):
+                if methodResponse.name == "selve.GW.service.ping":
+                    self._LOGGER.debug("Ping back")
+                    return True
+        except:
+            self._LOGGER.debug("Error in ping")
+        self._LOGGER.debug("No ping")
+        return False
+
 
     async def gatewayState(self):
         cmd = ServiceGetState()
@@ -1099,8 +1245,17 @@ class Selve:
         dev = self.getDevice(id, SelveTypes.DEVICE)
         dev.name = response.name if response.name else "None"
         dev.state = response.movementState if response.movementState else MovementState.UNKOWN.value
-        dev.value = response.value if response.value else 0
-        dev.targetValue = response.targetValue if response.targetValue else 0
+        if self.reversedStopPosition is 0:
+            dev.value = response.value if response.value else 0
+        else:
+            dev.value = 100 - response.value if response.value else 0
+
+
+        if self.reversedStopPosition is 0:
+            dev.targetValue = response.targetValue if response.targetValue else 0
+        else:
+            dev.targetValue = 100 - response.targetValue if response.targetValue else 0
+
         dev.unreachable = response.unreachable if response.unreachable else True
         dev.overload = response.overload if response.overload else False
         dev.obstructed = response.obstructed if response.obstructed else False
@@ -1116,12 +1271,19 @@ class Selve:
 
     def setDeviceValue(self, id: int, value: int, type: SelveTypes):
         dev = self.getDevice(id, type)
-        dev.value = value
+        if self.reversedStopPosition is 0:
+            dev.value = value
+        else:
+            dev.value = 100 - value
+
         self.addOrUpdateDevice(dev, type)
 
     def setDeviceTargetValue(self, id: int, value: int, type: SelveTypes):
         dev = self.getDevice(id, type)
-        dev.targetValue = value
+        if self.reversedStopPosition is 0:
+            dev.targetValue = value
+        else:
+            dev.targetValue = 100 - value
         self.addOrUpdateDevice(dev, type)
 
     def setDeviceState(self, id: int, state: MovementState, type: SelveTypes):

{python_selve_new-2.2.15 → python_selve_new-2.2.17}/setup.py

@@ -15,7 +15,7 @@ with open(path.join(here, 'README.md'), encoding='utf-8') as f:
 setup(
     
     name='python-selve-new',  # Required    
-    version='2.2.15',  # Required
+    version='2.2.17',  # Required
     description='Python library for interfacing with selve devices using the USB-RF controller. Written completely new.',  # Required   
     long_description=long_description,  # Optional 
     long_description_content_type="text/markdown",   

{python_selve_new-2.2.15 → python_selve_new-2.2.17}/test.py

@@ -8,7 +8,7 @@ import selve
 
 ## In HA this would be loop = self.hass.loop
 loop = asyncio.new_event_loop()
-portname = 'COM4'
+portname = None
 
 logger = logging.getLogger("Logger")
 logger.setLevel(logging.DEBUG)
@@ -19,23 +19,28 @@ handler.setFormatter(formatter)
 logger.addHandler(handler)
 
 
-selve = selve.Selve(portname, loop, develop=False, discover=False, logger=logger)
+selve = selve.Selve(portname, develop=True, discover=False, logger=logger)
+loop.run_until_complete(selve.setup())
 
+loop.run_until_complete(selve.discover())
 
+loop.run_until_complete(selve.setEvents(1,1,1,1,1))
+loop.run_until_complete(selve.getEvents())
 
 #try:
 #    loop.run_until_complete()
 #except KeyboardInterrupt:
 #    loop.close()
 
-threading.Thread(target=loop.run_forever, args=())
+#threading.Thread(target=loop.run_forever, args=())
 
-selve.pingGateway()
+#loop.run_until_complete(selve.pingGateway())
 #selve.resetGateway()
-selve.discover()
+#loop.run_until_complete(selve.discover())
 
+#print("Test")
 
 #selve.moveDeviceDown(selve.devices['device'][1])
-selve.moveGroupUp(selve.devices['group'][1])
+#selve.moveGroupUp(selve.devices['group'][1])
 
 loop.run_forever()