boneIO 0.1.0.dev26__tar.gz → 0.1.2__tar.gz

{boneio-0.1.0.dev26/boneio.egg-info → boneio-0.1.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev26
-Summary: Python Helper for BoneIO
-Home-page: https://github.com/maciejk1984/boneIO
+Version: 0.1.2
+Summary: Python App for BoneIO
+Home-page: https://github.com/boneIO-eu/app_bbb
 License: GNU General Public License v3.0
-Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev26.zip
+Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.1.2.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7
@@ -16,16 +16,24 @@ License-File: LICENSE
 Example usage:
 boneio run -dd -c config.yaml
 
-
-
 # Installation instructions
 
 ```
 sudo apt-get install libopenjp2-7-dev libatlas-base-dev python3-venv
-python3 -m venv venv
-wget https://raw.githubusercontent.com/pszafer/boneIO-1/main/Code/BoneIO/example_config/config.yaml
-wget https://raw.githubusercontent.com/pszafer/boneIO-1/main/Code/BoneIO/example_config/output.yaml
+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.1.2/README.md

@@ -0,0 +1,22 @@
+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.1.0.dev26 → boneio-0.1.2}/boneio/bonecli.py

@@ -7,21 +7,24 @@ import click
 from colorlog import ColoredFormatter
 
 from boneio.const import (
+    ADC,
     ENABLED,
-    INPUT,
     HA_DISCOVERY,
     HOST,
+    INPUT,
+    LM75,
     MCP23017,
     MCP_TEMP_9808,
+    MODBUS,
     MQTT,
     OLED,
     OUTPUT,
     PAHO,
     PASSWORD,
+    PYMODBUS,
+    SDM630,
     TOPIC_PREFIX,
     USERNAME,
-    LM75,
-    ADC,
 )
 from boneio.helper import CustomValidator, load_yaml_file
 from boneio.manager import Manager
@@ -117,6 +120,8 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
         _LOGGER.debug(f"Lib version is {__version__}")
     if debug > 1:
         logging.getLogger(PAHO).setLevel(logging.DEBUG)
+        logging.getLogger(PYMODBUS).setLevel(logging.DEBUG)
+        logging.getLogger("pymodbus.client").setLevel(logging.DEBUG)
     else:
         logging.getLogger(PAHO).setLevel(logging.WARN)
     schema = load_yaml_file(os.path.join(MAINPATH, "schema.yaml"))
@@ -140,9 +145,13 @@ async def run(ctx, debug: int, config: str, mqttpassword: str = ""):
         input_pins=_config.get(INPUT, []),
         ha_discovery=_config[MQTT][HA_DISCOVERY][ENABLED],
         ha_discovery_prefix=_config[MQTT][HA_DISCOVERY][TOPIC_PREFIX],
+        sensors={
+            LM75: _config.get(LM75),
+            MCP_TEMP_9808: _config.get(MCP_TEMP_9808),
+            SDM630: _config.get(SDM630),
+        },
         mcp23017=_config.get(MCP23017, []),
-        lm75=_config.get(LM75),
-        mcp9808=_config.get(MCP_TEMP_9808),
+        modbus=_config.get(MODBUS),
         oled=_config.get(OLED),
         adc_list=_config.get(ADC, []),
     )

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/const.py

@@ -25,7 +25,16 @@ ADC = "adc"
 IP = "ip"
 MASK = "mask"
 MAC = "mac"
-NONE="none"
+NONE = "none"
+MODBUS = "modbus"
+UART = "uart"
+RX = "rx"
+TX = "tx"
+
+UARTS = {
+    "uart1": {ID: "/dev/ttyS1", TX: "P9.24", RX: "P9.26"},
+    "uart4": {ID: "/dev/ttyS4", TX: "P9.13", RX: "P9.11"},
+}
 
 # TIMINGS FOR BUTTONS
 DEBOUNCE_DURATION = timedelta(seconds=0.2)
@@ -65,11 +74,13 @@ RELEASED = "released"
 
 # MQTT CONST
 PAHO = "paho.mqtt.client"
+PYMODBUS = "pymodbus"
 MQTT = "mqtt"
 HOST = "host"
 USERNAME = "username"
 PASSWORD = "password"
 ONLINE = "online"
+OFFLINE = "offline"
 TOPIC_PREFIX = "topic_prefix"
 
 # I2C and MCP CONST
@@ -86,6 +97,11 @@ BINARY_SENSOR = "binary_sensor"
 LM75 = "lm75"
 MCP_TEMP_9808 = "mcp9808"
 INPUT_SENSOR = "inputsensor"
+SDM630 = "sdm630"
+
+BASE = "base"
+LENGTH = "length"
+REGISTERS = "registers"
 
 # TYPING
 ClickTypes = Literal[SINGLE, DOUBLE, LONG, PRESSED, RELEASED]

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/helper/__init__.py

@@ -13,12 +13,12 @@ from boneio.helper.mqtt import BasicMqtt
 from boneio.helper.stats import HostData, host_stats
 from boneio.helper.yaml import CustomValidator, load_yaml_file
 from boneio.helper.ha_discovery import (
-    ha_relay_availibilty_message,
-    ha_sensor_temp_availibilty_message,
-    ha_binary_sensor_availibilty_message,
-    ha_input_availibilty_message,
-    ha_sensor_availibilty_message,
-    ha_adc_sensor_availibilty_message,
+    ha_relay_availabilty_message,
+    ha_sensor_temp_availabilty_message,
+    ha_binary_sensor_availabilty_message,
+    ha_input_availabilty_message,
+    ha_sensor_availabilty_message,
+    ha_adc_sensor_availabilty_message,
 )
 from boneio.helper.exceptions import GPIOInputException, I2CError
 from boneio.helper.queue import UniqueQueue
@@ -35,12 +35,12 @@ __all__ = [
     "read_input",
     "write_output",
     "make_font",
-    "ha_relay_availibilty_message",
-    "ha_sensor_availibilty_message",
-    "ha_adc_sensor_availibilty_message",
-    "ha_sensor_temp_availibilty_message",
-    "ha_binary_sensor_availibilty_message",
-    "ha_input_availibilty_message",
+    "ha_relay_availabilty_message",
+    "ha_sensor_availabilty_message",
+    "ha_adc_sensor_availabilty_message",
+    "ha_sensor_temp_availabilty_message",
+    "ha_binary_sensor_availabilty_message",
+    "ha_input_availabilty_message",
     "GPIOInputException",
     "I2CError",
     "GpioBaseClass",

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/helper/gpio.py

@@ -16,11 +16,11 @@ from boneio.const import (
 _LOGGER = logging.getLogger(__name__)
 
 
-def configure_pin(pin: str) -> None:
+def configure_pin(pin: str, mode: str = GPIO_STR) -> None:
     pin = f"{pin[0:3]}0{pin[3]}" if len(pin) == 4 else pin
-    _LOGGER.debug(f"Configuring pin for GPIO {pin}")
+    _LOGGER.debug(f"Configuring pin {pin} for mode {mode}.")
     subprocess.run(
-        [CONFIG_PIN, pin, GPIO_STR],
+        [CONFIG_PIN, pin, mode],
         stdout=subprocess.DEVNULL,
         stderr=subprocess.STDOUT,
         timeout=1,

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/helper/ha_discovery.py

@@ -4,7 +4,7 @@ from boneio.version import __version__
 from boneio.const import INPUT, OFF, ON, RELAY, STATE, SENSOR, INPUT_SENSOR
 
 
-def ha_relay_availibilty_message(id: str, name: str, topic: str = "boneio"):
+def ha_relay_availabilty_message(id: str, name: str, topic: str = "boneio"):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
@@ -25,7 +25,7 @@ def ha_relay_availibilty_message(id: str, name: str, topic: str = "boneio"):
     }
 
 
-def ha_availibilty_message(
+def ha_availabilty_message(
     id: str, name: str, topic: str = "boneio", sensor_type: str = INPUT
 ):
     """Create availability topic for HA."""
@@ -45,25 +45,25 @@ def ha_availibilty_message(
     }
 
 
-def ha_input_availibilty_message(**kwargs):
-    return ha_availibilty_message(sensor_type=INPUT, **kwargs)
+def ha_input_availabilty_message(**kwargs):
+    return ha_availabilty_message(sensor_type=INPUT, **kwargs)
 
 
-def ha_adc_sensor_availibilty_message(**kwargs):
-    msg = ha_availibilty_message(sensor_type=SENSOR, **kwargs)
+def ha_adc_sensor_availabilty_message(**kwargs):
+    msg = ha_availabilty_message(sensor_type=SENSOR, **kwargs)
     msg["unit_of_measurement"] = "V"
     msg["device_class"] = "voltage"
     msg["state_class"] = "measurement"
     return msg
 
 
-def ha_sensor_availibilty_message(unit_of_measurement: str = None, **kwargs):
-    msg = ha_availibilty_message(sensor_type=SENSOR, **kwargs)
+def ha_sensor_availabilty_message(unit_of_measurement: str = None, **kwargs):
+    msg = ha_availabilty_message(sensor_type=SENSOR, **kwargs)
     if not unit_of_measurement:
         return msg
 
 
-def ha_binary_sensor_availibilty_message(id: str, name: str, topic: str = "boneio"):
+def ha_binary_sensor_availabilty_message(id: str, name: str, topic: str = "boneio"):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
@@ -82,7 +82,7 @@ def ha_binary_sensor_availibilty_message(id: str, name: str, topic: str = "bonei
     }
 
 
-def ha_sensor_temp_availibilty_message(id: str, name: str, topic: str = "boneio"):
+def ha_sensor_temp_availabilty_message(id: str, name: str, topic: str = "boneio"):
     """Create availability topic for HA."""
     return {
         "availability": [{"topic": f"{topic}/{STATE}"}],
@@ -101,3 +101,28 @@ def ha_sensor_temp_availibilty_message(id: str, name: str, topic: str = "boneio"
         "unit_of_measurement": "°C",
         "value_template": "{{ value_json.state }}",
     }
+
+
+def sdm630_availabilty_message(
+    id: str,
+    sensor_id: str,
+    name: str,
+    topic: str = "sdm630",
+    sensor_type: str = SENSOR,
+    **kwargs,
+):
+    """Create SDM630 availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{id}{STATE}"}],
+        "device": {
+            "identifiers": [topic, id],
+            "manufacturer": "BoneIO",
+            "model": "SDM630",
+            "name": f"BoneIO {name.upper()}",
+            "sw_version": __version__,
+        },
+        "name": sensor_id,
+        "state_topic": f"{topic}/{sensor_type}/{id}/{sensor_id}",
+        "unique_id": f"{topic}{sensor_id.replace('_', '').lower()}",
+        **kwargs,
+    }

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/helper/stats.py

@@ -145,7 +145,12 @@ class HostData:
 
     data = {UPTIME: {}, NETWORK: {}, CPU: {}, DISK: {}, MEMORY: {}, SWAP: {}}
 
-    def __init__(self, output: dict, callback: Callable, temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None]) -> None:
+    def __init__(
+        self,
+        output: dict,
+        callback: Callable,
+        temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None],
+    ) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
         self.data[UPTIME] = {HOST: self._hostname, UPTIME: 0}

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/manager.py

@@ -1,4 +1,5 @@
 import asyncio
+from boneio.modbus import Modbus
 import logging
 import time
 from typing import Any, Callable, List, Optional, Set, Union
@@ -28,6 +29,7 @@ from boneio.const import (
     OUTPUT,
     PIN,
     RELAY,
+    SDM630,
     STATE,
     ClickTypes,
     InputTypes,
@@ -35,15 +37,17 @@ from boneio.const import (
     SHOW_HA,
     BINARY_SENSOR,
     INPUT_SENSOR,
+    UART,
     UPDATE_INTERVAL,
+    UARTS,
 )
 from boneio.helper import (
     HostData,
-    ha_relay_availibilty_message,
-    ha_input_availibilty_message,
-    ha_adc_sensor_availibilty_message,
-    ha_sensor_temp_availibilty_message,
-    ha_binary_sensor_availibilty_message,
+    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,
@@ -65,8 +69,8 @@ class Manager:
         topic_prefix: str,
         relay_pins: List,
         input_pins: List,
-        lm75: dict = None,
-        mcp9808: dict = None,
+        sensors: dict = {},
+        modbus: dict = None,
         ha_discovery: bool = True,
         ha_discovery_prefix: str = HOMEASSISTANT,
         mcp23017: Optional[List] = None,
@@ -77,6 +81,7 @@ class 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
@@ -88,6 +93,9 @@ class Manager:
         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."""
@@ -111,9 +119,9 @@ class Manager:
                 self.send_ha_autodiscovery(
                     id=id,
                     name=name,
-                    ha_type="sensor",
-                    prefix=ha_discovery_prefix,
-                    availibilty_msg_func=ha_sensor_temp_availibilty_message,
+                    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)
@@ -138,11 +146,12 @@ class Manager:
                     pass
 
         def create_adc():
+            """Create ADC sensor."""
             from boneio.sensor import initialize_adc, GpioADCSensor
 
             initialize_adc()
 
-            ## TODO: find what exception can ADC gpio throw.
+            # TODO: find what exception can ADC gpio throw.
             for gpio in adc_list:
                 name = gpio.get(ID)
                 id = name.replace(" ", "")
@@ -160,8 +169,8 @@ class Manager:
                         id=id,
                         name=name,
                         ha_type=SENSOR,
-                        prefix=ha_discovery_prefix,
-                        availibilty_msg_func=ha_adc_sensor_availibilty_message,
+                        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:
@@ -170,11 +179,43 @@ class Manager:
 
             return True
 
-        if lm75:
-            create_temp_sensor(sensor_type=LM75, temp_def=lm75)
+        def create_sdm_630(sensors):
+            """Create SDM sensor for each device."""
+            from boneio.sensor.sdm630 import Sdm630
 
-        if mcp9808:
-            create_temp_sensor(sensor_type=MCP_TEMP_9808, temp_def=mcp9808)
+            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()
@@ -204,7 +245,7 @@ class Manager:
                 self._grouped_outputs[mcp_id][relay_id] = mcp_relay
                 return mcp_relay
             elif gpio[KIND] == GPIO:
-                if not GPIO in self._grouped_outputs:
+                if GPIO not in self._grouped_outputs:
                     self._grouped_outputs[GPIO] = {}
                 gpio_relay = GpioRelay(
                     pin=gpio[PIN],
@@ -220,14 +261,13 @@ class Manager:
             gpio[ID].replace(" ", ""): configure_relay(gpio) for gpio in relay_pins
         }
         for out in self.output.values():
-            if ha_discovery:
-                self.send_ha_autodiscovery(
-                    id=out.id,
-                    name=out.name,
-                    ha_type=out.ha_type,
-                    prefix=ha_discovery_prefix,
-                    availibilty_msg_func=ha_relay_availibilty_message,
-                )
+            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,
@@ -249,7 +289,7 @@ class Manager:
                         ),
                         rest_pin=gpio,
                     )
-                    availibilty_msg_func = ha_binary_sensor_availibilty_message
+                    availabilty_msg_func = ha_binary_sensor_availabilty_message
                     ha_type = BINARY_SENSOR
                 else:
                     GpioInputButton(
@@ -262,15 +302,15 @@ class Manager:
                         ),
                         rest_pin=gpio,
                     )
-                    availibilty_msg_func = ha_input_availibilty_message
+                    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,
-                        prefix=ha_discovery_prefix,
-                        availibilty_msg_func=availibilty_msg_func,
+                        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)
@@ -301,7 +341,7 @@ class Manager:
         self.send_message(topic=f"{topic_prefix}/{STATE}", payload=ONLINE)
         _LOGGER.info("BoneIO manager is ready.")
 
-    def _host_data_callback(self, type):
+    def _host_data_callback(self, type: str):
         if self._oled:
             self._oled.handle_data_update(type)
 
@@ -329,13 +369,19 @@ class Manager:
         self,
         id: str,
         name: str,
-        prefix: str,
-        availibilty_msg_func: Callable,
+        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."""
-        msg = availibilty_msg_func(topic=self._topic_prefix, id=id, name=name)
-        topic = f"{prefix}/{ha_type}/{self._topic_prefix}/{id}/config"
+        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)
 

boneio-0.1.2/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

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/mqtt_client.py

@@ -49,20 +49,6 @@ class MQTTClient:
             **self.client_options,
         )
 
-    async def connect(self, *, timeout: float = 10.0) -> None:
-        """Connect to the broker.
-
-        Can raise asyncio_mqtt.MqttError.
-        """
-        await self.asyncio_client.connect(timeout=timeout)
-
-    async def disconnect(self, *, timeout: float = 10.0) -> None:
-        """Disconnect from the broker.
-
-        Can raise asyncio_mqtt.MqttError.
-        """
-        await self.asyncio_client.disconnect(timeout=timeout)
-
     async def publish(  # pylint:disable=too-many-arguments
         self,
         topic: str,

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/relay/mcp.py

@@ -1,9 +1,7 @@
 """MCP23017 Relay module."""
 
 import logging
-
 from adafruit_mcp230xx.mcp23017 import MCP23017
-
 from boneio.relay.basic import BasicRelay
 
 _LOGGER = logging.getLogger(__name__)

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/schema.yaml

@@ -52,6 +52,41 @@ oled:
   type: boolean
   coerce: to_bool
 
+modbus:
+  type: dict
+  required: False
+  schema:
+    uart:
+      type: string
+      required: True
+      meta:
+        label: Uart ID to use
+
+sdm630:
+  type: list
+  required: False
+  meta:
+    label: SDM630 sensor
+  schema:
+    type: dict
+    schema:
+      id:
+        type: string
+        required: False
+        meta:
+          label: Id of SDM630
+      address:
+        type: string
+        required: True
+        default: 0x33
+        meta:
+          label: Address of SDM to use.
+      update_interval:
+        type: integer
+        required: True
+        default: 30
+        meta:
+          label: Update interval in seconds.
 lm75:
   type: dict
   required: False

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/sensor/__init__.py

@@ -3,4 +3,10 @@ from boneio.sensor.temp import LM75Sensor, MCP9808Sensor
 from boneio.sensor.gpio import GpioInputSensor
 from boneio.sensor.adc import initialize_adc, GpioADCSensor
 
-__all__ = ["LM75Sensor", "MCP9808Sensor", "GpioInputSensor", "initialize_adc", "GpioADCSensor"]
+__all__ = [
+    "LM75Sensor",
+    "MCP9808Sensor",
+    "GpioInputSensor",
+    "initialize_adc",
+    "GpioADCSensor",
+]

boneio-0.1.2/boneio/sensor/sdm630.py

@@ -0,0 +1,193 @@
+import logging
+import asyncio
+from struct import unpack
+from collections import namedtuple
+
+from boneio.const import SDM630, SENSOR, STATE, ONLINE, OFFLINE, BASE, LENGTH, REGISTERS
+from boneio.helper import BasicMqtt
+from boneio.helper.ha_discovery import sdm630_availabilty_message
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def float32(result, base, addr):
+    """Read Float value from register."""
+    low = result.getRegister(addr - base)
+    high = result.getRegister(addr - base + 1)
+    data = bytearray(4)
+    data[0] = high & 0xFF
+    data[1] = high >> 8
+    data[2] = low & 0xFF
+    data[3] = low >> 8
+
+    val = unpack("f", bytes(data))
+
+    return val[0]
+
+
+RegistryEntry = namedtuple(
+    "RegistryEntry", "sensor_id address unit_of_measurement state_class device_class"
+)
+
+REGISTER_BASE = [
+    {
+        BASE: 0x00,
+        LENGTH: 60,
+        REGISTERS: [
+            RegistryEntry("Voltage_Phase1", 0x0000, "V", "measurement", "voltage"),
+            RegistryEntry("Voltage_Phase2", 0x0002, "V", "measurement", "voltage"),
+            RegistryEntry("Voltage_Phase3", 0x0004, "V", "measurement", "voltage"),
+            RegistryEntry("Current_Phase1", 0x0006, "A", "measurement", "current"),
+            RegistryEntry("Current_Phase2", 0x0008, "A", "measurement", "current"),
+            RegistryEntry("Current_Phase3", 0x000A, "A", "measurement", "current"),
+            RegistryEntry("Power_Phase1", 0x000C, "W", "measurement", "power"),
+            RegistryEntry("Power_Phase2", 0x000E, "W", "measurement", "power"),
+            RegistryEntry("Power_Phase3", 0x0010, "W", "measurement", "power"),
+            RegistryEntry("Power_VA_Phase1", 0x0012, "VA", "measurement", None),
+            RegistryEntry("Power_VA_Phase2", 0x0014, "VA", "measurement", None),
+            RegistryEntry("Power_VA_Phase3", 0x0016, "VA", "measurement", None),
+            RegistryEntry("Power_VAr_Phase1", 0x0018, "var", "measurement", None),
+            RegistryEntry("Power_VAr_Phase2", 0x001A, "var", "measurement", None),
+            RegistryEntry("Power_VAr_Phase3", 0x001C, "var", "measurement", None),
+            RegistryEntry("Power_Factor_Phase1", 0x001E, "%", "measurement", None),
+            RegistryEntry("Power_Factor_Phase2", 0x0020, "%", "measurement", None),
+            RegistryEntry("Power_Factor_Phase3", 0x0022, "%", "measurement", None),
+            RegistryEntry("Phase_Angle_Phase1", 0x0024, "°", "measurement", None),
+            RegistryEntry("Phase_Angle_Phase2", 0x0026, "°", "measurement", None),
+            RegistryEntry("Phase_Angle_Phase3", 0x0028, "°", "measurement", None),
+            RegistryEntry(
+                "Line_to_Neutral_AVG_Volts", 0x002A, "V", "measurement", None
+            ),
+            RegistryEntry("AVG_Current", 0x002E, "A", "measurement", "current"),
+            RegistryEntry("Sum_Current", 0x0030, "A", "measurement", "current"),
+            RegistryEntry("Total_Power_Watt", 0x0034, "W", "measurement", "power"),
+            RegistryEntry("Total_Power_VA", 0x0038, "VA", "measurement", None),
+        ],
+    },
+    {
+        BASE: 0x003C,
+        LENGTH: 48,
+        REGISTERS: [
+            RegistryEntry("System_VAr_Total", 0x003C, "var", "measurement", None),
+            RegistryEntry(
+                "System_Power_Factor_Total", 0x003E, "%", "measurement", None
+            ),
+            RegistryEntry("System_PhaseAngle", 0x0042, "°", "measurement", None),
+            RegistryEntry("Frequency", 0x0046, "Hz", "measurement", None),
+            RegistryEntry(
+                "Import_Energy_kWh_Total", 0x0048, "kWh", "total_increasing", "energy"
+            ),
+            RegistryEntry(
+                "Export_Energy_kWh_Total", 0x004A, "kWh", "total_increasing", "energy"
+            ),
+            RegistryEntry(
+                "Import_Energy_kVArh_Total", 0x004C, "kvArh", "total_increasing", None
+            ),
+            RegistryEntry(
+                "Export_Energy_kVArh_Total", 0x004E, "kvArh", "total_increasing", None
+            ),
+        ],
+    },
+    {
+        BASE: 0x0156,
+        LENGTH: 4,
+        REGISTERS: [
+            RegistryEntry("kWh_Total", 0x0156, "kWh", "total_increasing", "energy"),
+            RegistryEntry("kvarh_Total", 0x0158, "kvArh", "total_increasing", None),
+        ],
+    },
+]
+
+
+class Sdm630(BasicMqtt):
+    """Represent Sdm630 sensor in BoneIO."""
+
+    SensorClass = None
+    DefaultName = SDM630
+
+    def __init__(
+        self,
+        modbus,
+        address: str,
+        ha_discovery_prefix: str,
+        topic_prefix: str,
+        ha_discovery: bool = False,
+        id: str = DefaultName,
+        update_interval: int = 60,
+        **kwargs,
+    ):
+        """Initialize Sdm630 class."""
+        super().__init__(
+            id=id or address, topic_type=SENSOR, topic_prefix=topic_prefix, **kwargs
+        )
+        self._topic_prefix = topic_prefix
+        self._modbus = modbus
+        self._address = address
+        self._ha_discovery = ha_discovery
+        self._discovery_sent = False
+        self._ha_discovery_prefix = ha_discovery_prefix
+        self._update_interval = update_interval
+
+    def _send_ha_autodiscovery(
+        self, id: str, sdm_name: str, sensor_id: str, **kwargs
+    ) -> None:
+        """Send HA autodiscovery information for each SDM sensor."""
+        _LOGGER.debug("Sending HA discovery for sensor %s %s.", sdm_name, sensor_id)
+        self._send_message(
+            topic=(
+                f"{self._ha_discovery_prefix}/{SENSOR}/{self._topic_prefix}"
+                f"/{id}{sensor_id.replace('_', '').lower()}/config"
+            ),
+            payload=sdm630_availabilty_message(
+                topic=self._topic_prefix,
+                id=id,
+                name=sdm_name,
+                sensor_id=sensor_id,
+                **kwargs,
+            ),
+        )
+
+    def _send_discovery_for_all_registers(self, register: int = 0) -> bool:
+        """Send discovery message to HA for each register."""
+        if register > 0:
+            for data in REGISTER_BASE:
+                for register in data["registers"]:
+                    kwargs = {
+                        "unit_of_measurement": getattr(register, "unit_of_measurement"),
+                        "state_class": getattr(register, "state_class"),
+                        "value_template": "{{ value | round(2)}}",
+                        "sensor_id": getattr(register, "sensor_id"),
+                    }
+                    if getattr(register, "device_class"):
+                        kwargs["device_class"] = getattr(register, "device_class")
+                    self._send_ha_autodiscovery(
+                        id=self._id, sdm_name=self._name, **kwargs
+                    )
+            return True
+        return False
+
+    async def send_state(self) -> None:
+        """Fetch state periodically and send to MQTT."""
+        register = self._modbus.read_single_register(unit=self._address, address=0)
+        if not self._discovery_sent and self._ha_discovery:
+            self._discovery_sent = self._send_discovery_for_all_registers(register)
+        while True:
+            payload_online = OFFLINE
+            for data in REGISTER_BASE:
+                values = self._modbus.read_multiple_registers(
+                    unit=self._address, address=data[BASE], count=data[LENGTH]
+                )
+                if payload_online == OFFLINE:
+                    payload_online = ONLINE
+                    self._send_message(
+                        topic=f"{self._topic_prefix}/{self._id}{STATE}",
+                        payload=payload_online,
+                    )
+                for register in data["registers"]:
+                    self._send_message(
+                        topic=f'{self._send_topic}/{getattr(register, "sensor_id")}',
+                        payload=float32(
+                            values, data[BASE], getattr(register, "address")
+                        ),
+                    )
+            await asyncio.sleep(self._update_interval)

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio/sensor/temp/__init__.py

@@ -9,14 +9,9 @@ from boneio.helper.exceptions import I2CError
 from boneio.helper import BasicMqtt
 
 
-from boneio.const import STATE, SENSOR, LM75
-
-from boneio.helper.exceptions import I2CError
-from boneio.helper import BasicMqtt
-
-
 class TempSensor(BasicMqtt):
     """Represent Temp sensor in BoneIO."""
+
     SensorClass = None
     DefaultName = TEMPERATURE
 
@@ -45,10 +40,13 @@ class TempSensor(BasicMqtt):
 
 class LM75Sensor(TempSensor):
     """Represent LM75 sensor in BoneIO."""
+
     SensorClass = PCT2075
     DefaultName = LM75
 
+
 class MCP9808Sensor(TempSensor):
     """Represent MCP9808 sensor in BoneIO."""
+
     SensorClass = MCP9808
     DefaultName = MCP_TEMP_9808

boneio-0.1.2/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "0.1.2"

{boneio-0.1.0.dev26 → boneio-0.1.2/boneio.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: boneio
-Version: 0.1.0.dev26
-Summary: Python Helper for BoneIO
-Home-page: https://github.com/maciejk1984/boneIO
+Version: 0.1.2
+Summary: Python App for BoneIO
+Home-page: https://github.com/boneIO-eu/app_bbb
 License: GNU General Public License v3.0
-Download-URL: https://github.com/maciejk1984/boneIO/archive/0.1.0.dev26.zip
+Download-URL: https://github.com/boneIO-eu/app_bbb/archive/0.1.2.zip
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7
@@ -16,16 +16,24 @@ License-File: LICENSE
 Example usage:
 boneio run -dd -c config.yaml
 
-
-
 # Installation instructions
 
 ```
 sudo apt-get install libopenjp2-7-dev libatlas-base-dev python3-venv
-python3 -m venv venv
-wget https://raw.githubusercontent.com/pszafer/boneIO-1/main/Code/BoneIO/example_config/config.yaml
-wget https://raw.githubusercontent.com/pszafer/boneIO-1/main/Code/BoneIO/example_config/output.yaml
+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.1.0.dev26 → boneio-0.1.2}/boneio.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ boneio/__init__.py
 boneio/bonecli.py
 boneio/const.py
 boneio/manager.py
