boneIO 1.0.0.dev21__tar.gz → 1.0.0.dev23__tar.gz

{boneio-1.0.0.dev21/boneio.egg-info → boneio-1.0.0.dev23}/PKG-INFO

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

{boneio-1.0.0.dev21/boneio/boards/0.4 → boneio-1.0.0.dev23/boneio/boards/0.2}/output_24_16.yaml

@@ -1,8 +1,8 @@
 mcp23017:
   - id: mcp_left
-    address: 0x20
+    address: 0x23
   - id: mcp_right
-    address: 0x21
+    address: 0x22
 
 output_mapping:
   out_01:

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/boards/0.3/output_24_16.yaml

@@ -1,8 +1,8 @@
 mcp23017:
   - id: mcp_left
-    address: 0x20
+    address: 0x23
   - id: mcp_right
-    address: 0x21
+    address: 0x22
 
 output_mapping:
   out_01:

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/components/cover/time_based.py

@@ -41,7 +41,13 @@ class TimeBasedCover(BaseCover):
 
 
     def _move_cover(self, direction: str, duration: float, target_position: int | None = None):
-        """Metoda uruchamiana w oddzielnym wątku do fizycznego ruchu rolety."""
+        """Run in sepearate thread.
+        
+        Args:
+            direction: Direction of movement (OPEN or CLOSE)
+            duration: Full time for 0-100% movement in milliseconds
+            target_position: Optional target position (0-100)
+        """
         if direction == OPEN:
             relay = self._open_relay
             total_steps = 100 - self._position
@@ -56,18 +62,22 @@ class TimeBasedCover(BaseCover):
             self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
             return
 
+        # Calculate actual duration based on remaining distance
+        # duration is full time for 100% movement, scale it by actual distance to travel
+        actual_duration = duration * (total_steps / 100.0)
+
         relay.turn_on()
         start_time = time.monotonic()
 
         while not self._stop_event.is_set():
             current_time = time.monotonic()  # Pobierz aktualny czas tylko raz na iterację
             elapsed_time = (current_time - start_time) * 1000  # Konwersja na milisekundy
-            progress = elapsed_time / duration
+            progress = elapsed_time / actual_duration if actual_duration > 0 else 1.0
 
             if direction == OPEN:
-                self._position = min(100.0, self._initial_position + progress * 100)
+                self._position = min(100.0, self._initial_position + progress * total_steps)
             elif direction == CLOSE:
-                self._position = max(0.0, self._initial_position - progress * 100)
+                self._position = max(0.0, self._initial_position - progress * total_steps)
 
             self._last_timestamp = current_time # Użyj pobranego czasu
             if current_time - self._last_update_time >= 1:

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/components/cover/venetian.py

@@ -97,6 +97,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             )
             return
 
+        # Calculate actual duration based on remaining distance
+        # duration is full time for 100% movement, scale it by actual distance to travel
+        actual_duration = duration * (total_steps / 100.0)
+
         relay.turn_on()
         start_time = time.monotonic()
         progress = 0.0
@@ -116,15 +120,15 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
            
             if elapsed_time < needed_tilt_duration:
-                tilt_progress = elapsed_time / needed_tilt_duration
+                tilt_progress = elapsed_time / needed_tilt_duration if needed_tilt_duration > 0 else 1.0
                 progress = 0.0
             else:
                 tilt_progress = 1.0
-                progress = (elapsed_time - needed_tilt_duration) / duration
+                progress = (elapsed_time - needed_tilt_duration) / actual_duration if actual_duration > 0 else 1.0
 
             if direction == OPEN:
                 # Obliczanie _position dla kierunku OPEN
-                self._position = min(100.0, self._initial_position + progress * 100)
+                self._position = min(100.0, self._initial_position + progress * total_steps)
 
                 # Obliczanie _tilt_position dla kierunku OPEN
                 if target_tilt_position is not None:
@@ -135,7 +139,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
                     )
             elif direction == CLOSE:
                 # Obliczanie _position dla kierunku CLOSE
-                self._position = max(0.0, self._initial_position - progress * 100)
+                self._position = max(0.0, self._initial_position - progress * total_steps)
 
                 # Obliczanie _tilt_position dla kierunku CLOSE
                 if target_tilt_position is not None:

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/components/input/binary_sensor.py

@@ -54,9 +54,9 @@ class GpioInputBinarySensor(GpioBaseClass):
         _LOGGER.debug("Configured binary sensor %s on pin %s (inverted=%s)", 
                      self._name, self._pin, inverted)
         
-        # Send initial state if requested
+        # Send initial state if requested - register callback to run after GPIO manager starts
         if kwargs.get("initial_send", False):
-            self._loop.call_soon(callback=self._send_initial_state)
+            gpio_manager.register_on_start_callback(self._send_initial_state)
 
     def _send_initial_state(self) -> None:
         """Send initial state after setup."""

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/components/input/detectors.py

@@ -39,6 +39,10 @@ class ClickState:
     # Sequence tracking
     last_click_type: str | None = None
     last_click_time: float | None = None
+    # Exclusive mode: pending click waiting for sequence window
+    pending_click_type: str | None = None
+    pending_click_duration: float | None = None
+    pending_click_timer: asyncio.TimerHandle | None = None
 
 
 @dataclass
@@ -64,6 +68,9 @@ class MultiClickDetector:
         multiclick_window_ms: float = 220.0,
         hold_threshold_ms: float = 400.0,
         sequence_window_ms: float = DEFAULT_SEQUENCE_WINDOW_MS,
+        sequence_mode: str = "immediate",
+        enabled_sequences: set[str] | None = None,
+        enable_triple_click: bool = False,
         name: str = "unknown",
         pin: str = "unknown",
     ):
@@ -76,6 +83,9 @@ class MultiClickDetector:
             multiclick_window_ms: Window for double-click detection
             hold_threshold_ms: Time threshold for long press
             sequence_window_ms: Window for sequence detection (e.g., double_then_long)
+            sequence_mode: 'immediate' (default) or 'exclusive'
+            enabled_sequences: Set of enabled sequence types (e.g., {'double_then_long'})
+            enable_triple_click: Enable triple click detection (default: False)
             name: Name of the input
             pin: Pin name for logging
         """
@@ -85,9 +95,23 @@ class MultiClickDetector:
         self._multiclick_window = multiclick_window_ms / 1000.0
         self._hold_threshold = hold_threshold_ms / 1000.0
         self._sequence_window = sequence_window_ms / 1000.0
+        self._sequence_mode = sequence_mode
+        self._enabled_sequences = enabled_sequences or set()
+        self._enable_triple_click = enable_triple_click
         self._name = name
         self._pin = pin
         self._state = ClickState()
+        
+        # Pre-compute which click types should be delayed in exclusive mode
+        # based on enabled sequences
+        self._delay_click_types: set[str] = set()
+        if sequence_mode == "exclusive" and self._enabled_sequences:
+            for seq in self._enabled_sequences:
+                # Find which click type starts this sequence
+                for (first, _second), seq_name in CLICK_SEQUENCES.items():
+                    if seq_name == seq:
+                        self._delay_click_types.add(first)
+                        break
 
     def _finalize_clicks(self) -> None:
         """Finalize a multi-click sequence."""
@@ -100,8 +124,18 @@ class MultiClickDetector:
             click_type = DOUBLE
             _LOGGER.info("Detected DOUBLE click on %s (%s)", self._name, self._pin)
         elif count == 3:
-            click_type = TRIPLE
-            _LOGGER.info("Detected TRIPLE click on %s (%s)", self._name, self._pin)
+            if self._enable_triple_click:
+                click_type = TRIPLE
+                _LOGGER.info("Detected TRIPLE click on %s (%s)", self._name, self._pin)
+            else:
+                # Triple click disabled - emit double + single instead
+                _LOGGER.info("Triple click disabled on %s (%s), emitting DOUBLE + SINGLE", self._name, self._pin)
+                self._state.click_count = 0
+                self._state.finalizer = None
+                self._state.finalizer_scheduled_loop_ts = None
+                self._emit_click(DOUBLE, None)
+                self._emit_click(SINGLE, None)
+                return
         else:
             click_type = SINGLE  # Fallback for 4+ clicks
             _LOGGER.info("Detected %d clicks on %s (%s), treating as SINGLE", count, self._name, self._pin)
@@ -116,12 +150,22 @@ class MultiClickDetector:
     def _emit_click(self, click_type: ClickTypes, duration: float | None) -> None:
         """Emit a click event, checking for sequences first.
         
