boneIO 0.7.0.dev6__tar.gz → 0.8.0.dev1__tar.gz

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/PKG-INFO

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

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

@@ -113,7 +113,7 @@ def main() -> int:
             mqttpassword=args.mqttpassword,
             debug=debug,
         )
-
+    _LOGGER.info("Exiting with exit code %s", exit_code)
     return exit_code
 
 

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

@@ -56,7 +56,7 @@ UARTS = {
     "uart5": {ID: "/dev/ttyS5", TX: "P8.37", RX: "P8.38"},
 }
 
-relay_actions = {ON: "turn_on", OFF: "turn_off", TOGGLE: "toggle"}
+relay_actions = {ON: "async_turn_on", OFF: "async_turn_off", TOGGLE: "async_toggle"}
 
 # HA CONSTS
 HOMEASSISTANT = "homeassistant"
@@ -158,3 +158,5 @@ cover_actions = {
     "TOGGLE_OPEN": "toggle_open",
     "TOGGLE_CLOSE": "toggle_close",
 }
+
+INA219 = "ina219"

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/example_config/binary_sensor.yaml

@@ -1,9 +1,11 @@
 - id: IN_47
   pin: P8_12
   kind: sensor
+  detection_type: "old"
 - id: IN_48
   pin: P8_11
   kind: sensor
+  detection_type: "new"
 - id: IN_49
   pin: P8_10
   kind: sensor

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/example_config/config.yaml

@@ -23,4 +23,4 @@ binary_sensor: !include binary_sensor.yaml
 
 output: !include output32x5A.yaml
 
-adc: !include adc.yaml
+# adc: !include adc.yaml Uncomment only if needed.

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/example_config/event.yaml

@@ -1,5 +1,6 @@
 - id: IN_01
   pin: P8_37
+  detection_type: "old"
   actions:
     single:
       - action: output
@@ -9,6 +10,7 @@
         pin: switch 1
 - id: IN_02
   pin: P8_38
+  detection_type: "new"
   actions:
     single:
       - action: output

boneIO-0.8.0.dev1/boneio/example_config/event_all.yaml

@@ -0,0 +1,186 @@
+- id: IN_01
+  pin: P8_37
+  detection_type: "old"
+  actions:
+    single:
+      - action: output
+        pin: light 1
+    double:
+      - action: output
+        pin: switch 1
+- id: IN_02
+  pin: P8_38
+  detection_type: "new"
+  actions:
+    single:
+      - action: output
+        pin: light 2
+    double:
+      - action: output
+        pin: switch 2
+- id: IN_03
+  pin: P8_39
+  actions:
+    single:
+      - action: output
+        pin: light 3
+    double:
+      - action: output
+        pin: switch 3
+- id: IN_04
+  pin: P8_40
+  actions:
+    single:
+      - action: output
+        pin: light 4
+    double:
+      - action: output
+        pin: switch 4
+- id: IN_05
+  pin: P8_41
+  actions:
+    single:
+      - action: output
+        pin: light 5
+    double:
+      - action: output
+        pin: switch 5
+- id: IN_06
+  pin: P8_42
+  actions:
+    single:
+      - action: output
+        pin: light 6
+    double:
+      - action: output
+        pin: switch 6
+- id: IN_07
+  pin: P8_43
+  actions:
+    single:
+      - action: output
+        pin: light 7
+
+- id: IN_08
+  pin: P8_44
+  actions:
+    single:
+      - action: output
+        pin: light 8
+- id: IN_09
+  pin: P8_45
+  actions:
+    single:
+      - action: output
+        pin: light 9
+- id: IN_10
+  pin: P8_46
+  actions:
+    single:
+      - action: output
+        pin: light 10
+- id: IN_11
+  pin: P9_42
+  actions:
+    single:
+      - action: output
+        pin: light 11
+- id: IN_12
+  pin: P9_31
+  actions:
+    single:
+      - action: output
+        pin: light 12
+- id: IN_13
+  pin: P9_30
+  actions:
+    single:
+      - action: output
+        pin: light 13
+- id: IN_14
+  pin: P9_29
+  actions:
+    single:
+      - action: output
+        pin: light 14
+
+- id: IN_15
+  pin: P9_28
+  actions:
+    single:
+      - action: output
+        pin: light 15
+- id: IN_16
+  pin: P9_27
+  actions:
+    single:
+      - action: output
+        pin: light 16
+- id: IN_17
+  pin: P9_25
+  actions:
+    single:
+      - action: output
+        pin: light 4
+- id: IN_18
+  pin: P9_23
+- id: IN_19
+  pin: P9_22
+- id: IN_20
+  pin: P9_21
+- id: IN_21
+  pin: P9_18
+
+- id: IN_22
+  pin: P9_17
+- id: IN_23
+  pin: P9_16
+- id: IN_24
+  pin: P9_15
+- id: IN_25
+  pin: P9_14
+- id: IN_26
+  pin: P9_13
+- id: IN_27
+  pin: P9_12
+- id: IN_28
+  pin: P9_11
+
+- id: IN_29
+  pin: P8_36
+- id: IN_30
+  pin: P8_35
+- id: IN_31
+  pin: P8_34
+- id: IN_32
+  pin: P8_33
+
+- id: IN_33
+  pin: P8_32
+- id: IN_34
+  pin: P8_31
+- id: IN_35
+  pin: P8_30
+- id: IN_36
+  pin: P8_29
+- id: IN_37
+  pin: P8_28
+- id: IN_38
+  pin: P8_27
+- id: IN_39
+  pin: P8_26
+
+- id: IN_40
+  pin: P8_19
+- id: IN_41
+  pin: P8_18
+- id: IN_42
+  pin: P8_17
+- id: IN_43
+  pin: P8_16
+- id: IN_44
+  pin: P8_15
+- id: IN_45
+  pin: P8_14
+- id: IN_46
+  pin: P8_13

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/group/output.py

