Merge pull request #10 from RainerStaude/master

Update pybecker to add support to receive packets/commands from Becker Remotes

Author: Nicolas Berthel

README.md

@@ -29,8 +29,8 @@ pip install pybecker
 
 Usage
 -----
-The goal of this library is to be used in your home automation component. 
+The goal of this library is to be used in your home automation component.
 however after installation you can test it by runing
 ```console
-pybecker -a <UP|DOWN|PAIR|HALT> -c <CHANNEL>
+python -m pybecker -a <UP|DOWN|PAIR|HALT> -c <CHANNEL>
 ```

pybecker/__main__.py

@@ -1,18 +1,46 @@
 import argparse
 import asyncio
+import time
 
 from pybecker.becker import Becker
 
 
 async def main():
     """Main function"""
     parser = argparse.ArgumentParser()
-    parser.add_argument('-c', '--channel', required=True, help='channel')
-    parser.add_argument('-a', '--action', required=True, help='Command to execute (UP, DOWN, HALT, PAIR)')
-    parser.add_argument('-d', '--device', required=False, help='Device to use for connectivity')
+    parser.add_argument('-c', '--channel')
+    parser.add_argument(
+        '-a',
+        '--action',
+        choices=['UP', 'UP2', 'DOWN', 'DOWN2', 'HALT', 'PAIR'],
+        help='Command to execute (UP, DOWN, HALT, PAIR)',
+    )
+    parser.add_argument('-d', '--device', help='Device to use for connectivity')
+    parser.add_argument('-f', '--file', help='Database file')
+    parser.add_argument(
+        '-l',
+        '--log',
+        type = int,
+        help='Logs received commands (only UP, DOWN, HALT) for a certain time (in seconds)'
+    )
     args = parser.parse_args()
 
-    client = Becker()
+    if (args.channel is None) != (args.action is None):
+        parser.error('both --channel and --action are required')
+
+    if args.log is None:
+        callback = None
+    else:
+        commands = {'1':'HALT', '2':'UP', '4':'DOWN',}
+        callback = lambda packet: print(
+              "Received packet: "
+            + "unit_id: {}, ".format(packet.group('unit_id').decode())
+            + "channel: {}, ".format(packet.group('channel').decode())
+            + "command: {}, ".format(commands[packet.group('command').decode()])
+            + "argument: {}".format(packet.group('argument').decode())
+        )
+
+    client = Becker(device_name=args.device, db_filename=args.file, callback=callback)
 
     if args.action == "UP":
         await client.move_up(args.channel)
@@ -27,6 +55,19 @@ async def main():
     elif args.action == "PAIR":
         await client.pair(args.channel)
 
+    # wait for log
+    timeout = time.time() + (args.log or 0)
+    while timeout > time.time():
+        time.sleep(0.01)
+
+    # graceful shutdown
+    client.close()
 
 if __name__ == '__main__':
+    import sys
+
+    # to avoid crashing on exit when running on windows
+    if sys.version_info[0] == 3 and sys.version_info[1] >= 8 and sys.platform.startswith('win'):
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
     asyncio.run(main())

pybecker/becker.py

@@ -1,13 +1,11 @@
 import logging
-import os
 import re
-import serial
-import socket
 import time
+from random import randrange
 
 from .becker_helper import finalize_code
 from .becker_helper import generate_code
-from .becker_helper import BeckerConnectionError
+from .becker_helper import BeckerCommunicator
 from .database import Database
 
 COMMAND_UP = 0x20
@@ -31,7 +29,7 @@
 COMMAND_CLEARPOS3 = 0x92
 COMMAND_CLEARPOS4 = 0x93
 
-DEFAULT_DEVICE_NAME = '/dev/serial/by-id/usb-BECKER-ANTRIEBE_GmbH_CDC_RS232_v125_Centronic-if00'
+# DEFAULT_DEVICE_NAME moved to becker_helper
 
 logging.basicConfig()
 _LOGGER = logging.getLogger(__name__)
@@ -45,7 +43,7 @@ class Becker:
         Use this class to perform operations on your Becker Shutter using a centronic USB Stick
         This class will as well maintain a call increment in an internal database
     """
-    def __init__(self, device_name=DEFAULT_DEVICE_NAME, init_dummy=False, db_filename=None):
+    def __init__(self, device_name=None, init_dummy=False, db_filename=None, callback=None):
         """
             Create a new instance of the Becker controller
 
