boneIO 0.4.0dev1__tar.gz → 0.5.0dev1__tar.gz

boneIO-0.5.0.dev1/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: boneIO
+Version: 0.5.0dev1
+Summary: Python App for BoneIO
+License: GNU General Public License v3.0
+Author-email: Paweł Szafer <pszafer@gmail.com>
+Requires-Python: >=3.7
+Project-URL: Changelog, https://github.com/boneIO-eu/app_bbb/releases
+Project-URL: Documentation, https://boneio.eu/docs/intro/
+Project-URL: Homepage, https://boneio.eu
+Project-URL: Repository, https://github.com/boneIO-eu/app_bbb
+Description-Content-Type: text/markdown
+
+Example usage:
+boneio run -dd -c config.yaml
+
+# Installation instructions
+
+```
+sudo apt-get install libopenjp2-7-dev libatlas-base-dev python3-venv
+mkdir ~/boneio
+python3 -m venv ~/boneio/venv
+source ~/boneio/venv/bin/activate
+pip3 install --upgrade boneio
+cp ~/venv/lib/python3.7/site-packages/boneio/example_config/*.yaml ~/boneio/
+```
+
+Edit config.yaml
+
+# Start app
+
+```
+source ~/boneio/venv/bin/activate
+boneio run -c ~/boneio/config.yaml -dd
+```
+

{boneIO-0.4.0.dev1 → boneIO-0.5.0.dev1}/boneio/const.py

@@ -113,6 +113,7 @@ MCP_TEMP_9808 = "mcp9808"
 INPUT_SENSOR = "inputsensor"
 DS2482 = "ds2482"
 DALLAS = "dallas"
+ONEWIRE = "onewire"
 
 BASE = "base"
 LENGTH = "length"
@@ -134,3 +135,4 @@ Gpio_States = Literal[HIGH, LOW]
 Gpio_Edges = Literal[BOTH, FALLING]
 InputTypes = Literal[INPUT, INPUT_SENSOR]
 DEVICE_CLASS = "device_class"
+DallasBusTypes = Literal[DS2482, DALLAS]

{boneIO-0.4.0.dev1 → boneIO-0.5.0.dev1}/boneio/example_config/output32x5A.yaml

@@ -97,36 +97,35 @@
   pin: 7
   output_type: light
 
-
 # mcp1 - lower left 8 relays
 - id: OUT_17
   kind: mcp
   mcp_id: mcp1
-  pin: 8
+  pin: 15
   output_type: light
 
 - id: OUT_18
   kind: mcp
   mcp_id: mcp1
-  pin: 9
+  pin: 14
   output_type: light
 
 - id: OUT_19
   kind: mcp
   mcp_id: mcp1
-  pin: 10
+  pin: 13
   output_type: light
 
 - id: OUT_20
   kind: mcp
   mcp_id: mcp1
-  pin: 11
+  pin: 12
   output_type: light
 
 - id: OUT_21
   kind: mcp
   mcp_id: mcp1
-  pin: 12
+  pin: 11
   output_type: light
 
 - id: OUT_22
@@ -138,13 +137,13 @@
 - id: OUT_23
   kind: mcp
   mcp_id: mcp1
-  pin: 14
+  pin: 9
   output_type: light
 
 - id: OUT_24
   kind: mcp
   mcp_id: mcp1
-  pin: 15
+  pin: 8
   output_type: light
 
 
@@ -152,7 +151,7 @@
 - id: OUT_25
   kind: mcp
   mcp_id: mcp2
-  pin: 8
+  pin: 15
   output_type: light
 
 - id: OUT_26
@@ -164,31 +163,31 @@
 - id: OUT_27
   kind: mcp
   mcp_id: mcp2
-  pin: 10
+  pin: 13
   output_type: light
 
 - id: OUT_28
   kind: mcp
   mcp_id: mcp2
-  pin: 11
+  pin: 12
   output_type: light
 
 - id: OUT_29
   kind: mcp
   mcp_id: mcp2
-  pin: 12
+  pin: 11
   output_type: light
 
 - id: OUT_30
   kind: mcp
   mcp_id: mcp2
-  pin: 13
+  pin: 10
   output_type: light
 
 - id: OUT_31
   kind: mcp
   mcp_id: mcp2
-  pin: 14
+  pin: 9
   output_type: light
 
 - id: OUT_32

{boneIO-0.4.0.dev1 → boneIO-0.5.0.dev1}/boneio/helper/__init__.py

@@ -21,10 +21,11 @@ from boneio.helper.ha_discovery import (
     ha_switch_availabilty_message,
 )
 from boneio.helper.mqtt import BasicMqtt
