boneIO 0.1.0__py3-none-any.whl

boneio/helper/yaml.py

@@ -0,0 +1,46 @@
+from typing import Any
+import os
+from cerberus import Validator
+from boneio.const import ID, OUTPUT
+from yaml import load, YAMLError, SafeLoader
+
+
+class Loader(SafeLoader):
+    """Loader which support for include in yaml files."""
+
+    def __init__(self, stream):
+
+        self._root = os.path.split(stream.name)[0]
+
+        super(Loader, self).__init__(stream)
+
+    def include(self, node):
+
+        filename = os.path.join(self._root, self.construct_scalar(node))
+
+        with open(filename, "r") as f:
+            return load(f, Loader)
+
+
+Loader.add_constructor("!include", Loader.include)
+
+
+def load_yaml_file(filename: str) -> Any:
+    with open(filename, "r") as stream:
+        try:
+            return load(stream, Loader=Loader)
+        except YAMLError as exception:
+            raise exception
+
+
+class CustomValidator(Validator):
+    """Custom validator of cerberus"""
+
+    def _check_with_output_id_uniqueness(self, field, value):
+        """Check if outputs ids are unique."""
+        all_ids = [x[ID] for x in self.document[OUTPUT]]
+        if len(all_ids) != len(set(all_ids)):
+            self._error(field, "Output IDs are not unique.")
+
+    def _normalize_coerce_to_bool(self, value):
+        return True

boneio/input/__init__.py

@@ -0,0 +1,5 @@
+"""Input classes."""
+
+from boneio.input.gpio import GpioInputButton
+
+__all__ = ["GpioInputButton"]

boneio/input/gpio.py

@@ -0,0 +1,122 @@
+"""GPIOInputButton to receive signals."""
+import logging
+from datetime import datetime
+from functools import partial
+
+from boneio.const import (
+    DEBOUNCE_DURATION,
+    DELAY_DURATION,
+    DOUBLE,
+    LONG,
+    LONG_PRESS_DURATION,
+    SECOND_DELAY_DURATION,
+    SINGLE,
+)
+from boneio.helper import edge_detect, GpioBaseClass
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class GpioInputButton(GpioBaseClass):
+    """Represent Gpio input switch."""
+
+    def __init__(self, **kwargs) -> None:
+        """Setup GPIO Input Button"""
+        super().__init__(**kwargs)
+        edge_detect(self._pin, callback=self._handle_press, bounce=25)
+        self._first_press_timestamp = None
+        self._is_long_press = False
+        self._second_press_timestamp = None
+        self._second_check = False
+        _LOGGER.debug("Configured listening for input pin %s", self._pin)
+
+    def _handle_press(self, pin: str) -> None:
+        """Handle the button press callback"""
+        # Ignore if we are in a long press
+        if self._is_long_press:
+            return
+        now = datetime.now()
+
+        # Debounce button
+        if (
+            self._first_press_timestamp is not None
+            and now - self._first_press_timestamp < DEBOUNCE_DURATION
+        ):
+            return
+
+        # Second click debounce. Just in case.
+        if (
+            self._second_press_timestamp is not None
+            and now - self._second_press_timestamp < DEBOUNCE_DURATION
+        ):
+            return
+
+        if not self._first_press_timestamp:
+            self._first_press_timestamp = now
+        elif not self._second_press_timestamp:
+            self._second_press_timestamp = now
+
+        self._loop.call_soon_threadsafe(
+            self._loop.call_later,
+            DELAY_DURATION,
+            self.check_press_length,
+        )
+
+    def check_press_length(self) -> None:
+        """Check if it's a single, double or long press"""
+        # Check if button is still pressed
+        if self.is_pressed:
+            # Schedule a new check
+            self._loop.call_soon_threadsafe(
+                self._loop.call_later,
+                DELAY_DURATION,
+                self.check_press_length,
+            )
+
+            # Handle edge case due to multiple clicks
+            if self._first_press_timestamp is None:
+                return
+
+            # Check if we reached a long press
+            diff = datetime.now() - self._first_press_timestamp
+            if not self._is_long_press and diff > LONG_PRESS_DURATION:
+                self._is_long_press = True
+                _LOGGER.debug("Long button press on pin %s, call callback", self._pin)
+                self._loop.call_soon_threadsafe(
+                    partial(self._press_callback, LONG, self._pin)
+                )
+            return
+
+        # Handle short press
+        if not self._is_long_press:
+            if not self._second_press_timestamp and not self._second_check:
+                # let's try to check if second click will atempt
+                self._second_check = True
+                self._loop.call_soon_threadsafe(
+                    self._loop.call_later,
+                    SECOND_DELAY_DURATION,
+                    self.check_press_length,
+                )
+                return
+            if self._second_check:
+                if self._second_press_timestamp:
+                    _LOGGER.debug(
+                        "Double click event on pin %s, roznica %s",
+                        self._pin,
+                        self._second_press_timestamp - self._first_press_timestamp,
+                    )
+                    self._loop.call_soon_threadsafe(
+                        partial(self._press_callback, DOUBLE, self._pin)
+                    )
+
+                elif self._first_press_timestamp:
+                    _LOGGER.debug("One click event on pin %s, call callback", self._pin)
+                    self._loop.call_soon_threadsafe(
+                        partial(self._press_callback, SINGLE, self._pin)
+                    )
+
+        # Clean state on button released
+        self._first_press_timestamp = None
+        self._second_press_timestamp = None
+        self._second_check = False
+        self._is_long_press = False