+        In 'immediate' mode: emit events immediately, sequences are additional.
+        In 'exclusive' mode: delay single/double, if sequence detected only emit sequence.
+        
         Args:
             click_type: The detected click type (single, double, triple, long)
             duration: Duration of the click (for long press)
         """
         current_time = self._loop.time()
         
+        if self._sequence_mode == "exclusive":
+            self._emit_click_exclusive(click_type, duration, current_time)
+        else:
+            self._emit_click_immediate(click_type, duration, current_time)
+
+    def _emit_click_immediate(self, click_type: ClickTypes, duration: float | None, current_time: float) -> None:
+        """Immediate mode: emit events immediately, sequences are additional."""
         # Check if this click forms a sequence with the previous one
         sequence_type = self._check_sequence(click_type, current_time)
         if sequence_type:
@@ -144,6 +188,138 @@ class MultiClickDetector:
         self._state.last_click_type = click_type
         self._state.last_click_time = current_time
 
+    def _emit_click_exclusive(self, click_type: ClickTypes, duration: float | None, current_time: float) -> None:
+        """Exclusive mode: delay single/double, if sequence detected only emit sequence.
+        
+        Logic:
+        - For single/double: store as pending, start timer for sequence_window
+        - For long/single: check if pending exists, if so check for sequence
+        - Timer expiry: emit the pending click
+        
+        Supported sequences:
+        - double_then_long: double (pending) + long
+        - single_then_long: single (pending) + long
+        - double_then_single: double (pending) + single
+        """
+        # Check if there's a pending click and this could form a sequence
+        if self._state.pending_click_type:
+            # Check if we can form a sequence with current click
+            sequence_key = (self._state.pending_click_type, click_type)
+            sequence_type = CLICK_SEQUENCES.get(sequence_key)
+            
+            # Only detect sequences that are actually enabled
+            if sequence_type and sequence_type in self._enabled_sequences:
+                # Cancel pending timer
+                if self._state.pending_click_timer:
+                    self._state.pending_click_timer.cancel()
+                    self._state.pending_click_timer = None
+                
+                _LOGGER.info(
+                    "Detected sequence %s on %s (%s) [exclusive mode]",
+                    sequence_type.upper(), self._name, self._pin
+                )
+                
+                # Clear pending state
+                self._state.pending_click_type = None
+                self._state.pending_click_duration = None
+                
+                # Emit only the sequence, not the base events
+                try:
+                    self._callback(cast(ClickTypes, sequence_type), duration)
+                except Exception as exc:
+                    _LOGGER.error("Error in sequence callback for %s: %s", self._name, exc, exc_info=True)
+                
+                # Clear sequence tracking
+                self._state.last_click_type = None
+                self._state.last_click_time = None
+                return
+            else:
+                # Sequence not enabled - emit the pending click now and continue
+                # Cancel pending timer
+                if self._state.pending_click_timer:
+                    self._state.pending_click_timer.cancel()
+                    self._state.pending_click_timer = None
+                
+                pending_type = self._state.pending_click_type
+                pending_duration = self._state.pending_click_duration
+                
+                _LOGGER.debug(
+                    "Sequence %s not enabled, emitting pending click %s on %s",
+                    sequence_type, pending_type, self._name
+                )
+                
+                # Clear pending state
+                self._state.pending_click_type = None
+                self._state.pending_click_duration = None
+                
+                # Emit the pending click
+                try:
+                    self._callback(cast(ClickTypes, pending_type), pending_duration)
+                except Exception as exc:
+                    _LOGGER.error("Error in click callback for %s: %s", self._name, exc, exc_info=True)
+                
+                # Continue to process current click below (don't return)
+        
+        # Only delay click types that can start a configured sequence
+        # e.g., if only double_then_long is enabled, only delay 'double', not 'single'
+        if click_type in self._delay_click_types:
+            # Cancel any existing pending timer
+            if self._state.pending_click_timer:
+                self._state.pending_click_timer.cancel()
+            
+            # Store pending click
+            self._state.pending_click_type = click_type
+            self._state.pending_click_duration = duration
+            
+            # Start timer to emit after sequence window
+            self._state.pending_click_timer = self._loop.call_later(
+                self._sequence_window,
+                self._emit_pending_click
+            )
+            _LOGGER.debug(
+                "Pending click %s on %s, waiting %.0fms for sequence",
+                click_type, self._name, self._sequence_window * 1000
+            )
+            return
+        
+        # For long (without pending) or other types: emit immediately
+        try:
+            self._callback(click_type, duration)
+        except Exception as exc:
+            _LOGGER.error("Error in click callback for %s: %s", self._name, exc, exc_info=True)
+        
+        # Remember for sequence detection
+        self._state.last_click_type = click_type
+        self._state.last_click_time = current_time
+
+    def _emit_pending_click(self) -> None:
+        """Emit the pending click after sequence window expired (exclusive mode)."""
+        if not self._state.pending_click_type:
+            return
+        
+        click_type = cast(ClickTypes, self._state.pending_click_type)
+        duration = self._state.pending_click_duration
+        
+        _LOGGER.debug(
+            "Sequence window expired, emitting pending click %s on %s",
+            click_type, self._name
+        )
+        
+        # Clear pending state
+        self._state.pending_click_type = None
+        self._state.pending_click_duration = None
+        self._state.pending_click_timer = None
+        
+        # Emit the click
+        try:
+            self._callback(click_type, duration)
+        except Exception as exc:
+            _LOGGER.error("Error in pending click callback for %s: %s", self._name, exc, exc_info=True)
+        
+        # Remember for sequence detection (in case of chained sequences)
+        self._state.last_click_type = click_type
+        self._state.last_click_time = self._loop.time()
+
     def _check_sequence(self, current_click: ClickTypes, current_time: float) -> ClickTypes | None:
         """Check if current click forms a sequence with previous click.
         
