boneIO 0.3.0.dev4__py3-none-any.whl → 0.3.0.dev6__py3-none-any.whl

boneio/const.py

@@ -113,6 +113,8 @@ BINARY_SENSOR = "binary_sensor"
 LM75 = "lm75"
 MCP_TEMP_9808 = "mcp9808"
 INPUT_SENSOR = "inputsensor"
+DS2482 = "ds2482"
+DALLAS = "dallas"
 
 BASE = "base"
 LENGTH = "length"

boneio/cover.py

@@ -1,7 +1,7 @@
 """Cover module."""
 import asyncio
 import logging
-from typing import Any, Callable
+from typing import Callable
 from boneio.const import CLOSE, COVER, IDLE, OPEN, OPENING, CLOSING, CLOSED, STOP
 from boneio.helper.events import EventBus
 from boneio.helper.mqtt import BasicMqtt
@@ -44,7 +44,7 @@ class Cover(BasicMqtt):
     def __init__(
         self,
         id: str,
-        open_relay: Any,
+        open_relay: MCPRelay,
         close_relay: MCPRelay,
         state_save: Callable,
         open_time: TimePeriod,

boneio/helper/__init__.py

@@ -1,5 +1,4 @@
 """Helper dir for BoneIO."""
-from typing import Callable, TypeVar, Any
 
 from boneio.helper.gpio import (
     edge_detect,
@@ -35,20 +34,6 @@ from boneio.helper.exceptions import GPIOInputException, I2CError
 from boneio.helper.queue import UniqueQueue
 from boneio.helper.timeperiod import TimePeriod
 
-CALLABLE_T = TypeVar("CALLABLE_T", bound=Callable[..., Any])
-CALLBACK_TYPE = Callable[[], None]
-
-
-def callback(func: CALLABLE_T) -> CALLABLE_T:
-    """Annotation to mark method as safe to call from within the event loop."""
-    setattr(func, "_boneio_callback", True)
-    return func
-
-
-def is_callback(func: Callable[..., Any]) -> bool:
-    """Check if function is safe to be called in the event loop."""
-    return getattr(func, "_boneio_callback", False) is True
-
 
 __all__ = [
     "CustomValidator",
@@ -80,4 +65,6 @@ __all__ = [
     "load_config_from_string",
     "load_config_from_file",
     "TimePeriod",
+    "callback",
+    "is_callback",
 ]

boneio/helper/ds2482/__init__.py

@@ -0,0 +1,10 @@
+"""Helper dir for DS2482."""
+from boneio.helper.ds2482.ds2482 import DS2482, DS2482_ADDRESS
+from boneio.helper.ds2482.onewire import OneWire, OneWireBus
+
+
+def ds_address(rom: bytes) -> int:
+    return int.from_bytes(rom, "little")
+
+
+__all__ = ["DS2482", "OneWire", "OneWireBus", "ds_address", "DS2482_ADDRESS"]

boneio/helper/ds2482/ds2482.py

@@ -0,0 +1,163 @@
+"""DS2482 base class.
+Module by https://github.com/fgervais/ds2482
+"""
+import time
+
+import adafruit_bus_device.i2c_device as i2c_device
+
+# Default i2c address (AD0 = GND, AD1 = GND)
+DS2482_ADDRESS = 0x18
+
+# DS2482 device commands
+COMMAND_DEVICE_RESET = 0xF0
+COMMAND_SET_POINTER = 0xE1
+COMMAND_WRITE_CONFIG = 0xD2
+COMMAND_1W_RESET = 0xB4
+COMMAND_1W_SINGLE_BIT = 0x87
+COMMAND_1W_WRITE_BYTE = 0xA5
+COMMAND_1W_READ_BYTE = 0x96
+COMMAND_1W_TRIPLET = 0x78
+
+# DS2482 read pointer codes
+POINTER_STATUS = 0xF0
+POINTER_DATA = 0xE1
+POINTER_CONFIG = 0xC3
+
+# DS2482 configuration register
+CONFIG_ACTIVE_PULLUP = 0x01
+CONFIG_STRONG_PULLUP = 0x04
+CONFIG_1W_OVERDRIVE = 0x08
+
+CONFIG_MASK = 0x0F
+
+# DS2482 status register
+STATUS_1W_BUSY = 0x01
+STATUS_PRESENCE_PULSE = 0x02
+STATUT_SHORT_DETECTED = 0x04
+STATUS_LOGIC_LEVEL = 0x08
+STATUS_DEVICE_RESET = 0x10
+STATUS_SINGLE_BIT = 0x20
+STATUS_TRIPLET_BIT = 0x40
+STATUS_BRANCH_TAKEN = 0x80
+
+
+class DS2482:
+    def __init__(self, i2c, address=DS2482_ADDRESS, active_pullup=False):
+        self._i2c = i2c_device.I2CDevice(i2c, address)
+        self.device_reset()
+        if active_pullup:
+            self.device_config = CONFIG_ACTIVE_PULLUP
+
+        # 1-Wire bus busy with STRONG_PULLUP
+        self._bus_busy = time.monotonic()
+
+    def device_reset(self):
+        """Terminate any 1-wire communication and reset the DS2482"""
+        with self._i2c as i2c:
+            i2c.write(bytes([COMMAND_DEVICE_RESET]))
+
+    @property
+    def device_status(self):
+        with self._i2c as i2c:
+            buf = bytearray([COMMAND_SET_POINTER, POINTER_STATUS])
+            i2c.write_then_readinto(buf, buf, in_end=1)
+            return buf[0]
+
+    @property
+    def device_config(self):
+        with self._i2c as i2c:
+            buf = bytearray([COMMAND_SET_POINTER, POINTER_CONFIG])
+            i2c.write_then_readinto(buf, buf, in_end=1)
+            return buf[0] & 0x0F
+
+    @device_config.setter
+    def device_config(self, config):
+        with self._i2c as i2c:
+            i2c.write(
+                bytes([COMMAND_WRITE_CONFIG, (config & 0x0F) | ((~config << 4) & 0xF0)])
+            )
+
+    def reset(self):
+        with self._i2c as i2c:
+            buf = bytearray([COMMAND_1W_RESET])
+            i2c.write(buf)
+            while True:
+                i2c.readinto(buf)
+                if not buf[0] & STATUS_1W_BUSY:
+                    break
+                time.sleep(0.001)
+            return not buf[0] & STATUS_PRESENCE_PULSE
+
+    def single_bit(self, bit=1, strong_pullup=False, busy=None):
+        with self._i2c as i2c:
+            buf = bytearray(2)
+            if strong_pullup:
+                buf[0:2] = [COMMAND_SET_POINTER, POINTER_CONFIG]
+                i2c.write_then_readinto(buf, buf, in_start=1)
+                buf[0] = COMMAND_WRITE_CONFIG
+                buf[1] = buf[1] & CONFIG_MASK | CONFIG_STRONG_PULLUP
+                buf[1] |= (~buf[1] << 4) & 0xFF
+                i2c.write(buf)
+            buf[0:2] = [COMMAND_1W_SINGLE_BIT, 0x80 if bit else 0x00]
+            i2c.write(buf)
+            while True:
+                i2c.readinto(buf, end=1)
+                if not buf[0] & STATUS_1W_BUSY:
+                    break
+                time.sleep(0.001)
+            if busy:
+                self._bus_busy = time.monotonic() + busy
+            return buf[0] & STATUS_SINGLE_BIT != 0
+
+    def write_byte(self, data, strong_pullup=False, busy=None):
+        with self._i2c as i2c:
+            buf = bytearray(2)
+            if strong_pullup:
+                buf[0:2] = [COMMAND_SET_POINTER, POINTER_CONFIG]
+                i2c.write_then_readinto(buf, buf, in_start=1)
+                buf[0] = COMMAND_WRITE_CONFIG
+                buf[1] = buf[1] & CONFIG_MASK | CONFIG_STRONG_PULLUP
+                buf[1] |= (~buf[1] << 4) & 0xFF
+                i2c.write(buf)
+            buf[0:2] = [COMMAND_1W_WRITE_BYTE, data]
+            i2c.write(buf)
+            while True:
+                i2c.readinto(buf, end=1)
+                if buf[0] & STATUS_1W_BUSY == 0:
+                    break
+                time.sleep(0.001)
+            if busy:
+                self._bus_busy = time.monotonic() + busy
+
+    def read_byte(self):
+        with self._i2c as i2c:
+            buf = bytearray([COMMAND_1W_READ_BYTE, 0x00])
+            i2c.write(buf, end=1)
+            while True:
+                i2c.readinto(buf, end=1)
+                if not buf[0] & STATUS_1W_BUSY:
+                    break
+                time.sleep(0.001)
+            buf[0:2] = [COMMAND_SET_POINTER, POINTER_DATA]
+            i2c.write_then_readinto(buf, buf, in_end=1)
+            return buf[0]
+
+    def wait_ready(self):
+        while True:
+            t = self._bus_busy - time.monotonic()
+            if t > 0:
+                time.sleep(t)
+            else:
+                break
+        with self._i2c as i2c:
+            buf = bytearray([COMMAND_SET_POINTER, POINTER_STATUS])
+            i2c.write(buf)
+            while True:
+                i2c.readinto(buf, end=1)
+                if not buf[0] & STATUS_1W_BUSY:
+                    break
+                time.sleep(0.001)
+            return buf[0]
+
+    def triplet(self, dir):
+        pass

boneio/helper/ds2482/onewire.py

@@ -0,0 +1,44 @@
+"""OneWire base class for DS2482.
+Module by https://github.com/fgervais/ds2482
+"""
+import adafruit_onewire.bus
+import busio
+
+
+class OneWire(busio.OneWire):
+    def __init__(self, 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):
+        self._ow = OneWire(ds2482)
+        self._readbit = self._ow.read_bit
+        self._writebit = self._ow.write_bit
+        self._maximum_devices = adafruit_onewire.bus._MAX_DEV

boneio/helper/events.py

@@ -3,9 +3,9 @@ import datetime as dt
 import signal
 import logging
 import time
-from typing import Callable
+from typing import Callable, Optional
 from datetime import datetime
-from boneio.helper import callback
+from boneio.helper.util import callback
 
 _LOGGER = logging.getLogger(__name__)
 UTC = dt.timezone.utc
@@ -139,9 +139,9 @@ def async_track_point_in_time(
     # Ensure point_in_time is UTC
     utc_point_in_time = as_utc(point_in_time)
 
-    # Since this is called once, we accept a HassJob so we can avoid
+    # Since this is called once, we accept a so we can avoid
     # having to figure out how to call the action every time its called.
-    cancel_callback: asyncio.TimerHandle | None = None
+    cancel_callback: Optional[asyncio.TimerHandle] = None
 
     @callback
     def run_action(job) -> None:

boneio/helper/exceptions.py

@@ -13,5 +13,13 @@ class I2CError(BoneIOException):
     """I2C Exception."""
 
 
+class OneWireError(BoneIOException):
+    """One Wire Exception."""
+
+
 class ConfigurationException(BoneIOException):
     """Configuration yaml exception."""
+
+
+class CoverRelayException(BoneIOException):
+    """Cover configuration exception."""

boneio/helper/loader.py

@@ -43,10 +43,13 @@ from boneio.helper import (
     ha_input_availabilty_message,
     ha_sensor_temp_availabilty_message,
 )
+from adafruit_onewire.bus import OneWireAddress
+from boneio.helper.ds2482 import DS2482, OneWireBus, ds_address, DS2482_ADDRESS
 from boneio.helper.ha_discovery import ha_cover_availabilty_message
 from boneio.helper.timeperiod import TimePeriod
 from boneio.input.gpio import GpioInputButton
 from boneio.helper.config import ConfigHelper
+from boneio.sensor import DallasSensor
 
 # Typing imports that create a circular dependency
 if TYPE_CHECKING:
@@ -116,6 +119,7 @@ def create_temp_sensor(
             address=temp_def[ADDRESS],
             send_message=manager.send_message,
             topic_prefix=topic_prefix,
+            update_interval=temp_def.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
         )
         manager.send_ha_autodiscovery(
             id=id,
@@ -343,3 +347,47 @@ def configure_cover(
             availability_msg_func=ha_cover_availabilty_message,
         )
     return cover
+
+
+def configure_ds2482(i2cbusio: I2C, address: str = DS2482_ADDRESS) -> OneWireBus:
+    ds2482 = DS2482(i2c=i2cbusio, address=address)
+    ow_bus = OneWireBus(ds2482=ds2482)
+    return ow_bus
+
+
+def find_onewire_devices(ow_bus: OneWireBus):
+    devices = ow_bus.scan()
+    out = {}
+    for device in devices:
+        _addr: int = ds_address(device.rom)
+        _LOGGER.debug("Found device with address %s", hex(_addr))
+        out[_addr] = device
+    return out
+
+
+def create_ds2482_dallas_sensor(
+    manager: Manager,
+    ds2482_bus: OneWireBus,
+    address: OneWireAddress,
+    config: dict,
+    **kwargs,
+):
+    name = config.get(ID) or hex(address)
+    id = name.replace(" ", "")
+    sensor = DallasSensor(
+        bus=ds2482_bus,
+        address=address,
+        id=id,
+        name=name,
+        update_interval=config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
+        send_message=manager.send_message,
+        **kwargs,
+    )
+    if config.get(SHOW_HA, True):
+        manager.send_ha_autodiscovery(
+            id=sensor.id,
+            name=sensor.name,
+            ha_type=SENSOR,
+            availability_msg_func=ha_sensor_temp_availabilty_message,
+        )
+    return sensor

boneio/helper/util.py

@@ -0,0 +1,15 @@
+from typing import Callable, TypeVar, Any
+
+CALLABLE_T = TypeVar("CALLABLE_T", bound=Callable[..., Any])
+CALLBACK_TYPE = Callable[[], None]
+
+
+def callback(func: CALLABLE_T) -> CALLABLE_T:
+    """Annotation to mark method as safe to call from within the event loop."""
+    setattr(func, "_boneio_callback", True)
+    return func
+
+
+def is_callback(func: Callable[..., Any]) -> bool:
+    """Check if function is safe to be called in the event loop."""
+    return getattr(func, "_boneio_callback", False) is True

boneio/manager.py

@@ -7,6 +7,7 @@ from busio import I2C
 
 from boneio.const import (
     ACTION,
+    ADDRESS,
     BUTTON,
     CLOSE,
     COVER,
@@ -51,6 +52,7 @@ from boneio.helper.loader import (
     configure_relay,
     create_mcp23017,
     create_temp_sensor,
+    create_ds2482_dallas_sensor,
 )
 from boneio.helper.yaml_util import load_config_from_file
 from boneio.modbus import Modbus
@@ -75,6 +77,8 @@ class Manager:
         sensors: dict = {},
         modbus: dict = None,
         mcp23017: Optional[List] = None,
+        ds2482: Optional[dict] = None,
+        dallas: Optional[List] = None,
         oled: dict = {},
         adc_list: Optional[List] = None,
         covers: Optional[List] = [],
@@ -98,6 +102,8 @@ class Manager:
         self._oled = None
         self._tasks: List[asyncio.Task] = []
         self._covers = {}
+        self._ds_onewire = {}
+        self._ds_onewire_bus = {}
         self._temp_sensors = []
         self._modbus = None
         if modbus and modbus.get(UART) in UARTS:
@@ -130,6 +136,33 @@ class Manager:
             manager=self, mcp23017=mcp23017, i2cbusio=self._i2cbusio
         )
 
+        if ds2482:
+            _LOGGER.debug("Preparing DS2482 bus.")
+            from boneio.helper.loader import configure_ds2482, find_onewire_devices
+
+            self._ds_onewire_bus[ds2482[ID]] = configure_ds2482(
+                i2cbusio=self._i2cbusio, address=ds2482[ADDRESS]
+            )
+            self._ds_onewire = find_onewire_devices(
+                ow_bus=self._ds_onewire_bus[ds2482[ID]]
+            )
+        for sensor in dallas:
+            ds2482_bus_id = sensor.get("ds2482_id")
+            if ds2482_bus_id and ds2482_bus_id in self._ds_onewire_bus:
+                address = self._ds_onewire.get(sensor[ADDRESS])
+                if not address:
+                    continue
+
+                self._temp_sensors.append(
+                    create_ds2482_dallas_sensor(
+                        manager=self,
+                        ds2482_bus=self._ds_onewire_bus[ds2482_bus_id],
+                        address=address,
+                        topic_prefix=self._config_helper.topic_prefix,
+                        config=sensor,
+                    )
+                )
+
         if adc_list:
             from boneio.helper.loader import create_adc
 
@@ -171,6 +204,18 @@ class Manager:
             _id = _config[ID].replace(" ", "")
             open_relay = self._output.get(_config.get("open_relay"))
             close_relay = self._output.get(_config.get("close_relay"))
+            if not open_relay:
+                _LOGGER.error(
+                    "Can't configure cover %s. This relay doesn't exist.",
+                    _config.get("open_relay"),
+                )
+                continue
+            if not close_relay:
+                _LOGGER.error(
+                    "Can't configure cover %s. This relay doesn't exist.",
+                    _config.get("close_relay"),
+                )
+                continue
             if open_relay.output_type != NONE or close_relay.output_type != NONE:
                 _LOGGER.error(
                     "Can't configure cover %s. %s",

boneio/relay/mcp.py

@@ -2,7 +2,7 @@
 
 import logging
 from adafruit_mcp230xx.mcp23017 import MCP23017, DigitalInOut
-from boneio.helper import callback
+from boneio.helper.util import callback
 from boneio.relay.basic import BasicRelay
 from boneio.const import SWITCH, NONE
 from boneio.helper.events import async_track_point_in_time, utcnow

boneio/runner.py

@@ -5,6 +5,7 @@ import os
 from boneio.const import (
     ADC,
     COVER,
+    DALLAS,
     ENABLED,
     HA_DISCOVERY,
     HOST,
@@ -20,6 +21,7 @@ from boneio.const import (
     PORT,
     TOPIC_PREFIX,
     USERNAME,
+    DS2482,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -66,6 +68,8 @@ async def async_run(
             MODBUS: config.get("modbus_sensors"),
         },
         mcp23017=config.get(MCP23017, []),
+        ds2482=config.get(DS2482),
+        dallas=config.get(DALLAS, []),
         modbus=config.get(MODBUS),
         oled=config.get(OLED),
         adc_list=config.get(ADC, []),

boneio/schema/schema.yaml

@@ -146,6 +146,17 @@ lm75:
       default: 0x48
       meta:
         label: Address of I2C
+    update_interval:
+      type:
+        - string
+        - timeperiod
+      coerce:
+        - str
+        - positive_time_period
+      required: True
+      default: 60s
+      meta:
+        label: Update interval.
 
 
 mcp9808:
@@ -162,7 +173,18 @@ mcp9808:
       required: True
       default: 0x18
       meta:
-        label: GPIO of I2C SDA
+        label: Address of I2C device
+    update_interval:
+      type:
+        - string
+        - timeperiod
+      coerce:
+        - str
+        - positive_time_period
+      required: True
+      default: 60s
+      meta:
+        label: Update interval.
 
 mcp23017:
   type: list
@@ -356,6 +378,7 @@ adc:
           label: If you want you can disable discovering this input in HA.
 cover:
   type: list
+  required: False
   meta:
     label: Cover section
   schema:
@@ -414,3 +437,60 @@ cover:
         default: True
         meta:
           label: If you want you can disable discovering this input in HA.
+
+ds2482:
+  type: dict
+  required: False
+  schema:
+    id:
+      type: string
+      required: True
+      meta:
+        label: Id of I2C to use in pin config
+    address:
+      type: string
+      required: True
+      default: 0x18
+      meta:
+        label: GPIO of I2C SDA
+
+dallas:
+  type: list
+  required: False
+  meta:
+    label: Dallas DS18B20 section
+  schema:
+    type: dict
+    schema:
+      id:
+        type: string
+        required: False
+        meta:
+          label: Id to use in HA if needed. Default to address.
+      address:
+        type: integer
+        required: True
+        meta:
+          label: Address of Dallas device
+      ds2482_id:
+        type: string
+        required: False
+        meta:
+          label: Put DS2482 defined id if you want to add DS18B20 connected via DS2482.
+      show_in_ha:
+        type: boolean
+        required: True
+        default: True
+        meta:
+          label: If you want you can disable discovering this input in HA.
+      update_interval:
+        type:
+          - string
+          - timeperiod
+        coerce:
+          - str
+          - positive_time_period
+        required: True
+        default: 60s
+        meta:
+          label: Update interval.

boneio/sensor/__init__.py

@@ -1,9 +1,12 @@
 """Sensor module."""
-from boneio.sensor.temp import LM75Sensor, MCP9808Sensor
+from boneio.sensor.temp.lm75 import LM75Sensor
+from boneio.sensor.temp.mcp9808 import MCP9808Sensor
+from boneio.sensor.temp.dallas import DallasSensor
 from boneio.sensor.gpio import GpioInputSensor
 from boneio.sensor.adc import initialize_adc, GpioADCSensor
 
 __all__ = [
+    "DallasSensor",
     "LM75Sensor",
     "MCP9808Sensor",
     "GpioInputSensor",

boneio/sensor/modbus/__init__.py

@@ -22,6 +22,8 @@ from boneio.helper import BasicMqtt
 from boneio.helper.ha_discovery import modbus_sensor_availabilty_message
 from boneio.helper.timeperiod import TimePeriod
 from boneio.helper.config import ConfigHelper
+from boneio.modbus import Modbus
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -92,7 +94,7 @@ class ModbusSensor(BasicMqtt):
 
     def __init__(
         self,
-        modbus,
+        modbus: Modbus,
         address: str,
         model: str,
         config_helper: ConfigHelper,
@@ -104,7 +106,7 @@ class ModbusSensor(BasicMqtt):
         super().__init__(
             id=id or address,
             topic_type=SENSOR,
-            topic_prefix=self._config_helper.topic_prefix,
+            topic_prefix=config_helper.topic_prefix,
             **kwargs,
         )
         self._config_helper = config_helper

boneio/sensor/temp/__init__.py

@@ -1,13 +1,21 @@
 """Manage BoneIO onboard temp sensors."""
 
 import asyncio
-from adafruit_pct2075 import PCT2075
-from adafruit_mcp9808 import MCP9808
-from boneio.const import STATE, SENSOR, LM75, MCP_TEMP_9808, TEMPERATURE
+from datetime import datetime, timedelta
+from typing import Optional
+
+from boneio.const import STATE, SENSOR, TEMPERATURE
+
 
 from boneio.helper.exceptions import I2CError
 from boneio.helper import BasicMqtt
 
+from boneio.helper.util import callback
+from boneio.helper.events import async_track_point_in_time, utcnow
+
+
+from boneio.helper.timeperiod import TimePeriod
+
 
 class TempSensor(BasicMqtt):
     """Represent Temp sensor in BoneIO."""
@@ -15,11 +23,22 @@ class TempSensor(BasicMqtt):
     SensorClass = None
     DefaultName = TEMPERATURE
 
-    def __init__(self, i2c, address, id: str = DefaultName, **kwargs):
+    def __init__(
+        self,
+        i2c,
+        address: str,
+        id: str = DefaultName,
+        update_interval: int = TimePeriod(seconds=60),
+        **kwargs
+    ):
         """Initialize Temp class."""
         super().__init__(id=id, topic_type=SENSOR, **kwargs)
+        self._update_interval = update_interval
+        self._loop = asyncio.get_event_loop()
         try:
             self._pct = self.SensorClass(i2c_bus=i2c, address=address)
+            self._unsub_refresh = None
+            self._schedule_refresh(utcnow() + timedelta(seconds=2))
         except ValueError as err:
             raise I2CError(err)
 
@@ -28,25 +47,30 @@ class TempSensor(BasicMqtt):
         """Give rounded value of temperature."""
         return round(self._pct.temperature, 2)
 
-    async def send_state(self):
-        """Fetch temperature periodically and send to MQTT."""
-        while True:
-            self._send_message(
-                topic=self._send_topic,
-                payload={STATE: self.state},
-            )
-            await asyncio.sleep(60)
-
-
-class LM75Sensor(TempSensor):
-    """Represent LM75 sensor in BoneIO."""
+    def _schedule_refresh(self, update_time: Optional[datetime] = None):
+        if self._unsub_refresh:
+            self._unsub_refresh()
+            self._unsub_refresh = None
+        if not update_time:
+            update_time = utcnow() + self._update_interval.as_timedelta
+        self._unsub_refresh = async_track_point_in_time(
+            loop=self._loop,
+            action=self._refresh,
+            point_in_time=update_time,
+        )
 
-    SensorClass = PCT2075
-    DefaultName = LM75
+    @callback
+    def _refresh(self, time: datetime):
+        if self._unsub_refresh:
+            self._unsub_refresh()
+            self._unsub_refresh = None
 
+        self.send_state()
+        self._schedule_refresh()
 
-class MCP9808Sensor(TempSensor):
-    """Represent MCP9808 sensor in BoneIO."""
-
-    SensorClass = MCP9808
-    DefaultName = MCP_TEMP_9808
+    def send_state(self):
+        """Fetch temperature periodically and send to MQTT."""
+        self._send_message(
+            topic=self._send_topic,
+            payload={STATE: self.state},
+        )

boneio/sensor/temp/dallas.py

@@ -0,0 +1,43 @@
+"""Dallas temp sensor."""
+
+import asyncio
+from datetime import timedelta
+
+# from datetime import timedelta
+from adafruit_ds18x20 import DS18X20
+from adafruit_onewire.bus import OneWireAddress
+from boneio.const import SENSOR, TEMPERATURE
+
+
+from boneio.helper.exceptions import OneWireError
+from boneio.helper import BasicMqtt
+
+from boneio.helper.events import utcnow
+
+
+from boneio.helper.timeperiod import TimePeriod
+from . import TempSensor
+
+
+class DallasSensor(TempSensor):
+    DefaultName = TEMPERATURE
+    SensorClass = DS18X20
+
+    def __init__(
+        self,
+        bus,
+        address: OneWireAddress,
+        id: str = DefaultName,
+        update_interval: int = TimePeriod(seconds=60),
+        **kwargs
+    ):
+        """Initialize Temp class."""
+        self._update_interval = update_interval
+        self._loop = asyncio.get_event_loop()
+        BasicMqtt.__init__(self, id=id, topic_type=SENSOR, **kwargs)
+        try:
+            self._pct = DS18X20(bus=bus, address=address)
+            self._unsub_refresh = None
+            self._schedule_refresh(utcnow() + timedelta(seconds=2))
+        except ValueError as err:
+            raise OneWireError(err)

boneio/sensor/temp/lm75.py

@@ -0,0 +1,11 @@
+"""LM75 temp sensor."""
+from . import TempSensor
+from adafruit_pct2075 import PCT2075
+from boneio.const import LM75
+
+
+class LM75Sensor(TempSensor):
+    """Represent LM75 sensor in BoneIO."""
+
+    SensorClass = PCT2075
+    DefaultName = LM75

boneio/sensor/temp/mcp9808.py

@@ -0,0 +1,12 @@
+"""MCP9808 temp sensor."""
+
+from . import TempSensor
+from adafruit_mcp9808 import MCP9808
+from boneio.const import MCP_TEMP_9808
+
+
+class MCP9808Sensor(TempSensor):
+    """Represent MCP9808 sensor in BoneIO."""
+
+    SensorClass = MCP9808
+    DefaultName = MCP_TEMP_9808

boneio/version.py

@@ -1,2 +1,2 @@
 # flake8: noqa
-__version__ = "0.3.0.dev4"
+__version__ = "0.3.0.dev6"

{boneio-0.3.0.dev4.dist-info → boneio-0.3.0.dev6.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.3.0.dev4
+Version: 0.3.0.dev6
 Summary: Python App for BoneIO
 Home-page: https://github.com/boneIO-eu/app_bbb
-Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.3.0.dev4.zip
+Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.3.0.dev6.zip
 License: GNU General Public License v3.0
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
@@ -14,6 +14,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Adafruit-BBIO (==1.2.0)
 Requires-Dist: Adafruit-Blinka (==6.20.4)
+Requires-Dist: adafruit-circuitpython-ds18x20 (==1.3.10)
 Requires-Dist: adafruit-circuitpython-mcp230xx (==2.5.3)
 Requires-Dist: adafruit-circuitpython-mcp9808 (==3.3.10)
 Requires-Dist: adafruit-circuitpython-pct2075 (==1.1.12)

{boneio-0.3.0.dev4.dist-info → boneio-0.3.0.dev6.dist-info}/RECORD

@@ -1,13 +1,13 @@
 boneio/__init__.py,sha256=hoLKnu6h1uEsiCHA9Ql2MMDC7VQS0E-s_2cxBS-CTOg,147
 boneio/bonecli.py,sha256=Alvpbf3gZteV3IMX7DBUD6F_XV_-juKfZ1d4YpIM7PI,3093
-boneio/const.py,sha256=eBU9YNvTHvTRLvQtug0uqmsMZnVVNNcsKMZSow67fLM,2600
-boneio/cover.py,sha256=wKrnhaRGjJmEutUbisvDmPjVAYeDi4lYzV_de4nXxtA,8298
-boneio/manager.py,sha256=qfaND0Cw3qSAfBxV7eP1Gz41dQL9hps-9MRWWsbYeUg,14581
+boneio/const.py,sha256=nkL8SAMnZT3SfQiNOhWQ5RKoxUIoJV_9dH0BwLAJzXI,2636
+boneio/cover.py,sha256=Oi25Be0umRfKJ12kEBZYASw07bvRbLOT2s0emh4Kals,8298
+boneio/manager.py,sha256=jyQSbPOTbXWj1YuLviwugs5F4eKnG2DIEhc4F0Uf3TY,16321
 boneio/modbus.py,sha256=QWUAYHXLcP7A_vVKTMbZ7x8KS72qLw65t_UzTDI3448,4003
 boneio/mqtt_client.py,sha256=Y_Vt0pKEETIy1XKQ-WFhowlRJhuv9tWLtyoD8Vdz7hk,6983
 boneio/oled.py,sha256=Be9QeTHX1mmCQOshYY1KNGvqt4nzEtJCD3gCE3gRSsc,4836
-boneio/runner.py,sha256=Y3Xx4N4WZchVr7a9gUtqskp_l5-_Cp7T_dVLfHSz8vQ,2064
-boneio/version.py,sha256=aRsCpG8-QTx0XdbEXY9OSFnuyhz5H629k_Tk-UN_tSk,42
+boneio/runner.py,sha256=IdAV1Yu--LncQYbNjx6w2uGjqUDBxNcNPW5ZH3hZuBo,2162
+boneio/version.py,sha256=x346uF6-PqYb8v3BN7X9RPPWeWgBJitJpH-sVmzKGEg,42
 boneio/example_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boneio/example_config/adc.yaml,sha256=KaNfPuZmrhpiKJVUKC6uQXQ0YRCp0DoXVxYtqsbiSGI,168
 boneio/example_config/config.yaml,sha256=_gNf0Yo6p10Ao_rcSmHA_gCGMtDsvAdso3jNt3r3gqE,322
@@ -16,13 +16,13 @@ boneio/example_config/input.yaml,sha256=U5pN5Dyb8XrhqHeXsa3rYE5VFI4Y_BapNJkv9c1i
 boneio/example_config/output24x16A.yaml,sha256=uCj6U1j8qrnb3-Ui78-UjSFNZ3h_evNlab1p6P0H3-g,1691
 boneio/example_config/output32x5A.yaml,sha256=HuNSZ7S1qGMQi_XDAGJiMDe-W-aPcigvm6v-FYPgMeE,2471
 boneio/fonts/danube__.ttf,sha256=KBRPUcGvmroCjrWC8zK4MulUb9lV8R0lXkOY7lNnQWc,19372
-boneio/helper/__init__.py,sha256=wOr2NWtGamuaWVmmQQP4vcNaj1I6pXeT2rDf-FzXKYk,2289
+boneio/helper/__init__.py,sha256=zXVY9cTcFumVLf4wuNIutkL5UATTKL-ODcv8VjjxGfw,1816
 boneio/helper/config.py,sha256=WuHsEP7FazMuCB55Qgc6m-X2gMsSoscmXTS8BoX8vPE,881
-boneio/helper/events.py,sha256=oKXDpFXSmbfhnucSYTTCPlhaBBstcAYYg3bTIVS6D1w,5251
-boneio/helper/exceptions.py,sha256=4APZ9UrJtCWP-5hLqHUThJ9fLKOZr-LoulLy_1QAq-I,318
+boneio/helper/events.py,sha256=jXRyWyq_yFJHURs0YPyhKo4tR6dQ7FvGGqen9RfGqp4,5261
+boneio/helper/exceptions.py,sha256=2t7WvfE2vS17eK9cV4l_RmBEug1ZlkPXWLRMxDSPLFI,474
 boneio/helper/gpio.py,sha256=HOImpow_6rVOtgZ5FAZd-En61jNyigp2AVZMXYW0x3U,2765
 boneio/helper/ha_discovery.py,sha256=0Ab5xwplKoxArYTSwt5xyBtn5MaVbKlzdoRNw3tpRN8,5480
-boneio/helper/loader.py,sha256=lSkjp1o27dUCC5iSH8ymjcQCCBcMIRxguDMggYFs_94,9985
+boneio/helper/loader.py,sha256=qF0AKEz6TQhB0WLCHMx8LVV8l2CkiFgooW1ejvJtc34,11427
 boneio/helper/logger.py,sha256=8B0qeNPALGG5Dlz0cfujjknbf-TOPv4axLF3xj_Bzs8,1800
 boneio/helper/mqtt.py,sha256=q_0K5TOWNZNCvmhpHuFWloRSVyGxdklogx0jYxc5cpg,741
 boneio/helper/oled.py,sha256=f0XYbaFstUbJ6ISmFe1vQCnmNVMctQWtnStNdROrblc,351
@@ -30,28 +30,35 @@ boneio/helper/queue.py,sha256=7fE7d344-BEW8sljN40wmqsbBr4kPLvz4ShBjkT04p8,1066
 boneio/helper/state_manager.py,sha256=3xBj2Uo9_YrfTxmpxhOg5EaRY71YRv0f9PgBOGtki-g,1994
 boneio/helper/stats.py,sha256=wMoRP7k8v6EeMljaPK8YUZbfW8rlb06tOoDy58fjm3k,4898
 boneio/helper/timeperiod.py,sha256=KUivnt9hGyb_0bSqvmr8tCCm4axL6axuyF2jlkW--b0,5653
+boneio/helper/util.py,sha256=VG7VvPUX6L2M8ib6A3vK2mXh7_9KchahMsaXH9iaFr0,508
 boneio/helper/yaml_util.py,sha256=IQHE-MeaXlzuUAybw9Zkyr5cVYwkm14M1zfLk6gW5S8,10524
+boneio/helper/ds2482/__init__.py,sha256=Zsh_6hLOta9gjognR_ECideMmwtMTYpWN757eybC6gc,311
+boneio/helper/ds2482/ds2482.py,sha256=c2t_hdAMtFsHw4Vw41QzO_hEDDNMeb3J71mEwEMUBhM,5169
+boneio/helper/ds2482/onewire.py,sha256=KTNFmFFhNQsxnu0ue_GpBjilv54F1XJnWgVly-0BTIU,1085
 boneio/input/__init__.py,sha256=u9wuehuC_TNizL4tyn7EygZW5LaTFjSnFaZeZr3zZ1U,99
 boneio/input/gpio.py,sha256=kLsi6KRD_cZGnmsIp758TZ3tj5hegNYQPyEXYlkmc-s,4318
 boneio/relay/__init__.py,sha256=L_Peoep10-DdeMrEe-5YnnNCS-mxHtavCqtAesTPWFQ,135
 boneio/relay/basic.py,sha256=QTax7fGU3YrVx1wBH2Z91w3Hv_ALMs8EiJ4Tdkh1xno,2629
 boneio/relay/gpio.py,sha256=miuE2fOozmBnFf2Es4wqa5RivtZlUR8NFDGNAoajUk0,1163
-boneio/relay/mcp.py,sha256=yGnAYpYNqNi85m1cIUPKWg2xe-p56mL3Q08Z_-IAAIg,2693
+boneio/relay/mcp.py,sha256=Rx_JRxmRVOGPvA-fdoQN2KYglryHQPm5F7Jcb7TZQCg,2698
 boneio/schema/actions.yaml,sha256=HWBeyJLBVbJ_prSYj14ovP7f13QKXL3-9GRJgAOpHQ4,921
 boneio/schema/actions_sensor.yaml,sha256=LhXEsYsg6qs7iHqgQE6n-2jj-o-ZZRusDW_9nWIiZAY,129
 boneio/schema/actions_switch.yaml,sha256=qyooX0izkgl4wBEh8xUsYFEKMrvhbIAQYxOGTB5AROY,124
-boneio/schema/schema.yaml,sha256=pJHGIC92SlTLhCUqBUolIQOqsoIcevfgXRJhfPu9lpo,9458
-boneio/sensor/__init__.py,sha256=XJG-ktDfEPMs5RLt9hYT3gQmYhU_wMOR0Ud88-Q0KmM,305
+boneio/schema/schema.yaml,sha256=uSA-o14-l7hcOb9Iu9OFiSGDHwBjlMEvsL4YWmyc5po,11124
+boneio/sensor/__init__.py,sha256=jE2rgBN3eR0mh2nYA3J-H15RSjZB0J7k1eYNjnm47f4,419
 boneio/sensor/adc.py,sha256=mAxzgs0Eul1V6Fmye9V7TsJiPRnc59TQ-s7nb_PV7G8,1245
 boneio/sensor/gpio.py,sha256=9f_hNcCYvrEb7FvA00Xm-L5-fUXdH4SM-jZiOamOz2Q,1230
-boneio/sensor/modbus/__init__.py,sha256=O3Fvo_VtQhmZg7ZxSqahQTLhIA6Lt-rr09rkpwad_eM,8394
+boneio/sensor/modbus/__init__.py,sha256=Pk1xrgRl126-9WkIXMair6H9HZWpD9_WoKfgFKVrA8M,8430
 boneio/sensor/modbus/sdm120.json,sha256=4sueFfSw7G6a77gdIUhbfJvE-MNVJFOeVbRvHDw5Rvk,4145
 boneio/sensor/modbus/sdm630.json,sha256=6LbIfXWk_PVRW-OuJwrsFEnRGLVEmEqqGIbj-1FDaiI,10969
 boneio/sensor/modbus/sofar.json,sha256=A_YztQN_ctyItIm2LH1tfcs-pSyG18I530qleLd2tOw,5592
-boneio/sensor/temp/__init__.py,sha256=lhvQqD76atQNyoxdeyskH8_fVOLCaHFoVnpzby6kqeE,1416
-boneio-0.3.0.dev4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-boneio-0.3.0.dev4.dist-info/METADATA,sha256=OZIapR0ZqXnK00bit9n4JHlfL3D7lEXNuavp5XYPiOU,1887
-boneio-0.3.0.dev4.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-boneio-0.3.0.dev4.dist-info/entry_points.txt,sha256=JX7gluDIkQ6MBlzzxGHMItnBjciiJ73tsXwYcazMW_U,47
-boneio-0.3.0.dev4.dist-info/top_level.txt,sha256=ag9S5n1_KXZfyk9tN8R0YUDYbdA--e5a2w2FOD_yMdg,7
-boneio-0.3.0.dev4.dist-info/RECORD,,
+boneio/sensor/temp/__init__.py,sha256=AgjEbpkyY1D2Wo7tOGSFKr_uD2LexwLiezkaYP36yEY,2182
+boneio/sensor/temp/dallas.py,sha256=K-dOme8s1AGEvsbHeb3Tt3pkHrFwhX7_CAXiq8Se2uY,1168
+boneio/sensor/temp/lm75.py,sha256=aTvNlG6z7Kk2QnKtjTxq6NLV46-BH7AVHFt7g9XExbY,241
+boneio/sensor/temp/mcp9808.py,sha256=1DKfZyzFHA425xNSPS5is8nWWsClT-D0AbrQx9zgAJg,269
+boneio-0.3.0.dev6.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+boneio-0.3.0.dev6.dist-info/METADATA,sha256=NUHm0qYpXDomocRBX9T2RPNAjqvi_HT9dmF5TPVcw-Y,1944
+boneio-0.3.0.dev6.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+boneio-0.3.0.dev6.dist-info/entry_points.txt,sha256=JX7gluDIkQ6MBlzzxGHMItnBjciiJ73tsXwYcazMW_U,47
+boneio-0.3.0.dev6.dist-info/top_level.txt,sha256=ag9S5n1_KXZfyk9tN8R0YUDYbdA--e5a2w2FOD_yMdg,7
+boneio-0.3.0.dev6.dist-info/RECORD,,