@@ -1,14 +1,10 @@
-"""Cover module."""
+"""Group output module."""
 from __future__ import annotations
-import logging
 import asyncio
 from typing import List
-
 from boneio.const import COVER, SWITCH, ON, OFF
 from boneio.relay.basic import BasicRelay
 
-_LOGGER = logging.getLogger(__name__)
-
 
 class OutputGroup(BasicRelay):
     """Cover class of boneIO"""
@@ -41,23 +37,22 @@ class OutputGroup(BasicRelay):
             self._state = state
             self._loop.call_soon_threadsafe(self.send_state)
 
-    def turn_on(self) -> None:
+    async def async_turn_on(self) -> None:
         """Call turn on action."""
-        for x in self._group_members:
-            asyncio.create_task(x.async_turn_on())
+        await asyncio.gather(
+            *[self._loop.run_in_executor(self.executor, x.turn_on) for x in self._group_members]
+        )
 
-    def turn_off(self) -> None:
+    async def async_turn_off(self) -> None:
         """Call turn off action."""
-        for x in self._group_members:
-            asyncio.create_task(x.async_turn_off())
+        await asyncio.gather(
+            *[self._loop.run_in_executor(self.executor, x.turn_off) for x in self._group_members]
+        )
 
-    def toggle(self) -> None:
-        """Toggle group."""
-        _LOGGER.debug("Toggle relay.")
-        if self._state == ON:
-            self.turn_off()
-        else:
-            self.turn_on()
+    @property
+    def is_active(self) -> bool:
+        """Is relay active."""
+        return self._state == ON
 
     def send_state(self) -> None:
         """Send state to Mqtt on action."""

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/helper/__init__.py

@@ -21,6 +21,7 @@ from boneio.helper.ha_discovery import (
     ha_sensor_temp_availabilty_message,
     ha_switch_availabilty_message,
     ha_led_availabilty_message,
+    ha_sensor_ina_availabilty_message
 )
 from boneio.helper.mqtt import BasicMqtt
 from boneio.helper.async_updater import AsyncUpdater