+boneio/modbus.py
 boneio/mqtt_client.py
 boneio/oled.py
 boneio/schema.yaml
@@ -42,4 +43,5 @@ boneio/relay/mcp.py
 boneio/sensor/__init__.py
 boneio/sensor/adc.py
 boneio/sensor/gpio.py
+boneio/sensor/sdm630.py
 boneio/sensor/temp/__init__.py

{boneio-0.1.0.dev26 → boneio-0.1.2}/boneio.egg-info/requires.txt

@@ -13,7 +13,10 @@ gpio==0.3.0
 luma.core==2.3.1
 luma.oled==3.8.1
 numpy==1.21.4
+Pillow==9.0.0
 paho-mqtt==1.6.1
 psutil==5.8.0
 pyaml==21.10.1
+pymodbus==2.5.3
+pyserial-asyncio==0.6
 typing-extensions==3.10.0.2

{boneio-0.1.0.dev26 → boneio-0.1.2}/requirements.txt

@@ -23,7 +23,7 @@ luma.core==2.3.1
 luma.oled==3.8.1
 numpy==1.21.4
 paho-mqtt==1.6.1
-Pillow==8.4.0
+Pillow==9.0.0
 pkg-resources==0.0.0
 psutil==5.8.0
 pyaml==21.10.1
