boneIO 0.8.2__tar.gz → 0.8.3__tar.gz

{boneIO-0.8.2 → boneIO-0.8.3}/PKG-INFO

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

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/helper/gpio.py

@@ -141,6 +141,7 @@ class GpioBaseClass:
         self._actions = actions
         self._input_type = input_type
         self._empty_message_after = empty_message_after
+        self._pressed_state = ""
 
     def press_callback(
         self, click_type: ClickTypes, duration: float | None = None
@@ -174,6 +175,11 @@ class GpioBaseClass:
         """Is button pressed."""
         return read_input(self._pin)
 
+    @property
+    def pressed_state(self) -> str:
+        """Pressed state for"""
+        return self._pressed_state
+
     @property
     def name(self) -> str:
         """Name of the GPIO visible in HA/MQTT."""

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/helper/loader.py

@@ -372,8 +372,8 @@ def configure_event_sensor(
         name = gpio.pop(ID, pin)
         if input:
             if not isinstance(input, GpioEventButtonClass):
-                _LOGGER.warn(
-                    "You preconfigured type of input. It's forbidden. Please restart boneIO."
+                _LOGGER.warning(
+                    "You reconfigured type of input. It's forbidden. Please restart boneIO."
                 )
                 return input
             input.set_actions(actions=gpio.get(ACTIONS, {}))

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/helper/stats.py

@@ -30,6 +30,8 @@ from boneio.const import (
 # Typing imports that create a circular dependency
 from typing import TYPE_CHECKING
 
+from boneio.helper.gpio import GpioBaseClass
+
 if TYPE_CHECKING:
     from boneio.manager import Manager
 
@@ -158,6 +160,7 @@ class HostData:
     def __init__(
         self,
         output: dict,
+        inputs: dict[str, GpioBaseClass],
         callback: Callable,
         temp_sensor: Callable[[LM75Sensor, MCP9808Sensor], None] | None,
         ina219: INA219Class | None,
@@ -298,6 +301,12 @@ class HostData:
                 update_interval=_v["update_interval"],
             )
         self._output = output
+        self._inputs = {
+            f"Inputs screen {i + 1}": list(inputs.values())[
+                i * 25 : (i + 1) * 25
+            ]
+            for i in range((len(inputs) + 24) // 25)
+        }
         self._callback = callback
         self._loop = asyncio.get_running_loop()
 
@@ -305,6 +314,8 @@ class HostData:
         """Get saved stats."""
         if type in self._output:
             return self._get_output(type)
+        if type in self._inputs:
+            return self._get_input(type)
         return self._data[type].state
 
     def _get_output(self, type: str) -> dict:
@@ -313,3 +324,16 @@ class HostData:
         for output in self._output[type].values():
             out[output.id] = output.state
         return out
+
+    def _get_input(self, type: str) -> dict:
+        """Get stats for input."""
+        inputs = {}
+        for input in self._inputs[type]:
+            inputs[input.name] = (
+                input.pressed_state[0].upper() if input.pressed_state else ""
+            )
+        return inputs
+
+    @property
+    def inputs_length(self) -> int:
+        return len(self._inputs)

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/input/gpio_new.py

@@ -1,11 +1,13 @@
 """GpioEventButtonNew to receive signals."""
+
 from __future__ import annotations
 import time
 import logging
-from boneio.const import DOUBLE, LONG, SINGLE, BOTH
+from boneio.const import DOUBLE, LONG, SINGLE, BOTH, PRESSED, RELEASED
 from boneio.helper import GpioBaseClass, ClickTimer
 from boneio.helper.gpio import edge_detect
 from boneio.helper.timeperiod import TimePeriod
+
 _LOGGER = logging.getLogger(__name__)
 
 # TIMINGS FOR BUTTONS
@@ -20,6 +22,7 @@ class GpioEventButtonNew(GpioBaseClass):
         """Setup GPIO Input Button"""
         super().__init__(**kwargs)
         self._state = self.is_pressed
+        self._pressed_state = PRESSED if self._state else RELEASED
         self.button_pressed_time = 0.0
         self.last_click_time = 0.0
         self._double_test = None
@@ -35,7 +38,9 @@ class GpioEventButtonNew(GpioBaseClass):
         )
         self._double_click_ran = False
         self._long_press_ran = False
-        edge_detect(pin=self._pin, callback=self.check_state, bounce=0, edge=BOTH)
+        edge_detect(
+            pin=self._pin, callback=self.check_state, bounce=0, edge=BOTH
+        )
         _LOGGER.debug("Configured NEW listening for input pin %s", self._pin)
 
     def single_click_callback(self):
@@ -55,6 +60,7 @@ class GpioEventButtonNew(GpioBaseClass):
         time_now = time.time()
         self._state = self.is_pressed
         if self._state:
+            self._pressed_state = PRESSED
             if time_now - self.button_pressed_time >= self._bounce_time:
                 self.button_pressed_time = time_now
                 self._timer_long.start_timer()
@@ -66,9 +72,12 @@ class GpioEventButtonNew(GpioBaseClass):
                 self._timer_double.start_timer()
 
         else:
-            if not self._timer_double.is_waiting() and not self._double_click_ran:
+            self._pressed_state = RELEASED
+            if (
+                not self._timer_double.is_waiting()
+                and not self._double_click_ran
+            ):
                 if self._timer_long.is_waiting():
                     self.press_callback(click_type=SINGLE, duration=None)
             self._timer_long.reset()
             self._double_click_ran = False
-

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/manager.py

@@ -142,6 +142,7 @@ class Manager:
         self._ina219_sensors = []
         self._modbus_sensors = {}
         self._modbus = None
+        self._screens = []
 
         self._configure_modbus(modbus=modbus)
 
@@ -261,13 +262,14 @@ class Manager:
         if oled.get("enabled", False):
             from boneio.oled import Oled
 
-            screens = oled.get("screens", [])
+            self._screens = oled.get("screens", [])
             extra_sensors = oled.get("extra_screen_sensors", [])
 
             self._host_data = HostData(
                 manager=self,
-                enabled_screens=screens,
+                enabled_screens=self._screens,
                 output=self.grouped_outputs,
+                inputs=self._inputs,
                 temp_sensor=(
                     self._temp_sensors[0] if self._temp_sensors else None
                 ),
@@ -280,7 +282,7 @@ class Manager:
             try:
                 self._oled = Oled(
                     host_data=self._host_data,
-                    screen_order=screens,
+                    screen_order=self._screens,
                     output_groups=list(self.grouped_outputs),
                     sleep_timeout=oled.get("screensaver_timeout", 60),
                 )
@@ -387,7 +389,7 @@ class Manager:
                 pin=pin,
                 press_callback=self.press_callback,
                 send_ha_autodiscovery=self.send_ha_autodiscovery,
-                input=self._inputs.get(pin, None),
+                input=self._inputs.get(pin, None),  # for reload actions.
             )
             if input:
                 self._inputs[input.pin] = input
@@ -728,6 +730,11 @@ class Manager:
             self._loop.call_soon_threadsafe(
                 self._loop.call_later, 0.2, self.send_message, topic, ""
             )
+        if (
+            "Inputs screen 1" in self._screens
+            or "Inputs screen 2" in self._screens
+        ):
+            self._host_data_callback(type="inputs")
 
     def send_ha_autodiscovery(
         self,

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/oled.py

@@ -35,7 +35,9 @@ fonts = {
 START_ROW = 17
 UPTIME_ROWS = list(range(22, 60, 10))
 OUTPUT_ROWS = list(range(14, 60, 6))
+INPUT_ROWS = list(range(12, 60, 6))
 OUTPUT_COLS = range(0, 113, 56)
+INPUT_COLS = range(0, 113, 30)
 
 
 def shorten_name(name: str) -> str:
@@ -57,15 +59,47 @@ class Oled:
         """Initialize OLED screen."""
         self._loop = asyncio.get_running_loop()
         self._output_groups = None
+        self._input_groups = []
+        self._host_data = host_data
+
+        def configure_outputs() -> None:
+            try:
+                _ind_screen = screen_order.index("outputs")
+                if not output_groups:
+                    _LOGGER.debug("No outputs configured. Omitting in screen.")
+                    return
+                screen_order.pop(_ind_screen)
+                screen_order[_ind_screen:_ind_screen] = output_groups
+                self._output_groups = output_groups
+            except ValueError:
+                pass
+
+        def configure_inputs() -> None:
+            try:
+                _inputs_screen = screen_order.index("inputs")
+                input_groups = [
+                    f"Inputs screen {i + 1}"
+                    for i in range(
+                        0, self._host_data.inputs_length, 1
+                    )  # self._host_data.inputs_length
+                ]
+                if not _inputs_screen:
+                    _LOGGER.debug("No inputs configured. Omitting in screen.")
+                    return
+                screen_order.pop(_inputs_screen)
+                screen_order[_inputs_screen:_inputs_screen] = input_groups
+                self._input_groups = input_groups
+            except ValueError:
+                pass
+
         try:
-            _ind_screen = screen_order.index("outputs")
-            if not output_groups:
-                _LOGGER.debug("No outputs configured. Omitting in screen.")
-            screen_order.pop(_ind_screen)
-            screen_order[_ind_screen:_ind_screen] = output_groups
-            self._output_groups = output_groups
+            _ina219_screen = screen_order.index("ina219")
+            screen_order.pop(_ina219_screen)
         except ValueError:
             pass
+
+        configure_outputs()
+        configure_inputs()
         self._screen_order = cycle(screen_order)
         self._current_screen = next(self._screen_order)
         self._host_data = host_data
@@ -143,6 +177,29 @@ class Oled:
             )
             i += 1
 
+    def _draw_input(self, data: dict, draw: ImageDraw) -> None:
+        "Draw inputs of boneIO Black."
+        cols = cycle(INPUT_COLS)
+        draw.text(
+            (1, 1),
+            f"{self._current_screen}",
+            font=fonts["small"],
+            fill=WHITE,
+        )
+        i = 0
+        j = next(cols)
+        for k in data:
+            if len(INPUT_ROWS) == i:
+                j = next(cols)
+                i = 0
+            draw.text(
+                (j, INPUT_ROWS[i]),
+                f"{shorten_name(k)} {data[k]}",
+                font=fonts["extraSmall"],
+                fill=WHITE,
+            )
+            i += 1
+
     def render_display(self) -> None:
         """Render display."""
         data = self._host_data.get(self._current_screen)
@@ -155,6 +212,11 @@ class Oled:
                     self._draw_output(data, draw)
                 elif self._current_screen == UPTIME:
                     self._draw_uptime(data, draw)
+                elif (
+                    self._input_groups
+                    and self._current_screen in self._input_groups
+                ):
+                    self._draw_input(data, draw)
                 else:
                     self._draw_standard(data, draw)
         else:
@@ -168,7 +230,11 @@ class Oled:
 
     def handle_data_update(self, type: str):
         """Callback to handle new data present into screen."""
-        if type == self._current_screen and not self._sleep:
+        if (
+            type == "inputs"
+            and self._current_screen in self._input_groups
+            or type == self._current_screen
+        ) and not self._sleep:
             self.render_display()
 
     def _handle_press(self, pin: any) -> None:

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/schema/schema.yaml

@@ -86,6 +86,7 @@ oled:
           'memory',
           'swap',
           'outputs',
+          'inputs',
           'extra_sensors',
         ]
       default:

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/sensor/gpio_new.py

@@ -8,6 +8,7 @@ from boneio.helper.gpio import add_event_callback, add_event_detect
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class GpioInputBinarySensorNew(GpioBaseClass):
     """Represent Gpio sensor on input boards."""
 
@@ -21,6 +22,9 @@ class GpioInputBinarySensorNew(GpioBaseClass):
             if kwargs.get("inverted", False)
             else (PRESSED, RELEASED)
         )
+        self._pressed_state = (
+            self._click_type[0] if self._state else self._click_type[1]
+        )
         self._initial_send = kwargs.get("initial_send", False)
         _LOGGER.debug("Configured sensor pin %s", self._pin)
         add_event_detect(pin=self._pin, edge=BOTH)
@@ -36,11 +40,13 @@ class GpioInputBinarySensorNew(GpioBaseClass):
         ):
             return
         self._state = state
-        click_type = self._click_type[0] if state else self._click_type[1]
+        self._pressed_state = (
+            self._click_type[0] if state else self._click_type[1]
+        )
         _LOGGER.debug(
             "Binary sensor: %s event on pin %s - %s",
-            click_type,
+            self._pressed_state,
             self._pin,
             self.name,
         )
-        self.press_callback(click_type=click_type, duration=None)
+        self.press_callback(click_type=self._pressed_state, duration=None)

{boneIO-0.8.2 → boneIO-0.8.3}/boneio/sensor/temp/dallas.py

@@ -5,7 +5,11 @@ import logging
 from datetime import datetime
 
 from adafruit_ds18x20 import DS18X20
-from w1thermsensor import SensorNotReadyError, NoSensorFoundError
+from w1thermsensor import (
+    SensorNotReadyError,
+    NoSensorFoundError,
+    W1ThermSensorError,
+)
 
 from boneio.const import SENSOR, STATE, TEMPERATURE
 from boneio.helper import AsyncUpdater, BasicMqtt
@@ -81,3 +85,5 @@ class DallasSensorW1(TempSensor, AsyncUpdater):
             _LOGGER.error("Sensor not ready, can't update %s", err)
         except NoSensorFoundError as err:
             _LOGGER.error("Sensor not found, can't update %s", err)
+        except W1ThermSensorError as err:
+            _LOGGER.error("Sensor not working, can't update %s", err)

boneIO-0.8.3/boneio/version.py

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

{boneIO-0.8.2 → boneIO-0.8.3}/pyproject.toml

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

boneIO-0.8.2/boneio/version.py

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