@@ -54,53 +52,30 @@ def __init__(self, device_name=DEFAULT_DEVICE_NAME, init_dummy=False, db_filenam
             :type device_name: str
             :type init_dummy: bool
         """
-        self.is_serial = "/" in device_name
-        if self.is_serial and not os.path.exists(device_name):
-            raise BeckerConnectionError(device_name + " is not existing")
-        self.device = device_name
+        self.communicator = BeckerCommunicator(device_name, callback)
         self.db = Database(db_filename)
 
         # If no unit is defined create a dummy one
         units = self.db.get_all_units()
         if not units and init_dummy:
             self.db.init_dummy()
 
-        try:
-            self._connect()
-        except serial.SerialException:
-            raise BeckerConnectionError("Error when trying to establish connection using " + device_name)
+        # Start communicator thread
+        self.communicator.start()
 
-    def _connect(self):
-        if self.is_serial:
-            self.s = serial.Serial(self.device, 115200, timeout=1)
-            self.write_function = self.s.write
-        else:
-            if ':' in self.device:
-                host, port = self.device.split(':', 1)
-            else:
-                host = self.device
-                port = '5000'
-            self.s = socket.create_connection((host, port))
-            self.write_function = self._reconnecting_sendall
-
-    def _reconnecting_sendall(self, *args, **kwargs):
-        """Wrapper for socker.sendall that reconnects (once) on failure"""
-
-        try:
-            return self.s.sendall(*args, **kwargs)
-        except OSError:
-            # Assume the connection failed, and connect again
-            self._connect()
-            return self.s.sendall(*args, **kwargs)
+    def close(self):
+        """Stop communicator thread, close device and database"""
+        self.communicator.close()
+        self.db.conn.close()
 
     async def write(self, codes):
         for code in codes:
-            self.write_function(finalize_code(code))
-            time.sleep(0.1)
+            self.communicator.send(finalize_code(code))
+            # Sleep implemented in BeckerCommunicator
 
     async def run_codes(self, channel, unit, cmd, test):
         if unit[2] == 0 and cmd != "TRAIN":
-            _LOGGER.error("The unit %s is not configured" % (unit[0]))
+            _LOGGER.error("The unit %s is not configured", (unit[0]))
             return
 
         # move up/down dependent on given time
@@ -171,21 +146,14 @@ async def run_codes(self, channel, unit, cmd, test):
         self.db.set_unit(unit, test)
 
     async def send(self, channel, cmd, test=False):
-        b = channel.split(':')
-        if len(b) > 1:
-            ch = int(b[1])
-            un = int(b[0])
-        else:
-            ch = int(channel)
-            un = 1
+
+        un, ch = self._split_channel(channel)
 
         if not 1 <= ch <= 7 and ch != 15:
             _LOGGER.error("Channel must be in range of 1-7 or 15")
             return
 
-        if not self.device:
-            _LOGGER.error("No device defined")
-            return
+        # device check implemented in BeckerCommunicator
 
         if un > 0:
             unit = self.db.get_unit(un)
@@ -255,3 +223,39 @@ async def list_units(self):
         """
 
         return self.db.get_all_units()
+
+    @staticmethod
+    def _split_channel(channel):
+        b = channel.split(':')
+        if len(b) > 1:
+            ch = int(b[1])
+            un = int(b[0])
+        else:
+            ch = int(channel)
+            un = 1
+        return un, ch
+
+    async def init_unconfigured_unit(self, channel, name=None):
+        """Init unconfigured units in database and send init call"""
+        # check if unit is configured
+        un, ch = self._split_channel(channel)   # pylint: disable=unused-variable
+        unit = self.db.get_unit(un)
+        if unit[2] == 0:
+            _LOGGER.warning(
+                "Unit %s%s with channel %s not registered in database file %s!",
+                un,
+                " of " + name if name is not None else "",
+                channel,
+                self.db.filename,
+            )
+            # set the unit as configured
+            unit[1] = randrange(10, 40, 1)
+            unit[2] = 1
+            self.db.set_unit(unit)
+            # send init call to sync with database (5 required for my Roto cover)
+            for init_call_count in range(1,6):
+                _LOGGER.debug(
+                    "Init call to %s:%s #%d", un, 1, init_call_count)
+                await self.stop(':'.join((str(un), '1')))
+                # 0.5 to 0.9 seconds (works with my Roto cover)
+                time.sleep(randrange(5, 10, 1) / 10)