boneIO 1.0.0.dev22__tar.gz → 1.0.0.dev24__tar.gz

{boneio-1.0.0.dev22/boneio.egg-info → boneio-1.0.0.dev24}/PKG-INFO

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

{boneio-1.0.0.dev22/boneio/boards/0.4 → boneio-1.0.0.dev24/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.dev22 → boneio-1.0.0.dev24}/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.dev22 → boneio-1.0.0.dev24}/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.dev22 → boneio-1.0.0.dev24}/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.dev22 → boneio-1.0.0.dev24}/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.dev22 → boneio-1.0.0.dev24}/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.dev22 → boneio-1.0.0.dev24}/boneio/core/manager/inputs.py

@@ -216,10 +216,12 @@ class InputManager:
             # Reload: update existing input's actions and name
             if existing_input:
                 
-                # Check if HA-relevant fields changed (name, area)
+                # Check if HA-relevant fields changed (name, area, mqtt_sequences)
                 old_name = existing_input._name if hasattr(existing_input, '_name') else None
                 old_area = getattr(existing_input, 'area', None)
-                ha_fields_changed = (old_name != name) or (old_area != area)
+                old_mqtt_sequences = existing_input.mqtt_sequences if hasattr(existing_input, 'mqtt_sequences') else {}
+                new_mqtt_sequences = gpio.get("mqtt_sequences", {})
+                ha_fields_changed = (old_name != name) or (old_area != area) or (old_mqtt_sequences != new_mqtt_sequences)
                 
                 # Update actions (always - this is internal to the controller)
                 existing_input.set_actions(actions=actions)
@@ -231,14 +233,22 @@ class InputManager:
                 # Store area on input
                 existing_input.area = area
                 
+                # Update mqtt_sequences configuration
+                if hasattr(existing_input, '_mqtt_sequences'):
+                    existing_input._mqtt_sequences = new_mqtt_sequences
+                
                 # Update timing parameters if this is an event button
                 existing_input.update_timings(
                     double_click_duration=gpio.get('double_click_duration'),
                     long_press_duration=gpio.get('long_press_duration'),
                     sequence_window_duration=gpio.get('sequence_window_duration'),
+                    sequence_mode=gpio.get('sequence_mode'),
+                    actions=actions,
+                    mqtt_sequences=new_mqtt_sequences,
+                    enable_triple_click=gpio.get('enable_triple_click'),
                 )
                 
-                # Re-send HA discovery only if HA-relevant fields changed (name, area)
+                # Re-send HA discovery only if HA-relevant fields changed (name, area, mqtt_sequences)
                 # Actions are internal to the controller and don't need HA update
                 if ha_fields_changed and gpio.get(SHOW_HA, True):
                     _LOGGER.debug(f"HA-relevant fields changed for {input_id}, re-sending discovery")
@@ -249,6 +259,8 @@ class InputManager:
                         device_class=gpio.get(DEVICE_CLASS, None),
                         availability_msg_func=ha_event_availabilty_message,
                         area=area,
+                        mqtt_sequences=gpio.get("mqtt_sequences"),
+                        enable_triple_click=gpio.get("enable_triple_click", False),
                     )
                 return existing_input
             
@@ -275,6 +287,8 @@ class InputManager:
                     device_class=gpio.get(DEVICE_CLASS, None),
                     availability_msg_func=ha_event_availabilty_message,
                     area=area,
+                    mqtt_sequences=gpio.get("mqtt_sequences"),
+                    enable_triple_click=gpio.get("enable_triple_click", False),
                 )
             
             return input_device
@@ -566,6 +580,9 @@ class InputManager:
             # Remove from internal cache
             self._manager._config_helper.remove_autodiscovery_msg(ha_type, topic)
 
+    # Sequence click types that require mqtt_sequences configuration
+    SEQUENCE_CLICK_TYPES = {"double_then_long", "single_then_long", "double_then_single"}
+
     def _publish_input_event_to_mqtt(
         self, input_instance: GpioBaseClass, event: InputEvent
     ) -> None:
@@ -574,6 +591,9 @@ class InputManager:
         For event buttons (input_type=INPUT): sends JSON with event_type
         For binary sensors (input_type=INPUT_SENSOR): sends pressed/released state
         
+        Sequence events (double_then_long, single_then_long, double_then_single) are only
+        published if explicitly enabled in mqtt_sequences configuration.
+        
         Args:
             input_instance: The input device instance
             event: The input event data
@@ -584,7 +604,21 @@ class InputManager:
         click_type = event.click_type
         topic = f"{topic_prefix}/input/{input_id}"
         
-        if input_type == INPUT:         
+        if input_type == INPUT:
+            # Check if this is a sequence event that requires mqtt_sequences config
+            if click_type in self.SEQUENCE_CLICK_TYPES:
+                _LOGGER.debug(
+                    "Sequence event %s on %s, mqtt_sequences=%s, should_publish=%s",
+                    click_type, input_id, input_instance.mqtt_sequences,
+                    input_instance.should_publish_sequence_to_mqtt(click_type)
+                )
+                if not input_instance.should_publish_sequence_to_mqtt(click_type):
+                    _LOGGER.debug(
+                        "Skipping MQTT publish for sequence %s on %s (not enabled in mqtt_sequences)",
+                        click_type, input_id
+                    )
+                    return
+            
             event_payload: dict[str, str | float | None] = {"event_type": click_type}
             if event.duration is not None:
                 event_payload["duration"] = round(event.duration, 3)
@@ -671,6 +705,8 @@ class InputManager:
                         device_class=getattr(input_device, '_device_class', None),
                         availability_msg_func=ha_event_availabilty_message,
                         area=input_area,