@@ -33,6 +33,8 @@ pyparsing==2.2.0
 PyQRCode==1.2.1
 pyserial==3.5
 pyusb==1.2.1
+pymodbus==2.5.3
+pyserial-asyncio==0.6
 PyYAML==6.0
 recordclass==0.16.3
 requests==2.26.0

{boneio-0.1.0.dev26 → boneio-0.1.2}/setup.py

@@ -12,11 +12,11 @@ with open("boneio/version.py") as f:
 setup(
     name="boneio",
     version=__version__,  # type: ignore # noqa: F821,
-    description="Python Helper for BoneIO",
+    description="Python App for BoneIO",
     long_description=long_description,
     long_description_content_type="text/markdown",
-    url="https://github.com/maciejk1984/boneIO",
-    download_url="https://github.com/maciejk1984/boneIO/archive/{}.zip".format(
+    url="https://github.com/boneIO-eu/app_bbb",
+    download_url="https://github.com/boneIO-eu/app_bbb/archive/{}.zip".format(
         __version__  # type: ignore # noqa: F821
     ),
     packages=find_packages(exclude=["tests*"]),
@@ -44,9 +44,12 @@ setup(
         "luma.core==2.3.1",
         "luma.oled==3.8.1",
         "numpy==1.21.4",
+        "Pillow==9.0.0",
         "paho-mqtt==1.6.1",
         "psutil==5.8.0",
         "pyaml==21.10.1",
+        "pymodbus==2.5.3",
+        "pyserial-asyncio==0.6",
         "typing-extensions==3.10.0.2",
     ],
     entry_points={"console_scripts": ["boneio=boneio.bonecli:cli"]},

boneio-0.1.0.dev26/README.md

@@ -1,14 +0,0 @@
-Example usage:
-boneio run -dd -c config.yaml
-
-
-
-# Installation instructions
-
-```
-sudo apt-get install libopenjp2-7-dev libatlas-base-dev python3-venv
-python3 -m venv venv
-wget https://raw.githubusercontent.com/pszafer/boneIO-1/main/Code/BoneIO/example_config/config.yaml
-wget https://raw.githubusercontent.com/pszafer/boneIO-1/main/Code/BoneIO/example_config/output.yaml
-```
-

boneio-0.1.0.dev26/boneio/version.py

@@ -1,2 +0,0 @@
-# flake8: noqa
-__version__ = "0.1.0.dev26"