boneIO 0.8.0.dev11__tar.gz → 0.8.0.dev12__tar.gz

{boneIO-0.8.0.dev11 → boneIO-0.8.0.dev12}/PKG-INFO

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

{boneIO-0.8.0.dev11 → boneIO-0.8.0.dev12}/boneio/const.py

@@ -213,3 +213,4 @@ PINS = {
     "P9_27": {"chip": 3, "line": 19},
     "P9_25": {"chip": 3, "line": 21},
 }
+NAME = "name"

boneIO-0.8.0.dev12/boneio/helper/gpiod.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+import asyncio
+import logging
+from boneio.const import PINS
+import gpiod
+from gpiod.line import Direction, Bias, Edge, Value
+from gpiod.line_settings import LineSettings
+from datetime import timedelta
+_LOGGER = logging.getLogger(__name__)
+
+
+
+def _get_device(pin: str):
+    pin = PINS.get(pin, "P9_22")
+    return f"/dev/gpiochip{pin["chip"]}"
+
+def _configure_line(device, port, **kwargs):
+    return gpiod.request_lines(
+        device, 
+        consumer="gpio", 
+        config={port: LineSettings(**kwargs)})
+
+def setup_input(device, line, pull_mode):
+    """Set up a GPIO as input."""
+    _LOGGER.debug("Requesting input %s:%s", device, line)
+    return _configure_line(
+        device,
+        line, 
+        direction=Direction.INPUT,
+        bias=(Bias.PULL_UP if pull_mode == "gpio_pu" else Bias.PULL_DOWN))
+
+def enable_edge_detect(req, detect_edges, debounce_ms):
+    """Add detection for RISING and FALLING events."""
+    _LOGGER.debug("Detecting %s edges on %s:%s", detect_edges, req.chip_name, req.lines)
+    req.reconfigure_lines(
+        {port: LineSettings(edge_detection=getattr(Edge, detect_edges),
+                            debounce_period=timedelta(milliseconds=debounce_ms))
+         for port in req.lines})
+
+class GpioD:
+
+    def __init__(self, pin: str, pull_mode: str = "gpio"):
+        self._pin = pin
+        self._gpiod_pin = PINS.get(pin, {"chip": 0, "line": 2})
+        self._chip = self._gpiod_pin["chip"]
+        self._line = self._gpiod_pin["line"]
+        self._device = _get_device(self._pin)
+        self._line = setup_input(self._device, self._line, pull_mode)
+
+    def edge_detect(self, callback, bounce=0, edge=Edge.RISING):
+        enable_edge_detect(self._line, edge=Edge.BOTH, debounce_ms=bounce)
+
+    
+
+    
+

{boneIO-0.8.0.dev11 → boneIO-0.8.0.dev12}/boneio/helper/loader.py

@@ -193,15 +193,16 @@ def create_expander(
     return grouped_outputs
 
 
-def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> None:
+def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> dict:
     """Create Modbus sensor for each device."""
     from boneio.modbus.sensor import ModbusSensor
 
+    modbus_sensors = {}
     for sensor in sensors:
         name = sensor.get(ID)
         id = name.replace(" ", "")
         try:
-            ModbusSensor(
+            modbus_sensors[id.lower()] = ModbusSensor(
                 address=sensor[ADDRESS],
                 id=id,
                 name=name,
@@ -221,6 +222,7 @@ def create_modbus_sensors(manager: Manager, sensors, **kwargs) -> None:
                 err,
             )
             pass
+    return modbus_sensors
 
 
 OutputEntry = namedtuple("OutputEntry", "OutputClass output_kind expander_id")

{boneIO-0.8.0.dev11 → boneIO-0.8.0.dev12}/boneio/helper/mqtt.py

@@ -1,8 +1,10 @@
 """Class to help initialize classes which uses mqtt send."""
 
-from typing import Callable, Union
+from __future__ import annotations
+
+
+from typing import Callable, Union, Optional
 from boneio.helper.util import strip_accents
-from typing import Optional
 
 
 class BasicMqtt:

{boneIO-0.8.0.dev11 → boneIO-0.8.0.dev12}/boneio/helper/stats.py

@@ -161,6 +161,7 @@ class HostData:
         ina219: INA219Class | None,
         manager: Manager,
         enabled_screens: List[str],
+        extra_sensors: List[dict],
     ) -> None:
         """Initialize HostData."""
         self._hostname = socket.gethostname()
@@ -244,6 +245,38 @@ class HostData:
                 "f": get_ina_values,
                 "update_interval": TimePeriod(seconds=60),
             }