@@ -54,6 +55,7 @@ __all__ = [
     "ha_sensor_temp_availabilty_message",
     "ha_binary_sensor_availabilty_message",
     "ha_button_availabilty_message",
+    "ha_sensor_ina_availabilty_message",
     "ha_event_availabilty_message",
     "ha_led_availabilty_message",
     "GPIOInputException",

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/helper/async_updater.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import asyncio
-
+import time
 # Typing imports that create a circular dependency
 from typing import TYPE_CHECKING
 
@@ -19,11 +19,11 @@ class AsyncUpdater:
         while True:
             if hasattr(self, "async_update"):
                 update_interval = (
-                    await self.async_update(time=None)
+                    await self.async_update(time=time.time())
                     or self._update_interval.total_in_seconds
                 )
             else:
                 update_interval = (
-                    self.update(time=None) or self._update_interval.total_in_seconds
+                    self.update(time=time.time()) or self._update_interval.total_in_seconds
                 )
             await asyncio.sleep(update_interval)

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/helper/click_timer.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
+import logging
 import asyncio
 from boneio.helper.timeperiod import TimePeriod
 import time
 
+_LOGGER = logging.getLogger(__name__)
+
+
 class ClickTimer:
     """Represent async call later function with variable to check if timing is ON."""
 
@@ -16,6 +20,10 @@ class ClickTimer:
     def is_waiting(self) -> bool:
         """If variable is set then timer is ON, if None is Off."""
         return self._remove_listener is not None
+    
+    @property
+    def delay(self) -> float:
+        return self._delay
 
     def reset(self) -> None:
         """Uninitialize variable remove_listener."""

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/helper/events.py

@@ -4,7 +4,8 @@ import logging
 import signal
 import time
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Any, Coroutine, List, Optional, Callable, Optional
+
 
 from boneio.helper.util import callback
 
@@ -261,3 +262,22 @@ def async_call_later_miliseconds(
     return async_track_point_in_timestamp(
         loop=loop, action=action, timestamp=expected_fire_timestamp
     )
+
+
+def create_unawaited_task_threadsafe(
+    loop: asyncio.AbstractEventLoop,
+    transient_tasks: List["asyncio.Task[Any]"],
+    coro: Coroutine[Any, Any, None],
+    task_future: Optional["asyncio.Future[asyncio.Task[Any]]"] = None,
+) -> None:
+    """
+    Schedule a coroutine on the loop and add the Task to transient_tasks.
+    """
+
+    def callback() -> None:
+        task = loop.create_task(coro)
+        transient_tasks.append(task)
+        if task_future is not None:
+            task_future.set_result(task)
+
+    loop.call_soon_threadsafe(callback)

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/helper/gpio.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import asyncio
 import logging
-
+from datetime import datetime
 try:
     from Adafruit_BBIO import GPIO
 except ModuleNotFoundError:
@@ -17,13 +17,14 @@ except ModuleNotFoundError:
     pass
 
 import subprocess
-from typing import Callable
+from typing import Callable, Awaitable, List
 
 from boneio.const import CONFIG_PIN, FALLING
 from boneio.const import GPIO as GPIO_STR
-from boneio.const import GPIO_MODE, LOW, ClickTypes, Gpio_Edges, Gpio_States
+from boneio.const import GPIO_MODE, LOW, ClickTypes, Gpio_Edges, Gpio_States, InputTypes
 from boneio.helper.exceptions import GPIOInputException
 from boneio.helper.timeperiod import TimePeriod
+from concurrent.futures import ThreadPoolExecutor
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -81,22 +82,20 @@ def edge_detect(
         GPIO.add_event_detect(gpio=pin, edge=edge, callback=callback, bouncetime=bounce)
     except RuntimeError as err:
         raise GPIOInputException(err)
-    
-def add_event_detect(
-    pin: str, edge: Gpio_Edges = FALLING
-) -> None:
+
+
+def add_event_detect(pin: str, edge: Gpio_Edges = FALLING) -> None:
     """Add detection for RISING and FALLING events."""
     try:
         GPIO.add_event_detect(gpio=pin, edge=edge)
     except RuntimeError as err:
         raise GPIOInputException(err)
-    
-def add_event_callback(
-    pin: str, callback: Callable
-) -> None:
+
+
+def add_event_callback(pin: str, callback: Callable) -> None:
     """Add detection for RISING and FALLING events."""
     try:
-        GPIO.add_event_callback(gpio=pin,callback=callback)
+        GPIO.add_event_callback(gpio=pin, callback=callback)
     except RuntimeError as err:
         raise GPIOInputException(err)
 
@@ -105,24 +104,61 @@ class GpioBaseClass:
     """Base class for initialize GPIO"""
 
     def __init__(
-        self, pin: str, press_callback: Callable[[ClickTypes, str, bool | None], None], **kwargs
+        self,
+        pin: str,
+        press_callback: Callable[
+            [ClickTypes, str, List, InputTypes, bool, float | None], Awaitable[None]
+        ],
+        name: str,
+        actions: dict,
+        input_type,
+        empty_message_after: bool,
+        **kwargs,
     ) -> None:
         """Setup GPIO Input Button"""
         self._pin = pin
         gpio_mode = kwargs.get(GPIO_MODE, GPIO_STR)
-        self._bounce_time = kwargs.get("bounce_time", TimePeriod(milliseconds=50))
+        bounce_time: TimePeriod = kwargs.get("bounce_time", TimePeriod(milliseconds=50))
+        self._bounce_time = bounce_time.total_in_seconds
         self._loop = asyncio.get_running_loop()
         self._press_callback = press_callback
+        self._name = name
         setup_input(pin=self._pin, pull_mode=gpio_mode)
+        self.executor = ThreadPoolExecutor()
+        self._actions = actions
+        self._input_type = input_type
+        self._empty_message_after = empty_message_after
 
-    def set_press_callback(self, press_callback: Callable[[ClickTypes, str, bool | None], None]) -> None:
-        self._press_callback = press_callback
+    def press_callback(self, click_type: ClickTypes, duration: float | None = None) -> None:
+        actions = self._actions.get(click_type, [])
+        self._loop.create_task(self.async_press_callback(click_type, duration, actions))
+
+    async def async_press_callback(
+        self, click_type: ClickTypes, duration: float | None = None, actions: List = []
+    ) -> None:
+        _LOGGER.warn("press callback %s", datetime.now())
+        await self._press_callback(
+            click_type,
+            self._pin,
+            actions,
+            self._input_type,
+            self._empty_message_after,
+            duration,
+        )
+
+    def set_actions(self, actions: dict) -> None:
+        self._actions = actions
 
     @property
     def is_pressed(self) -> bool:
         """Is button pressed."""
         return read_input(self._pin)
-    
+
+    @property
+    def name(self) -> str:
+        """Name of the GPIO visible in HA/MQTT."""
+        return self._name
+
     @property
     def pin(self) -> str:
         """Return configured pin."""

{boneIO-0.7.0.dev6 → boneIO-0.8.0.dev1}/boneio/helper/ha_discovery.py

@@ -131,6 +131,28 @@ def ha_binary_sensor_availabilty_message(id: str, name: str, device_class: str,
     }
 
 
+def ha_sensor_ina_availabilty_message(
+    id: str, name: str, topic: str = "boneIO", **kwargs
+):
+    """Create availability topic for HA."""
+    return {
+        "availability": [{"topic": f"{topic}/{STATE}"}],
+        "device": {
+            "identifiers": [topic],
+            "manufacturer": "boneIO",
+            "model": "boneIO Relay Board",
+            "name": f"boneIO {topic}",
+            "sw_version": __version__,
+        },
+        "name": name,
+        "state_topic": f"{topic}/{SENSOR}/{id}",
+        "unique_id": f"{topic}{SENSOR}{id}",
+        "state_class": "measurement",
+        "value_template": "{{ value_json.state }}",
+        **kwargs,
+    }
+
+
 def ha_sensor_temp_availabilty_message(
     id: str, name: str, topic: str = "boneIO", **kwargs
 ):