boneIO 0.7.2.dev4__py3-none-any.whl → 0.8.0.dev2__py3-none-any.whl

{boneIO-0.7.2.dev4.dist-info → boneIO-0.8.0.dev2.dist-info}/METADATA

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

{boneIO-0.7.2.dev4.dist-info → boneIO-0.8.0.dev2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 boneio/__init__.py,sha256=hoLKnu6h1uEsiCHA9Ql2MMDC7VQS0E-s_2cxBS-CTOg,147
-boneio/bonecli.py,sha256=fKPcTEMjYG8zhWig3F6dqE2jDxBd17ydWHp0XVnq6sc,3491
+boneio/bonecli.py,sha256=JR4ILR5E3fVFkVL28-_tJcxckrKUIQwbNFkVF3YPMXs,7280
 boneio/const.py,sha256=eIpq1EvFYh1p9I83xaDSOrF_JfdYr-1-yXO5vsAaqCg,5093
 boneio/cover.py,sha256=EfO1DAOGTPQykfgJHzg1WqPs0U8b1AnD2NMI-sLZccM,8444
 boneio/example_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,12 +22,12 @@ boneio/helper/click_timer.py,sha256=Gu8sEi1S8GG42SYbfaMju7WXFhnnil9gYfirLZX7kJk,
 boneio/helper/config.py,sha256=5cDnJ7usJDlUvXv8K2rSWEx30OFcU2k1U1vUEjO69WY,2431
 boneio/helper/events.py,sha256=f4JDMMkyp0lWz9w8ABZ_hlKyAbJWtYHGnGTs2vv4vac,8648
 boneio/helper/exceptions.py,sha256=vyYSUojwB7OttOPUjbxeHFM7C_o5ZQmRUcZ_vYpxYYI,717
-boneio/helper/filter.py,sha256=UcjifjaC5wHDW2He7wmwCX2IjSSeLVhXyhrXHeT8RmA,885
+boneio/helper/filter.py,sha256=8jgSbHDaInEVlAPd7nrahnFYsi1y6C2fmI0yn55XzK0,935
 boneio/helper/gpio.py,sha256=q2r2uklPWePuuekPO63kVfoaQdkvNObUJ3ktwsHgOB0,4771
 boneio/helper/ha_discovery.py,sha256=B2t1cfOfKWys4EM1H7OxvOaYL8H_v18CTuHCEVP2w2c,7107
-boneio/helper/loader.py,sha256=zbg6WrKg7sfFRjny6qNQL7l-6ENbPq5AoEuW2T69PQE,17333
+boneio/helper/loader.py,sha256=mkvM6Fg_4xHI079iiWFcUQFW1w8819AXAkiBja0vKxo,17473
 boneio/helper/logger.py,sha256=zyF_Vk3o2eSHuXypJhNzK99eZgkWDWybuB5KcJgurDs,1801
-boneio/helper/mqtt.py,sha256=novgn5Xl--dmwJ3p6gYVnurVxF5uf-i_t9rj5EmmvP8,859
+boneio/helper/mqtt.py,sha256=1YgwO0RjkarN5qS5HS5rONf4H3_m3ak7tT_hHm-HeOQ,931
 boneio/helper/oled.py,sha256=f0XYbaFstUbJ6ISmFe1vQCnmNVMctQWtnStNdROrblc,351
 boneio/helper/onewire/W1ThermSensor.py,sha256=Pu5Fp29pKbxjJqDbFs05Mjg3Vy-9z_DTVoBpSWM_byA,2430
 boneio/helper/onewire/__init__.py,sha256=4djH-uxiq5XhAiFTOxyqjvWVoJe0c8U8iN0BfmH8nSU,448
@@ -36,16 +36,29 @@ boneio/helper/onewire/onewire.py,sha256=tHofTu1l0qG7hH2XoSf-lj8gW7wVKe27j57qQWpV
 boneio/helper/pcf8575.py,sha256=qeNYLqV5foDEQCyAz1WRQRi1CYYxtbPIha06Z5TyZVQ,311
 boneio/helper/queue.py,sha256=7fE7d344-BEW8sljN40wmqsbBr4kPLvz4ShBjkT04p8,1066
 boneio/helper/sensor/ina_219_smbus.py,sha256=eXp2epjUgsqaXamTSWSn3LMow5X_YxAxdREaWD7N3mk,6170
-boneio/helper/state_manager.py,sha256=W63oGPCKo1vZ8zr5Q_3SALM0mgjuab5b8Y397HAiO_o,2633
+boneio/helper/state_manager.py,sha256=6OeqJsLQPCyQhhmFlNxCd80cTYLnKb02L4AZ1ZFFVBE,2616
 boneio/helper/stats.py,sha256=Ard04Z0WpkV7U6hgv1Uf4KxkjIde5iIW8W2cqRGXZyg,6731
 boneio/helper/timeperiod.py,sha256=xpg9oe30Z5WiLDQPq3EBKKScejOnN47NhcpeFvDd3bY,5806
-boneio/helper/util.py,sha256=SwTxVnUFe-YCmzubRzfICJDgrr0xMAJaR0G1wBXCMR8,681
+boneio/helper/util.py,sha256=DyppBTE2zTWoxVpl83Kb4SpJLEqOOSEkxXEITCrwnfk,938
 boneio/helper/yaml_util.py,sha256=aaXMwXC2JoDYkBMcZkkB8nic3QOyGOhxPTRxWvMf3G4,11334
 boneio/input/__init__.py,sha256=8Hcps-wCCl6bCAMoEmDJecR-Q9giFL29AvG1ZGe0dZw,200
 boneio/input/gpio.py,sha256=mqmce4P_dNzmNHqNNiNAmKeeZKbbKtPUtQ6zd8-R-9I,2438
 boneio/input/gpio_new.py,sha256=gpPfDr39B8FVUyh9XHtLgVQr4glMGFBgQsyIMzXDPaw,2822
-boneio/manager.py,sha256=Qgnk_5-rnVZ4ZcvpsFMmJndXJiWnxb4AarlPs37E_1s,29859
-boneio/modbus.py,sha256=edeBrIKfpcPdU6KkfVTgCCVijrqkhZzx9hBmR2b0czk,5550
+boneio/manager.py,sha256=06smEmgB9UDWUjCvy2l_lEHFyONU6N6ppW_dOiRv-wM,29866
+boneio/modbus/__init__.py,sha256=yeHIxZ0_u7eCL7CqScvob5Utcru6Iza0LEtTagEtNtw,116
+boneio/modbus/client.py,sha256=tmArCt9ac6rxUymdmFMEn4xpZtGdU7Yby7r3RkGJVxM,6030
+boneio/modbus/cwt.json,sha256=4zJAHAV-h1JsV_Yp4VF6ecg_0eef-EHOdzRnhnMHRQs,814
+boneio/modbus/dts1964_3f.json,sha256=WABph_2X4OgMidSM28vw4dLd9ZByRoiUP-RqE0UMpR8,8810
+boneio/modbus/modbuscli.py,sha256=kt9T707FHCOzWE7SJEMTbLyM8BPPnTmcWsY5-0q9zqU,5502
+boneio/modbus/orno-or-we-517.json,sha256=PtaG0B_uNLCemN2vrIXFS4Kzt6JBVoGCYhNMG-1wZhg,505
+boneio/modbus/pt100.json,sha256=bzKNYDc3lMto94Ut8gutVIsHytQiMobwFCkonOiMegs,526
+boneio/modbus/r4dcb08.json,sha256=oj4eK3bD1bG8BTRE4STVHB5L92luWaJ3FYFHQvFg-ZA,2735
+boneio/modbus/sdm120.json,sha256=4sueFfSw7G6a77gdIUhbfJvE-MNVJFOeVbRvHDw5Rvk,4145
+boneio/modbus/sdm630.json,sha256=TUiuc060IpF64p_HSDvdxEQcwkWHWUpnd48_xaGU-_o,8255
+boneio/modbus/sensor.py,sha256=tfFYQNK0dE1yA0Otw66dxoM5wJ1b6nvW2_k4y8WAk_g,8303
+boneio/modbus/socomec_e23.json,sha256=Is51YelEd4d6SYmz4Gd_oKx4Qi3bp-VHsl9zxWOFI5s,2882
+boneio/modbus/sofar.json,sha256=A_YztQN_ctyItIm2LH1tfcs-pSyG18I530qleLd2tOw,5592
+boneio/modbus/utils.py,sha256=cG75mmKTGaw_qrCG_D1qw-jl9XybUXa03i1ap5oBxGE,1753
 boneio/mqtt_client.py,sha256=hzGT3IyftPHNrQXSKbWUXGYZBpP-VdRBkOrILkXDNHs,8665
 boneio/oled.py,sha256=dLfAaH2Qto9P3mil_JK4siGvkSQ7LebhCabhL-OYGaM,5505
 boneio/relay/__init__.py,sha256=Cz6D37GKHxm8DiuPuxE2EMaey2wdUdJYVet_hfR0lzA,231
@@ -61,7 +74,7 @@ boneio/schema/actions_switch.yaml,sha256=cDgSi12k4S-TWADQ20Fy9NvYKOXnm7YkyMaWpPy
 boneio/schema/filters.yaml,sha256=WopX1SmCZsSZXNiGccLoi7uMCsUpdbs0eVfsAjmbay4,286
 boneio/schema/filters_adc.yaml,sha256=3e0ts92MoFKOnfGOOn6WYIHxu0-tnZe9OjAjN9m7hiI,304
 boneio/schema/id.yaml,sha256=vHI_6dxkJwoiGp5ien_pPpyaWA1F06eirTgfWMyWa1E,75
-boneio/schema/schema.yaml,sha256=f7fgzVI14yMmL_j2ojFKx2kG95a1KjkuSnP3tP8Vay0,18368
+boneio/schema/schema.yaml,sha256=R9EqtON1dTNsyCtIXDy6B1vJQArGnSQlnSLExJhVmqc,18418
 boneio/schema/temp_unit.yaml,sha256=m32VGz9RTW92Lz08l9n6RftkcVNZquOGPPr5mc3eZVc,65
 boneio/schema/update_interval.yaml,sha256=L_YLddAZdybcdO-T57Qhlv1GaWIVDwhvH-GadD1oOIo,133
 boneio/sensor/__init__.py,sha256=Ztj-xzey-SWrEdVEozcwFsZSuEmJW8STVaf_vPMWiVc,619
@@ -69,21 +82,13 @@ boneio/sensor/adc.py,sha256=tCUdr3KN5uSbgXiwhNXbMjeNkO2CzPYhIOncHR5_LD0,1328
 boneio/sensor/gpio.py,sha256=8m07tW1xDsrhBM2dZ9_VvmvYRn-5hLQVTTUhPlKg1rg,1199
 boneio/sensor/gpio_new.py,sha256=m54agOF2gUh3aoC6f8WpCPAmBRADvqlKeWLqwlon9fg,1223
 boneio/sensor/ina219.py,sha256=kBwaCjY63CNFj1mRZ2EEtm2BrMZ6BW4ahjAD2LT-0jo,3439
-boneio/sensor/modbus/__init__.py,sha256=qB7MGcC6c-2X0U0iN7ai5qSo7tHp4zwZ_FX6TcQmiNU,10129
-boneio/sensor/modbus/dts1964_3f.json,sha256=WABph_2X4OgMidSM28vw4dLd9ZByRoiUP-RqE0UMpR8,8810
-boneio/sensor/modbus/pt100.json,sha256=bzKNYDc3lMto94Ut8gutVIsHytQiMobwFCkonOiMegs,526
-boneio/sensor/modbus/r4dcb08.json,sha256=oj4eK3bD1bG8BTRE4STVHB5L92luWaJ3FYFHQvFg-ZA,2735
-boneio/sensor/modbus/sdm120.json,sha256=4sueFfSw7G6a77gdIUhbfJvE-MNVJFOeVbRvHDw5Rvk,4145
-boneio/sensor/modbus/sdm630.json,sha256=TUiuc060IpF64p_HSDvdxEQcwkWHWUpnd48_xaGU-_o,8255
-boneio/sensor/modbus/socomec_e23.json,sha256=G4dEvOQbJpkLonubpjI77KFtlt13iwVxmArMgUzuwm0,2859
-boneio/sensor/modbus/sofar.json,sha256=A_YztQN_ctyItIm2LH1tfcs-pSyG18I530qleLd2tOw,5592
 boneio/sensor/temp/__init__.py,sha256=JLNH6Nc78ezleftnIYylIcNtKIm0rdqetbPZLsuCgDc,1844
 boneio/sensor/temp/dallas.py,sha256=xrvd1LNBh1fRcjz_yd_9S29Lv26ItVtLCmhZgVQWJos,2485
 boneio/sensor/temp/lm75.py,sha256=-mpOv78429plRPBp9s09Ljz1x2Bdxuagalqz40vlAKE,243
 boneio/sensor/temp/mcp9808.py,sha256=yAh5yJzZLGTqa39xV4fyqsruj7oy3niOZAUV2W6eyCM,271
-boneio/version.py,sha256=MwhIhpPdwgnlOYgQUWre-MHZsuhOMXaDZ69JqvVW4uU,41
-boneIO-0.7.2.dev4.dist-info/entry_points.txt,sha256=Igl1SMDEWwMg144bwRz28UOCb80hdxomC99QJ3u6qC0,46
-boneIO-0.7.2.dev4.dist-info/WHEEL,sha256=B19PGBCYhWaz2p_UjAoRVh767nYQfk14Sn4TpIZ-nfU,87
-boneIO-0.7.2.dev4.dist-info/METADATA,sha256=wVLYQttucUYjOEYNEDHL1W6zM8JELdY5tBq_V01Iq7Q,1801
-boneIO-0.7.2.dev4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-boneIO-0.7.2.dev4.dist-info/RECORD,,
+boneio/version.py,sha256=qUYOwKU4jFQvDJRLavdrZJyoMqaNsiJCiYpN35E3_Ak,41
+boneIO-0.8.0.dev2.dist-info/entry_points.txt,sha256=Igl1SMDEWwMg144bwRz28UOCb80hdxomC99QJ3u6qC0,46
+boneIO-0.8.0.dev2.dist-info/WHEEL,sha256=B19PGBCYhWaz2p_UjAoRVh767nYQfk14Sn4TpIZ-nfU,87
+boneIO-0.8.0.dev2.dist-info/METADATA,sha256=hcxcGSVtqYAvfGFFwZuI5FBtvvMd6Kf_Ingf-D-OWlo,1801
+boneIO-0.8.0.dev2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+boneIO-0.8.0.dev2.dist-info/RECORD,,

boneio/bonecli.py

@@ -1,20 +1,28 @@
 """Bonecli script."""
+
 from __future__ import annotations
-import argparse
-import asyncio
-import logging
-import sys
+
 import os
-from typing import Any
 
 os.environ["W1THERMSENSOR_NO_KERNEL_MODULE"] = "1"
 
+import argparse
+import asyncio
+import logging
+import sys
 from colorlog import ColoredFormatter
 from yaml import MarkedYAMLError
 
+from boneio.modbus.modbuscli import async_run_modbus_set, async_run_modbus_get
+from boneio.modbus.client import VALUE_TYPES
+
+
 from boneio.const import ACTION
 from boneio.helper import load_config_from_file
-from boneio.helper.exceptions import ConfigurationException, RestartRequestException
+from boneio.helper.exceptions import (
+    ConfigurationException,
+    RestartRequestException,
+)
 from boneio.helper.events import GracefulExit
 from boneio.helper.logger import configure_logger
 from boneio.runner import async_run
@@ -49,30 +57,114 @@ def get_arguments() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description="boneIO app for BeagleBone Black.",
     )