+        if extra_sensors:
+
+            def get_extra_sensors_values():
+                output = {}
+                for sensor in extra_sensors[:3]:
+                    sensor_type = sensor.get("sensor_type")
+                    sensor_id = sensor.get("sensor_id")
+                    if sensor_type == "modbus":
+                        modbus_id = sensor.get("modbus_id")
+                        _modbus_sensors = manager.modbus_sensors.get(modbus_id)
+                        if _modbus_sensors:
+                            single_sensor = _modbus_sensors.get_sensor_by_name(
+                                sensor_id
+                            )
+                            short_name = "".join(
+                                [x[:3] for x in single_sensor.name.split()]
+                            )
+                            output[short_name] = (
+                                f"{round(single_sensor.state, 2)} {single_sensor.unit_of_measurement}"
+                            )
+                    elif sensor_type == "dallas":
+                        for single_sensor in manager.temp_sensors:
+                            if sensor_id == single_sensor.id:
+                                output[single_sensor.name] = (
+                                    f"{round(single_sensor.state, 2)} C"
+                                )
+                return output
+
+            host_stats["extra_sensors"] = {
+                "f": get_extra_sensors_values,
+                "update_interval": TimePeriod(seconds=60),
+            }
         self._data = {}
         for k, _v in host_stats.items():
             if k not in enabled_screens:

{boneIO-0.8.0.dev11 → boneIO-0.8.0.dev12}/boneio/helper/yaml_util.py

@@ -41,20 +41,28 @@ class BoneIOLoader(SafeLoader):
     def construct_secret(self, node):
         secrets = load_yaml_file(self._rel_path(SECRET_YAML))
         if node.value not in secrets:
-            raise MarkedYAMLError(f"Secret '{node.value}' not defined", node.start_mark)
+            raise MarkedYAMLError(
+                f"Secret '{node.value}' not defined", node.start_mark
+            )
         val = secrets[node.value]
         _SECRET_VALUES[str(val)] = node.value
         return val
 
     def represent_stringify(self, value):
-        return self.represent_scalar(tag="tag:yaml.org,2002:str", value=str(value))
+        return self.represent_scalar(
+            tag="tag:yaml.org,2002:str", value=str(value)
+        )
 
     def construct_include_dir_list(self, node):
-        files = filter_yaml_files(_find_files(self._rel_path(node.value), "*.yaml"))
+        files = filter_yaml_files(
+            _find_files(self._rel_path(node.value), "*.yaml")
+        )
         return [load_yaml_file(f) for f in files]
 
     def construct_include_dir_merge_list(self, node):
-        files = filter_yaml_files(_find_files(self._rel_path(node.value), "*.yaml"))
+        files = filter_yaml_files(
+            _find_files(self._rel_path(node.value), "*.yaml")
+        )
         merged_list = []
         for fname in files:
             loaded_yaml = load_yaml_file(fname)
@@ -63,7 +71,9 @@ class BoneIOLoader(SafeLoader):
         return merged_list
 
     def construct_include_dir_named(self, node):
-        files = filter_yaml_files(_find_files(self._rel_path(node.value), "*.yaml"))
+        files = filter_yaml_files(
+            _find_files(self._rel_path(node.value), "*.yaml")
+        )
         mapping = OrderedDict()
         for fname in files:
             filename = os.path.splitext(os.path.basename(fname))[0]
@@ -71,7 +81,9 @@ class BoneIOLoader(SafeLoader):
         return mapping
 
     def construct_include_dir_merge_named(self, node):
-        files = filter_yaml_files(_find_files(self._rel_path(node.value), "*.yaml"))
+        files = filter_yaml_files(
+            _find_files(self._rel_path(node.value), "*.yaml")
+        )
         mapping = OrderedDict()
         for fname in files:
             loaded_yaml = load_yaml_file(fname)