+                        mqtt_sequences=input_device.mqtt_sequences,
+                        enable_triple_click=getattr(input_device._detector, '_enable_triple_click', False),
                     )
                 elif isinstance(input_device, GpioInputBinarySensor):
                     self._manager.send_ha_autodiscovery(

{boneio-1.0.0.dev22 → boneio-1.0.0.dev24}/boneio/core/manager/manager.py

@@ -766,6 +766,7 @@ class Manager:
             "virtual_energy_sensor": self.sensors.reload_virtual_energy_sensors,  # Virtual energy sensors
             "logger": self._reload_logger,  # Logger configuration
             "remote_devices": self._reload_remote_devices,  # Remote devices configuration
+            "areas": lambda: None,  # Areas are already reloaded in reload_config above
         }
         
         # If specific sections requested, filter
@@ -920,6 +921,17 @@ class Manager:
                         await cover.set_cover_position(position)
                     except ValueError:
                         _LOGGER.warning("Invalid cover position value: %s", message)
+                elif command == "tilt":
+                    # Set cover tilt position (only for VenetianCover)
+                    from boneio.components.cover.venetian import VenetianCover
+                    if isinstance(cover, VenetianCover):
+                        try:
+                            tilt = int(message)
+                            await cover.set_tilt(tilt)
+                        except ValueError:
+                            _LOGGER.warning("Invalid cover tilt value: %s", message)
+                    else:
+                        _LOGGER.debug("Cover %s does not support tilt control", device_id)
                 else:
                     # Handle open/close/stop/toggle actions
                     action = cover_actions.get(message.upper())

{boneio-1.0.0.dev22 → boneio-1.0.0.dev24}/boneio/core/system/host_data.py

@@ -317,7 +317,7 @@ class HostData:
             return None
         network_state = self._data[NETWORK].state
         if IP in network_state:
-            return f"{self._manager.config_helper.http_proto}://{network_state[IP]}:{self._manager.config_helper.ha_configuration_port}"
+            return f"{self._manager.config_helper.http_proto}://{network_state[IP]}:{self._manager.config_helper.web_configuration_port}"
         return None
 
     def get(self, type: str) -> dict | str | None:

{boneio-1.0.0.dev22 → boneio-1.0.0.dev24}/boneio/example_config/24x16/config.yaml

@@ -37,6 +37,6 @@ logger:
 
 web:
   port: 8090 #If you change this you need to change Nginx proxy settings in /home/boneio/docker/
-  proxy_port: 8091
+  proxy_port: 8443
 # adc: !include adc.yaml Uncomment only if needed. Not supported yet in v1.0.0
 

{boneio-1.0.0.dev22 → boneio-1.0.0.dev24}/boneio/example_config/32x10/config.yaml

@@ -37,5 +37,5 @@ logger:
 
 web:
   port: 8090 #If you change this you need to change Nginx proxy settings in /home/boneio/docker/
-  proxy_port: 8091
+  proxy_port: 8443
 # adc: !include adc.yaml Uncomment only if needed. Not supported yet in v1.0.0

{boneio-1.0.0.dev22 → boneio-1.0.0.dev24}/boneio/example_config/cover/config.yaml

@@ -38,5 +38,5 @@ logger:
 
 web:
   port: 8090 #If you change this you need to change Nginx proxy settings in /home/boneio/docker/
-  proxy_port: 8091
+  proxy_port: 8443
 # adc: !include adc.yaml Uncomment only if needed. Not supported yet in v1.0.0

{boneio-1.0.0.dev22 → boneio-1.0.0.dev24}/boneio/example_config/cover_mix/config.yaml

@@ -38,5 +38,5 @@ logger:
 
 web:
   port: 8090 #If you change this you need to change Nginx proxy settings in /home/boneio/docker/
-  proxy_port: 8091
+  proxy_port: 8443
 # adc: !include adc.yaml Uncomment only if needed. Not supported yet in v1.0.0

{boneio-1.0.0.dev22 → boneio-1.0.0.dev24}/boneio/hardware/gpio/input/base.py

@@ -76,6 +76,11 @@ class GpioBaseClass:
         self._event_bus = event_bus
         self._event_lock = asyncio.Lock()
         self.area: str | None = None  # HA area/room assignment
+        # MQTT sequences configuration - which sequences to publish to MQTT
+        mqtt_seq = kwargs.get("mqtt_sequences")
+        self._mqtt_sequences: dict[str, bool] = mqtt_seq if isinstance(mqtt_seq, dict) else {}
+        # Sequence mode: 'immediate' (default) or 'exclusive'
+        self._sequence_mode: str = kwargs.get("sequence_mode", "immediate")
 
     @property
     def boneio_input(self) -> str:
@@ -222,3 +227,32 @@ class GpioBaseClass:
             Unix timestamp
         """
         return self._last_timestamp
+
+    @property
+    def mqtt_sequences(self) -> dict[str, bool]:
+        """Get MQTT sequences configuration.
+        
+        Returns:
+            Dictionary mapping sequence types to boolean (publish to MQTT or not)
+        """
+        return self._mqtt_sequences
+
+    @property
+    def sequence_mode(self) -> str:
+        """Get sequence mode.
+        
+        Returns:
+            'immediate' or 'exclusive'
+        """
+        return self._sequence_mode
+
+    def should_publish_sequence_to_mqtt(self, sequence_type: str) -> bool:
+        """Check if a sequence type should be published to MQTT.
+        
+        Args:
+            sequence_type: Type of sequence (e.g., 'double_then_long')
+            
+        Returns:
+            True if the sequence should be published to MQTT
+        """
+        return self._mqtt_sequences.get(sequence_type, False)