-    parser.add_argument(ACTION, type=str, default="run")
-    parser.add_argument("--version", action="version", version=__version__)
-    parser.add_argument(
+    subparsers = parser.add_subparsers(dest=ACTION, required=True)
+    run_parser = subparsers.add_parser("run")
+    run_parser.add_argument(
+        "--debug",
+        "-d",
+        action="count",
+        help="Start boneIO in debug mode",
+        default=0,
+    )
+    run_parser.add_argument(
         "-c",
         "--config",
         metavar="path_to_config_dir",
         default="./config.yaml",
         help="File which contains boneIO configuration",
     )
-    parser.add_argument(
-        "--debug", "-d", action="count", help="Start boneIO in debug mode", default=0
+    run_parser.add_argument(
+        "--mqttusername",
+        help="Mqtt username to use if you don't want provide in file.",
+    )
+    run_parser.add_argument(
+        "--mqttpassword",
+        help="Mqtt password to use if you don't want provide in file.",
+    )
+    modbus_parser = subparsers.add_parser("modbus")
+    modbus_parser.add_argument(
+        "--debug",
+        "-d",
+        action="count",
+        help="Start boneIO in debug mode",
+        default=0,
+    )
+    modbus_parser.add_argument(
+        "--uart",
+        type=str,
+        choices=["uart1", "uart4"],
+        help="Choose UART",
+        required=True,
+    )
+    modbus_parser.add_argument(
+        "--address",
+        type=lambda x: int(x, 0),
+        required=True,
+        help="Current device address (hex or integer)",
+    )
+    modbus_parser.add_argument(
+        "--baudrate",
+        type=int,
+        choices=[2400, 4800, 9600, 19200],
+        required=True,
+        help="Current baudrate",
+    )
+
+    modbus_sub_parser = modbus_parser.add_subparsers(
+        dest="modbus_action", required=True
     )
-    parser.add_argument(
-        "--mqttusername", help="Mqtt username to use if you don't want provide in file."
+    set_modbus_parser = modbus_sub_parser.add_parser("set")
+    set_modbus_parser.add_argument(
+        "--device",
+        type=str,
+        choices=["cwt"],
+        help="Choose device to set modbus address/baudrate",
+        required=True,
     )
-    parser.add_argument(
-        "--mqttpassword", help="Mqtt password to use if you don't want provide in file."
+    set_modbus_parser_group = set_modbus_parser.add_mutually_exclusive_group()
+    set_modbus_parser_group.add_argument(
+        "--new-address",
+        type=lambda x: int(x, 0),
+        help="Set new address (hex or integer / 1 - 253/)",
     )
+
+    set_modbus_parser_group.add_argument(
+        "--new-baudrate",
+        type=int,
+        choices=[2400, 4800, 9600, 19200],
+        help="Choose new baudrate to set",
+    )
+
+    get_modbus_parser = modbus_sub_parser.add_parser("get")
+    get_modbus_parser.add_argument(
+        "--register-address",
+        type=int,
+        help="Register address",
+        required=True,
+    )
+    get_modbus_parser.add_argument(
+        "--register-type",
+        type=str,
+        choices=["input", "holding"],
+        help="Register type",
+        required=True,
+    )
+    get_modbus_parser.add_argument(
+        "--value-type",
+        type=str,
+        choices=VALUE_TYPES.keys(),
+        help="Value types",
+        required=True,
+    )
+    parser.add_argument("--version", action="version", version=__version__)
     arguments = parser.parse_args()
 
     return arguments
 
 
-def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "") -> int:
+def run(
+    config: str, debug: int, mqttusername: str = "", mqttpassword: str = ""
+) -> int:
     """Run BoneIO."""
     _LOGGER.info("BoneIO %s starting.", __version__)
     try:
@@ -99,6 +191,45 @@ def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "")
         return 1
 
 
+def run_modbus_command(
+    args: argparse.Namespace,
+) -> int:
+    """Run BoneIO."""
+    _LOGGER.info("BoneIO %s starting.", __version__)
+    try:
+        configure_logger(log_config={}, debug=args.debug)
+        if args.modbus_action == "set":
+            ret = asyncio.run(
+                async_run_modbus_set(
+                    device=args.device,
+                    uart=args.uart,
+                    address=args.address,
+                    baudrate=args.baudrate,
+                    new_baudrate=args.new_baudrate,
+                    new_address=args.new_address,
+                ),
+            )
+        else:
+            ret = asyncio.run(
+                async_run_modbus_get(
+                    uart=args.uart,
+                    device_address=args.address,
+                    baudrate=args.baudrate,
+                    register_address=args.register_address,
+                    register_type=args.register_type,
+                    value_type=args.value_type,
+                ),
+            )
+        return ret
+    except (RestartRequestException, GracefulExit) as err:
+        if err is not None:
+            _LOGGER.info(err)
+        return 0
+    except (ConfigurationException, MarkedYAMLError) as err:
+        _LOGGER.error("Failed to load config. %s Exiting.", err)
+        return 1
+
+
 def main() -> int:
     """Start boneIO."""
 
@@ -113,6 +244,12 @@ def main() -> int:
             mqttpassword=args.mqttpassword,
             debug=debug,
         )
+    elif args.action == "modbus":
+        _LOGGER.info("BoneIO Modbus helper %s .", __version__)
+        exit_code = run_modbus_command(
+            args=args,
+        )
+
     _LOGGER.info("Exiting with exit code %s", exit_code)
     return exit_code
 

boneio/helper/filter.py

@@ -1,4 +1,5 @@
 """Filter class to adjust sensor values."""
+
 from __future__ import annotations
 import logging
 
@@ -22,7 +23,9 @@ class Filter:
         for filter in self._filters:
             for k, v in filter.items():
                 if k not in FILTERS:
-                    _LOGGER.warn("Filter %s doesn't exists. Fix it in config.", k)
+                    _LOGGER.warning(
+                        "Filter %s doesn't exists. Fix it in config.", k
+                    )
                     continue
                 value = FILTERS[k](value, v)
                 if value is None:

boneio/helper/loader.py

@@ -103,7 +103,9 @@ def create_adc(manager: Manager, topic_prefix: str, adc_list: list = []):
                 manager=manager,
                 send_message=manager.send_message,
                 topic_prefix=topic_prefix,
-                update_interval=gpio.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
+                update_interval=gpio.get(
+                    UPDATE_INTERVAL, TimePeriod(seconds=60)
+                ),
                 filters=gpio.get(FILTERS, []),
             )
             if gpio.get(SHOW_HA, True):