+from boneio.helper.async_updater import AsyncUpdater
 from boneio.helper.oled import make_font
 from boneio.helper.queue import UniqueQueue
 from boneio.helper.state_manager import StateManager
-from boneio.helper.stats import HostData, host_stats
+from boneio.helper.stats import HostData
 from boneio.helper.timeperiod import TimePeriod
 from boneio.helper.yaml_util import (
     CustomValidator,
@@ -38,7 +39,6 @@ __all__ = [
     "CustomValidator",
     "load_yaml_file",
     "HostData",
-    "host_stats",
     "setup_input",
     "setup_output",
     "edge_detect",
@@ -59,6 +59,7 @@ __all__ = [
     "StateManager",
     "configure_pin",
     "BasicMqtt",
+    "AsyncUpdater",
     "UniqueQueue",
     "schema_file",
     "load_config_from_string",

boneIO-0.5.0.dev1/boneio/helper/async_updater.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+import asyncio
+
+# Typing imports that create a circular dependency
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..manager import Manager
+from boneio.helper.timeperiod import TimePeriod
+
+
+class AsyncUpdater:
+    def __init__(self, manager: Manager, update_interval: TimePeriod, **kwargs):
+        self.manager = manager
+        self._update_interval = update_interval or TimePeriod(seconds=60)
+        self.manager.append_task(coro=self._refresh, name=self.id)
+
+    async def _refresh(self):
+        while True:
+            if hasattr(self, "async_update"):
+                update_interval = (
+                    await self.async_update(time=None)
+                    or self._update_interval.total_in_seconds
+                )
+            else:
+                update_interval = (
+                    self.update(time=None) or self._update_interval.total_in_seconds
+                )
+            await asyncio.sleep(update_interval)

{boneIO-0.4.0.dev1 → boneIO-0.5.0.dev1}/boneio/helper/loader.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
-import asyncio
 import logging
 import time
 from collections import namedtuple
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, Dict, Union
 
 from adafruit_mcp230xx.mcp23017 import MCP23017
-from adafruit_onewire.bus import OneWireAddress
 
 from boneio.const import (
     ACTIONS,
@@ -34,6 +32,7 @@ from boneio.const import (
     SENSOR,
     SHOW_HA,
     UPDATE_INTERVAL,
+    DallasBusTypes,
 )
 from boneio.cover import Cover
 from boneio.helper import (
@@ -45,11 +44,18 @@ from boneio.helper import (
     ha_input_availabilty_message,
     ha_sensor_temp_availabilty_message,
 )
-from boneio.helper.ds2482 import DS2482, DS2482_ADDRESS, OneWireBus, ds_address
+from boneio.helper.onewire import (
+    DS2482,
+    DS2482_ADDRESS,
+    OneWireBus,
+    AsyncBoneIOW1ThermSensor,
+    OneWireAddress,
+)
 from boneio.helper.ha_discovery import ha_cover_availabilty_message
 from boneio.helper.timeperiod import TimePeriod
 from boneio.input.gpio import GpioInputButton
-from boneio.sensor import DallasSensor
+from boneio.sensor import DallasSensorDS2482
+from boneio.sensor.temp.dallas import DallasSensorW1
 
 # Typing imports that create a circular dependency
 if TYPE_CHECKING:
@@ -75,10 +81,11 @@ def create_adc(manager: Manager, topic_prefix: str, adc_list: list = []):
         id = name.replace(" ", "")
         pin = gpio[PIN]
         try:
-            adc = GpioADCSensor(
+            GpioADCSensor(
                 id=id,
                 pin=pin,
                 name=name,
+                manager=manager,
                 send_message=manager.send_message,
                 topic_prefix=topic_prefix,
                 update_interval=gpio.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
@@ -90,7 +97,6 @@ def create_adc(manager: Manager, topic_prefix: str, adc_list: list = []):
                     ha_type=SENSOR,
                     availability_msg_func=ha_adc_sensor_availabilty_message,
                 )
-            manager.append_task(asyncio.create_task(adc.send_state()))
         except I2CError as err:
             _LOGGER.error("Can't configure ADC sensor %s. %s", id, err)
             pass
@@ -165,16 +171,16 @@ def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> None:
         name = sensor.get(ID)
         id = name.replace(" ", "")
         try:
-            sdm = ModbusSensor(
+            ModbusSensor(
                 address=sensor[ADDRESS],
                 id=id,
                 name=name,
+                manager=manager,
                 model=sensor[MODEL],
                 send_message=manager.send_message,
                 update_interval=sensor.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
                 **kwargs,
             )
-            manager.append_task(asyncio.create_task(sdm.send_state()))
         except FileNotFoundError as err:
             _LOGGER.error(
                 "Can't configure Modbus sensor %s. %s. No such model in database.",
@@ -349,27 +355,39 @@ def configure_ds2482(i2cbusio: I2C, address: str = DS2482_ADDRESS) -> OneWireBus
     return ow_bus
 
 
-def find_onewire_devices(ow_bus: OneWireBus):
-    devices = ow_bus.scan()
+def configure_dallas() -> AsyncBoneIOW1ThermSensor:
+    return AsyncBoneIOW1ThermSensor
+
+
+def find_onewire_devices(
+    ow_bus: Union[OneWireBus, AsyncBoneIOW1ThermSensor],
+    bus_id: str,
+    bus_type: DallasBusTypes,
+) -> Dict[OneWireAddress]:
     out = {}
-    for device in devices:
-        _addr: int = ds_address(device.rom)
-        _LOGGER.debug("Found device with address %s", hex(_addr))
-        out[_addr] = device
+    try:
+        devices = ow_bus.scan()
+        for device in devices:
+            _addr: int = device.int_address
+            _LOGGER.debug("Found device on bus %s with address %s", bus_id, hex(_addr))
+            out[_addr] = device
+    except RuntimeError as err:
+        _LOGGER.error("Problem with scanning %s bus. %s", bus_type, err)
     return out
 
 
-def create_ds2482_dallas_sensor(
+def create_dallas_sensor(
     manager: Manager,
-    ds2482_bus: OneWireBus,
     address: OneWireAddress,
     config: dict,
     **kwargs,
-):
+) -> Union[DallasSensorDS2482, DallasSensorW1]:
     name = config.get(ID) or hex(address)
     id = name.replace(" ", "")
-    sensor = DallasSensor(
-        bus=ds2482_bus,
+    bus: OneWireBus = kwargs.get("bus")
+    cls = DallasSensorDS2482 if bus else DallasSensorW1
+    sensor = cls(
+        manager=manager,
         address=address,
         id=id,
         name=name,

{boneIO-0.4.0.dev1 → boneIO-0.5.0.dev1}/boneio/helper/mqtt.py

@@ -12,6 +12,7 @@ class BasicMqtt:
         name: str,
         send_message: Callable[[str, Union[str, dict]], None],
         topic_type: str,
+        **kwargs,
     ):
         """Initialize module."""
         self._id = id.replace(" ", "")

boneIO-0.5.0.dev1/boneio/helper/onewire/W1ThermSensor.py

@@ -0,0 +1,73 @@
+"""Custom W1ThermSensor class to support hex addressing of W1 sensors.
+"""
+from typing import List
+from w1thermsensor import AsyncW1ThermSensor, Sensor
+from boneio.helper.onewire import OneWireAddress, reverse_dallas_id
+
+
+def crc82(data: bytearray) -> int:
+    """
+    Perform the 1-Wire CRC check on the provided data. Function from Circuit Python Adafruit.
+
+    :param bytearray data: 8 byte array representing 64 bit ROM code
+    """
+    crc = 0
+
+    for byte in data:
+        crc ^= byte
+        for _ in range(8):
+            if crc & 0x01:
+                crc = (crc >> 1) ^ 0x8C
+            else:
+                crc >>= 1
+            crc &= 0xFF
+    return crc
+
+
+class AsyncBoneIOW1ThermSensor(AsyncW1ThermSensor):
+    def __init__(self, *args, **kwargs):  # pragma: no cover
+        """Custom init function to work with same addressing type as esphome."""
+        self._ds18b20_str_id = hex(Sensor.DS18B20)[2:]
+        try:
+            sensor_id = kwargs.pop("sensor_id")
+            if type(sensor_id) == OneWireAddress:
+                sensor_id = sensor_id.hw_id
+            super().__init__(*args, **kwargs, sensor_id=sensor_id)
+        except KeyError:
+            super().__init__(*args, **kwargs)
+        _crc = crc82(
+            bytes.fromhex(f"{self._ds18b20_str_id}{reverse_dallas_id(self.id)}")
+        )
+        self._hex_id = f"{hex(_crc)}{self.id}{self._ds18b20_str_id}".lower()
+
+    @classmethod
+    def scan(cls) -> List["OneWireAddress"]:
+        """Return only DS18B20 sensors. Add more sensors in the future."""
+
+        def is_sensor(dir_name):
+            return dir_name.startswith(hex(Sensor.DS18B20)[2:])
+
+        def get_hex(name):
+            _hex_id = bytes.fromhex(f"{name[:2]}{reverse_dallas_id(name[3:])}")
+            return _hex_id + bytes([crc82(_hex_id)])
+
+        return [
+            OneWireAddress(get_hex(name=s.name))
+            for s in cls.BASE_DIRECTORY.iterdir()
+            if is_sensor(s.name)
+        ]
+
+    @property
+    def rom(self) -> bytes:
+        """Get rom id."""
+        return bytearray.fromhex(self.hex_id)
+
+    @property
+    def hex_id(self) -> str:
+        """Get hex representation of sensor."""
+        if not self._hex_id:
+            _crc = crc82(
+                bytes.fromhex(f"{self._ds18b20_str_id}{reverse_dallas_id(self.id)}")
+            )
+            self._hex_id = f"{hex(_crc)}{self.id}{self._ds18b20_str_id}".lower()
+        return self._hex_id

boneIO-0.5.0.dev1/boneio/helper/onewire/__init__.py

@@ -0,0 +1,20 @@
+"""Helper dir for DS2482."""
+from boneio.helper.onewire.ds2482 import DS2482, DS2482_ADDRESS
+from boneio.helper.onewire.onewire import (
+    OneWire,
+    OneWireBus,
+    OneWireAddress,
+    reverse_dallas_id,
+)
+from boneio.helper.onewire.W1ThermSensor import AsyncBoneIOW1ThermSensor
+
+
+__all__ = [
+    "DS2482",
+    "OneWire",
+    "OneWireBus",
+    "DS2482_ADDRESS",
+    "AsyncBoneIOW1ThermSensor",
+    "OneWireAddress",
+    "reverse_dallas_id",
+]

boneIO-0.5.0.dev1/boneio/helper/onewire/onewire.py

@@ -0,0 +1,91 @@
+"""OneWire base class for DS2482.
+Module by https://github.com/fgervais/ds2482
+"""
+import adafruit_onewire.bus
+from onewireio import OneWire as OneWireIO
+from boneio.helper.onewire import DS2482
+from typing import List
+from adafruit_onewire.bus import OneWireAddress as AdafruitOneWireAddress
+
+
+def ds_address(rom: bytes) -> int:
+    return int.from_bytes(rom, "little")
+
+
+def reverse_dallas_id(a: str) -> str:
+    """Reverse sensor address."""
+    return "".join(reversed([a[i : i + 2] for i in range(0, len(a), 2)]))
+
+
+class OneWireAddress(AdafruitOneWireAddress):
+    @property
+    def int_address(self) -> int:
+        return ds_address(self.rom)
+
+    @property
+    def hex_id(self) -> str:
+        return reverse_dallas_id(self.rom.hex())
+
+    @property
+    def hw_id(self) -> str:
+        return self.hex_id[2:-2]
+
+
+class OneWire(OneWireIO):
+    def __init__(self, ds2482: DS2482):
+        self.ds2482 = ds2482
+
+    def deinit(self):
+        """
+        Deinitialize the OneWire bus and release any hardware resources for reuse.
+        """
+        self.ds2482.device_reset()
+
+    def reset(self):
+        """
+        Reset the OneWire bus and read presence
+
+        :return: False when at least one device is present
+        """
+        return self.ds2482.reset()
+
+    def read_bit(self):
+        """
+        Read in a bit
+        """
+        return self.ds2482.single_bit()
+
+    def write_bit(self, value):
+        """
+        Write out a bit based on value.
+        """
+        self.ds2482.single_bit(value)
+
+
+class OneWireBus(adafruit_onewire.bus.OneWireBus):
+    def __init__(self, ds2482: DS2482):
+        self._ow = OneWire(ds2482)
+        self._readbit = self._ow.read_bit
+        self._writebit = self._ow.write_bit
+        self._maximum_devices = adafruit_onewire.bus._MAX_DEV
+
+    def scan(self) -> List[OneWireAddress]:
+        """Scan for devices on the bus and return a list of addresses."""
+        devices = []
+        diff = 65
+        rom = None
+        count = 0
+        for _ in range(0xFF):
+            rom, diff = self._search_rom(rom, diff)
+            if rom:
+                count += 1
+                if count > self.maximum_devices:
+                    raise RuntimeError(
+                        "Maximum device count of {} exceeded.".format(
+                            self.maximum_devices
+                        )
+                    )
+                devices.append(OneWireAddress(rom))
+            if diff == 0:
+                break
+        return devices