boneIO 0.8.0.dev1__tar.gz → 0.8.0.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boneIO
-Version: 0.8.0.dev1
+Version: 0.8.0.dev3
 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/bonecli.py

@@ -0,0 +1,289 @@
+"""Bonecli script."""
+
+from __future__ import annotations
+
+import os
+
+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.events import GracefulExit
+from boneio.helper.logger import configure_logger
+from boneio.runner import async_run
+from boneio.version import __version__
+
+TASK_CANCELATION_TIMEOUT = 1
+
+_LOGGER = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+fmt = "%(asctime)s %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+datefmt = "%Y-%m-%d %H:%M:%S"
+colorfmt = f"%(log_color)s{fmt}%(reset)s"
+logging.getLogger().handlers[0].setFormatter(
+    ColoredFormatter(
+        colorfmt,
+        datefmt=datefmt,
+        reset=True,
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "green",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red",
+        },
+    )
+)
+
+
+def get_arguments() -> argparse.Namespace:
+    """Get parsed passed in arguments."""
+
+    parser = argparse.ArgumentParser(
+        description="boneIO app for BeagleBone Black.",
+    )
+    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",
+    )
+    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_parser.add_argument(
+        "--bytesize",
+        type=int,
+        required=True,
+        default=8,
+        help="Bytesize",
+    )
+
+    modbus_parser.add_argument(
+        "--stopbits",
+        type=int,
+        required=True,
+        default=1,
+        help="stopbits",
+    )
+
+    modbus_parser.add_argument(
+        "--parity",
+        type=str,
+        choices=["P", "E", "N"],
+        default="N",
+        required=True,
+        help="Parity",
+    )
+
+    modbus_sub_parser = modbus_parser.add_subparsers(
+        dest="modbus_action", required=True
+    )
+    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,
+    )
+    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:
+    """Run BoneIO."""
+    _LOGGER.info("BoneIO %s starting.", __version__)
+    try:
+        _config = load_config_from_file(config_file=config)
+        if not _config:
+            _LOGGER.error("Config not loaded. Exiting.")
+            return 1
+        configure_logger(log_config=_config.get("logger"), debug=debug)
+        asyncio.run(
+            async_run(
+                config=_config,
+                config_file=config,
+                mqttusername=mqttusername,
+                mqttpassword=mqttpassword,
+            ),
+        )
+        return 0
+    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 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,
+                    parity=args.parity,
+                    bytesize=args.bytesize,
+                    stopbits=args.stopbits,
+                    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,
+                    parity=args.parity,
+                    bytesize=args.bytesize,
+                    stopbits=args.stopbits,
+                    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."""
+
+    args = get_arguments()
+    debug = args.debug
+
+    exit_code = 0
+    if args.action == "run":
+        exit_code = run(
+            config=args.config,
+            mqttusername=args.mqttusername,
+            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
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -56,7 +56,11 @@ UARTS = {
     "uart5": {ID: "/dev/ttyS5", TX: "P8.37", RX: "P8.38"},
 }
 
-relay_actions = {ON: "async_turn_on", OFF: "async_turn_off", TOGGLE: "async_toggle"}
+relay_actions = {
+    ON: "async_turn_on",
+    OFF: "async_turn_off",
+    TOGGLE: "async_toggle",
+}
 
 # HA CONSTS
 HOMEASSISTANT = "homeassistant"
@@ -67,7 +71,8 @@ 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
@@ -160,3 +165,52 @@ cover_actions = {
 }
 
 INA219 = "ina219"
+PINS = {
+    "P9_22": {"chip": 0, "line": 2},
+    "P9_21": {"chip": 0, "line": 3},
+    "P9_18": {"chip": 0, "line": 4},
+    "P9_17": {"chip": 0, "line": 5},
+    "P8_35": {"chip": 0, "line": 8},
+    "P8_33": {"chip": 0, "line": 9},
+    "P8_31": {"chip": 0, "line": 10},
+    "P8_32": {"chip": 0, "line": 11},
+    "P8_19": {"chip": 0, "line": 22},
+    "P8_13": {"chip": 0, "line": 23},
+    "P8_14": {"chip": 0, "line": 26},
+    "P8_17": {"chip": 0, "line": 27},
+    "P8_12": {"chip": 1, "line": 12},
+    "P8_11": {"chip": 1, "line": 13},
+    "P8_16": {"chip": 1, "line": 14},
+    "P8_15": {"chip": 1, "line": 15},
+    "P9_23": {"chip": 1, "line": 17},
+    "P9_14": {"chip": 1, "line": 18},
+    "P9_16": {"chip": 1, "line": 19},
+    "P8_26": {"chip": 1, "line": 29},
+    "P8_18": {"chip": 2, "line": 1},
+    "P8_7": {"chip": 2, "line": 2},
+    "P8_8": {"chip": 2, "line": 3},
+    "P8_10": {"chip": 2, "line": 4},
+    "P8_9": {"chip": 2, "line": 5},
+    "P8_45": {"chip": 2, "line": 6},
+    "P8_46": {"chip": 2, "line": 7},
+    "P8_43": {"chip": 2, "line": 8},
+    "P8_44": {"chip": 2, "line": 9},
+    "P8_41": {"chip": 2, "line": 10},
+    "P8_42": {"chip": 2, "line": 11},
+    "P8_39": {"chip": 2, "line": 12},
+    "P8_40": {"chip": 2, "line": 13},
+    "P8_37": {"chip": 2, "line": 14},
+    "P8_38": {"chip": 2, "line": 15},
+    "P8_36": {"chip": 2, "line": 16},
+    "P8_34": {"chip": 2, "line": 17},
+    "P8_27": {"chip": 2, "line": 22},
+    "P8_29": {"chip": 2, "line": 23},
+    "P8_28": {"chip": 2, "line": 24},
+    "P8_30": {"chip": 2, "line": 25},
+    "P9_31": {"chip": 3, "line": 14},
+    "P9_29": {"chip": 3, "line": 15},
+    "P9_30": {"chip": 3, "line": 16},
+    "P9_28": {"chip": 3, "line": 17},
+    "P9_27": {"chip": 3, "line": 19},
+    "P9_25": {"chip": 3, "line": 21},
+}

{boneIO-0.8.0.dev1 → boneIO-0.8.0.dev3}/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-0.8.0.dev1 → boneIO-0.8.0.dev3}/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-0.8.0.dev1 → boneIO-0.8.0.dev3}/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-0.8.0.dev1 → boneIO-0.8.0.dev3}/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-0.8.0.dev1 → boneIO-0.8.0.dev3}/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