@@ -163,7 +165,10 @@ expander_class = {MCP: MCP23017, PCA: PCA9685, PCF: PCF8575}
 
 
 def create_expander(
-    expander_dict: dict, expander_config: list, exp_type: ExpanderTypes, i2cbusio: I2C
+    expander_dict: dict,
+    expander_config: list,
+    exp_type: ExpanderTypes,
+    i2cbusio: I2C,
 ) -> dict:
     grouped_outputs = {}
     for expander in expander_config:
@@ -189,7 +194,7 @@ def create_expander(
 
 def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> None:
     """Create Modbus sensor for each device."""
-    from boneio.sensor.modbus import ModbusSensor
+    from boneio.modbus.sensor import ModbusSensor
 
     for sensor in sensors:
         name = sensor.get(ID)
@@ -202,7 +207,9 @@ def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> None:
                 manager=manager,
                 model=sensor[MODEL],
                 send_message=manager.send_message,
-                update_interval=sensor.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
+                update_interval=sensor.get(
+                    UPDATE_INTERVAL, TimePeriod(seconds=60)
+                ),
                 **kwargs,
             )
         except FileNotFoundError as err:
@@ -272,7 +279,9 @@ def configure_relay(
         if restore_state
         else False
     )
-    if output_type == NONE and state_manager.get(attr_type=RELAY, attr=relay_id):
+    if output_type == NONE and state_manager.get(
+        attr_type=RELAY, attr=relay_id
+    ):
         state_manager.del_attribute(attr_type=RELAY, attribute=relay_id)
         restored_state = False
 
