boneio 1.2.0.dev26__tar.gz → 1.3.0.dev1__tar.gz

{boneio-1.2.0.dev26/boneio.egg-info → boneio-1.3.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.2.0.dev26
+Version: 1.3.0.dev1
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -35,6 +35,7 @@ Requires-Dist: requests==2.32.5
 Requires-Dist: packaging==25.0
 Requires-Dist: aioesphomeapi>=29.0.0
 Requires-Dist: zeroconf>=0.148.0
+Requires-Dist: canopen-asyncio>=2.3.0
 Dynamic: license-file
 
 Example usage:

{boneio-1.2.0.dev26 → boneio-1.3.0.dev1}/boneio/components/input/detectors.py

@@ -31,6 +31,7 @@ class ClickState:
     """State for tracking multi-click detection."""
     click_count: int = 0
     last_press_ts: float | None = None
+    last_press_loop_ts: float | None = None  # Event loop time of last press (for duration calc)
     last_release_ts: float | None = None
     finalizer: asyncio.TimerHandle | None = None
     finalizer_scheduled_loop_ts: float | None = None
@@ -77,6 +78,7 @@ class MultiClickDetector:
         enable_triple_click: bool = False,
         name: str = "unknown",
         pin: str = "unknown",
+        max_long_press_seconds: float = 120.0,
     ):
         """Initialize multiclick detector.
         
@@ -92,6 +94,7 @@ class MultiClickDetector:
             enable_triple_click: Enable triple click detection (default: False)
             name: Name of the input
             pin: Pin name for logging
+            max_long_press_seconds: Safety timeout for long press in seconds (default: 120s)
         """
         self._loop = loop
         self._callback = callback
@@ -104,6 +107,7 @@ class MultiClickDetector:
         self._enable_triple_click = enable_triple_click
         self._name = name
         self._pin = pin
+        self._max_long_press_seconds = max_long_press_seconds
         self._state = ClickState()
         
         # Pre-compute which click types should be delayed in exclusive mode
@@ -357,14 +361,14 @@ class MultiClickDetector:
 
     def _detect_long_press(self) -> None:
         """Detect and report a long press and start periodic updates."""
-        if not self._state.last_press_ts:
+        if not self._state.last_press_loop_ts:
             return
         
         # Reset executed actions for new long press
         self._state.executed_long_actions = set()
         self._state.last_repeat_times = {}
         
-        duration = self._loop.time() - self._state.last_press_ts
+        duration = self._loop.time() - self._state.last_press_loop_ts
         
         _LOGGER.info("Detected LONG press on %s (%s)", self._name, self._pin)
         
@@ -383,11 +387,24 @@ class MultiClickDetector:
     
     def _send_periodic_long_event(self) -> None:
         """Send periodic 'long' event with updated duration."""
-        if not self._state.last_press_ts or self._state.last_release_ts:
+        if not self._state.last_press_loop_ts or self._state.last_release_ts:
             # Button released or invalid state
             return
         
-        duration = self._loop.time() - self._state.last_press_ts
+        duration = self._loop.time() - self._state.last_press_loop_ts
+        
+        # Safety timeout: stop periodic events if duration exceeds max
+        if duration > self._max_long_press_seconds:
+            _LOGGER.warning(
+                "Safety timeout: long press on %s (%s) exceeded %.0fs (duration=%.1fs). "
+                "Possible missed RELEASE event. Forcing stop.",
+                self._name,
+                self._pin,
+                self._max_long_press_seconds,
+                duration,
+            )
+            self._force_stop_long_press()
+            return
         
         _LOGGER.debug(
             "Periodic long event on %s (%s), duration=%.3fs",
@@ -404,6 +421,34 @@ class MultiClickDetector:
             0.2,
             self._send_periodic_long_event
         )
