boneio 1.2.0.dev21__tar.gz → 1.2.0.dev25__tar.gz

{boneio-1.2.0.dev21/boneio.egg-info → boneio-1.2.0.dev25}/PKG-INFO

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

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/components/cover/cover.py

@@ -16,11 +16,11 @@ from boneio.const import (
     OPEN,
     OPENING,
 )
-from boneio.core.events import EventBus, async_track_point_in_time, utcnow
+from boneio.core.events import EventBus
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
 from boneio.models import CoverState, PositionDict
-from boneio.components.output import MCPOutput
+from boneio.components.output import BasicOutput
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
@@ -30,8 +30,8 @@ class BaseCoverABC(ABC):
 
     @abstractmethod
     def __init__(self, id: str,
-        open_relay: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,
@@ -147,8 +147,8 @@ class BaseVenetianCoverABC:
 
 class BaseCover(BaseCoverABC, BasicMqtt):
     def __init__(self, id: str,
-        open_relay: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,
@@ -265,6 +265,10 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         _LOGGER.debug("Toggle cover %s from input.", self._id)
         if self._current_operation != IDLE:
             await self.stop()
+        elif self._position >= 100:
+            await self.close()
+        elif self._position <= 0:
+            await self.open()
         elif self._last_operation == CLOSING:
             await self.open()
         else:
@@ -284,6 +288,33 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         else:
             await self.close()
 
+    async def smart_toggle(self, always_open_till: int = 50) -> None:
+        """Smart toggle with position threshold.
+
+        If cover is moving → stop.
+        If position <= always_open_till → open (to 100%).
+        If position > always_open_till → normal toggle (based on last_operation).
+
+        Args:
+            always_open_till: Position threshold (0-100%). Below or equal this
+                value the cover will always open. Above it, normal toggle applies.
+        """
+        _LOGGER.debug(
+            "Smart toggle cover %s (position=%d%%, threshold=%d%%)",
+            self._id, self._position, always_open_till,
+        )
+        if self._current_operation != IDLE:
+            await self.stop()
+        elif self._position <= always_open_till:
+            await self.open()
+        elif self._position >= 100:
+            await self.close()
+        elif self._position <= 0:
+            await self.open()
+        elif self._last_operation == CLOSING:
+            await self.open()
+        else:
+            await self.close()
 
     @property
     def state(self) -> str:

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/components/cover/time_based.py

@@ -10,7 +10,7 @@ from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.components.cover.cover import BaseCover
 from boneio.core.events import EventBus
 from boneio.core.utils import TimePeriod
-from boneio.components.output import MCPOutput
+from boneio.components.output import BasicOutput
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_RESTORED_STATE = {"position": 100}
@@ -19,8 +19,8 @@ class TimeBasedCover(BaseCover):
     """Time-based cover algorithm similar to ESPHome."""
     def __init__(
         self,
-        open_relay: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/const.py

@@ -181,11 +181,39 @@ cover_actions = {
     "STOP": "stop",
     "TOGGLE_OPEN": "toggle_open",
     "TOGGLE_CLOSE": "toggle_close",
+    "SMART_TOGGLE": "smart_toggle",
     "TILT": "set_tilt",
     'TILT_OPEN': 'tilt_open',
     'TILT_CLOSE': 'tilt_close',
 }
 
+# Map of cover action method name -> accepted extra_data keys.
+# Actions not listed here (open, close, toggle, stop, etc.) accept no extra params.
+_COVER_ACTION_PARAMS: dict[str, set[str]] = {
+    "smart_toggle": {"always_open_till"},
+    "set_cover_position": {"position"},
+    "set_tilt": {"tilt_position"},
+    "set_cover_tilt_position": {"tilt_position"},
+}
+
+
+def filter_cover_extra_data(action_name: str, extra_data: dict) -> dict:
+    """Filter extra_data to only include params accepted by the cover action.
+
+    Args:
+        action_name: The cover method name (e.g. 'open', 'toggle', 'smart_toggle')
+        extra_data: Raw extra_data dict from action config
+
+    Returns:
+        Filtered dict with only accepted params for the action.
+    """
+    if not extra_data:
+        return {}
+    allowed = _COVER_ACTION_PARAMS.get(action_name)
+    if allowed is None:
+        return {}
+    return {k: v for k, v in extra_data.items() if k in allowed}
+
 INA219 = "ina219"
 VIRTUAL_ENERGY_SENSOR = "virtual_energy_sensor"
 PINS = {

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/core/manager/covers.py

@@ -13,7 +13,7 @@ import json
 import logging
 from typing import TYPE_CHECKING, Any
 
-from boneio.const import COVER, DEVICE_CLASS, ID, NAME, RESTORE_STATE, SHOW_HA, cover_actions
+from boneio.const import COVER, DEVICE_CLASS, ID, NAME, RESTORE_STATE, SHOW_HA, cover_actions, filter_cover_extra_data
 from boneio.core.utils import TimePeriod, strip_accents
 from boneio.exceptions import CoverConfigurationException
 from boneio.integration import ha_cover_availabilty_message
@@ -72,6 +72,28 @@ class CoverManager:
             config = self._manager._config_helper.reload_config()
             self._config_covers = config.get(COVER, [])
             self._manager._config_helper.clear_autodiscovery_type(ha_type=COVER)
+
+            # Remove covers that are no longer in config
+            new_ids = set()
+            for _cfg in self._config_covers:
+                if _cfg.get(ID):
+                    new_ids.add(strip_accents(_cfg[ID]))
+                else:
+                    _open = str(_cfg.get("open_relay", ""))
+                    _close = str(_cfg.get("close_relay", ""))
+                    new_ids.add(f"cover_{_open}_{_close}".lower().replace(" ", "_"))
+
+            removed_ids = [cid for cid in self._covers if cid not in new_ids]
+            for cid in removed_ids:
+                _LOGGER.info("Cover %s removed from config, cleaning up", cid)
+                cover = self._covers.pop(cid)
+                # Stop cover movement if running
+                try:
+                    asyncio.ensure_future(cover.stop())
+                except Exception:
+                    pass
+                # Remove HA autodiscovery
+                self._remove_cover_ha_discovery(cid)
         
         for _config in self._config_covers:
             # Get relay outputs for cover
@@ -365,8 +387,10 @@ class CoverManager:
         
         try:
             _f = getattr(cover, action_to_execute)
-            if extra_data:
-                await _f(**extra_data)
+            # Filter extra_data to only pass params accepted by the action
+            filtered = filter_cover_extra_data(action_to_execute, extra_data or {})
+            if filtered:
+                await _f(**filtered)
             else:
                 await _f()
         except Exception as err:

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/core/manager/manager.py

@@ -28,6 +28,7 @@ from boneio.const import (
     STATE,
     TOGGLE,
     cover_actions,
+    filter_cover_extra_data,
     output_actions,
 )
 from boneio.core.config import ConfigHelper
@@ -669,6 +670,8 @@ class Manager:
                     continue
                 action_to_execute = action_definition.get("action_to_execute")
                 extra_data = action_definition.get("extra_data", {})
+                # Filter extra_data to only pass params accepted by each action
+                filtered_data = filter_cover_extra_data(action_to_execute, extra_data)
                 _LOGGER.debug(
                     "Executing action %s for cover %s. Duration: %s",
                     action_to_execute,
@@ -676,7 +679,7 @@ class Manager:
                     time.time() - start_time,
                 )
                 _f = getattr(cover, action_to_execute)
-                await _f(**extra_data)
+                await _f(**filtered_data)
                 
             elif action == OUTPUT_OVER_MQTT:
                 boneio_id = action_definition.get("boneio_id")

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/core/manager/remote.py

@@ -587,6 +587,7 @@ class RemoteDeviceManager:
             return await device.control_cover(
                 cover_id=cover_id,
                 action=action,
+                **kwargs,
             )
         
         # For MQTT devices, use standard control_cover

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/core/remote/esphome.py

@@ -364,7 +364,10 @@ class ESPHomeRemoteDevice(RemoteDevice):
                             "current_operation": current_op,
                             "last_known_operation": last_op,
                         }
-                        _LOGGER.debug("Cover '%s' position: %.2f", cover_id, state.position)
+                        _LOGGER.debug(
+                            "Cover '%s' state update: position=%.2f, current_op=%s, last_op=%s",
+                            cover_id, state.position, current_op, last_op,
+                        )
                         break
         except Exception as e:
             _LOGGER.debug("Error processing state change: %s", e)
@@ -854,27 +857,52 @@ class ESPHomeRemoteDevice(RemoteDevice):
                 self._client.cover_command(cover_key, position=0.0)
             elif action_upper == "STOP":
                 self._client.cover_command(cover_key, stop=True)
-            elif action_upper == "TOGGLE":
-                # Toggle based on current operation or last known operation
+            elif action_upper in ("TOGGLE", "SMART_TOGGLE"):
+                # Toggle based on current operation, position, or last known operation
                 state = self._cover_states.get(cover_id, {})
                 current_op = state.get("current_operation", 0) # 0=IDLE, 1=OPENING, 2=CLOSING
                 last_op = state.get("last_known_operation", 2)
                 cover_pos = state.get("position")
+                always_open_till = kwargs.get("always_open_till", 50) if action_upper == "SMART_TOGGLE" else None
                 _LOGGER.debug(
-                    "TOGGLE cover '%s': key=%s, state=%s, current_op=%s, last_op=%s, position=%s, all_states=%s",
-                    cover_id, cover_key, state, current_op, last_op, cover_pos,
-                    {k: v for k, v in self._cover_states.items()},
+                    "ESPHome %s cover '%s': current_op=%s, last_op=%s, position=%s, always_open_till=%s",
+                    action_upper, cover_id, current_op, last_op, cover_pos, always_open_till,
                 )
                 
                 if current_op != 0: # If moving, stop it
-                    _LOGGER.debug("TOGGLE -> STOP (cover is moving, current_op=%s)", current_op)
+                    _LOGGER.debug("%s -> STOP (cover is moving, current_op=%s)", action_upper, current_op)
                     self._client.cover_command(cover_key, stop=True)
-                elif last_op == 2: # If last operation was CLOSING, open it
-                    _LOGGER.debug("TOGGLE -> OPEN (last_op=CLOSING)")
-                    self._client.cover_command(cover_key, position=1.0)
-                else: # Otherwise close it
-                    _LOGGER.debug("TOGGLE -> CLOSE (last_op=%s)", last_op)
-                    self._client.cover_command(cover_key, position=0.0)
+                elif cover_pos is not None:
+                    # Position is known — use it for smarter decisions
+                    pos_pct = int(cover_pos * 100)
+                    if always_open_till is not None and pos_pct <= always_open_till:
+                        # SMART_TOGGLE: below threshold → always open
+                        _LOGGER.debug("SMART_TOGGLE -> OPEN (pos=%d%% <= threshold=%d%%)", pos_pct, always_open_till)
+                        self._client.cover_command(cover_key, position=1.0)
+                    elif cover_pos >= 0.99:
+                        # Fully open → close
+                        _LOGGER.debug("%s -> CLOSE (fully open, pos=%.2f)", action_upper, cover_pos)
+                        self._client.cover_command(cover_key, position=0.0)
+                    elif cover_pos <= 0.01:
+                        # Fully closed → open
+                        _LOGGER.debug("%s -> OPEN (fully closed, pos=%.2f)", action_upper, cover_pos)
+                        self._client.cover_command(cover_key, position=1.0)
+                    elif last_op == 2:
+                        # Last was closing → open
+                        _LOGGER.debug("%s -> OPEN (last_op=CLOSING)", action_upper)
+                        self._client.cover_command(cover_key, position=1.0)
+                    else:
+                        # Last was opening → close
+                        _LOGGER.debug("%s -> CLOSE (last_op=%s)", action_upper, last_op)
+                        self._client.cover_command(cover_key, position=0.0)
+                else:
+                    # No position known — use last_op only
+                    if last_op == 2:
+                        _LOGGER.debug("%s -> OPEN (no position, last_op=CLOSING)", action_upper)
+                        self._client.cover_command(cover_key, position=1.0)
+                    else:
+                        _LOGGER.debug("%s -> CLOSE (no position, last_op=%s)", action_upper, last_op)
+                        self._client.cover_command(cover_key, position=0.0)
             elif action_upper == "TOGGLE_OPEN":
                 state = self._cover_states.get(cover_id, {})
                 current_op = state.get("current_operation", 0)

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/hardware/display/oled.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+import subprocess
 from itertools import cycle
 from typing import TYPE_CHECKING
 
@@ -13,7 +14,7 @@ from luma.oled.device import sh1106
 from PIL import Image, ImageDraw
 from PIL.ImageDraw import ImageDraw as ImageDrawType
 
-from boneio.const import OLED_PIN, UPTIME, WHITE
+from boneio.const import LONG, OLED_PIN, SINGLE, UPTIME, WHITE
 from boneio.core.events import EventBus, async_track_point_in_time, utcnow
 from boneio.core.system import HostData
 from boneio.core.utils.font_util import make_font
@@ -102,6 +103,24 @@ class Oled:
         self._cancel_sleep_handle = None
         self._sleep_timeout = sleep_timeout
         
+        # Shutdown confirmation state machine
+        # States: None -> "wait_release" -> "confirm" -> "progress" -> shutdown
+        # - First long press → show confirm screen, enter "wait_release"
+        # - Release after first long → enter "confirm" (waiting for second long)
+        # - Second long press → enter "progress" with filling progress bar
+        # - Hold 5s → execute shutdown
+        # - Single click or 10s timeout → cancel
+        self._shutdown_state: str | None = None
+        self._shutdown_cancel_handle = None
+        # Timer to detect button release (no LONG event for 300ms = released)
+        self._shutdown_release_timer: asyncio.TimerHandle | None = None
+        # Last seen long press duration — used to detect new press cycle (duration resets)
+        self._shutdown_last_long_duration: float = 0.0
+        # Duration (seconds) the user must hold the button to confirm shutdown
+        self._shutdown_hold_duration: float = 5.0
+        # Timeout (seconds) to cancel shutdown confirmation if no action
+        self._shutdown_confirm_timeout: float = 10.0
+        
         # Initialize I2C display
         try:
             # Use luma.oled for now, but could be refactored to use SMBus2I2C
@@ -219,14 +238,98 @@ class Oled:
         # Display the centered QR code
         self._device.display(display_image)
 
-    async def _handle_button_press(self, event: dict) -> None:
-        """Handle button press event from input."""
-        _LOGGER.debug(f"OLED button pressed event received: {event}")
+    async def _handle_button_press(self, event) -> None:
+        """Handle button press event from input.
+
+        Supports shutdown flow via long press:
+        1. First long press → show confirmation screen
+        2. User releases button → state moves to "confirm"
+        3. Second long press (held 5s) → progress bar fills, then shutdown
+        4. Any single click or 10s timeout → cancel shutdown
+
+        The detector emits periodic LONG events (every 200ms) with growing
+        duration while the button is held. A new press cycle is detected
+        when duration resets (new duration < last tracked duration).
+
+        Args:
+            event: InputEvent from EventBus with click_type and duration
+        """
+        click_type = getattr(event, "click_type", None)
+        duration = getattr(event, "duration", None) or 0.0
+
+        _LOGGER.debug("OLED button event: click_type=%s, duration=%.2f, shutdown_state=%s",
+                       click_type, duration, self._shutdown_state)
+
+        # --- Shutdown state machine ---
+
+        if self._shutdown_state == "wait_release":
+            # Absorb periodic LONG events from the first long press.
+            # Detector does NOT emit SINGLE after long press release.
+            # Detect release via timer: each LONG resets a 300ms timer.
+            # When no more LONG events arrive, timer fires → "confirm".
+            if click_type == LONG:
+                self._shutdown_last_long_duration = duration
+                # Reset release-detection timer
+                self._reset_release_timer()
+                return
+            elif click_type == SINGLE:
+                # Shouldn't happen after long, but handle gracefully
+                self._cancel_release_timer()
+                self._shutdown_state = "confirm"
+                self._shutdown_last_long_duration = 0.0
+                return
+            # Ignore other events
+            return
+
+        if self._shutdown_state == "confirm":
+            if click_type == LONG:
+                # Second long press — enter progress mode
+                self._shutdown_state = "progress"
+                self._cancel_shutdown_timeout()
+                self._shutdown_last_long_duration = duration
+                self._draw_shutdown_progress(duration)
+                if duration >= self._shutdown_hold_duration:
+                    await self._execute_shutdown()
+                return
+            elif click_type == SINGLE:
+                # Single click cancels shutdown confirmation
+                self._cancel_shutdown()
+                return
+            # Ignore other events during confirm
+            return
+
+        if self._shutdown_state == "progress":
+            if click_type == LONG:
+                if duration < self._shutdown_last_long_duration:
+                    # Duration reset — user released and pressed again, cancel
+                    self._cancel_shutdown()
+                    return
+                # Still holding — update progress bar
+                self._shutdown_last_long_duration = duration
+                self._draw_shutdown_progress(duration)
+                if duration >= self._shutdown_hold_duration:
+                    await self._execute_shutdown()
+                return
+            else:
+                # Released (single) or other — cancel
+                self._cancel_shutdown()
+                return
+
+        # --- Normal mode ---
         if self._sleep:
-            # Display is sleeping - wake it up
             self.wake_up()
-        else:
-            # Display is active - go to next screen
+            return
+
+        if click_type == LONG and duration < 1.0:
+            # First long press event — show confirmation, enter wait_release
+            self._shutdown_state = "wait_release"
+            self._shutdown_last_long_duration = duration
+            self._draw_shutdown_confirm()
+            self._start_shutdown_timeout()
+            self._reset_release_timer()
+            return
+
+        if click_type == SINGLE:
             self._next_screen()
 
     def _next_screen(self) -> None:
@@ -240,6 +343,150 @@ class Oled:
         self._current_screen = next(self._screen_cycle)
         self.render_display()
 
+    # --- Shutdown helper methods ---
+
+    def _draw_shutdown_confirm(self) -> None:
+        """Draw shutdown confirmation screen on OLED.
+        
+        Shows a warning message asking the user to hold the button
+        for 5 seconds to confirm system shutdown.
+        """
+        with canvas(self._device) as draw:
+            # Warning triangle
+            draw.polygon([(64, 2), (54, 18), (74, 18)], outline=WHITE)
+            draw.text((61, 5), "!", font=fonts["small"], fill=WHITE)
+            # Message
+            draw.text((10, 24), "Shutdown system?", font=fonts["small"], fill=WHITE)
+            draw.text((4, 38), "Hold button 5s to confirm", font=fonts["extraSmall"], fill=WHITE)
+            draw.text((8, 52), "Click to cancel (10s)", font=fonts["extraSmall"], fill=WHITE)
+
+    def _draw_shutdown_progress(self, duration: float) -> None:
+        """Draw shutdown progress bar on OLED.
+        
+        Shows a progress bar that fills proportionally to how long
+        the user has been holding the button vs the required duration.
+        
+        Args:
+            duration: How long the button has been held (seconds)
+        """
+        progress = min(duration / self._shutdown_hold_duration, 1.0)
+        bar_x, bar_y = 10, 34
+        bar_w, bar_h = 108, 14
+        fill_w = int(bar_w * progress)
+
+        with canvas(self._device) as draw:
+            draw.text((20, 4), "Shutting down...", font=fonts["small"], fill=WHITE)
+            draw.text((28, 18), f"{int(progress * 100)}%", font=fonts["small"], fill=WHITE)
+            # Progress bar outline
+            draw.rectangle([bar_x, bar_y, bar_x + bar_w, bar_y + bar_h], outline=WHITE)
+            # Progress bar fill
+            if fill_w > 0:
+                draw.rectangle([bar_x + 1, bar_y + 1, bar_x + fill_w - 1, bar_y + bar_h - 1], fill=WHITE)
+            draw.text((22, 54), "Release to cancel", font=fonts["extraSmall"], fill=WHITE)
+
+    def _start_shutdown_timeout(self) -> None:
+        """Start a 10-second timeout that cancels the shutdown confirmation.
+        
+        If the user doesn't interact within the timeout period,
+        the shutdown flow is cancelled and the normal screen is restored.
+        """
+        self._cancel_shutdown_timeout()
+        loop = self._event_bus._loop
+
+        def _timeout_callback() -> None:
+            """Cancel shutdown after timeout expires."""
+            _LOGGER.info("Shutdown confirmation timed out, cancelling")
+            self._shutdown_state = None
+            self._shutdown_cancel_handle = None
+            self.render_display()
+
+        self._shutdown_cancel_handle = loop.call_later(
+            self._shutdown_confirm_timeout, _timeout_callback
+        )
+
+    def _cancel_shutdown_timeout(self) -> None:
+        """Cancel the pending shutdown timeout timer."""
+        if self._shutdown_cancel_handle is not None:
+            self._shutdown_cancel_handle.cancel()
+            self._shutdown_cancel_handle = None
+
+    def _reset_release_timer(self) -> None:
+        """Reset the 300ms release-detection timer.
+        
+        Called on each periodic LONG event during wait_release state.
+        If no more LONG events arrive within 300ms, the timer fires
+        and transitions to 'confirm' state (button was released).
+        """
+        self._cancel_release_timer()
+        loop = self._event_bus._loop
+
+        def _on_release_detected() -> None:
+            """No LONG event for 300ms — button was released."""
+            self._shutdown_release_timer = None
+            if self._shutdown_state == "wait_release":
+                _LOGGER.debug("OLED button release detected (no LONG for 300ms)")
+                self._shutdown_state = "confirm"
+                self._shutdown_last_long_duration = 0.0
+                # Timeout already running from first long press
+
+        self._shutdown_release_timer = loop.call_later(0.3, _on_release_detected)
+
+    def _cancel_release_timer(self) -> None:
+        """Cancel the pending release-detection timer."""
+        if self._shutdown_release_timer is not None:
+            self._shutdown_release_timer.cancel()
+            self._shutdown_release_timer = None
+
+    def _cancel_shutdown(self) -> None:
+        """Cancel the shutdown flow and return to normal display.
+        
+        Resets the shutdown state machine and restores the current screen.
+        """
+        _LOGGER.info("Shutdown cancelled by user")
+        self._cancel_shutdown_timeout()
+        self._cancel_release_timer()
+        self._shutdown_state = None
+        self._shutdown_last_long_duration = 0.0
+        self.render_display()
+
+    async def _execute_shutdown(self) -> None:
+        """Execute system shutdown.
+        
+        Draws a final 'Goodbye' message on the OLED, then runs
+        'sudo shutdown -h now' to power off the device.
+        """
+        _LOGGER.warning("System shutdown initiated from OLED button")
+        self._shutdown_state = None
+        self._shutdown_last_long_duration = 0.0
+        self._cancel_shutdown_timeout()
+
+        # Draw goodbye screen
+        with canvas(self._device) as draw:
+            draw.text((20, 10), "Goodbye!", font=fonts["big"], fill=WHITE)
+            draw.text((15, 35), "System shutting down...", font=fonts["extraSmall"], fill=WHITE)
+
+        # Small delay so the user sees the message
+        await asyncio.sleep(1)
+
+        try:
+            subprocess.run(
+                ["sudo", "shutdown", "-h", "now"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            _LOGGER.error("Failed to shutdown device: %s", e.stderr)
+            # Show error on OLED and return to normal
+            with canvas(self._device) as draw:
+                draw.text((10, 20), "Shutdown failed!", font=fonts["small"], fill=WHITE)
+                draw.text((10, 40), str(e.stderr)[:20], font=fonts["extraSmall"], fill=WHITE)
+            await asyncio.sleep(3)
+            self.render_display()
+        except Exception as e:
+            _LOGGER.error("Error shutting down device: %s", e)
+            self.render_display()
+
     def render_display(self) -> None:
         """Render display - main method that decides what to display."""
         

{boneio-1.2.0.dev21 → boneio-1.2.0.dev25}/boneio/schema/actions.yaml

@@ -35,7 +35,7 @@ schema:
       action: ['cover', 'cover_over_mqtt', 'remote_cover']
     forbidden_if:
       action: ['output', 'mqtt', 'mqtt_output', 'remote_output']
-    allowed: ['TOGGLE', 'OPEN', 'CLOSE', 'STOP', 'TOGGLE_OPEN', 'TOGGLE_CLOSE', 'TILT', 'TILT_OPEN', 'TILT_CLOSE']
+    allowed: ['TOGGLE', 'OPEN', 'CLOSE', 'STOP', 'TOGGLE_OPEN', 'TOGGLE_CLOSE', 'SMART_TOGGLE', 'TILT', 'TILT_OPEN', 'TILT_CLOSE']
     coerce: action_field
     default: TOGGLE
     case_insensitive: true
@@ -58,6 +58,18 @@ schema:
         required: False
         meta:
           label: Tilt position to set cover to. 0 means closed, 100 means opened.
+      always_open_till:
+        type: integer
+        required: False
+        min: 0
+        max: 100
+        default: 50
+        meta:
+          label: Smart toggle threshold (0-100%).
+          description: |
+            Position threshold for SMART_TOGGLE action.
+            If cover position is at or below this value, it will always open.
+            Above this value, normal toggle behavior applies.
   action_output:
     type: string
     required_if:

boneio-1.2.0.dev25/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.2.0dev25"