owlsensor 0.1__py3-none-any.whl

owlsensor/serial_cm.py

@@ -0,0 +1,191 @@
+"""
+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.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Pascal Brunot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

owlsensor-0.1.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: owlsensor
+Version: 0.1
+Summary: Library to read data from OWL Energy meters
+Home-page: https://github.com/PBrunot/owlsensor
+Author: Pascal Brunot
+Author-email: pbr-dev@gmail.com
+License: MIT
+Keywords: serial owl cm160 energy_meter homeautomation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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
+
+This package is designed for integrating into Home Assistant a serial-connected OWL energy meter.

owlsensor-0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+owlsensor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+owlsensor/serial_cm.py,sha256=sY-wY-XY8qe406lkcY6q_KE27QY2vp8DJ_ehoAJh0BQ,6547
+owlsensor-0.1.dist-info/LICENSE,sha256=zO0Kn9_4x_mTcq8F_qHpFcT5FfHjtZusfzQmyzcJv-c,1070
+owlsensor-0.1.dist-info/METADATA,sha256=r4OobPhclkJ5pPpR_iamV3RtieKUcEg0dDcNmpyxAn8,807
+owlsensor-0.1.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+owlsensor-0.1.dist-info/top_level.txt,sha256=bBZKOvuoXB-czUcp0cSeR8EmD2hVzDEqmucOBabtmXs,10
+owlsensor-0.1.dist-info/RECORD,,

owlsensor-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.5.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

owlsensor-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+owlsensor