@@ -347,7 +356,7 @@ def configure_event_sensor(
     pin: str,
     press_callback: Callable,
     send_ha_autodiscovery: Callable,
-    input: GpioEventButtonOld | GpioEventButtonNew | None = None
+    input: GpioEventButtonOld | GpioEventButtonNew | None = None,
 ) -> GpioEventButtonOld | GpioEventButtonNew | None:
     """Configure input sensor or button."""
     try:
@@ -473,7 +482,9 @@ def configure_cover(
     return cover
 
 
-def configure_ds2482(i2cbusio: I2C, address: str = DS2482_ADDRESS) -> OneWireBus:
+def configure_ds2482(
+    i2cbusio: I2C, address: str = DS2482_ADDRESS
+) -> OneWireBus:
     ds2482 = DS2482(i2c=i2cbusio, address=address)
     ow_bus = OneWireBus(ds2482=ds2482)
     return ow_bus
@@ -493,7 +504,9 @@ def find_onewire_devices(
         devices = ow_bus.scan()
         for device in devices:
             _addr: int = device.int_address
-            _LOGGER.debug("Found device on bus %s with address %s", bus_id, hex(_addr))
+            _LOGGER.debug(
+                "Found device on bus %s with address %s", bus_id, hex(_addr)
+            )
             out[_addr] = device
     except RuntimeError as err:
         _LOGGER.error("Problem with scanning %s bus. %s", bus_type, err)

boneio/helper/mqtt.py

@@ -1,6 +1,8 @@
 """Class to help initialize classes which uses mqtt send."""
+
 from typing import Callable, Union
 from boneio.helper.util import strip_accents
+from typing import Optional
 
 
 class BasicMqtt:
@@ -11,7 +13,9 @@ class BasicMqtt:
         id: str,
         topic_prefix: str,
         name: str,
-        send_message: Callable[[str, Union[str, dict], bool], None],
+        send_message: Callable[
+            [str, Union[str, int, dict, None], Optional[bool]], None
+        ],
         topic_type: str,
         **kwargs,
     ):

boneio/helper/state_manager.py

@@ -1,4 +1,5 @@
 """State files manager."""
+
 from __future__ import annotations
 import asyncio
 import logging
@@ -38,16 +39,19 @@ class StateManager:
         if attr_type in self._state and attribute in self._state[attr_type]:
             del self._state[attr_type][attribute]
 
-    def save_attribute(self, attr_type: str, attribute: str, value: str) -> None:
+    def save_attribute(
+        self, attr_type: str, attribute: str, value: str
+    ) -> None:
         """Save single attribute to file."""
         if attr_type not in self._state:
             self._state[attr_type] = {}
         self._state[attr_type][attribute] = value
         if self._save_attributes_callback is not None:
-            print(self._save_attributes_callback)
             self._save_attributes_callback.cancel()
             self._save_attributes_callback = None
-        self._save_attributes_callback = self._loop.call_later(1, lambda: self._loop.create_task(self.save_state()))
+        self._save_attributes_callback = self._loop.call_later(
+            1, lambda: self._loop.create_task(self.save_state())
+        )
 
     def get(self, attr_type: str, attr: str, default_value: Any = None) -> Any:
         """Retrieve attribute from json."""
@@ -60,7 +64,7 @@ class StateManager:
     def state(self) -> dict:
         """Retrieve all states."""
         return self._state
-    
+
     def _save_state(self) -> None:
         with open(self._file, "w+", encoding="utf-8") as f:
             json.dump(self._state, f, indent=2)

boneio/helper/util.py

@@ -1,4 +1,6 @@
 import unicodedata
+import os
+import json
 from typing import Any, Callable, TypeVar
 
 CALLABLE_T = TypeVar("CALLABLE_T", bound=Callable[..., Any])
@@ -17,5 +19,17 @@ def is_callback(func: Callable[..., Any]) -> bool:
 
 
 def strip_accents(s):
-    return ''.join(c for c in unicodedata.normalize('NFD', s)
-                   if unicodedata.category(c) != 'Mn' and c != ' ')
+
+    return "".join(
+        c
+        for c in unicodedata.normalize("NFD", s)
+        if unicodedata.category(c) != "Mn" and c != " "
+    )
+
+
+def open_json(path: str, model: str) -> dict:
+    """Open json file."""
+    file = f"{os.path.join(path)}/{model}.json"
+    with open(file, "r") as db_file:
+        datastore = json.load(db_file)
+        return datastore

boneio/manager.py

@@ -74,7 +74,7 @@ from boneio.helper.loader import (
 )
 from boneio.helper.logger import configure_logger
 from boneio.helper.yaml_util import load_config_from_file
-from boneio.modbus import Modbus
+from boneio.modbus.client import Modbus
 
 from w1thermsensor.errors import KernelModuleLoadError
 

boneio/modbus/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .modbuscli import async_run_modbus_set
+
+__all__ = ["async_run_modbus_set"]

boneio/{modbus.py → modbus/client.py}

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import struct
 from typing import Any
 
 from pymodbus.client.sync import BaseModbusClient, ModbusSerialClient
@@ -27,6 +28,8 @@ VALUE_TYPES = {
     "U_QWORD": {"f": "decode_64bit_uint", "byteorder": Endian.Big},
     "S_QWORD": {"f": "decode_64bit_int", "byteorder": Endian.Big},
     "U_QWORD_R": {"f": "decode_64bit_uint", "byteorder": Endian.Little},
+    "FP32": {"f": "decode_32bit_float", "byteorder": Endian.Big},
+    "FP32_R": {"f": "decode_32bit_float", "byteorder": Endian.Little},
 }
 
 
@@ -73,6 +76,11 @@ class Modbus:
         except ModbusException as exception_error:
             _LOGGER.error(exception_error)
 
+    @property
+    def client(self) -> ModbusSerialClient | None:
+        """Return client."""
+        return self._client
+
     async def async_close(self) -> None:
         """Disconnect client."""
         async with self._lock:
@@ -94,7 +102,11 @@ class Modbus:
             return False
 
     async def read_single_register(
-        self, unit: int, address: int, count: int = 2, method: str = "input"
+        self,
+        unit: int | str,
+        address: int,
+        count: int = 2,
+        method: str = "input",
     ) -> float | None:
         """Call sync. pymodbus."""
         async with self._lock:
@@ -106,7 +118,7 @@ class Modbus:
                 result: ReadInputRegistersResponse = self._read_methods[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):
@@ -117,7 +129,11 @@ class Modbus:
             ).decode_32bit_float()
 
     async def read_multiple_registers(
-        self, unit: int, address: int, count: int = 2, method: str = "input"
+        self,
+        unit: int | str,  # device address
+        address: int,  # modbus register address
+        count: int = 2,  # number of registers to read
+        method: str = "input",  # type of register: input, holding
     ) -> ModbusResponse:
         """Call sync. pymodbus."""
         async with self._lock:

boneio/modbus/cwt.json

@@ -0,0 +1,34 @@
+{
+  "model": "CWT Temp and Humidity sensor",
+  "set_base": {
+    "set_address_address": 2000,
+    "set_baudrate_address": 2001
+  },
+  "registers_base": [
+    {
+      "base": 0,
+      "length": 2,
+      "register_type": "holding",
+      "registers": [
+        {
+          "name": "Humidity",
+          "address": 0,
+          "unit_of_measurement": "%",
+          "state_class": "measurement",
+          "device_class": "humidity",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        },
+        {
+          "name": "Temperature",
+          "address": 1,
+          "unit_of_measurement": "°C",
+          "state_class": "measurement",
+          "device_class": "temperature",
+          "value_type": "S_WORD",
+          "filters": [{ "multiply": 0.1 }]
+        }
+      ]
+    }
+  ]
+}

boneio/modbus/modbuscli.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+import logging
+import os
+from ..helper.util import open_json
+from boneio.const import UARTS, REGISTERS
+from .client import Modbus
+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"
+
+
+class ModbusHelper:
+    """Modbus Helper."""
+
+    baud_rates = [2400, 4800, 9600, 19200]
+
+    def __init__(
+        self,
+        device: str,
+        uart: str,
+        address: int,
+        baudrate: int,
+        model: dict,
+        check_record: dict,
+        check_record_method: str,
+    ) -> None:
+        """Initialize Modbus Helper."""
+        self._modbus = Modbus(
+            uart=UARTS[uart],
+            baudrate=baudrate,
+            stopbits=1,
+            bytesize=8,
+            parity="N",
+        )
+        self._model = model
+        self._device = device
+        self._device_address = address
+        self._check_record = check_record
+        self._check_record_method = check_record_method
+
+    async def check_connection(self) -> bool:
+        """Check Modbus connection."""
+        name = self._check_record.get("name")
+        address = self._check_record.get("address", 1)
+        value_type = self._check_record.get("value_type")
+        _LOGGER.info(
+            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(
+            unit=self._device_address,
+            address=address,
+            count=count,
+            method=self._check_record_method,
+        )
+        if not value:
+            _LOGGER.error("No returned value.")
+            return False
+        payload = value.registers[0:count]
+        decoded_value = self._modbus.decode_value(payload, value_type)
+        for filter in self._check_record.get("filters", []):
+            for key, value in filter.items():
+                if key in allowed_operations:
+                    lamda_function = allowed_operations[key]
+                    decoded_value = lamda_function(decoded_value, value)
+        _LOGGER.info(
+            f"Checked {name} with address {address} and value {decoded_value}"
+        )
+        if not decoded_value:
+            return False
+        return True
+
+    def set_connection_speed(self, new_baudrate: int):
+        ind = self.baud_rates.index(new_baudrate)
+        if ind:
+            result = self._modbus.client.write_register(
+                address=self._model[SET_BAUDRATE],
+                value=ind,
+                unit=self._device_address,
+            )
+        if result.isError():
+            _LOGGER.error("Operation failed.")
+        else:
+            _LOGGER.info(
+                "Operation succeeded. Now restart device by disconnecting it."
+            )
+
+    def set_new_address(self, new_address: int):
+        if 0 < new_address < 253:
+            result = self._modbus.client.write_register(
+                address=self._model[SET_ADDRESS],
+                value=new_address,
+                unit=self._device_address,
+            )
+            if result.isError():
+                _LOGGER.error("Operation failed.")
+            else:
+                _LOGGER.info(
+                    "Operation succeeded. Now restart device by disconnecting it."
+                )
+        else:
+            _LOGGER.error("Invalid new address.")
+
+
+async def async_run_modbus_set(
+    device: str,
+    uart: str,
+    address: int,
+    baudrate: int,
+    new_baudrate: int,
+    new_address: int,
+):
+    """Run Modbus Set Function."""
+    if new_address and new_baudrate:
+        _LOGGER.error("Can't set both methods new_address and new_baudrate.")
+    _db = open_json(path=os.path.dirname(__file__), model=device)
+    set_base = _db.get(SET_BASE, {})
+    first_reg_base = _db.get(REGISTERS_BASE, [])[0]
+    if not first_reg_base:
+        return False
+    first_record = first_reg_base.get(REGISTERS, [])[0]
+    modbus_helper = ModbusHelper(
+        device=device,
+        uart=uart,
+        address=address,
+        baudrate=baudrate,
+        model=set_base,
+        check_record=first_record,
+        check_record_method=first_reg_base.get("register_type", "input"),
+    )
+    if not await modbus_helper.check_connection():
+        _LOGGER.error("Can't connect with sensor. Exiting")
+        return 1
+    if new_baudrate:
+        modbus_helper.set_connection_speed(new_baudrate=new_baudrate)
+        return 0
+    if new_address:
+        modbus_helper.set_new_address(new_address=new_address)
+        return 0
+    return 1
+
+
+async def async_run_modbus_get(
+    uart: str,
+    device_address: int,
+    register_address: int,
+    register_type: str,
+    baudrate: int,
+    value_type: str,
+):
+    """Run Modbus Get Function."""
+    _modbus = Modbus(
+        uart=UARTS[uart],
+        baudrate=baudrate,
+        stopbits=1,
+        bytesize=8,
+        parity="N",
+    )
+    count = 1 if value_type == "S_WORD" or value_type == "U_WORD" else 2
+    value = await _modbus.read_multiple_registers(
+        unit=device_address,
+        address=register_address,
+        count=count,
+        method=register_type,
+    )
+    if value:
+        payload = value.registers[0:count]
+        decoded_value = _modbus.decode_value(payload, value_type)
+        _LOGGER.info("Value: %s", decoded_value)
+        return 0
+    _LOGGER.error("No returned value.")
+    return 1

boneio/modbus/orno-or-we-517.json

@@ -0,0 +1,20 @@
+{
+    "model": "orno-or-we-517",
+    "registers_base": [
+        {
+            "base": 14,
+            "length": 4,
+	    "register_type": "holding",
+	    "registers": [
+                {
+                    "name": "Napiecie_L1",
+                    "address": 14,
+                    "unit_of_measurement": "V",
+                    "state_class": "measurement",
+                    "device_class": "voltage",
+                    "return_type": "float32"
+                }
+            ]
+        }
+    ]
+}

boneio/{sensor/modbus/__init__.py → modbus/sensor.py}

@@ -1,11 +1,10 @@
 from __future__ import annotations
 import asyncio
-import json
 import logging
 import os
 from datetime import datetime
-from struct import unpack
-
+from typing import Optional
+from .utils import CONVERT_METHODS, REGISTERS_BASE, allowed_operations
 from boneio.const import (
     ADDRESS,
     BASE,
@@ -21,88 +20,11 @@ from boneio.helper import BasicMqtt, AsyncUpdater
 from boneio.helper.config import ConfigHelper
 from boneio.helper.events import EventBus
 from boneio.helper.ha_discovery import modbus_sensor_availabilty_message
-from boneio.modbus import Modbus
+from .client import Modbus
+from boneio.helper.util import open_json
 
 _LOGGER = logging.getLogger(__name__)
 
-allowed_operations = {"multiply": lambda x, y: x * y}
-
-
-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]
-
-
-def floatsofar(result, base, addr):
-    """Read Float value from register."""
-    low = result.getRegister(addr - base)
-    high = result.getRegister(addr - base + 1)
-    return high + low
-
-
-def multiply0_1(result, base, addr):
-    low = result.getRegister(addr - base)
-    return round(low * 0.1, 4)
-
-
-def multiply0_01(result, base, addr):
-    low = result.getRegister(addr - base)
-    return round(low * 0.01, 4)
-
-
-def multiply0_001(result, base, addr):
-    low = result.getRegister(addr - base)
-    return round(low * 0.001, 4)
-
-
-def multiply10(result, base, addr):
-    low = result.getRegister(addr - base)
-    return round(low * 10, 4)
-
-
-def multiply100(result, base, addr):
-    low = result.getRegister(addr - base)
-    return round(low * 100, 4)
-
-
-def multiply1000(result, base, addr):
-    low = result.getRegister(addr - base)
-    return round(low * 1000, 4)
-
-
-def regular_result(result, base, addr):
-    return result.getRegister(addr - base)
-
-
-CONVERT_METHODS = {
-    "float32": float32,
-    "multiply0_1": multiply0_1,
-    "multiply0_01": multiply0_01,
-    "multiply0_001": multiply0_001,
-    "floatsofar": floatsofar,
-    "multiply10": multiply10,
-    "multiply100": multiply100,
-    "multiply1000": multiply1000,
-    "regular": regular_result,
-}
-REGISTERS_BASE = "registers_base"
-
-
-def open_json(model: str) -> dict:
-    """Open json file."""
-    file = f"{os.path.join(os.path.dirname(__file__))}/{model}.json"
-    with open(file, "r") as db_file:
-        datastore = json.load(db_file)
-        return datastore
-
 
 class ModbusSensor(BasicMqtt, AsyncUpdater):
     """Represent Modbus sensor in BoneIO."""
@@ -129,7 +51,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
         )
         self._config_helper = config_helper
         self._modbus = modbus