boneio/manager.py

@@ -0,0 +1,398 @@
+import asyncio
+from boneio.modbus import Modbus
+import logging
+import time
+from typing import Any, Callable, List, Optional, Set, Union
+
+from adafruit_mcp230xx.mcp23017 import MCP23017
+from board import SCL, SDA
+from busio import I2C
+
+from boneio.const import (
+    ACTION,
+    ACTIONS,
+    ADDRESS,
+    GPIO,
+    HA_TYPE,
+    HOMEASSISTANT,
+    ID,
+    INIT_SLEEP,
+    INPUT,
+    KIND,
+    LM75,
+    MCP,
+    MCP_ID,
+    MCP_TEMP_9808,
+    OFF,
+    ON,
+    ONLINE,
+    OUTPUT,
+    PIN,
+    RELAY,
+    SDM630,
+    STATE,
+    ClickTypes,
+    InputTypes,
+    SENSOR,
+    SHOW_HA,
+    BINARY_SENSOR,
+    INPUT_SENSOR,
+    UART,
+    UPDATE_INTERVAL,
+    UARTS,
+)
+from boneio.helper import (
+    HostData,
+    ha_relay_availabilty_message,
+    ha_input_availabilty_message,
+    ha_adc_sensor_availabilty_message,
+    ha_sensor_temp_availabilty_message,
+    ha_binary_sensor_availabilty_message,
+    host_stats,
+    GPIOInputException,
+    I2CError,
+)
+from boneio.input import GpioInputButton
+
+from boneio.relay import GpioRelay, MCPRelay
+from boneio.sensor import GpioInputSensor
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Manager:
+    """Manager to communicate MQTT with GPIO inputs and outputs."""
+
+    def __init__(
+        self,
+        send_message: Callable[[str, Union[str, dict]], None],
+        topic_prefix: str,
+        relay_pins: List,
+        input_pins: List,
+        sensors: dict = {},
+        modbus: dict = None,
+        ha_discovery: bool = True,
+        ha_discovery_prefix: str = HOMEASSISTANT,
+        mcp23017: Optional[List] = None,
+        oled: bool = False,
+        adc_list: Optional[List] = None,
+    ) -> None:
+        """Initialize the manager."""
+        _LOGGER.info("Initializing manager module.")
+        self._loop = asyncio.get_event_loop()
+        self._host_data = None
+        self._ha_discovery = ha_discovery
+
+        self.send_message = send_message
+        self._topic_prefix = topic_prefix
+        self.relay_topic = f"{topic_prefix}/{RELAY}/+/set"
+        self._input_pins = input_pins
+        self._i2cbusio = I2C(SCL, SDA)
+        self._mcp = {}
+        self._grouped_outputs = {}
+        self._oled = None
+        self._tasks: List[asyncio.Task] = []
+        self._temp_sensors = []
+        self._modbus = None
+        if modbus and modbus.get(UART) in UARTS:
+            self._modbus = Modbus(UARTS[modbus.get(UART)])
+
+        def create_temp_sensor(sensor_type: str, temp_def: dict = {}):
+            """Create LM sensor in manager."""
+            if sensor_type == LM75:
+                from .sensor import LM75Sensor as TempSensor
+            elif sensor_type == MCP_TEMP_9808:
+                from .sensor import MCP9808Sensor as TempSensor
+            else:
+                return
+            name = temp_def.get(ID)
+            id = name.replace(" ", "")
+            try:
+                temp_sensor = TempSensor(
+                    id=id,
+                    name=name,
+                    i2c=self._i2cbusio,
+                    address=temp_def[ADDRESS],
+                    send_message=self.send_message,
+                    topic_prefix=topic_prefix,
+                )
+                self.send_ha_autodiscovery(
+                    id=id,
+                    name=name,
+                    ha_type=SENSOR,
+                    ha_discovery_prefix=ha_discovery_prefix,
+                    availabilty_msg_func=ha_sensor_temp_availabilty_message,
+                )
+                self._tasks.append(asyncio.create_task(temp_sensor.send_state()))
+                self._temp_sensors.append(temp_sensor)
+            except I2CError as err:
+                _LOGGER.error("Can't configure Temp sensor. %s", err)
+                pass
+
+        def create_mcp23017():
+            """Create MCP23017."""
+            for mcp in mcp23017:
+                id = mcp[ID] or mcp[ADDRESS]
+                try:
+                    self._mcp[id] = MCP23017(i2c=self._i2cbusio, address=mcp[ADDRESS])
+                    sleep_time = mcp.get(INIT_SLEEP, 0)
+                    _LOGGER.debug(
+                        f"Sleeping for {sleep_time}s while MCP {id} is initializing."
+                    )
+                    time.sleep(sleep_time)
+                    self._grouped_outputs[id] = {}
+                except TimeoutError as err:
+                    _LOGGER.error("Can't connect to MCP %s. %s", id, err)
+                    pass
+
+        def create_adc():
+            """Create ADC sensor."""
+            from boneio.sensor import initialize_adc, GpioADCSensor
+
+            initialize_adc()
+
+            # TODO: find what exception can ADC gpio throw.
+            for gpio in adc_list:
+                name = gpio.get(ID)
+                id = name.replace(" ", "")
+                pin = gpio[PIN]
+                try:
+                    adc = GpioADCSensor(
+                        id=id,
+                        pin=pin,
+                        name=name,
+                        send_message=self.send_message,
+                        topic_prefix=topic_prefix,
+                        update_interval=gpio.get(UPDATE_INTERVAL, 60),
+                    )
+                    self.send_ha_autodiscovery(
+                        id=id,
+                        name=name,
+                        ha_type=SENSOR,
+                        ha_discovery_prefix=ha_discovery_prefix,
+                        availabilty_msg_func=ha_adc_sensor_availabilty_message,
+                    )
+                    self._tasks.append(asyncio.create_task(adc.send_state()))
+                except I2CError as err:
+                    _LOGGER.error("Can't configure ADC sensor %s. %s", id, err)
+                    pass
+
+            return True
+
+        def create_sdm_630(sensors):
+            """Create SDM sensor for each device."""
+            from boneio.sensor.sdm630 import Sdm630
+
+            for sensor in sensors:
+                name = sensor.get(ID)
+                id = name.replace(" ", "")
+                try:
+                    sdm = Sdm630(
+                        modbus=self._modbus,
+                        address=sensor[ADDRESS],
+                        id=id,
+                        name=name,
+                        send_message=self.send_message,
+                        topic_prefix=topic_prefix,
+                        ha_discovery=ha_discovery,
+                        ha_discovery_prefix=ha_discovery_prefix,
+                        update_interval=sensor.get(UPDATE_INTERVAL, 30),
+                    )
+
+                    self._tasks.append(asyncio.create_task(sdm.send_state()))
+                except I2CError as err:
+                    _LOGGER.error("Can't configure SDM630 sensor %s. %s", id, err)
+                    pass
+
+            return True
+
+        if sensors.get(LM75):
+            create_temp_sensor(sensor_type=LM75, temp_def=sensors.get(LM75))
+
+        if sensors.get(MCP_TEMP_9808):
+            create_temp_sensor(
+                sensor_type=MCP_TEMP_9808, temp_def=sensors.get(MCP_TEMP_9808)
+            )
+
+        if sensors.get(SDM630) and self._modbus:
+            create_sdm_630(sensors=sensors.get(SDM630))
+
+        if mcp23017:
+            create_mcp23017()
+
+        if adc_list:
+            create_adc()
+
+        def configure_relay(gpio: dict) -> Any:
+            """Configure kind of relay. Most common MCP."""
+            relay_id = gpio[ID].replace(" ", "")
+            if gpio[KIND] == MCP:
+                mcp_id = gpio.get(MCP_ID, "")
+                mcp = self._mcp.get(mcp_id)
+                if not mcp:
+                    _LOGGER.error("No such MCP configured!")
+                    return
+                mcp_relay = MCPRelay(
+                    pin=int(gpio[PIN]),
+                    id=gpio[ID],
+                    send_message=self.send_message,
+                    topic_prefix=topic_prefix,
+                    mcp=mcp,
+                    mcp_id=mcp_id,
+                    ha_type=gpio[HA_TYPE],
+                    callback=lambda: self._host_data_callback(mcp_id),
+                )
+                self._grouped_outputs[mcp_id][relay_id] = mcp_relay
+                return mcp_relay
+            elif gpio[KIND] == GPIO:
+                if GPIO not in self._grouped_outputs:
+                    self._grouped_outputs[GPIO] = {}
+                gpio_relay = GpioRelay(
+                    pin=gpio[PIN],
+                    id=gpio[ID],
+                    send_message=self.send_message,
+                    topic_prefix=topic_prefix,
+                    callback=lambda: self._host_data_callback(GPIO),
+                )
+                self._grouped_outputs[GPIO][relay_id] = gpio_relay
+                return gpio_relay
+
+        self.output = {
+            gpio[ID].replace(" ", ""): configure_relay(gpio) for gpio in relay_pins
+        }
+        for out in self.output.values():
+            self.send_ha_autodiscovery(
+                id=out.id,
+                name=out.name,
+                ha_type=out.ha_type,
+                ha_discovery_prefix=ha_discovery_prefix,
+                availabilty_msg_func=ha_relay_availabilty_message,
+            )
+            self._loop.call_soon_threadsafe(
+                self._loop.call_later,
+                0.5,
+                out.send_state,
+            )
+
+        def configure_input(gpio):
+            try:
+                pin = gpio[PIN]
+                input_type = gpio.get(KIND)
+                if input_type == SENSOR:
+                    GpioInputSensor(
+                        pin=pin,
+                        press_callback=lambda x, i: self.press_callback(
+                            x=x,
+                            inpin=i,
+                            actions=gpio.get(ACTIONS, {}),
+                            input_type=INPUT_SENSOR,
+                        ),
+                        rest_pin=gpio,
+                    )
+                    availabilty_msg_func = ha_binary_sensor_availabilty_message
+                    ha_type = BINARY_SENSOR
+                else:
+                    GpioInputButton(
+                        pin=pin,
+                        press_callback=lambda x, i: self.press_callback(
+                            x=x,
+                            inpin=i,
+                            actions=gpio.get(ACTIONS, {}),
+                            input_type=INPUT,
+                        ),
+                        rest_pin=gpio,
+                    )
+                    availabilty_msg_func = ha_input_availabilty_message
+                    ha_type = SENSOR
+                if gpio.get(SHOW_HA, True):
+                    self.send_ha_autodiscovery(
+                        id=pin,
+                        name=gpio.get(ID, pin),
+                        ha_type=ha_type,
+                        ha_discovery_prefix=ha_discovery_prefix,
+                        availabilty_msg_func=availabilty_msg_func,
+                    )
+            except GPIOInputException as err:
+                _LOGGER.error("This PIN %s can't be configured. %s", pin, err)
+                pass
+
+        _LOGGER.info("Initializing inputs. This will take a while.")
+        for gpio in self._input_pins:
+            configure_input(gpio=gpio)
+
+        if oled:
+            from boneio.oled import Oled
+
+            self._host_data = HostData(
+                output=self._grouped_outputs,
+                temp_sensor=self._temp_sensors[0] if self._temp_sensors else None,
+                callback=self._host_data_callback,
+            )
+            for f in host_stats.values():
+                self._tasks.append(asyncio.create_task(f(self._host_data)))
+            _LOGGER.debug("Gathering host data enabled.")
+            try:
+                self._oled = Oled(
+                    host_data=self._host_data, output_groups=list(self._grouped_outputs)
+                )
+            except (GPIOInputException, I2CError) as err:
+                _LOGGER.error("Can't configure OLED display. %s", err)
+
+        self.send_message(topic=f"{topic_prefix}/{STATE}", payload=ONLINE)
+        _LOGGER.info("BoneIO manager is ready.")
+
+    def _host_data_callback(self, type: str):
+        if self._oled:
+            self._oled.handle_data_update(type)
+
+    def get_tasks(self) -> Set[asyncio.Task]:
+        return self._tasks
+
+    def press_callback(
+        self, x: ClickTypes, inpin: str, actions: dict, input_type: InputTypes = INPUT
+    ) -> None:
+        """Press callback to use in input gpio.
+        If relay input map is provided also toggle action on relay."""
+        topic = f"{self._topic_prefix}/{input_type}/{inpin}"
+        self.send_message(topic=topic, payload=x)
+        action = actions.get(x)
+        if action:
+            if action[ACTION] == OUTPUT:
+                """For now only output type is supported"""
+                relay = self.output.get(action[PIN].replace(" ", ""))
+                if relay:
+                    relay.toggle()
+        # This is similar how Z2M is clearing click sensor.
+        self._loop.call_soon_threadsafe(self.send_message, topic, "")
+
+    def send_ha_autodiscovery(
+        self,
+        id: str,
+        name: str,
+        ha_discovery_prefix: str,
+        availabilty_msg_func: Callable,
+        ha_type: str = "switch",
+        topic_prefix: str = None,
+        **kwargs,
+    ) -> None:
+        """Send HA autodiscovery information for each relay."""
+        if not self._ha_discovery:
+            return
+        if not topic_prefix:
+            topic_prefix = self._topic_prefix
+        msg = availabilty_msg_func(topic=topic_prefix, id=id, name=name, **kwargs)
+        topic = f"{ha_discovery_prefix}/{ha_type}/{topic_prefix}/{id}/config"
+        _LOGGER.debug("Sending HA discovery for %s, %s.", ha_type, name)
+        self.send_message(topic=topic, payload=msg)
+
+    def receive_message(self, topic: str, message: str) -> None:
+        """Callback for receiving action from Mqtt."""
+        extracted_relay = topic.replace(f"{self._topic_prefix}/{RELAY}/", "").replace(
+            "/set", ""
+        )
+        target_device = self.output.get(extracted_relay)
+        if target_device:
+            if message == ON:
+                target_device.turn_on()
+            elif message == OFF:
+                target_device.turn_off()

