owlsensor 0.1__tar.gz → 0.2__tar.gz

{owlsensor-0.1 → owlsensor-0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: owlsensor
-Version: 0.1
+Version: 0.2
 Summary: Library to read data from OWL Energy meters
 Home-page: https://github.com/PBrunot/owlsensor
 Author: Pascal Brunot
@@ -16,6 +16,6 @@ Classifier: Programming Language :: Python :: 3.4
 Classifier: Programming Language :: Python :: 3.5
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: pyserial>=3
+Requires-Dist: pyserial-asyncio-fast>=0.14
 
 This package is designed for integrating into Home Assistant a serial-connected OWL energy meter.

owlsensor-0.2/owlsensor/const.py

@@ -0,0 +1,9 @@
+""" Constants """
+PACKET_LENGTH = 11
+ID_REPLY = "IDTCMV001"
+ID_WAIT_HISTORY = "IDTWAITPC"
+CONTINUE_REQUEST = [0xa5]
+START_REQUEST = [0x5a]
+PACKET_ID_HISTORY = 0xa9
+PACKET_ID_HISTORY_DATA = 0x59
+PACKET_ID_REALTIME = 0x51

owlsensor-0.2/owlsensor/serial_cm.py

@@ -0,0 +1,193 @@
+"""
+Reading data from particulate matter sensors with a serial interface.
+"""
+import time
+import logging
+import asyncio
+import serial_asyncio_fast
+
+from .const import CONTINUE_REQUEST, ID_WAIT_HISTORY,ID_REPLY, PACKET_ID_HISTORY, PACKET_ID_HISTORY_DATA, PACKET_ID_REALTIME, START_REQUEST
+
+STARTBLOCK = "SB"
+RECORD_LENGTH = "RL"
+# Ofsets of the PM data (always 2 byte)
+CURRENT = "Current"
+BAUD_RATE = "BAUD"
+BYTE_ORDER = "BO",
+LSB = "lsb"
+MSB = "msb"
+DTR_ON = "DTR"
+DTR_OFF = "NOT_DTR"
+MULTIPLIER = "MP"
+TIMEOUT = "TO"
+
+# Owl CM160 settings
+OWL_CM160 = {
+    "TheOWL": "CM160",
+    STARTBLOCK: bytes([0x42, 0x4d, 0x00, 0x14]),
+    RECORD_LENGTH: 11,
+    CURRENT: 8,
+    BAUD_RATE: 250000,
+    BYTE_ORDER: LSB,
+    MULTIPLIER: 0.07,
+    TIMEOUT: 30
+}
+
+SUPPORTED_SENSORS = {
+    "TheOWL,CM160": OWL_CM160
+}
+
+DEVICE_STATES = {
+    "Unknown": 0,
+    "IdentifierReceived": 1,
+    "TransmittingHistory": 2,
+    "TransmittingRealtime": 3
+}
+
+CMVALS=[CURRENT]
+
+LOGGER = logging.getLogger(__name__)
+
+
+class CMDataCollector():
+    """Controls the serial interface and reads data from the sensor."""
+
+# pylint: disable=too-many-instance-attributes
+    def __init__(self,
+                 serialdevice,
+                 configuration,
+                 scan_interval=0):
+        """Initialize the data collector based on the given parameters."""
+
+        self.record_length = configuration[RECORD_LENGTH]
+        self.byte_order = configuration[BYTE_ORDER]
+        self.multiplier = configuration[MULTIPLIER]
+        self.timeout = configuration[TIMEOUT]
+        self.scan_interval = scan_interval
+        self.listeners = []
+        self.sensordata = {}
+        self.config = configuration
+        self._data = None
+        self.last_poll = None
+        self.device_state = DEVICE_STATES["Unknown"]
+        self.device_found = False
+        self.serialdevice = serialdevice
+        self.reader = None
+        self.writer = None
+        self.baudrate = configuration[BAUD_RATE]
+
+    async def connect(self):
+        """Establish the serial connection asynchronously."""
+        self.reader, self.writer = await serial_asyncio_fast.open_serial_connection(
+            url=self.serialdevice,
+            baudrate=self.baudrate
+        )
+
+        if self.scan_interval > 0:
+            asyncio.create_task(self.refresh())
+
+    async def refresh(self):
+        """Asynchronous background refreshing task."""
+        while True:
+            await self.read_data()
+            await asyncio.sleep(self.scan_interval)
+            
+    async def send_data(self, data: bytes):
+        LOGGER.debug("-> %s", ''.join(format(x, '02x') for x in data))
+        self.writer.write(data)
+        await self.writer.drain()
+    
+    async def get_packet(self):
+        sbuf = bytearray()
+        starttime = asyncio.get_event_loop().time()
+
+        while len(sbuf) != self.record_length:
+            elapsed = asyncio.get_event_loop().time() - starttime
+            if elapsed > self.timeout:
+                LOGGER.error("Timeout waiting for data")
+                return bytearray()
+
+            try:
+                sbuf += await self.reader.readexactly(1)
+            except asyncio.IncompleteReadError:
+                LOGGER.warning("Timeout on data on serial")
+                return bytearray()
+
+        return sbuf
+
+    async def parse_packet(self, buffer: bytearray) -> dict | None:
+        if len(buffer) != self.record_length:
+            LOGGER.error("Wrong buffer length: %d", len(buffer))
+            return
+
+        LOGGER.debug("<- %s", ''.join(format(x, '02x') for x in buffer))
+        str_buffer = buffer[1:10].decode("cp850")
+
+        if ID_REPLY in str_buffer:
+            LOGGER.info("Device found (%s)", str_buffer)
+            self.device_found = True
+
+        if self.device_found and ID_WAIT_HISTORY in str_buffer:
+            await self.send_data(CONTINUE_REQUEST)
+
+        if buffer[0] == PACKET_ID_HISTORY:
+            if self.device_found:
+                await self.send_data(START_REQUEST)
+        elif buffer[0] == PACKET_ID_REALTIME:
+            LOGGER.info("Realtime data received")
+            self.device_state = DEVICE_STATES["TransmittingRealtime"]
+            res = self.parse_buffer(buffer)
+            return res
+        elif buffer[0] == PACKET_ID_HISTORY_DATA:
+            self.device_state = DEVICE_STATES["TransmittingHistory"]
+
+        return None
+
+    async def read_data(self):
+        """Read data from the serial interface asynchronously."""
+        mytime = asyncio.get_event_loop().time()
+        if (self.last_poll is not None) and \
+           (mytime - self.last_poll) <= 15 and \
+           self._data is not None:
+            return self._data
+
+        res = None
+        finished = False
+
+        while not finished:
+            packet = await self.get_packet()
+            if packet:
+                result = await self.parse_packet(packet)
+                if result is not None:
+                    res = result
+                    finished = True
+
+        self._data = res
+        self.last_poll = asyncio.get_event_loop().time()
+        return res
+
+    def parse_buffer(self, sbuf):
+        """Parse the buffer and return the CM values."""
+        res = {}
+        for pmname in CMVALS:
+            offset = self.config[pmname]
+            if offset is not None:
+                if self.byte_order == MSB:
+                    res[pmname] = sbuf[offset] * \
+                        256 + sbuf[offset + 1]
+                else:
+                    res[pmname] = sbuf[offset + 1] * \
+                        256 + sbuf[offset]
+
+                res[pmname] = round(res[pmname] * self.multiplier, 1)
+
+        return res
+
+    def supported_values(self) -> list:
+        """Returns the list of supported values for the actual device"""
+        res = []
+        for pmname in CMVALS:
+            offset = self.config[pmname]
+            if offset is not None:
+                res.append(pmname)
+        return res

{owlsensor-0.1 → owlsensor-0.2}/owlsensor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: owlsensor
-Version: 0.1
+Version: 0.2
 Summary: Library to read data from OWL Energy meters
 Home-page: https://github.com/PBrunot/owlsensor
 Author: Pascal Brunot
@@ -16,6 +16,6 @@ Classifier: Programming Language :: Python :: 3.4
 Classifier: Programming Language :: Python :: 3.5
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: pyserial>=3
+Requires-Dist: pyserial-asyncio-fast>=0.14
 
 This package is designed for integrating into Home Assistant a serial-connected OWL energy meter.

{owlsensor-0.1 → owlsensor-0.2}/owlsensor.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.rst
 setup.py
 owlsensor/__init__.py
+owlsensor/const.py
 owlsensor/serial_cm.py
 owlsensor.egg-info/PKG-INFO
 owlsensor.egg-info/SOURCES.txt

owlsensor-0.2/owlsensor.egg-info/requires.txt

@@ -0,0 +1 @@
+pyserial-asyncio-fast>=0.14

{owlsensor-0.1 → owlsensor-0.2}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(name='owlsensor',
-      version='0.1',
+      version='0.2',
       description='Library to read data from OWL Energy meters',
       long_description='This package is designed for integrating into Home Assistant a serial-connected OWL energy meter.',
       long_description_content_type = 'text/x-rst',
@@ -19,6 +19,6 @@ setup(name='owlsensor',
           'Programming Language :: Python :: 3.5'
       ],
       packages=find_packages(),
-      install_requires=['pyserial>=3'],
+      install_requires=['pyserial-asyncio-fast>=0.14'],
       keywords='serial owl cm160 energy_meter homeautomation',
       zip_safe=False)

owlsensor-0.1/owlsensor/serial_cm.py

@@ -1,191 +0,0 @@
-"""
-Reading data from particulate matter sensors with a serial interface.
-"""
-import time
-import threading
-import logging
-
-import serial
-
-STARTBLOCK = "SB"
-RECORD_LENGTH = "RL"
-# Ofsets of the PM data (always 2 byte)
-CURRENT = "Current"
-BAUD_RATE = "BAUD"
-BYTE_ORDER = "BO",
-LSB = "lsb"
-MSB = "msb"
-DTR_ON = "DTR"
-DTR_OFF = "NOT_DTR"
-MULTIPLIER = "MP"
-TIMEOUT = "TO"
-
-# Owl CM160 settings
-OWL_CM160 = {
-    "TheOWL": "CM160",
-    STARTBLOCK: bytes([0x42, 0x4d, 0x00, 0x14]),
-    RECORD_LENGTH: 24,
-    CURRENT: 8,
-    BAUD_RATE: 250000,
-    BYTE_ORDER: MSB,
-    MULTIPLIER: 0.07,
-    TIMEOUT: 2
-}
-
-SUPPORTED_SENSORS = {
-    "TheOWL,CM160": OWL_CM160
-}
-
-CMVALS=[CURRENT]
-
-LOGGER = logging.getLogger(__name__)
-
-
-class CMDataCollector():
-    """Controls the serial interface and reads data from the sensor."""
-
-# pylint: disable=too-many-instance-attributes
-    def __init__(self,
-                 serialdevice,
-                 configuration,
-                 power_control=DTR_ON,
-                 scan_interval=0):
-        """Initialize the data collector based on the given parameters."""
-
-        self.record_length = configuration[RECORD_LENGTH]
-        self.start_sequence = configuration[STARTBLOCK]
-        self.byte_order = configuration[BYTE_ORDER]
-        self.multiplier = configuration[MULTIPLIER]
-        self.timeout = configuration[TIMEOUT]
-        self.scan_interval = scan_interval
-        self.listeners = []
-        self.power_control = power_control
-        self.sensordata = {}
-        self.config = configuration
-        self.data = None
-        self.last_poll = None
-        self.start_func = None
-        self.stop_func = None
-
-        self.ser = serial.Serial(port=serialdevice,
-                                 baudrate=configuration[BAUD_RATE],
-                                 parity=serial.PARITY_NONE,
-                                 stopbits=serial.STOPBITS_ONE,
-                                 bytesize=serial.EIGHTBITS,
-                                 timeout=0.5)
-
-        # Update date in using a background thread
-        if self.scan_interval > 0:
-            thread = threading.Thread(target=self.refresh, args=())
-            thread.daemon = True
-            thread.start()
-
-    def refresh(self):
-        """Background refreshing thread."""
-        while True:
-            self.read_data()
-            time.sleep(self.scan_interval)
-
-# pylint: disable=too-many-branches
-    def read_data(self):
-        """Read data from serial interface and return it as a dictionary.
-
-        There is some caching implemented the sensor won't be polled twice 
-        within a 15 second interval. If data is requested within 15 seconds 
-        after it has been read, the data from the last read_data operation will
-        be returned again 
-        """
-
-        mytime = time.time()
-        if (self.last_poll is not None) and \
-                (mytime - self.last_poll) <= 15:
-            return self._data
-
-        # Start function that can do several things (e.g. turning the
-        # sensor on)
-        if self.start_func:
-            self.start_func(self.ser)
-
-        res = None
-        finished = False
-        sbuf = bytearray()
-        starttime = time.time()
-        checkCode = int(0);
-        expectedCheckCode = int()
-        #it is necessary to reset input buffer because data is cotinously received by the system and placed in the device buffer when serial is open.
-        #But "Home Assistant" code read it only from time to time so the data we read here would be placed in the past. 
-        #Better is to clean the buffer and read new data from "present" time.
-        self.ser.reset_input_buffer()
-        while not finished:
-            mytime = time.time()
-            if mytime - starttime > self.timeout:
-                LOGGER.error("read timeout after %s seconds, read %s bytes",
-                             self.timeout, len(sbuf))
-                return {}
-
-            if self.ser.inWaiting() > 0:
-                sbuf += self.ser.read(1)
-                if len(sbuf) == len(self.start_sequence):
-                    if sbuf == self.start_sequence:
-                        LOGGER.debug("Found start sequence %s",
-                                     self.start_sequence)
-                    else:
-                        LOGGER.debug("Start sequence not yet found")
-                        # Remove first character
-                        sbuf = sbuf[1:]
-
-                if len(sbuf) == self.record_length:
-                    #Check the control sum if it is known how to do it
-                    if self.config == PLANTOWER1:                    
-                        for c in sbuf[0:(self.record_length-2)]:
-                            checkCode += c
-                        expectedCheckCode = sbuf[30]*256 + sbuf[31]
-                        if checkCode != expectedCheckCode:
-			    #because of data inconsistency clean the buffer
-                            LOGGER.error("PM sensor data sum error %d, expected %d", checkCode, expectedCheckCode)
-                            sbuf = []
-                            checkCode = 0                      
-                            continue    
-
-                    #if it is ok then send it for interpretation
-                    res = self.parse_buffer(sbuf)
-                    LOGGER.debug("Finished reading data %s", sbuf)
-                    finished = True
-
-            else:
-                time.sleep(.5)
-                LOGGER.debug("Serial waiting for data, buffer length=%s",
-                             len(sbuf))
-
-        if self.stop_func:
-            self.stop_func(self.ser)
-
-        self._data = res
-        self.last_poll = time.time()
-        return res
-
-    def parse_buffer(self, sbuf):
-        """Parse the buffer and return the CM values."""
-        res = {}
-        for pmname in CMVALS:
-            offset = self.config[pmname]
-            if offset is not None:
-                if self.byte_order == MSB:
-                    res[pmname] = sbuf[offset] * \
-                        256 + sbuf[offset + 1]
-                else:
-                    res[pmname] = sbuf[offset + 1] * \
-                        256 + sbuf[offset]
-
-                res[pmname] = round(res[pmname] * self.multiplier, 1)
-
-        return res
-
-    def supported_values(self) -> list:
-        """Returns the list of supported values for the actual device"""
-        res = []
-        for pmname in CMVALS:
-            offset = self.config[pmname]
-            if offset is not None:
-                res.append(pmname)
-        return res

owlsensor-0.1/owlsensor.egg-info/requires.txt

@@ -1 +0,0 @@
-pyserial>=3