boneIO 0.7.0.dev1__tar.gz → 0.7.0.dev3__tar.gz

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

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

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

@@ -15,6 +15,7 @@ from yaml import MarkedYAMLError
 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__
@@ -89,8 +90,9 @@ def run(config: str, debug: int, mqttusername: str = "", mqttpassword: str = "")
             ),
         )
         return 0
-    except RestartRequestException as err:
-        _LOGGER.info(err)
+    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)

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

@@ -104,10 +104,13 @@ TOPIC_PREFIX = "topic_prefix"
 # I2C, PCA and MCP CONST
 ADDRESS = "address"
 MCP23017 = "mcp23017"
+PCF8575 = "pcf8575"
 PCA9685 = "pca9685"
 MCP = "mcp"
+PCF = "pcf"
 MCP_ID = "mcp_id"
 PCA_ID = "pca_id"
+PCF_ID = "pcf_id"
 INIT_SLEEP = "init_sleep"
 
 # SENSOR CONST
@@ -141,6 +144,7 @@ OledDataTypes = Literal[UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]
 Gpio_States = Literal[HIGH, LOW]
 Gpio_Edges = Literal[BOTH, FALLING]
 InputTypes = Literal[INPUT, INPUT_SENSOR]
+ExpanderTypes = Literal[MCP23017, PCA9685, PCF8575]
 DEVICE_CLASS = "device_class"
 DallasBusTypes = Literal[DS2482, DALLAS]
 FILTERS = "filters"

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

@@ -24,9 +24,10 @@ class ClickTimer:
             self._remove_listener = None
 
     async def _start_async_timer(self) -> None:
+        start = time.time()
         await asyncio.sleep(self._delay)
         self._remove_listener = None
-        self._action(time.time())
+        self._action(round(time.time() - start, 2))
 
     def start_timer(self) -> None:
         """Start timer."""

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

@@ -105,6 +105,7 @@ class EventBus:
         for target in self._sigterm_listeners:
             target()
         self._timer_handle()
+
         _LOGGER.info("Shutdown gracefully.")
         raise GracefulExit(code=0)
 

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

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import asyncio
 import logging
 
@@ -104,7 +105,7 @@ class GpioBaseClass:
     """Base class for initialize GPIO"""
 
     def __init__(
-        self, pin: str, press_callback: Callable[[ClickTypes, str], None], **kwargs
+        self, pin: str, press_callback: Callable[[ClickTypes, str, bool | None], None], **kwargs
     ) -> None:
         """Setup GPIO Input Button"""
         self._pin = pin

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/helper/loader.py