boneio/modbus.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from boneio.helper import configure_pin
+from boneio.const import ID, RX, TX, UART, REGISTERS
+from pymodbus.client.sync import (
+    BaseModbusClient,
+    ModbusSerialClient,
+)
+from pymodbus.register_read_message import ReadInputRegistersResponse
+from pymodbus.payload import BinaryPayloadDecoder
+from pymodbus.constants import Endian
+from typing import Any
+from pymodbus.exceptions import ModbusException
+from pymodbus.pdu import ModbusResponse
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Modbus:
+    """Represent modbus connection over chosen UART."""
+
+    def __init__(self, uart: dict[str, Any]) -> None:
+        """Initialize the Modbus hub."""
+
+        configure_pin(pin=uart[RX], mode=UART)
+        configure_pin(pin=uart[TX], mode=UART)
+        self._uart = uart
+
+        # generic configuration
+        self._client: BaseModbusClient | None = None
+        self._lock = asyncio.Lock()
+        try:
+            self._client = ModbusSerialClient(
+                port=self._uart[ID],
+                method="rtu",
+                baudrate=9600,
+                stopbits=1,
+                bytesize=8,
+                parity="N",
+            )
+        except ModbusException as exception_error:
+            _LOGGER.error(exception_error)
+
+    async def async_close(self) -> None:
+        """Disconnect client."""
+        async with self._lock:
+            if self._client:
+                try:
+                    self._client.close()
+                except ModbusException as exception_error:
+                    _LOGGER.error(exception_error)
+                del self._client
+                self._client = None
+                _LOGGER.warning("modbus communication closed")
+
+    def _pymodbus_connect(self) -> bool:
+        """Connect client."""
+        try:
+            self._client.connect()  # type: ignore[union-attr]
+        except ModbusException as exception_error:
+            _LOGGER.error(exception_error)
+            return False
+        else:
+            _LOGGER.info("modbus communication open")
+            return True
+
+    def read_single_register(self, unit: int, address: int, count: int = 2) -> float:
+        """Call sync. pymodbus."""
+        if not self._pymodbus_connect:
+            _LOGGER.error("Can't connect to Modbus.")
+            return None
+        kwargs = {"unit": unit, "count": count} if unit else {}
+        try:
+            result: ReadInputRegistersResponse = self._client.read_input_registers(
+                address, **kwargs
+            )
+        except ModbusException as exception_error:
+            _LOGGER.error(exception_error)
+            return None
+        if not hasattr(result, REGISTERS):
+            _LOGGER.error(str(result))
+            return None
+        return BinaryPayloadDecoder.fromRegisters(
+            result.registers, byteorder=Endian.Big, wordorder=Endian.Big
+        ).decode_32bit_float()
+
+    def read_multiple_registers(
+        self, unit: int, address: int, count: int = 2
+    ) -> ModbusResponse:
+        """Call sync. pymodbus."""
+        if not self._pymodbus_connect:
+            _LOGGER.error("Can't connect to Modbus.")
+            return None
+        kwargs = {"unit": unit, "count": count} if unit else {}
+        try:
+            result: ReadInputRegistersResponse = self._client.read_input_registers(
+                address, **kwargs
+            )
+        except ModbusException as exception_error:
+            _LOGGER.error(exception_error)
+            return None
+        if not hasattr(result, REGISTERS):
+            _LOGGER.error(str(result))
+            return None
+        return result