-        self._db = open_json(model=model)
+        self._db = open_json(path=os.path.dirname(__file__), model=model)
         self._model = self._db[MODEL]
         self._address = address
         self._discovery_sent = False
@@ -164,7 +86,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
         )
         self._send_message(topic=topic, payload=payload)
 
-    def _send_discovery_for_all_registers(self, register: int = 0) -> datetime:
+    def _send_discovery_for_all_registers(self) -> datetime:
         """Send discovery message to HA for each register."""
         for data in self._db[REGISTERS_BASE]:
             for register in data[REGISTERS]:
@@ -207,7 +129,7 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
                 )
                 if register is not None:
                     self._discovery_sent = (
-                        self._send_discovery_for_all_registers(register)
+                        self._send_discovery_for_all_registers()
                     )
                     await asyncio.sleep(2)
                     break
@@ -243,10 +165,10 @@ class ModbusSensor(BasicMqtt, AsyncUpdater):
                     # Let's assume device is offline.
                     self.set_payload_offline()
                     self._send_message(
-                        topic=f"{self._config_helper.topic_prefix}/{self._id}{STATE}",
+                        topic=f"{self._config_helper.topic_prefix}/{self._id}aa",
                         payload=self._payload_online,
                     )
-                _LOGGER.warn(
+                _LOGGER.warning(
                     "Can't fetch data from modbus device %s. Will sleep for %s seconds",
                     self.id,
                     update_interval,

boneio/{sensor/modbus → modbus}/socomec_e23.json

@@ -83,18 +83,19 @@
         {
           "name": "Total_Positive_Active_Energy",
           "address": 50946,
-          "unit_of_measurement": "Wh",
-          "state_class": "total_increasing",
+          "unit_of_measurement": "kWh",
+          "value_type": "U_DWORD",
+          "state_class": "total",
           "device_class": "energy",
-          "return_type": "multiply0_01"
+          "filters": [{ "multiply": 0.01 }]
         },
         {
           "name": "Total_Negative_Active_Energy",
           "address": 50952,
-          "unit_of_measurement": "Wh",
-          "state_class": "total_increasing",
+          "unit_of_measurement": "kWh",
+          "state_class": "total",
           "device_class": "energy",
-          "return_type": "multiply0_01"
+          "filters": [{ "multiply": 0.01 }]
         }
       ]
     }

