Merge pull request #53 from plugwise/refactor_stick

Refactor code for USB-stick

Author: brefra

.coveragerc

@@ -4,9 +4,8 @@ omit=
     */venv/*
     setup.py
     plugwise/connections/*
-    plugwise/message.py
+    plugwise/controller.py
     plugwise/messages/*
-    plugwise/node.py
     plugwise/nodes/*
     plugwise/parser.py
     plugwise/stick.py

CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.8.6 - Code quality improvements for stick
+
+- Bug-fix: Power history was not reported (0 value) during last week of the month
+- Improvement: Validate message checksums
+- Improvement: Do a single ping request to validate if node is on-line
+- Improvement: Guard Scan sensitivity setting to medium
+- Improvement: Move general module code of messages, nodes, connection to the  __init__.py files.
+- Improvement: Do proper timeout handling while sequence counter resets (once every 65532 messages)
+- Improvement: Better code separation. All logic is in their designated files:
+  1. Connection (connection/*.py)
+  2. Data parsing (parser.py)
+  3. Data encoding/decoding of message (messages/*.py)
+  4. Message handling - Initialization & transportation (controller.py)
+  5. Message processing - Do the required stuff (stick.py & nodes/*.py)
+- Improvement: Resolves all flake8 comments
+
 ## 0.8.5 - Fix sensor scaling
   - Fix for via HA Core issue #44349
   - Fix other value scaling bugs

plugwise/__init__.py

@@ -1,6 +1,6 @@
 """Plugwise module."""
 
-__version__ = "0.8.5"
+__version__ = "0.8.6"
 
 from plugwise.smile import Smile
 from plugwise.stick import stick

plugwise/connections/__init__.py

@@ -1 +1,123 @@
-"""Plugwise connections."""
+"""Base class for serial or socket connections to USB-Stick."""
+import logging
+import queue
+import threading
+import time
+
+from ..constants import SLEEP_TIME
+from ..messages.requests import NodeRequest
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class StickConnection:
+    """Generic Plugwise stick connection."""
+
+    def __init__(self, port, parser):
+        """Initialize StickConnection."""
+        self.port = port
+        self.parser = parser
+        self.run_reader_thread = False
+        self.run_writer_thread = False
+        self._is_connected = False
+        self._writer = None
+
+        self._reader_thread = None
+        self._write_queue = None
+        self._writer_thread = None
+
+    ################################################
+    ###             Open connection              ###
+    ################################################
+
+    def connect(self) -> bool:
+        """Open the connection."""
+        if not self._is_connected:
+            self._open_connection()
+        return self._is_connected
+
+    ################################################
+    ###                   Reader                 ###
+    ################################################
+
+    def _reader_start(self, name):
+        """Start the reader thread to receive data."""
+        self._reader_thread = threading.Thread(None, self._reader_deamon, name, (), {})
+        self.run_reader_thread = True
+        self._reader_thread.start()
+
+    def _reader_deamon(self):
+        """Thread to collect available data from connection."""
+        while self.run_reader_thread:
+            data = self._read_data()
+            if data:
+                self.parser(data)
+            time.sleep(0.01)
+        _LOGGER.debug("Reader daemon stopped")
+
+    ################################################
+    ###                 Writer                   ###
+    ################################################
+
+    def _writer_start(self, name: str):
+        """Start the writer thread to send data."""
+        self._write_queue = queue.Queue()
+        self._writer_thread = threading.Thread(None, self._writer_daemon, name, (), {})
+        self._writer_thread.daemon = True
+        self.run_writer_thread = True
+        self._writer_thread.start()
+
+    def _writer_daemon(self):
+        """Thread to write data from queue to existing connection."""
+        while self.run_writer_thread:
+            try:
+                (message, callback) = self._write_queue.get(block=True, timeout=1)
+            except queue.Empty:
+                time.sleep(SLEEP_TIME)
+            else:
+                _LOGGER.debug(
+                    "Sending %s to plugwise stick (%s)",
+                    message.__class__.__name__,
+                    message.serialize(),
+                )
+                self._write_data(message.serialize())
+                time.sleep(SLEEP_TIME)
+                if callback:
+                    callback()
+        _LOGGER.debug("Writer daemon stopped")
+
+    def send(self, message: NodeRequest, callback=None):
+        """Add message to write queue."""
+        self._write_queue.put_nowait((message, callback))
+
+    ################################################
+    ###             Connection state             ###
+    ################################################
+
+    def is_connected(self):
+        """Return connection state."""
+        return self._is_connected
+
+    def read_thread_alive(self):
+        """Return state of write thread."""
+        return self._reader_thread.isAlive() if self.run_reader_thread else False
+
+    def write_thread_alive(self):
+        """Return state of write thread."""
+        return self._writer_thread.isAlive() if self.run_writer_thread else False
+
+    ################################################
+    ###             Close connection             ###
+    ################################################
+
+    def disconnect(self):
+        """Close the connection."""
+        if self._is_connected:
+            self._is_connected = False
+            self.run_writer_thread = False
+            self.run_reader_thread = False
+            max_wait = 5 * SLEEP_TIME
+            while self._writer_thread.isAlive():
+                time.sleep(SLEEP_TIME)
+                max_wait -= SLEEP_TIME
+            self._close_connection()

plugwise/connections/connection.py

@@ -3,18 +3,18 @@
 
 import serial
 
-from plugwise.connections.connection import StickConnection
-from plugwise.constants import BAUD_RATE, BYTE_SIZE, STOPBITS
-from plugwise.exceptions import PortError
+from ..connections import StickConnection
+from ..constants import BAUD_RATE, BYTE_SIZE, STOPBITS
+from ..exceptions import PortError
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class PlugwiseUSBConnection(StickConnection):
     """Simple wrapper around serial module."""
 
-    def __init__(self, port, stick=None):
-        super().__init__(port, stick)
+    def __init__(self, port, parser):
+        super().__init__(port, parser)
         self._baud = BAUD_RATE
         self._byte_size = BYTE_SIZE
         self._stopbits = STOPBITS

plugwise/connections/serial.py

@@ -2,17 +2,17 @@
 import logging
 import socket
 
-from plugwise.connections.connection import StickConnection
-from plugwise.exceptions import PortError
+from ..connections import StickConnection
+from ..exceptions import PortError
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class SocketConnection(StickConnection):
     """Wrapper for Socket connection configuration."""
 
-    def __init__(self, port, stick=None):
-        super().__init__(port, stick)
+    def __init__(self, port, parser):
+        super().__init__(port, parser)
         # get the address from a <host>:<port> format
         port_split = self.port.split(":")
         self._socket_host = port_split[0]