@@ -166,7 +342,8 @@ class MultiClickDetector:
         sequence_key = (self._state.last_click_type, current_click)
         sequence_type = CLICK_SEQUENCES.get(sequence_key)
         
-        if sequence_type:
+        # Only detect sequences that are actually enabled
+        if sequence_type and sequence_type in self._enabled_sequences:
             # Clear sequence state to prevent chaining
             self._state.last_click_type = None
             self._state.last_click_time = None
@@ -227,6 +404,16 @@ class MultiClickDetector:
                 self._state.finalizer = None
                 self._state.finalizer_scheduled_loop_ts = None
 
+            # In exclusive mode: if there's a pending click waiting for sequence,
+            # cancel its timer - user is continuing the sequence with this press
+            if self._sequence_mode == "exclusive" and self._state.pending_click_timer:
+                _LOGGER.debug(
+                    "Cancelling pending click timer for %s - user continuing sequence",
+                    self._name
+                )
+                self._state.pending_click_timer.cancel()
+                self._state.pending_click_timer = None
+
             # Schedule a check for a long press
             scheduled_at = self._loop.time()
             self._state.long_press_scheduled_loop_ts = scheduled_at

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/components/input/event.py

@@ -65,6 +65,30 @@ class GpioEventButton(GpioBaseClass):
             DEFAULT_SEQUENCE_WINDOW_MS
         )
         
