boneio 1.0.0.dev6__tar.gz → 1.0.0.dev7__tar.gz

{boneio-1.0.0.dev6/boneio.egg-info → boneio-1.0.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.0.0.dev6
+Version: 1.0.0.dev7
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/components/cover/previous.py

@@ -340,5 +340,15 @@ class PreviousCover(BasicMqtt):
         return "previous"
     
     def update_config_times(self, config: dict) -> None:
-        self._open_duration = config.get("open_duration", self._open_duration)
-        self._close_duration = config.get("close_duration", self._close_duration)
+        """Update cover timing configuration.
+        
+        Args:
+            config: Dictionary with timing values as TimePeriod objects.
+                   Keys: open_time, close_time
+        """
+        if "open_time" in config:
+            self._open_time = config["open_time"]
+            self._open = RelayHelper(relay=self._open.relay, time=config["open_time"])
+        if "close_time" in config:
+            self._close_time = config["close_time"]
+            self._close = RelayHelper(relay=self._close.relay, time=config["close_time"])

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/components/cover/time_based.py

@@ -111,6 +111,14 @@ class TimeBasedCover(BaseCover):
         return "time"
 
     def update_config_times(self, config: dict) -> None:
-        self._open_duration = config.get("open_duration", self._open_duration)
-        self._close_duration = config.get("close_duration", self._close_duration)
+        """Update cover timing configuration.
+        
+        Args:
+            config: Dictionary with timing values as TimePeriod objects.
+                   Keys: open_time, close_time
+        """
+        if "open_time" in config:
+            self._open_time = config["open_time"].total_milliseconds
+        if "close_time" in config:
+            self._close_time = config["close_time"].total_milliseconds
     

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/components/cover/venetian.py

@@ -260,12 +260,18 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         await self.set_tilt(tilt_position=0)
 
     def update_config_times(self, config: dict) -> None:
-        self._open_duration = config.get("open_duration", self._open_duration)
-        self._close_duration = config.get("close_duration", self._close_duration)
-        self._actuator_activation_duration = config.get(
-            "actuator_activation_duration", self._actuator_activation_duration
-        )
-        self._tilt_duration = config.get("tilt_duration", self._tilt_duration)
+        """Update cover timing configuration.
+        
+        Args:
+            config: Dictionary with timing values as TimePeriod objects.
+                   Keys: open_time, close_time, tilt_duration
+        """
+        if "open_time" in config:
+            self._open_time = config["open_time"].total_milliseconds
+        if "close_time" in config:
+            self._close_time = config["close_time"].total_milliseconds
+        if "tilt_duration" in config and config["tilt_duration"]:
+            self._tilt_duration = config["tilt_duration"].total_milliseconds
 
     async def run_cover(
         self,

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/components/group/output_group.py

@@ -86,20 +86,26 @@ class OutputGroup(BasicOutput):
     async def async_turn_on(self, timestamp=None) -> None:
         """Turn on all members in the group.
         
+        Executes turn_on sequentially to prevent I2C bus contention
+        when multiple outputs are on the same GPIO expander.
+        
         Args:
             timestamp: Optional timestamp for the operation
         """
         for x in self._group_members:
-            self._loop.create_task(x.async_turn_on(timestamp=timestamp))
+            await x.async_turn_on(timestamp=timestamp)
 
     async def async_turn_off(self, timestamp=None) -> None:
         """Turn off all members in the group.
         
+        Executes turn_off sequentially to prevent I2C bus contention
+        when multiple outputs are on the same GPIO expander.
+        
         Args:
             timestamp: Optional timestamp for the operation
         """
         for x in self._group_members:
-            self._loop.create_task(x.async_turn_off(timestamp=timestamp))
+            await x.async_turn_off(timestamp=timestamp)
 
     @property
     def is_active(self) -> bool:

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/core/manager/covers.py

@@ -110,26 +110,43 @@ class CoverManager:
                 # Update existing cover or create new one
                 if _id in self._covers:
                     _cover = self._covers[_id]
-                    _cover.update_config_times(_config)
-                    # Re-send HA autodiscovery with potentially new area
-                    if _config.get(SHOW_HA, True):
-                        # Remove old autodiscovery first (in case area changed)
-                        self._remove_cover_ha_discovery(_id)
-                        # Send new autodiscovery
-                        platform = _config.get("platform", "previous")
-                        if platform == "venetian":
-                            availability_msg_func = ha_cover_with_tilt_availabilty_message
-                        else:
-                            availability_msg_func = ha_cover_availabilty_message
-                        self._manager.send_ha_autodiscovery(
-                            id=_cover.id,
-                            name=_cover.name,
-                            ha_type=COVER,
-                            device_class=_config.get(DEVICE_CLASS),
-                            area=_config.get("area"),
-                            availability_msg_func=availability_msg_func,
+                    new_platform = _config.get("platform", "previous")
+                    
+                    # Check if platform (cover type) changed - need to recreate cover
+                    current_kind = _cover.kind
+                    new_kind = "venetian" if new_platform == "venetian" else ("time" if new_platform == "time_based" else "previous")
+                    
+                    if current_kind != new_kind:
+                        # Platform changed - remove old cover and create new one
+                        _LOGGER.info(
+                            "Cover %s platform changed from %s to %s, recreating cover",
+                            _id, current_kind, new_kind
                         )
-                    continue
+                        # Remove old HA autodiscovery
+                        self._remove_cover_ha_discovery(_id)
+                        # Remove old cover from dict (will be recreated below)
+                        del self._covers[_id]
+                    else:
+                        # Same platform - just update times and autodiscovery
+                        _cover.update_config_times(_config)
+                        # Re-send HA autodiscovery with potentially new area
+                        if _config.get(SHOW_HA, True):
+                            # Remove old autodiscovery first (in case area changed)
+                            self._remove_cover_ha_discovery(_id)
+                            # Send new autodiscovery
+                            if new_platform == "venetian":
+                                availability_msg_func = ha_cover_with_tilt_availabilty_message
+                            else:
+                                availability_msg_func = ha_cover_availabilty_message
+                            self._manager.send_ha_autodiscovery(
+                                id=_cover.id,
+                                name=_cover.name,
+                                ha_type=COVER,
+                                device_class=_config.get(DEVICE_CLASS),
+                                area=_config.get("area"),
+                                availability_msg_func=availability_msg_func,
+                            )
+                        continue
                 
                 self._covers[_id] = self._configure_cover(
                     cover_id=_id,
@@ -197,7 +214,7 @@ class CoverManager:
                 restored_state=restored_state,
                 tilt_duration=tilt_duration,
                 actuator_activation_duration=config.get("actuator_activation_duration", TimePeriod(milliseconds=0)),
-                **{k: v for k, v in config.items() if k not in ("platform", "actuator_activation_duration", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
+                **{k: v for k, v in config.items() if k not in ("platform", "actuator_activation_duration", "tilt_duration", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
             )
             availability_msg_func = ha_cover_with_tilt_availabilty_message
         elif platform == "time_based":
@@ -365,19 +382,21 @@ class CoverManager:
         This is called after reload to ensure frontend receives
         the state of all covers, including newly created ones.
         
-        Handles both PreviousCover (async_send_state) and BaseCover 
-        (send_state with state and position args) implementations.
+        Handles both PreviousCover (send_state with no args) and BaseCover 
+        (send_state with state and json_position args) implementations.
         """
+        from boneio.components.cover import PreviousCover, TimeBasedCover, VenetianCover
+        
         for cover in self._covers.values():
             try:
-                # PreviousCover has async_send_state()
-                if hasattr(cover, 'async_send_state'):
-                    self._manager.loop.create_task(cover.async_send_state())
-                # BaseCover (TimeBasedCover, VenetianCover) has send_state(state, json_position)
-                elif hasattr(cover, 'send_state') and hasattr(cover, 'json_position'):
+                if isinstance(cover, PreviousCover):
+                    # PreviousCover.send_state() takes no arguments
+                    cover.send_state()
+                elif isinstance(cover, (TimeBasedCover, VenetianCover)):
+                    # BaseCover.send_state(state, json_position) takes 2 arguments
                     cover.send_state(cover.state, cover.json_position)
             except Exception as e:
-                _LOGGER.debug(f"Error broadcasting cover state {cover.id}: {e}")
+                _LOGGER.debug("Error broadcasting cover state %s: %s", cover.id, e)
 
     async def send_ha_autodiscovery(self) -> None:
         """Send Home Assistant autodiscovery for all covers."""

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/core/manager/inputs.py

@@ -9,6 +9,7 @@ This module manages all input devices including:
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
 from typing import TYPE_CHECKING, Callable
 
@@ -22,6 +23,8 @@ from boneio.const import (
     INPUT,
     INPUT_SENSOR,
     PIN,
+    PRESSED,
+    RELEASED,
     SHOW_HA,
 )
 from boneio.exceptions import GPIOInputException
@@ -524,6 +527,50 @@ class InputManager:
             # Remove from internal cache
             self._manager._config_helper.remove_autodiscovery_msg(ha_type, topic)
 
+    def _publish_input_event_to_mqtt(
+        self, input_instance: GpioBaseClass, event: InputEvent
+    ) -> None:
+        """Publish input event to MQTT for Home Assistant.
+        
+        For event buttons (input_type=INPUT): sends JSON with event_type
+        For binary sensors (input_type=INPUT_SENSOR): sends pressed/released state
+        
+        Args:
+            input_instance: The input device instance
+            event: The input event data
+        """
+        topic_prefix = self._manager._config_helper.topic_prefix
+        input_id = input_instance.id
+        input_type = input_instance.input_type
+        click_type = event.click_type
+        topic = f"{topic_prefix}/input/{input_id}"
+        
+        if input_type == INPUT:         
+            event_payload: dict[str, str | float | None] = {"event_type": click_type}
+            if event.duration is not None:
+                event_payload["duration"] = round(event.duration, 3)
+            
+            self._manager.send_message(
+                topic=topic,
+                payload=json.dumps(event_payload),
+            )
+            _LOGGER.debug(
+                "Published event to MQTT: topic=%s, payload=%s",
+                topic, event_payload
+            )
+            
+        elif input_type == INPUT_SENSOR:
+            payload = str(click_type)  # "pressed" or "released"
+            
+            self._manager.send_message(
+                topic=topic,
+                payload=payload,
+            )
+            _LOGGER.debug(
+                "Published binary sensor state to MQTT: topic=%s, payload=%s",
+                topic, payload
+            )
+
     async def handle_input_event(self, event: InputEvent) -> None:
         """Handle input event from EventBus.
         
@@ -557,6 +604,9 @@ class InputManager:
             len(actions)
         )
         
+        # Send event to MQTT for Home Assistant
+        self._publish_input_event_to_mqtt(input_instance, event)
+        
         # Execute actions for this input event
         if actions:
             await self._manager.execute_actions(actions=actions)

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/hardware/gpio/expanders/mcp23017.py

@@ -7,6 +7,8 @@ This implementation is output-only for relay control.
 from __future__ import annotations
 
 import logging
+import threading
+import time
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -22,6 +24,10 @@ GPIOB = 0x13   # GPIO register for port B
 OLATA = 0x14   # Output latch register for port A
 OLATB = 0x15   # Output latch register for port B
 
+# Minimum delay between I2C operations in seconds
+# This prevents bus contention when switching multiple outputs rapidly
+I2C_OPERATION_DELAY = 0.002  # 2ms
+
 
 class MCP23017:
     """MCP23017 16-bit I2C GPIO expander driver.
@@ -54,10 +60,17 @@ class MCP23017:
         self._i2c = i2c
         self._address = address
         
+        # Lock for thread-safe pin operations
+        # This prevents race conditions when multiple outputs are switched simultaneously
+        self._lock = threading.Lock()
+        
         # Track output states (16 pins, 2 bytes)
         self._port_a_state = 0x00  # Pins 0-7
         self._port_b_state = 0x00  # Pins 8-15
         
+        # Timestamp of last I2C operation for rate limiting
+        self._last_operation_time = 0.0
+        
         # Lock the I2C bus for initialization
         if not self._i2c.try_lock():
             raise RuntimeError("Failed to lock I2C bus for MCP23017 initialization")
@@ -130,25 +143,36 @@ class MCP23017:
     def _write_pin(self, pin_number: int, value: bool) -> None:
         """Write value to a pin.
         
+        Thread-safe operation with rate limiting to prevent I2C bus contention.
+        
         Args:
             pin_number: Pin number (0-15)
             value: Output state (True=HIGH, False=LOW)
         """
-        if pin_number < 8:
-            # Port A (pins 0-7)
-            if value:
-                self._port_a_state |= (1 << pin_number)  # Set bit
-            else:
-                self._port_a_state &= ~(1 << pin_number)  # Clear bit
-            self._write_register(OLATA, self._port_a_state)
-        else:
-            # Port B (pins 8-15)
-            pin_bit = pin_number - 8
-            if value:
-                self._port_b_state |= (1 << pin_bit)  # Set bit
+        with self._lock:
+            # Rate limiting: ensure minimum delay between I2C operations
+            now = time.monotonic()
+            elapsed = now - self._last_operation_time
+            if elapsed < I2C_OPERATION_DELAY:
+                time.sleep(I2C_OPERATION_DELAY - elapsed)
+            
+            if pin_number < 8:
+                # Port A (pins 0-7)
+                if value:
+                    self._port_a_state |= (1 << pin_number)  # Set bit
+                else:
+                    self._port_a_state &= ~(1 << pin_number)  # Clear bit
+                self._write_register(OLATA, self._port_a_state)
             else:
-                self._port_b_state &= ~(1 << pin_bit)  # Clear bit
-            self._write_register(OLATB, self._port_b_state)
+                # Port B (pins 8-15)
+                pin_bit = pin_number - 8
+                if value:
+                    self._port_b_state |= (1 << pin_bit)  # Set bit
+                else:
+                    self._port_b_state &= ~(1 << pin_bit)  # Clear bit
+                self._write_register(OLATB, self._port_b_state)
+            
+            self._last_operation_time = time.monotonic()
 
     def configure_pin_as_output(self, pin_number: int, value: bool = False) -> None:
         """Configure a pin as output and set initial value.

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/hardware/gpio/expanders/pca9685.py

@@ -28,6 +28,7 @@ Each channel has 4 registers:
 from __future__ import annotations
 
 import logging
+import threading
 import time
 from typing import TYPE_CHECKING
 
@@ -36,6 +37,10 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+# Minimum delay between I2C operations in seconds
+# This prevents bus contention when switching multiple outputs rapidly
+I2C_OPERATION_DELAY = 0.002  # 2ms
+
 # Register addresses
 MODE1 = 0x00
 MODE2 = 0x01
@@ -188,6 +193,13 @@ class PCA9685:
         self._address = address
         self._reference_clock_speed = reference_clock_speed
         
+        # Lock for thread-safe channel operations
+        # This prevents race conditions when multiple outputs are switched simultaneously
+        self._lock = threading.Lock()
+        
+        # Timestamp of last I2C operation for rate limiting
+        self._last_operation_time = 0.0
+        
         # Initialize channels container
         self.channels = PCAChannels(self)
         
@@ -267,6 +279,8 @@ class PCA9685:
     def _write_channel(self, channel: int, value: int) -> None:
         """Write PWM value to a channel (0-4095).
         
+        Thread-safe operation with rate limiting to prevent I2C bus contention.
+        
         Args:
             channel: Channel number (0-15)
             value: PWM value (0-4095, 12-bit)
@@ -277,52 +291,61 @@ class PCA9685:
         if not 0 <= value <= 4095:
             raise ValueError(f"PWM value must be 0-4095, got {value}")
         
-        # Calculate register addresses for this channel
-        # Each channel has 4 registers: ON_L, ON_H, OFF_L, OFF_H
-        base_reg = LED0_ON_L + (channel * 4)
-        
-        # For normal PWM:
-        # - ON time = 0 (start at beginning of cycle)
-        # - OFF time = value (turn off at specified point)
-        on_time = 0
-        off_time = value
-        
-        # Special case: full off (value = 0)
-        if value == 0:
-            # Set bit 12 of OFF time to turn LED fully off
-            off_time = 0x1000
-        # Special case: full on (value = 4095)
-        elif value == 4095:
-            # Set bit 12 of ON time to turn LED fully on
-            on_time = 0x1000
-            off_time = 0
-        
-        # Write 4 bytes: ON_L, ON_H, OFF_L, OFF_H
-        data = [
-            on_time & 0xFF,         # ON_L
-            (on_time >> 8) & 0xFF,  # ON_H
-            off_time & 0xFF,        # OFF_L
-            (off_time >> 8) & 0xFF, # OFF_H
-        ]
-        
-        try:
-            self._i2c.write_i2c_block_data(self._address, base_reg, data)
-            _LOGGER.debug(
-                "PCA9685 0x%02X: Channel %d set to %d (ON=0x%04X, OFF=0x%04X)",
-                self._address,
-                channel,
-                value,
-                on_time,
-                off_time,
-            )
-        except Exception as e:
-            _LOGGER.error(
-                "Failed to write channel %d on PCA9685 at 0x%02X: %s",
-                channel,
-                self._address,
-                e,
-            )
-            raise
+        with self._lock:
+            # Rate limiting: ensure minimum delay between I2C operations
+            now = time.monotonic()
+            elapsed = now - self._last_operation_time
+            if elapsed < I2C_OPERATION_DELAY:
+                time.sleep(I2C_OPERATION_DELAY - elapsed)
+            
+            # Calculate register addresses for this channel
+            # Each channel has 4 registers: ON_L, ON_H, OFF_L, OFF_H
+            base_reg = LED0_ON_L + (channel * 4)
+            
+            # For normal PWM:
+            # - ON time = 0 (start at beginning of cycle)
+            # - OFF time = value (turn off at specified point)
+            on_time = 0
+            off_time = value
+            
+            # Special case: full off (value = 0)
+            if value == 0:
+                # Set bit 12 of OFF time to turn LED fully off
+                off_time = 0x1000
+            # Special case: full on (value = 4095)
+            elif value == 4095:
+                # Set bit 12 of ON time to turn LED fully on
+                on_time = 0x1000
+                off_time = 0
+            
+            # Write 4 bytes: ON_L, ON_H, OFF_L, OFF_H
+            data = [
+                on_time & 0xFF,         # ON_L
+                (on_time >> 8) & 0xFF,  # ON_H
+                off_time & 0xFF,        # OFF_L
+                (off_time >> 8) & 0xFF, # OFF_H
+            ]
+            
+            try:
+                self._i2c.write_i2c_block_data(self._address, base_reg, data)
+                _LOGGER.debug(
+                    "PCA9685 0x%02X: Channel %d set to %d (ON=0x%04X, OFF=0x%04X)",
+                    self._address,
+                    channel,
+                    value,
+                    on_time,
+                    off_time,
+                )
+            except Exception as e:
+                _LOGGER.error(
+                    "Failed to write channel %d on PCA9685 at 0x%02X: %s",
+                    channel,
+                    self._address,
+                    e,
+                )
+                raise
+            
+            self._last_operation_time = time.monotonic()
 
     def _read_channel(self, channel: int) -> int:
         """Read PWM value from a channel (0-4095).

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/hardware/gpio/expanders/pcf8575.py

@@ -22,6 +22,8 @@ For BoneIO, we use PCF8575 primarily for output (relay control).
 from __future__ import annotations
 
 import logging
+import threading
+import time
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -29,6 +31,10 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+# Minimum delay between I2C operations in seconds
+# This prevents bus contention when switching multiple outputs rapidly
+I2C_OPERATION_DELAY = 0.002  # 2ms
+
 
 class PCF8575:
     """PCF8575 16-bit I2C GPIO expander.
@@ -61,11 +67,18 @@ class PCF8575:
         self._i2c = i2c
         self._address = address
         
+        # Lock for thread-safe pin operations
+        # This prevents race conditions when multiple outputs are switched simultaneously
+        self._lock = threading.Lock()
+        
         # State tracking for all 16 pins (2 bytes)
         # Bit = 1: HIGH (output) or input with pull-up
         # Bit = 0: LOW (output)
         self._state = 0xFFFF  # All pins HIGH (default state)
         
+        # Timestamp of last I2C operation for rate limiting
+        self._last_operation_time = 0.0
+        
         # Initialize device - write default state
         self._write_state()
         
@@ -202,28 +215,48 @@ class PCF8575:
     def _set_pin_output(self, pin: int, value: bool) -> None:
         """Set a pin to output mode with specified value.
         
+        Thread-safe operation with rate limiting to prevent I2C bus contention.
+        
         Args:
             pin: Pin number (0-15)
             value: Output value (True=HIGH, False=LOW)
         """
-        if value:
-            # Set bit to 1 (HIGH)
-            self._state |= (1 << pin)
-        else:
-            # Clear bit to 0 (LOW)
-            self._state &= ~(1 << pin)
-        
-        self._write_state()
+        with self._lock:
+            # Rate limiting: ensure minimum delay between I2C operations
+            now = time.monotonic()
+            elapsed = now - self._last_operation_time
+            if elapsed < I2C_OPERATION_DELAY:
+                time.sleep(I2C_OPERATION_DELAY - elapsed)
+            
+            if value:
+                # Set bit to 1 (HIGH)
+                self._state |= (1 << pin)
+            else:
+                # Clear bit to 0 (LOW)
+                self._state &= ~(1 << pin)
+            
+            self._write_state()
+            self._last_operation_time = time.monotonic()
 
     def _set_pin_input(self, pin: int) -> None:
         """Set a pin to input mode (enables pull-up).
         
+        Thread-safe operation with rate limiting.
+        
         Args:
             pin: Pin number (0-15)
         """
-        # Set bit to 1 to enable pull-up for input
-        self._state |= (1 << pin)
-        self._write_state()
+        with self._lock:
+            # Rate limiting: ensure minimum delay between I2C operations
+            now = time.monotonic()
+            elapsed = now - self._last_operation_time
+            if elapsed < I2C_OPERATION_DELAY:
+                time.sleep(I2C_OPERATION_DELAY - elapsed)
+            
+            # Set bit to 1 to enable pull-up for input
+            self._state |= (1 << pin)
+            self._write_state()
+            self._last_operation_time = time.monotonic()
 
     def _read_pin(self, pin: int) -> bool:
         """Read the current value of a pin.

{boneio-1.0.0.dev6 → boneio-1.0.0.dev7}/boneio/modbus/coordinator.py

@@ -428,7 +428,7 @@ class ModbusCoordinator(BasicMqtt, AsyncUpdater, Filter):
         """
         return self._additional_entities_by_name.get(name)
 
-    def find_entity(self, entity_id: str) -> BaseEntity | None:
+    def find_entity(self, entity_id: str) -> ModbusEntity | DerivedEntity | ModbusDerivedNumericSensor | ModbusDerivedTextSensor | ModbusDerivedSelect | ModbusDerivedSwitch | None:
         """Find entity by ID or decoded name in both regular and additional entities.
         
         Args:

boneio-1.0.0.dev7/boneio/version.py

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