+    
+    def _force_stop_long_press(self) -> None:
+        """Force stop a long press due to safety timeout (missed RELEASE).
+        
+        Cleans up all long-press related state as if a RELEASE event occurred.
+        """
+        if self._state.long_hold_periodic_timer:
+            self._state.long_hold_periodic_timer.cancel()
+            self._state.long_hold_periodic_timer = None
+        
+        if self._state.long_press_timer:
+            self._state.long_press_timer.cancel()
+            self._state.long_press_timer = None
+            self._state.long_press_scheduled_loop_ts = None
+        
+        # Simulate release: use last_press_ts (kernel time) as base to stay
+        # consistent with debounce comparisons that use kernel timestamps
+        self._state.last_release_ts = self._state.last_press_ts or 0.0
+        
+        # Reset long press action tracking
+        self._state.executed_long_actions = set()
+        self._state.last_repeat_times = {}
+        
+        _LOGGER.info(
+            "Forced long press stop on %s (%s) - state cleaned up",
+            self._name,
+            self._pin,
+        )
 
     def handle_event(self, event: gpiod.EdgeEvent) -> None:
         """Process a GPIO edge event and update click state.
@@ -435,6 +480,7 @@ class MultiClickDetector:
 
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
+            self._state.last_press_loop_ts = self._loop.time()  # Store loop time for duration calc
             self._state.last_release_ts = None  # Reset release timestamp for new press
 
             # Cancel any pending finalizer for a multi-click sequence
@@ -510,8 +556,8 @@ class MultiClickDetector:
                 # Note: The callback creates an async task, so we need to delay
                 # the reset of executed_actions to allow the async handler to
                 # read the current state before it's cleared
-                if self._state.last_press_ts:
-                    duration = timestamp_s - self._state.last_press_ts
+                if self._state.last_press_loop_ts:
+                    duration = self._loop.time() - self._state.last_press_loop_ts
                     _LOGGER.debug(
                         "Sending final long event on release for %s, duration=%.3fs, executed_actions=%s",
                         self._name,

{boneio-1.2.0.dev26 → boneio-1.3.0.dev1}/boneio/components/input/event.py

@@ -89,6 +89,12 @@ class GpioEventButton(GpioBaseClass):
         # Get enable_triple_click setting (default: False)
         enable_triple_click = kwargs.get('enable_triple_click', False)
         
+        # Safety timeout for long press (default: 120s)
+        max_long_press_seconds = _to_milliseconds(
+            kwargs.get('max_long_press_duration'),
+            120 * 1000  # 120s default
+        ) / 1000.0
+        
         # Create multiclick detector
         self._detector = MultiClickDetector(
             loop=self._loop,
@@ -102,6 +108,7 @@ class GpioEventButton(GpioBaseClass):
             enable_triple_click=enable_triple_click,
             name=self._name,
             pin=self._pin,
+            max_long_press_seconds=max_long_press_seconds,
         )
         
         # Register with GPIO manager
@@ -148,6 +155,7 @@ class GpioEventButton(GpioBaseClass):
         mqtt_sequences: dict | None = None,
         enable_triple_click: bool | None = None,
         long_press_mqtt_mode: str | None = None,
+        max_long_press_duration: int | float | None = None,
     ) -> None:
         """Update timing parameters for click detection.
         
@@ -163,6 +171,7 @@ class GpioEventButton(GpioBaseClass):
             mqtt_sequences: MQTT sequences dict to determine enabled sequences
             enable_triple_click: Enable triple click detection
             long_press_mqtt_mode: 'single' or 'periodic' for MQTT long press events
+            max_long_press_duration: Safety timeout for long press in ms (default: 120000ms)
         """
         from boneio.const import CLICK_SEQUENCES
         
@@ -217,6 +226,11 @@ class GpioEventButton(GpioBaseClass):
                             break
             _LOGGER.debug("Updated enabled_sequences to %s for %s", enabled_sequences, self._name)
 
+        if max_long_press_duration is not None:
+            value_ms = _to_milliseconds(max_long_press_duration, 120 * 1000)
+            self._detector._max_long_press_seconds = value_ms / 1000.0
+            _LOGGER.debug("Updated max_long_press_duration to %dms for %s", value_ms, self._name)
+
         if long_press_mqtt_mode is not None:
             self._long_press_mqtt_mode = long_press_mqtt_mode
             _LOGGER.debug("Updated long_press_mqtt_mode to %s for %s", long_press_mqtt_mode, self._name)

{boneio-1.2.0.dev26 → boneio-1.3.0.dev1}/boneio/const.py

@@ -40,6 +40,7 @@ NONE = "none"
 MODBUS = "modbus"
 MODBUS_SENSOR  = "modbus_sensor"
 MODBUS_DEVICE = "modbus_device"
+CAN = "can"
 UART = "uart"
 RX = "rx"
 TX = "tx"

{boneio-1.2.0.dev26 → boneio-1.3.0.dev1}/boneio/core/config/config_helper.py

@@ -50,6 +50,7 @@ class ConfigHelper:
         update_channel: str = "stable",
         cloud_registration: bool = False,
         pwa_name: str | None = None,
+        ha_child_devices: bool = False,
     ):
         self._name = name
         
@@ -81,6 +82,7 @@ class ConfigHelper:
         self._receive_boneio_autodiscovery = receive_boneio_autodiscovery
         self._update_channel = update_channel
         self._cloud_registration = cloud_registration
+        self._ha_child_devices = ha_child_devices
         self._device_type = device_type
         self._web_port = web_port
         self._proxy_port = proxy_port
@@ -225,6 +227,15 @@ class ConfigHelper:
         """Check if cloud registration (PWA) is enabled."""
         return self._cloud_registration
 
+    @property
+    def ha_child_devices(self) -> bool:
+        """Check if experimental HA child devices mode is enabled.
+        
+        When enabled, each output/input/cover becomes its own child device
+        in Home Assistant instead of being grouped under one main device.
+        """
+        return self._ha_child_devices
+
     @property
     def device_type(self) -> str:
         return self._device_type