boneio/modbus/utils.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from struct import unpack
+
+
+allowed_operations = {"multiply": lambda x, y: x * y}
+
+
+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]
+
+
+def floatsofar(result, base, addr):
+    """Read Float value from register."""
+    low = result.getRegister(addr - base)
+    high = result.getRegister(addr - base + 1)
+    return high + low
+
+
+def multiply0_1(result, base, addr):
+    low = result.getRegister(addr - base)
+    return round(low * 0.1, 4)
+
+
+def multiply0_01(result, base, addr):
+    low = result.getRegister(addr - base)
+    return round(low * 0.01, 4)
+
+
+def multiply0_001(result, base, addr):
+    low = result.getRegister(addr - base)
+    return round(low * 0.001, 4)
+
+
+def multiply10(result, base, addr):
+    low = result.getRegister(addr - base)
+    return round(low * 10, 4)
+
+
+def multiply100(result, base, addr):
+    low = result.getRegister(addr - base)
+    return round(low * 100, 4)
+
+
+def multiply1000(result, base, addr):
+    low = result.getRegister(addr - base)
+    return round(low * 1000, 4)
+
+
+def regular_result(result, base, addr):
+    return result.getRegister(addr - base)
+
+
+CONVERT_METHODS = {
+    "float32": float32,
+    "multiply0_1": multiply0_1,
+    "multiply0_01": multiply0_01,
+    "multiply0_001": multiply0_001,
+    "floatsofar": floatsofar,
+    "multiply10": multiply10,
+    "multiply100": multiply100,
+    "multiply1000": multiply1000,
+    "regular": regular_result,
+}
+REGISTERS_BASE = "registers_base"

boneio/schema/schema.yaml

@@ -154,7 +154,8 @@ modbus_sensors:
       model:
         type: string
         required: True
-        allowed: ['sdm630', 'sdm120', 'sofar']
+        allowed:
+          ['sdm630', 'sdm120', 'sofar', 'socomec_e23', 'cwt', 'orno-or-we-517']
         meta:
           label: Model to load from database.
       update_interval:

boneio/version.py

@@ -1,2 +1,2 @@
 # flake8: noqa
-__version__ = "0.7.2dev4"
+__version__ = "0.8.0dev2"