@@ -103,7 +115,9 @@ BoneIOLoader.add_constructor(
 BoneIOLoader.add_constructor(
     "!include_dir_merge_named", BoneIOLoader.construct_include_dir_merge_named
 )
-BoneIOLoader.add_constructor("!include_files", BoneIOLoader.construct_include_files)
+BoneIOLoader.add_constructor(
+    "!include_files", BoneIOLoader.construct_include_files
+)
 
 
 def filter_yaml_files(files):
@@ -240,6 +254,9 @@ class CustomValidator(Validator):
     def _normalize_coerce_lower(self, value):
         return str(value).lower()
 
+    def _normalize_coerce_remove_space(self, value):
+        return str(value).replace(" ", "")
+
     def _normalize_coerce_upper(self, value):
         return str(value).upper()
 
@@ -273,7 +290,9 @@ class CustomValidator(Validator):
         if isinstance(value, TimePeriod):
             value = str(value)
         if not isinstance(value, str):
-            raise ConfigurationException("Expected string for time period with unit.")
+            raise ConfigurationException(
+                "Expected string for time period with unit."
+            )
 
         unit_to_kwarg = {
             "us": "microseconds",
@@ -295,12 +314,16 @@ class CustomValidator(Validator):
 
         match = re.match(r"^([-+]?[0-9]*\.?[0-9]*)\s*(\w*)$", value)
         if match is None:
-            raise ConfigurationException(f"Expected time period with unit, got {value}")
+            raise ConfigurationException(
+                f"Expected time period with unit, got {value}"
+            )
         kwarg = unit_to_kwarg[one_of(*unit_to_kwarg)(match.group(2))]
         return TimePeriod(**{kwarg: float(match.group(1))})
 
     def _normalize_coerce_check_action_def(self, value):
-        parent = self.root_document[self.document_path[0]][self.document_path[1]]
+        parent = self.root_document[self.document_path[0]][
+            self.document_path[1]
+        ]
         _schema = self.schema["actions"]
         keys = value.keys()
         out = {}

{boneIO-0.8.0.dev11 → boneIO-0.8.0.dev12}/boneio/manager.py

@@ -140,13 +140,14 @@ class Manager:
         self._covers = {}
         self._temp_sensors = []
         self._ina219_sensors = []
+        self._modbus_sensors = {}
         self._modbus = None
 
         self._configure_modbus(modbus=modbus)
 
         self._configure_temp_sensors(sensors=sensors)
 
-        self._configure_modbus_sensors(sensors=sensors)
+        self._modbus_sensors = self._configure_modbus_sensors(sensors=sensors)
         self._configure_ina219_sensors(sensors=sensors)
         self._configure_sensors(
             dallas=dallas, ds2482=ds2482, sensors=sensors.get(ONEWIRE)
@@ -261,6 +262,7 @@ class Manager:
             from boneio.oled import Oled
 
             screens = oled.get("screens", [])
+            extra_sensors = oled.get("extra_screen_sensors", [])
 
             self._host_data = HostData(
                 manager=self,
@@ -272,6 +274,7 @@ class Manager:
                 ina219=(
                     self._ina219_sensors[0] if self._ina219_sensors else None
                 ),
+                extra_sensors=extra_sensors,
                 callback=self._host_data_callback,
             )
             try:
@@ -291,6 +294,14 @@ class Manager:
     def mqtt_state(self) -> bool:
         return self._mqtt_state()
 
+    @property
+    def modbus_sensors(self) -> dict:
+        return self._modbus_sensors
+
+    @property
+    def temp_sensors(self) -> list:
+        return self._temp_sensors
+
     def _configure_output_group(self):
         def get_outputs(output_list):
             outputs = []
@@ -547,17 +558,18 @@ class Manager:
                 if ina219:
                     self._ina219_sensors.append(ina219)
 
-    def _configure_modbus_sensors(self, sensors: dict) -> None:
+    def _configure_modbus_sensors(self, sensors: dict) -> dict:
         if sensors.get(MODBUS) and self._modbus:
             from boneio.helper.loader import create_modbus_sensors
 
-            create_modbus_sensors(
+            return create_modbus_sensors(
                 manager=self,
                 event_bus=self._event_bus,
                 sensors=sensors.get(MODBUS),
                 modbus=self._modbus,
                 config_helper=self._config_helper,
             )
+        return {}
 
     async def reconnect_callback(self) -> None:
         """Function to invoke when connection to MQTT is (re-)established."""