+        # Determine which sequences are enabled based on configured actions OR mqtt_sequences
+        # A sequence is enabled if it has actions defined OR is set to publish to MQTT
+        enabled_sequences: set[str] = set()
+        sequence_types = {'double_then_long', 'single_then_long', 'double_then_single'}
+        
+        # Check actions
+        actions = kwargs.get('actions', {})
+        if isinstance(actions, dict):
+            for seq_type in sequence_types:
+                if seq_type in actions and actions[seq_type]:
+                    enabled_sequences.add(seq_type)
+        
+        # Check mqtt_sequences
+        mqtt_sequences = kwargs.get('mqtt_sequences', {})
+        if isinstance(mqtt_sequences, dict):
+            for seq_type in sequence_types:
+                if mqtt_sequences.get(seq_type):
+                    enabled_sequences.add(seq_type)
+        
+        _LOGGER.debug("Enabled sequences for %s: %s", self._name, enabled_sequences)
+        
+        # Get enable_triple_click setting (default: False)
+        enable_triple_click = kwargs.get('enable_triple_click', False)
+        
         # Create multiclick detector
         self._detector = MultiClickDetector(
             loop=self._loop,
@@ -73,6 +97,9 @@ class GpioEventButton(GpioBaseClass):
             multiclick_window_ms=double_click_duration,
             hold_threshold_ms=long_press_duration,
             sequence_window_ms=sequence_window_duration,
+            sequence_mode=self._sequence_mode,
+            enabled_sequences=enabled_sequences,
+            enable_triple_click=enable_triple_click,
             name=self._name,
             pin=self._pin,
         )
@@ -116,6 +143,10 @@ class GpioEventButton(GpioBaseClass):
         double_click_duration: int | float | None = None,
         long_press_duration: int | float | None = None,
         sequence_window_duration: int | float | None = None,
+        sequence_mode: str | None = None,
+        actions: dict | None = None,
+        mqtt_sequences: dict | None = None,
+        enable_triple_click: bool | None = None,
     ) -> None:
         """Update timing parameters for click detection.
         
@@ -126,7 +157,13 @@ class GpioEventButton(GpioBaseClass):
             double_click_duration: Time window in ms to detect double click
             long_press_duration: Time in ms to detect long press
             sequence_window_duration: Time window in ms to detect sequences
+            sequence_mode: 'immediate' or 'exclusive'
+            actions: Actions dict to determine enabled sequences
+            mqtt_sequences: MQTT sequences dict to determine enabled sequences
+            enable_triple_click: Enable triple click detection
         """
+        from boneio.const import CLICK_SEQUENCES
+        
         if double_click_duration is not None:
             value_ms = _to_milliseconds(double_click_duration, DEFAULT_DOUBLE_CLICK_DURATION_MS)
             self._detector._multiclick_window = value_ms / 1000.0
@@ -140,4 +177,40 @@ class GpioEventButton(GpioBaseClass):
         if sequence_window_duration is not None:
             value_ms = _to_milliseconds(sequence_window_duration, DEFAULT_SEQUENCE_WINDOW_MS)
             self._detector._sequence_window = value_ms / 1000.0
