boneIO 0.8.0.dev3__tar.gz → 0.8.0.dev6__tar.gz

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boneIO
-Version: 0.8.0.dev3
+Version: 0.8.0.dev6
 Summary: Python App for BoneIO
 License: GNU General Public License v3.0
 Author-email: Paweł Szafer <pszafer@gmail.com>

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/bonecli.py

@@ -113,7 +113,7 @@ def get_arguments() -> argparse.Namespace:
     modbus_parser.add_argument(
         "--bytesize",
         type=int,
-        required=True,
+        required=False,
         default=8,
         help="Bytesize",
     )
@@ -121,7 +121,7 @@ def get_arguments() -> argparse.Namespace:
     modbus_parser.add_argument(
         "--stopbits",
         type=int,
-        required=True,
+        required=False,
         default=1,
         help="stopbits",
     )
@@ -131,7 +131,7 @@ def get_arguments() -> argparse.Namespace:
         type=str,
         choices=["P", "E", "N"],
         default="N",
-        required=True,
+        required=False,
         help="Parity",
     )
 
@@ -142,7 +142,7 @@ def get_arguments() -> argparse.Namespace:
     set_modbus_parser.add_argument(
         "--device",
         type=str,
-        choices=["cwt"],
+        choices=["cwt", "r4dcb08"],
         help="Choose device to set modbus address/baudrate",
         required=True,
     )
@@ -156,8 +156,8 @@ def get_arguments() -> argparse.Namespace:
     set_modbus_parser_group.add_argument(
         "--new-baudrate",
         type=int,
-        choices=[2400, 4800, 9600, 19200],
-        help="Choose new baudrate to set",
+        choices=[1200, 2400, 4800, 9600, 19200],
+        help="Choose new baudrate to set. CWT doesn't work on 1200.",
     )
 
     get_modbus_parser = modbus_sub_parser.add_parser("get")

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/const.py

@@ -71,8 +71,7 @@ SHOW_HA = "show_in_ha"
 # OLED CONST
 OLED = "oled"
 FONTS = "fonts"
-OLED_PIN = ("",)
-"P9_41"
+OLED_PIN = "P9_41"
 GIGABYTE = 1073741824
 MEGABYTE = 1048576
 WIDTH = 128

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/modbus/client.py

@@ -101,34 +101,26 @@ class Modbus:
             _LOGGER.error(exception_error)
             return False
 