@@ -37,7 +37,11 @@ from boneio.const import (
     SHOW_HA,
     UPDATE_INTERVAL,
     DallasBusTypes,
-    EVENT_ENTITY
+    EVENT_ENTITY,
+    ExpanderTypes,
+    PCF,
+    PCA,
+    PCF_ID
 )
 from boneio.cover import Cover
 from boneio.helper import (
@@ -59,6 +63,7 @@ from boneio.helper.onewire import (
 )
 from boneio.helper.ha_discovery import ha_cover_availabilty_message
 from boneio.helper.timeperiod import TimePeriod
+from boneio.helper.pcf8575 import PCF8575
 from boneio.input import GpioEventButton, GpioEventButtonBeta
 from boneio.sensor import DallasSensorDS2482, GpioInputBinarySensor, GpioInputBinarySensorBeta
 from boneio.sensor.temp.dallas import DallasSensorW1
@@ -69,7 +74,7 @@ if TYPE_CHECKING:
 
 from busio import I2C
 
-from boneio.relay import GpioRelay, MCPRelay, PWMPCA
+from boneio.relay import GpioRelay, MCPRelay, PWMPCA, PCFRelay
 from boneio.sensor import GpioADCSensor, initialize_adc
 
 _LOGGER = logging.getLogger(__name__)
@@ -149,49 +154,37 @@ def create_temp_sensor(
         pass
 
 
-def create_mcp23017(
-    manager: Manager,
-    mcp23017: list,
-    i2cbusio: I2C,
-) -> dict:
-    """Create MCP23017."""
-    grouped_outputs = {}
-    for mcp in mcp23017:
-        id = mcp[ID] or mcp[ADDRESS]
-        try:
-            manager._mcp[id] = MCP23017(i2c=i2cbusio, address=mcp[ADDRESS], reset=False)
-            sleep_time = mcp.get(INIT_SLEEP, TimePeriod(seconds=0))
-            _LOGGER.debug(
-                f"Sleeping for {sleep_time.total_seconds}s while MCP {id} is initializing."
-            )
-            time.sleep(sleep_time.total_seconds)
-            grouped_outputs[id] = {}
-        except TimeoutError as err:
-            _LOGGER.error("Can't connect to MCP %s. %s", id, err)
-            pass
-    return grouped_outputs
+expander_class = {
+    MCP: MCP23017,
+    PCA: PCA9685,
+    PCF: PCF8575
+}
 
 
-def create_pca9685(
-    manager: Manager,
-    pca9685: list,
-    i2cbusio: I2C,
+def create_expander(
+        expander_dict: dict,
+        expander_config: list,
+        exp_type: ExpanderTypes,
+        i2cbusio: I2C
 ) -> dict:
-    """Create MCP23017."""
     grouped_outputs = {}
-    for pca in pca9685:
-        id = pca[ID] or pca[ADDRESS]
+    for expander in expander_config:
+        id = expander[ID] or expander[ADDRESS]
         try:
-            manager._pca[id] = PCA9685(i2c_bus=i2cbusio, address=pca[ADDRESS])
-            manager._pca[id].frequency = 500
-            sleep_time = pca.get(INIT_SLEEP, TimePeriod(seconds=0))
-            _LOGGER.debug(
-                f"Sleeping for {sleep_time.total_seconds}s while PCA {id} is initializing."
-            )
-            time.sleep(sleep_time.total_seconds)
+            expander_dict[id] = expander_class[exp_type](i2c=i2cbusio, address=expander[ADDRESS], reset=False)
+            sleep_time = expander.get(INIT_SLEEP, TimePeriod(seconds=0))
+            if sleep_time.total_seconds > 0:
+                _LOGGER.debug(
+                    f"Sleeping for {sleep_time.total_seconds}s while {exp_type} {id} is initializing."
+                )
+                time.sleep(sleep_time.total_seconds)
+            else:
+                _LOGGER.debug(
+                    f"{exp_type} {id} is initializing."
+                )
             grouped_outputs[id] = {}
         except TimeoutError as err:
-            _LOGGER.error("Can't connect to PCA %s. %s", id, err)
+            _LOGGER.error("Can't connect to %s %s. %s", exp_type, id, err)
             pass
     return grouped_outputs
 
@@ -236,6 +229,9 @@ def output_chooser(output_kind: str, config):
     elif output_kind == PCA:
         output_id = config.pop(PCA_ID, None)
         return OutputEntry(PWMPCA, PCA, output_id)
+    elif output_kind == PCF:
+        output_id = config.pop(PCF_ID, None)
+        return OutputEntry(PCFRelay, PCF, output_id)
     else:
         raise GPIOOutputException(f"""Output type {output_kind} dont exists""")
 
@@ -284,6 +280,17 @@ def configure_relay(
             "pca_id": getattr(output, "output_id"),
             "output_type": output_type,
         }
+    elif getattr(output, "output_kind") == PCF:
+        expander = manager.pcf.get(getattr(output, "output_id"))
+        if not expander:
+            _LOGGER.error("No such PCF configured!")
+            return None
+        kwargs = {
+            "pin": int(config.pop(PIN)),
+            "expander": expander,
+            "expander_id": getattr(output, "output_id"),
+            "output_type": output_type,
+        }
     elif getattr(output, "output_kind") == GPIO:
         if GPIO not in manager.grouped_outputs:
             manager.grouped_outputs[GPIO] = {}
@@ -342,12 +349,13 @@ def configure_event_sensor(
         GpioEventButtonClass = GpioEventButton if gpio.get("detection_type", "stable") == "stable" else GpioEventButtonBeta
         GpioEventButtonClass(
             pin=pin,
-            press_callback=lambda x, i: press_callback(
+            press_callback=lambda x, i, z: press_callback(
                 x=x,
                 inpin=i,
                 actions=gpio.get(ACTIONS, {}).get(x, []),
                 input_type=INPUT,
-                empty_message_after=gpio.get("clear_message", False)
+                empty_message_after=gpio.get("clear_message", False),
+                duration=z
             ),
             **gpio,
         )
@@ -373,7 +381,7 @@ def configure_binary_sensor(
     """Configure input sensor or button."""
     try:
         GpioInputBinarySensorClass = GpioInputBinarySensor if gpio.get("detection_type", "stable") == "stable" else GpioInputBinarySensorBeta
-        GpioInputBinarySensor(
+        GpioInputBinarySensorClass(
             pin=pin,
             press_callback=lambda x, i: press_callback(
                 x=x,

boneIO-0.7.0.dev3/boneio/helper/pcf8575.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from adafruit_pcf8575 import PCF8575 as AdafruitPCF8575
+try:
+    from busio import I2C
+except ImportError:
+    pass
+
+
+class PCF8575(AdafruitPCF8575):
+
+    def __init__(self, i2c: I2C, address: int, reset: bool) -> None:
+        super().__init__(i2c_bus=i2c, address=address)

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/input/gpio_beta.py

@@ -19,6 +19,7 @@ _LOGGER = logging.getLogger(__name__)
 DOUBLE_CLICK_DURATION_MS = 300
 LONG_PRESS_DURATION_MS = 600
 
+
 class GpioEventButtonBeta(GpioBaseClass):
     """Represent Gpio input switch."""
 
@@ -38,7 +39,7 @@ class GpioEventButtonBeta(GpioBaseClass):
         )
         self._timer_long = ClickTimer(
             delay=TimePeriod(milliseconds=LONG_PRESS_DURATION_MS),
-            action=lambda x: self.press_callback(click_type=LONG),
+            action=lambda x: self.press_callback(click_type=LONG, duration=x),
         )
         self._double_click_ran = False
         self._is_waiting_for_second_click = False
@@ -51,7 +52,7 @@ class GpioEventButtonBeta(GpioBaseClass):
     def double_click_press_callback(self):
         self._is_waiting_for_second_click = False
         if not self._state and not self._timer_long.is_waiting():
-            self.press_callback(click_type=SINGLE)
+            self.press_callback(click_type=SINGLE, duration=None)
 
     def check_state(self, channel) -> None:
         time_now = time.time()
@@ -64,7 +65,7 @@ class GpioEventButtonBeta(GpioBaseClass):
                 if self._timer_double.is_waiting():
                     self._timer_double.reset()
                     self._double_click_ran = True
-                    self.press_callback(click_type=DOUBLE)
+                    self.press_callback(click_type=DOUBLE, duration=None)
                     return
                 self._timer_double.start_timer()
                 self._is_waiting_for_second_click = True
@@ -72,13 +73,12 @@ class GpioEventButtonBeta(GpioBaseClass):
         else:
             if not self._is_waiting_for_second_click and not self._double_click_ran:
                 if self._timer_long.is_waiting():
-                    self.press_callback(click_type=SINGLE)
+                    self.press_callback(click_type=SINGLE, duration=None)
             self._timer_long.reset()
             self._double_click_ran = False
 
-
-    def press_callback(self, click_type: ClickTypes):
+    def press_callback(self, click_type: ClickTypes, duration: float | None = None):
         self.click_count = 0
         self._loop.call_soon_threadsafe(
-            partial(self._press_callback, click_type, self._pin)
+            partial(self._press_callback, click_type, self._pin, duration)
         )

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/manager.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import asyncio
 import logging
 from collections import deque
@@ -37,6 +38,9 @@ from boneio.const import (
     LIGHT,
     LED,
     SET_BRIGHTNESS,
+    MCP,
+    PCA,
+    PCF
 )
 from boneio.helper import (
     GPIOInputException,
@@ -57,8 +61,7 @@ from boneio.helper.loader import (
     configure_binary_sensor,
     configure_relay,
     create_dallas_sensor,
-    create_mcp23017,
-    create_pca9685,
+    create_expander,
     create_temp_sensor,
 )
 from boneio.helper.logger import configure_logger
@@ -92,6 +95,7 @@ class Manager:
         modbus: dict = {},
         pca9685: list = [],
         mcp23017: list = [],
+        pcf8575: list = [],
         ds2482: Optional[List] = [],
         dallas: Optional[dict] = None,
         oled: dict = {},
@@ -107,7 +111,7 @@ class Manager:
         self._host_data = None
         self._config_file_path = config_file_path
         self._state_manager = state_manager
-        self._event_bus = EventBus(self._loop)
+        self._event_bus = EventBus(loop=self._loop)
 
         self.send_message = send_message
         self.stop_client = stop_client
@@ -115,6 +119,7 @@ class Manager:
         self._binary_pins = binary_pins
         self._i2cbusio = I2C(SCL, SDA)
         self._mcp = {}
+        self._pcf = {}
         self._pca = {}
         self._output = {}
         self._oled = None
@@ -132,13 +137,25 @@ class Manager:
             dallas=dallas, ds2482=ds2482, sensors=sensors.get(ONEWIRE)
         )
 
-        self.grouped_outputs = create_mcp23017(
-            manager=self, mcp23017=mcp23017, i2cbusio=self._i2cbusio
+        self.grouped_outputs = create_expander(
+            expander_dict=self._mcp,
+            expander_config=mcp23017,
+            exp_type=MCP,
+            i2cbusio=self._i2cbusio
         )
         self.grouped_outputs.update(
-            create_pca9685(manager=self, pca9685=pca9685, i2cbusio=self._i2cbusio)
-        )
-
+            create_expander(
+                expander_dict=self._pcf,
+                expander_config=pcf8575,
+                exp_type=PCF,
+                i2cbusio=self._i2cbusio))
+        self.grouped_outputs.update(
+            create_expander(
+                expander_dict=self._pca,
+                expander_config=pca9685,
+                exp_type=PCA,
+                i2cbusio=self._i2cbusio))
+        
         self._configure_adc(adc_list=adc)
 
         for _config in relay_pins:
@@ -456,14 +473,27 @@ class Manager:
     def pca(self):
         """Get PCA by it's id."""
         return self._pca
+    
+    @property
+    def pcf(self):
+        """Get PCF by it's id."""
+        return self._pcf
 
     def press_callback(
-        self, x: ClickTypes, inpin: str, actions: List, input_type: InputTypes = INPUT, empty_message_after: bool = False
+        self, x: ClickTypes, inpin: str, actions: List, input_type: InputTypes = INPUT, empty_message_after: bool = False, duration: float | None = None
     ) -> None:
         """Press callback to use in input gpio.
         If relay input map is provided also toggle action on relay or cover or mqtt."""
         topic = f"{self._config_helper.topic_prefix}/{input_type}/{inpin}"
-        self.send_message(topic=topic, payload=x, retain=False)
+
+        def generate_payload():
+            if input_type == INPUT:
+                if duration:
+                    return {"event_type": x, "duration": duration}
+                return {"event_type": x}
+            return x
+            
+        self.send_message(topic=topic, payload=generate_payload(), retain=False)
         for action_definition in actions:
             _LOGGER.debug("Executing action %s", action_definition)
             if action_definition[ACTION] == OUTPUT:

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/mqtt_client.py

@@ -15,9 +15,10 @@ from aiomqtt import Client as AsyncioClient, MqttError, Will
 from paho.mqtt.properties import Properties
 from paho.mqtt.subscribeoptions import SubscribeOptions
 
-from boneio.const import ONLINE, PAHO, STATE
+from boneio.const import OFFLINE, PAHO, STATE
 from boneio.helper import UniqueQueue
 from boneio.helper.config import ConfigHelper
+from boneio.helper.events import GracefulExit
 from boneio.manager import Manager
 from boneio.helper.exceptions import RestartRequestException
 
@@ -58,7 +59,7 @@ class MQTTClient:
             self.port,
             will=Will(
                 topic=f"{self._config_helper.topic_prefix}/{STATE}",
-                payload=ONLINE,
+                payload=OFFLINE,
                 qos=0,
                 retain=False,
             ),
@@ -128,7 +129,7 @@ class MQTTClient:
         await self.asyncio_client.unsubscribe(topic=topics, **params)
 
     def send_message(
-        self, topic: str, payload: Union[str, dict, None], retain: bool = False
+        self, topic: str, payload: Union[str, int, dict, None], retain: bool = False
     ) -> None:
         """Send a message from the manager options."""
         to_publish = (
@@ -148,26 +149,30 @@ class MQTTClient:
     async def start_client(self, manager: Manager) -> None:
         """Start the client with the manager."""
         # Reconnect automatically until the client is stopped.
-        while True:
-            try:
-                await self._subscribe_manager(manager)
-            except MqttError as err:
-                self.reconnect_interval = min(self.reconnect_interval * 2, 900)
-                _LOGGER.error(
-                    "MQTT error: %s. Reconnecting in %s seconds",
-                    err,
-                    self.reconnect_interval,
-                )
-                self._connection_established = False
-                await asyncio.sleep(self.reconnect_interval)
-                self.create_client()  # reset connect/reconnect futures
+        try:
+            while True:
+                try:
+                    await self._subscribe_manager(manager)
+                except MqttError as err:
+                    self.reconnect_interval = min(self.reconnect_interval * 2, 900)
+                    _LOGGER.error(
+                        "MQTT error: %s. Reconnecting in %s seconds",
+                        err,
+                        self.reconnect_interval,
+                    )
+                    self._connection_established = False
+                    await asyncio.sleep(self.reconnect_interval)
+                    self.create_client()  # reset connect/reconnect futures
+        except (asyncio.CancelledError, GracefulExit):
+            _LOGGER.info("MQTT client task canceled.")
+            pass
 
     async def stop_client(self) -> None:
         await self.unsubscribe(
             topics=self._topics
         )
         raise RestartRequestException("Restart requested.")
-
+    
     async def _subscribe_manager(self, manager: Manager) -> None:
         """Connect and subscribe to manager topics + host stats."""
         async with AsyncExitStack() as stack:

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/relay/__init__.py

@@ -1,6 +1,7 @@
 """Relay module."""
 from boneio.relay.gpio import GpioRelay
 from boneio.relay.mcp import MCPRelay
+from boneio.relay.pcf import PCFRelay
 from boneio.relay.pca import PWMPCA
 
-__all__ = ["MCPRelay", "GpioRelay", "PWMPCA"]
+__all__ = ["MCPRelay", "GpioRelay", "PWMPCA", "PCFRelay"]

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/relay/basic.py

@@ -3,7 +3,7 @@
 import asyncio
 import logging
 from typing import Callable
-
+from boneio.helper.util import callback
 from boneio.const import LIGHT, NONE, OFF, ON, RELAY, STATE, SWITCH
 from boneio.helper import BasicMqtt
 
@@ -82,6 +82,11 @@ class BasicRelay(BasicMqtt):
         else:
             self.turn_on()
 
+    @callback
+    def _momentary_callback(self, time, action):
+        _LOGGER.info("Momentary callback at %s", time)
+        action()
+
     @property
     def is_active(self) -> bool:
         """Is active check."""

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/relay/mcp.py

@@ -4,9 +4,8 @@ import logging
 
 from adafruit_mcp230xx.mcp23017 import MCP23017, DigitalInOut
 
-from boneio.const import NONE, SWITCH
+from boneio.const import NONE, SWITCH, MCP
 from boneio.helper.events import async_track_point_in_time, utcnow
-from boneio.helper.util import callback
 from boneio.relay.basic import BasicRelay
 
 _LOGGER = logging.getLogger(__name__)
@@ -34,23 +33,23 @@ class MCPRelay(BasicRelay):
             **kwargs, output_type=output_type, restored_state=restored_state
         )
         self._pin_id = pin
-        self._mcp_id = mcp_id
+        self._expander_id = mcp_id
         _LOGGER.debug("Setup MCP with pin %s", self._pin_id)
 
     @property
-    def is_mcp_type(self) -> bool:
-        """Check if relay is mcp type."""
-        return True
+    def expander_type(self) -> str:
+        """Check expander type."""
+        return MCP
 
     @property
-    def pin_id(self) -> str:
+    def pin_id(self) -> int:
         """Return PIN id."""
         return self._pin_id
 
     @property
-    def mcp_id(self) -> str:
+    def expander_id(self) -> str:
         """Retrieve parent MCP ID."""
-        return self._mcp_id
+        return self._expander_id
 
     @property
     def is_active(self) -> bool:
@@ -62,11 +61,6 @@ class MCPRelay(BasicRelay):
         """PIN of the relay"""
         return self._pin
 
-    @callback
-    def _momentary_callback(self, time, action):
-        _LOGGER.info("Momentary callback at %s", time)
-        action()
-
     def turn_on(self) -> None:
         """Call turn on action."""
         self.pin.value = True

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/relay/pca.py

@@ -9,7 +9,7 @@ from adafruit_pca9685 import PCA9685, PCAChannels
 from boneio.helper.events import async_track_point_in_time, utcnow
 from boneio.helper.util import callback
 
-from boneio.const import LED, NONE, OFF, ON, STATE, SWITCH, BRIGHTNESS, RELAY
+from boneio.const import LED, NONE, OFF, ON, STATE, SWITCH, BRIGHTNESS, RELAY, PCA
 from boneio.helper import BasicMqtt
 
 _LOGGER = logging.getLogger(__name__)
@@ -58,9 +58,9 @@ class PWMPCA(BasicMqtt):
         _LOGGER.debug("Setup PCA with pin %s", self._pin_id)
 
     @property
-    def is_pca_type(self) -> bool:
-        """Check if relay is pca type."""
-        return True
+    def expander_type(self) -> str:
+        """Check expander type."""
+        return PCA
 
     @property
     def output_type(self) -> str:

boneIO-0.7.0.dev3/boneio/relay/pcf.py

@@ -0,0 +1,86 @@
+"""PCF8575 Relay module."""
+
+import logging
+
+from adafruit_pcf8575 import DigitalInOut
+
+from boneio.const import NONE, SWITCH, PCF
+from boneio.helper.events import async_track_point_in_time, utcnow
+from boneio.helper.pcf8575 import PCF8575
+from boneio.relay.basic import BasicRelay
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class PCFRelay(BasicRelay):
+    """Represents PCF Relay output"""
+
+    def __init__(
+        self,
+        pin: int,
+        expander: PCF8575,
+        expander_id: str,
+        output_type: str = SWITCH,
+        restored_state: bool = False,
+        **kwargs,
+    ) -> None:
+        """Initialize MCP relay."""
+        self._pin: DigitalInOut = expander.get_pin(pin)
+        if output_type == NONE:
+            """Just in case to not restore state of covers etc."""
+            restored_state = False
+        self._pin.switch_to_output(value=restored_state)
+        super().__init__(
+            **kwargs, output_type=output_type, restored_state=restored_state
+        )
+        self._pin_id = pin
+        self._expander_id = expander_id
+        self._active_state = False
+        _LOGGER.debug("Setup PCF with pin %s", self._pin_id)
+
+    @property
+    def expander_type(self) -> str:
+        """Check expander type."""
+        return PCF
+
+    @property
+    def pin_id(self) -> int:
+        """Return PIN id."""
+        return self._pin_id
+
+    @property
+    def expander_id(self) -> str:
+        """Retrieve parent MCP ID."""
+        return self._expander_id
+
+    @property
+    def is_active(self) -> bool:
+        """Is relay active."""
+        return self.pin.value == self._active_state
+
+    @property
+    def pin(self) -> str:
+        """PIN of the relay"""
+        return self._pin
+
+    def turn_on(self) -> None:
+        """Call turn on action."""
+        self.pin.value = self._active_state
+        if self._momentary_turn_on:
+            async_track_point_in_time(
+                loop=self._loop,
+                action=lambda x: self._momentary_callback(time=x, action=self.turn_off),
+                point_in_time=utcnow() + self._momentary_turn_on.as_timedelta,
+            )
+        self._loop.call_soon_threadsafe(self.send_state)
+
+    def turn_off(self) -> None:
+        """Call turn off action."""
+        self.pin.value = not self._active_state
+        if self._momentary_turn_off:
+            async_track_point_in_time(
+                loop=self._loop,
+                action=lambda x: self._momentary_callback(time=x, action=self.turn_on),
+                point_in_time=utcnow() + self._momentary_turn_off.as_timedelta,
+            )
+        self._loop.call_soon_threadsafe(self.send_state)

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/runner.py

@@ -17,6 +17,7 @@ from boneio.const import (
     EVENT_ENTITY,
     LM75,
     MCP23017,
+    PCF8575,
     PCA9685,
     MCP_TEMP_9808,
     MODBUS,
@@ -34,11 +35,13 @@ from boneio.helper import StateManager
 from boneio.helper.config import ConfigHelper
 from boneio.manager import Manager
 from boneio.mqtt_client import MQTTClient
+from boneio.helper.events import EventBus
 
 _LOGGER = logging.getLogger(__name__)
 
 config_modules = [
     {"name": MCP23017, "default": []},
+    {"name": PCF8575, "default": []},
     {"name": PCA9685, "default": []},
     {"name": DS2482, "default": []},
     {"name": ADC, "default": []},
@@ -56,7 +59,6 @@ async def async_run(
     mqttpassword: str = "",
 ) -> list[Any]:
     """Run BoneIO."""
-
     _config_helper = ConfigHelper(
         topic_prefix=config[MQTT].pop(TOPIC_PREFIX),
         ha_discovery=config[MQTT][HA_DISCOVERY].pop(ENABLED),
@@ -98,4 +100,4 @@ async def async_run(
     tasks.update(manager.get_tasks())
     _LOGGER.info("Connecting to MQTT.")
     tasks.add(client.start_client(manager))
-    return await asyncio.gather(*tasks)
+    return await asyncio.gather(*tasks, return_exceptions=True)

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/schema/schema.yaml

@@ -218,6 +218,33 @@ mcp23017:
         meta:
           label: How long to sleep for MCP to initialize.
 
+
+pcf8575:
+  type: list
+  required: False
+  meta:
+    label: pcf8575 Pin config
+  schema:
+    type: dict
+    schema:
+      id: !include id.yaml
+      address:
+        type: integer
+        required: True
+        meta:
+          label: GPIO of I2C SDA
+      init_sleep:
+        type:
+          - string
+          - timeperiod
+        coerce:
+          - str
+          - positive_time_period
+        required: True
+        default: 0s
+        meta:
+          label: How long to sleep for PCF to initialize.
+
 pca9685:
   type: list
   required: False
@@ -260,7 +287,7 @@ output:
           label: Id to send to use in HA and in GPIO Input. Default to `kind_pin`
       kind:
         type: string
-        allowed: ["gpio", "mcp", "pca"]
+        allowed: ["gpio", "mcp", "pca", "pcf"]
         meta:
           label: Either GPIO or i2c.
       mcp_id:
@@ -273,6 +300,11 @@ output:
         required: False
         meta:
           label: PCA ID to connect
+      pcf_id:
+        type: string
+        required: False
+        meta:
+          label: PCF ID to connect
       pin:
         type:
           - string

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/boneio/sensor/gpio_beta.py

@@ -1,9 +1,10 @@
 """GpioInputBinarySensor to receive signals."""
 import logging
 from functools import partial
-from boneio.const import PRESSED, RELEASED
+from boneio.const import PRESSED, RELEASED, BOTH
 from boneio.helper import GpioBaseClass
 from boneio.helper.gpio import add_event_callback, add_event_detect
+
 _LOGGER = logging.getLogger(__name__)
 
 

boneIO-0.7.0.dev3/boneio/version.py

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

{boneIO-0.7.0.dev1 → boneIO-0.7.0.dev3}/pyproject.toml

@@ -26,9 +26,10 @@ dependencies = [
     "adafruit-circuitpython-onewire>=2.0.5",
     "w1thermsensor[async]>=2.0.0",
     "adafruit-circuitpython-pca9685>=3.4.10",
+    "adafruit-circuitpython-pcf8575>=1.0.2",
 ]
 requires-python = ">=3.7"
-version = "0.7.0.dev1"
+version = "0.7.0.dev3"
 
 [project.license]
 text = "GNU General Public License v3.0"
@@ -42,8 +43,6 @@ Changelog = "https://github.com/boneIO-eu/app_bbb/releases"
 [project.scripts]
 boneio = "boneio.bonecli:main"
 
-[project.optional-dependencies]
-
 [tool.pdm.version]
 from = "boneio/version.py"
 

boneIO-0.7.0.dev1/boneio/version.py

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