-            _LOGGER.debug("Updated sequence_window_duration to %dms for %s", value_ms, self._name)
+            _LOGGER.debug("Updated sequence_window_duration to %dms for %s", value_ms, self._name)
+        
+        if sequence_mode is not None:
+            self._sequence_mode = sequence_mode
+            self._detector._sequence_mode = sequence_mode
+            _LOGGER.debug("Updated sequence_mode to %s for %s", sequence_mode, self._name)
+        
+        if enable_triple_click is not None:
+            self._detector._enable_triple_click = enable_triple_click
+            _LOGGER.debug("Updated enable_triple_click to %s for %s", enable_triple_click, self._name)
+        
+        # Update enabled sequences based on actions and mqtt_sequences
+        sequence_types = {'double_then_long', 'single_then_long', 'double_then_single'}
+        enabled_sequences: set[str] = set()
+        
+        if actions is not None and isinstance(actions, dict):
+            for seq_type in sequence_types:
+                if seq_type in actions and actions[seq_type]:
+                    enabled_sequences.add(seq_type)
+        
+        if mqtt_sequences is not None and isinstance(mqtt_sequences, dict):
+            for seq_type in sequence_types:
+                if mqtt_sequences.get(seq_type):
+                    enabled_sequences.add(seq_type)
+        
+        if actions is not None or mqtt_sequences is not None:
+            self._detector._enabled_sequences = enabled_sequences
+            
+            # Recompute delay_click_types
+            self._detector._delay_click_types = set()
+            if self._detector._sequence_mode == "exclusive" and enabled_sequences:
+                for seq in enabled_sequences:
+                    for (first, _second), seq_name in CLICK_SEQUENCES.items():
+                        if seq_name == seq:
+                            self._detector._delay_click_types.add(first)
+                            break
+            _LOGGER.debug("Updated enabled_sequences to %s for %s", enabled_sequences, self._name)

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/core/config/config_helper.py

@@ -146,7 +146,7 @@ class ConfigHelper:
         return "https" if self._proxy_port else "http"
 
     @property
-    def ha_configuration_port(self) -> int:
+    def web_configuration_port(self) -> int:
         """Get port for HA discovery URL. Uses proxy_port if set, otherwise web_port."""
         return self._proxy_port if self._proxy_port else self._web_port
 

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/core/manager/covers.py

@@ -216,7 +216,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", "tilt_duration", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
+                **{k: v for k, v in config.items() if k not in ("id", "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":
@@ -236,7 +236,7 @@ class CoverManager:
                 event_bus=self._manager._event_bus,
                 topic_prefix=self._manager._topic_prefix,
                 restored_state=restored_state,
-                **{k: v for k, v in config.items() if k not in ("platform", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
+                **{k: v for k, v in config.items() if k not in ("id", "platform", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
             )
             availability_msg_func = ha_cover_availabilty_message
         elif platform == "previous":
@@ -256,7 +256,7 @@ class CoverManager:
                 event_bus=self._manager._event_bus,
                 topic_prefix=self._manager._topic_prefix,
                 restored_state=restored_state,
-                **{k: v for k, v in config.items() if k not in ("platform", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
+                **{k: v for k, v in config.items() if k not in ("id", "platform", RESTORE_STATE, SHOW_HA, DEVICE_CLASS, NAME)},
             )
             availability_msg_func = ha_cover_availabilty_message
         

{boneio-1.0.0.dev21 → boneio-1.0.0.dev23}/boneio/core/manager/display.py

@@ -190,10 +190,28 @@ class DisplayManager:
             
         except (GPIOInputException, I2CError) as err:
             _LOGGER.error("Can't configure OLED display: %s", err)
+            # Store error in manager for WebUI display
+            self._manager._hardware_errors.append({
+                'type': 'display',
+                'id': 'oled',
+                'name': 'OLED Display',
+                'address': 0x3C,
+                'error': str(err),
+                'message': f"OLED display at address 0x3C: {err}",
+            })
         except ImportError as err:
             _LOGGER.error("Failed to import OLED modules: %s", err)
         except Exception as err:
             _LOGGER.error("Unexpected error configuring OLED: %s", err)
+            # Store error in manager for WebUI display
+            self._manager._hardware_errors.append({
+                'type': 'display',
+                'id': 'oled',
+                'name': 'OLED Display',
+                'address': 0x3C,
+                'error': str(err),
+                'message': f"OLED display: {err}",
+            })
 
     def get_oled(self) -> Any | None:
         """Get OLED display instance.