-    async def read_single_register(
+    async def read_and_decode(
         self,
         unit: int | str,
         address: int,
+        payload_type: str,
         count: int = 2,
         method: str = "input",
     ) -> float | None:
         """Call sync. pymodbus."""
-        async with self._lock:
-            if not self._pymodbus_connect():
-                _LOGGER.error("Can't connect to Modbus address %s.", address)
-                return None
-            kwargs = {"unit": unit, "count": count} if unit else {}
-            try:
-                result: ReadInputRegistersResponse = self._read_methods[method](
-                    address, **kwargs
-                )
-            except (ModbusException, struct.error) 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()
+        result = await self.read_registers(
+            unit=unit, address=address, count=count, method=method
+        )
+        if not result or result.isError():
+            return None
+        decoded_value = self.decode_value(
+            payload=result.registers, value_type=payload_type
+        )
+        return decoded_value
 
-    async def read_multiple_registers(
+    async def read_registers(
         self,
         unit: int | str,  # device address
         address: int,  # modbus register address
@@ -142,10 +134,18 @@ class Modbus:
                 return None
             kwargs = {"unit": unit, "count": count} if unit else {}
             try:
-                result: ReadInputRegistersResponse = self._read_methods[method](
+                read_method = self._read_methods[method]
+                _LOGGER.debug(
+                    "Multiple reading %s registers from %s with method %s from device %s.",
+                    count,
+                    address,
+                    method,
+                    unit,
+                )
+                result: ReadInputRegistersResponse = read_method(
                     address, **kwargs
                 )
-            except ModbusException as exception_error:
+            except (ModbusException, struct.error) as exception_error:
                 _LOGGER.error(exception_error)
                 return None
             if not hasattr(result, REGISTERS):

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/modbus/cwt.json

@@ -2,7 +2,10 @@
   "model": "CWT Temp and Humidity sensor",
   "set_base": {
     "set_address_address": 2000,
-    "set_baudrate_address": 2001
+    "set_baudrate": {
+      "address": 2001,
+      "possible_baudrates": [2400, 4800, 9600, 19200]
+    }
   },
   "registers_base": [
     {

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/modbus/modbuscli.py

@@ -9,7 +9,7 @@ from .utils import REGISTERS_BASE, allowed_operations
 _LOGGER = logging.getLogger(__name__)
 SET_BASE = "set_base"
 SET_ADDRESS = "set_address_address"
-SET_BAUDRATE = "set_baudrate_address"
+SET_BAUDRATE = "set_baudrate"
 
 
 class ModbusHelper:
@@ -53,7 +53,7 @@ class ModbusHelper:
             f"Checking connection {self._device_address}, address {address}."
         )
         count = 1 if value_type == "S_WORD" or value_type == "U_WORD" else 2
-        value = await self._modbus.read_multiple_registers(
+        value = await self._modbus.read_registers(
             unit=self._device_address,
             address=address,
             count=count,
@@ -76,20 +76,23 @@ class ModbusHelper:
             return False
         return True
 
-    def set_connection_speed(self, new_baudrate: int):
-        ind = self.baud_rates.index(new_baudrate)
+    def set_connection_speed(self, new_baudrate: int) -> int:
+        baudrate_model = self._model[SET_BAUDRATE]
+        ind = baudrate_model["possible_baudrates"].index(new_baudrate)
         if ind:
             result = self._modbus.client.write_register(
-                address=self._model[SET_BAUDRATE],
+                address=baudrate_model["address"],
                 value=ind,
                 unit=self._device_address,
             )
         if result.isError():
             _LOGGER.error("Operation failed.")
+            return 1
         else:
             _LOGGER.info(
                 "Operation succeeded. Now restart device by disconnecting it."
             )
+            return 0
 
     def set_new_address(self, new_address: int):
         if 0 < new_address < 253:
@@ -128,6 +131,9 @@ async def async_run_modbus_set(
     if not first_reg_base:
         return False
     first_record = first_reg_base.get(REGISTERS, [])[0]
+    _LOGGER.debug(
+        f"Connecting with params uart: {uart}, baudrate: {baudrate}, stopbits: {stopbits}, bytesize: {bytesize}, parity: {parity}."
+    )
     modbus_helper = ModbusHelper(
         device=device,
         uart=uart,
@@ -144,8 +150,7 @@ async def async_run_modbus_set(
         _LOGGER.error("Can't connect with sensor. Exiting")
         return 1
     if new_baudrate:
-        modbus_helper.set_connection_speed(new_baudrate=new_baudrate)
-        return 0
+        return modbus_helper.set_connection_speed(new_baudrate=new_baudrate)
     if new_address:
         modbus_helper.set_new_address(new_address=new_address)
         return 0
@@ -164,6 +169,9 @@ async def async_run_modbus_get(
     parity: str = "N",
 ):
     """Run Modbus Get Function."""
+    _LOGGER.debug(
+        f"Connecting with params uart: {uart}, baudrate: {baudrate}, stopbits: {stopbits}, bytesize: {bytesize}, parity: {parity}."
+    )
     _modbus = Modbus(
         uart=UARTS[uart],
         baudrate=baudrate,
@@ -172,7 +180,7 @@ async def async_run_modbus_get(
         parity=parity,
     )
     count = 1 if value_type == "S_WORD" or value_type == "U_WORD" else 2
-    value = await _modbus.read_multiple_registers(
+    value = await _modbus.read_registers(
         unit=device_address,
         address=register_address,
         count=count,

boneIO-0.8.0.dev6/boneio/modbus/r4dcb08.json

@@ -0,0 +1,91 @@
+{
+  "model": "R4DCB08",
+  "set_base": {
+    "set_address_address": 254,
+    "set_baudrate": {
+      "address": 255,
+      "possible_baudrates": [1200, 2400, 4800, 9600, 19200]
+    }
+  },
+  "registers_base": [
+    {
+      "base": 0,
+      "length": 16,
+      "register_type": "holding",
+      "registers": [
+        {
+          "name": "Temperature 1",
+          "address": 0,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature 2",
+          "address": 1,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature 3",
+          "address": 2,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature 4",
+          "address": 3,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature 5",
+          "address": 4,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature 6",
+          "address": 5,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature 7",
+          "address": 6,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature 8",
+          "address": 7,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        }
+      ]
+    }
+  ]
+}

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/modbus/sensor.py

@@ -122,10 +122,13 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
             register_method = first_register_base.get("register_type", "input")
             # Let's try fetch register 2 times in case something wrong with initial packet.
             for _ in [0, 1]:
-                register = await self._modbus.read_single_register(
+                register = await self._modbus.read_and_decode(
                     unit=self._address,
                     address=first_register_base[REGISTERS][0][ADDRESS],
                     method=register_method,
+                    payload_type=first_register_base[REGISTERS][0].get(
+                        "value_type", "FP32"
+                    ),
                 )
                 if register is not None:
                     self._discovery_sent = (
@@ -144,7 +147,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
         update_interval = self._update_interval.total_in_seconds
         await self.check_availability()
         for data in self._db[REGISTERS_BASE]:
-            values = await self._modbus.read_multiple_registers(
+            values = await self._modbus.read_registers(
                 unit=self._address,
                 address=data[BASE],
                 count=data[LENGTH],

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/oled.py

@@ -26,8 +26,7 @@ fonts = {
     "big": make_font("DejaVuSans.ttf", 12),
     "small": make_font("DejaVuSans.ttf", 9),
     "extraSmall": make_font("DejaVuSans.ttf", 7),
-    "danube": make_font("danube__.ttf", 15, local=True)
-
+    "danube": make_font("danube__.ttf", 15, local=True),
 }
 
 # screen_order = [UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP]
@@ -96,7 +95,9 @@ class Oled:
 
     def _sleeptime(self):
         with canvas(self._device) as draw:
-            draw.rectangle(self._device.bounding_box, outline="black", fill="black")
+            draw.rectangle(
+                self._device.bounding_box, outline="black", fill="black"
+            )
         self._sleep = True
 
     def _draw_uptime(self, data: dict, draw: ImageDraw) -> None:
@@ -116,7 +117,12 @@ class Oled:
     def _draw_output(self, data: dict, draw: ImageDraw) -> None:
         "Draw outputs of GPIO/MCP relays."
         cols = cycle(OUTPUT_COLS)
-        draw.text((1, 1), f"Relay {self._current_screen}", font=fonts["small"], fill=WHITE)
+        draw.text(
+            (1, 1),
+            f"Relay {self._current_screen}",
+            font=fonts["small"],
+            fill=WHITE,
+        )
         i = 0
         j = next(cols)
         for k in data:
@@ -124,7 +130,10 @@ class Oled:
                 j = next(cols)
                 i = 0
             draw.text(
-                (j, OUTPUT_ROWS[i]), f"{shorten_name(k)} {data[k]}", font=fonts["extraSmall"], fill=WHITE
+                (j, OUTPUT_ROWS[i]),
+                f"{shorten_name(k)} {data[k]}",
+                font=fonts["extraSmall"],
+                fill=WHITE,
             )
             i += 1
 
@@ -133,7 +142,10 @@ class Oled:
         data = self._host_data.get(self._current_screen)
         if data:
             with canvas(self._device) as draw:
-                if self._output_groups and self._current_screen in self._output_groups:
+                if (
+                    self._output_groups
+                    and self._current_screen in self._output_groups
+                ):
                     self._draw_output(data, draw)
                 elif self._current_screen == UPTIME:
                     self._draw_uptime(data, draw)

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/boneio/schema/schema.yaml

@@ -123,6 +123,7 @@ modbus:
     stopbits:
       type: integer
       default: 1
+      allowed: [1, 2]
     bytesize:
       type: integer
       default: 8

boneIO-0.8.0.dev6/boneio/version.py

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

{boneIO-0.8.0.dev3 → boneIO-0.8.0.dev6}/pyproject.toml

@@ -30,7 +30,7 @@ dependencies = [
     "Adafruit-BBIO>=1.2.0",
 ]
 requires-python = ">=3.7"
-version = "0.8.0.dev3"
+version = "0.8.0.dev6"
 
 [project.license]
 text = "GNU General Public License v3.0"

boneIO-0.8.0.dev3/boneio/modbus/r4dcb08.json

@@ -1,76 +0,0 @@
-{
-    "model": "R4DCB08",
-    "registers_base": [
-        {
-            "base": 0,
-            "length": 16,
-            "register_type": "holding",
-            "registers": [
-                {
-                    "name": "Temperature 1",
-                    "address": 0,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                },
-                {
-                    "name": "Temperature 2",
-                    "address": 1,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                },
-                {
-                    "name": "Temperature 3",
-                    "address": 2,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                },
-                {
-                    "name": "Temperature 4",
-                    "address": 3,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                },
-                {
-                    "name": "Temperature 5",
-                    "address": 4,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                },
-                {
-                    "name": "Temperature 6",
-                    "address": 5,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                },
-                {
-                    "name": "Temperature 7",
-                    "address": 6,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                },
-                {
-                    "name": "Temperature 8",
-                    "address": 7,
-                    "unit_of_measurement": "°C",
-                    "state_class": "measurement",
-                    "device_class": "temperature",
-                    "return_type": "multiply0_1"
-                }
-            ]
-        }
-    ]
-}

boneIO-0.8.0.dev3/boneio/version.py

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