boneIO 0.11.0.dev2__py3-none-any.whl → 0.11.0.dev4__py3-none-any.whl

boneio/const.py

@@ -163,6 +163,9 @@ cover_actions = {
     "STOP": "stop",
     "TOGGLE_OPEN": "toggle_open",
     "TOGGLE_CLOSE": "toggle_close",
+    "TILT": "set_tilt",
+    'TILT_OPEN': 'tilt_open',
+    'TILT_CLOSE': 'tilt_close',
 }
 
 INA219 = "ina219"

boneio/cover/__init__.py

@@ -0,0 +1,6 @@
+"""Cover classes."""
+from .previous import PreviousCover
+from .time_based import TimeBasedCover
+from .venetian import VenetianCover
+
+__all__ = ["TimeBasedCover", "PreviousCover", "VenetianCover"]

boneio/cover/cover.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+import time
+from abc import ABC, abstractmethod
+from typing import Callable
+
+from boneio.const import (
+    CLOSED,
+    CLOSING,
+    COVER,
+    IDLE,
+    OPEN,
+    OPENING,
+)
+from boneio.helper.events import EventBus
+from boneio.helper.mqtt import BasicMqtt
+from boneio.helper.timeperiod import TimePeriod
+from boneio.models import CoverState, PositionDict
+from boneio.relay import MCPRelay
+
+_LOGGER = logging.getLogger(__name__)
+
+class BaseCoverABC(ABC):
+    """Base cover class."""
+
+    @abstractmethod
+    def __init__(self, id: str,
+        open_relay: MCPRelay,
+        close_relay: MCPRelay,
+        state_save: Callable,
+        open_time: TimePeriod,
+        close_time: TimePeriod,
+        event_bus: EventBus,
+        position: int = 100,
+        **kwargs,
+    ) -> None:
+        pass
+        
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop cover.""" 
+        pass
+
+    @abstractmethod
+    async def open(self) -> None:
+        """Open cover."""
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close cover."""
+        pass
+
+    @abstractmethod
+    async def toggle(self) -> None:
+        """Toggle cover to open or close."""
+        pass
+
+    @abstractmethod
+    async def toggle_open(self) -> None:
+        """Toggle cover to open or stop."""
+        pass
+
+    @abstractmethod
+    async def toggle_close(self) -> None:
+        """Toggle cover to close or stop."""
+        pass
+
+    @abstractmethod
+    async def set_cover_position(self, position: int) -> None:
+        """Set cover position."""
+        pass
+
+
+    @property
+    @abstractmethod
+    def state(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def position(self) -> int:
+        pass
+
+    @property
+    @abstractmethod
+    def current_operation(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def last_timestamp(self) -> float:
+        pass
+
+
+    @abstractmethod
+    async def run_cover(self, current_operation: str, target_position: float | None = None,  target_tilt: float | None = None) -> None:
+        """This function is called to run cover after calling open, close, toggle, toggle_open, toggle_close, set_cover_position"""
+        pass
+
+    @abstractmethod
+    async def send_state(self, state: str, position: float) -> None:
+        pass
+
+class BaseVenetianCoverABC:
+    @property
+    @abstractmethod
+    def tilt_position(self) -> int:
+        pass
+
+    @property
+    @abstractmethod
+    def tilt_current_operation(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def last_tilt_timestamp(self) -> float:
+        pass
+
+    @abstractmethod
+    async def set_cover_tilt_position(self, position: int) -> None:
+        """Set cover tilt position."""
+        pass
+
+    @abstractmethod
+    async def tilt_open(self) -> None:
+        """Open cover tilt."""
+        pass
+
+    @abstractmethod
+    async def tilt_close(self) -> None:
+        """Close cover tilt."""
+        pass
+
+
+class BaseCover(BaseCoverABC, BasicMqtt):
+    def __init__(self, id: str,
+        open_relay: MCPRelay,
+        close_relay: MCPRelay,
+        state_save: Callable,
+        open_time: TimePeriod,
+        close_time: TimePeriod,
+        event_bus: EventBus,
+        position: int = 100,
+        **kwargs,
+    ) -> None:
+        BasicMqtt.__init__(self, id=id, name=id, topic_type=COVER, **kwargs)
+        self._loop = asyncio.get_event_loop()
+        self._id = id
+        self._open_relay = open_relay
+        self._close_relay = close_relay
+        self._state_save = state_save
+        self._event_bus = event_bus
+        self._open_time = open_time.total_milliseconds
+        self._close_time = close_time.total_milliseconds
+        self._position = position
+        self._initial_position = None
+        self._current_operation = IDLE
+
+        self._last_timestamp = time.monotonic()
+
+        self._last_update_time = 0
+        self._closed = position <= 0
+
+        self._movement_thread = None
+        self._stop_event = threading.Event()
+
+        self._event_bus.add_sigterm_listener(self.on_exit)
+
+        def _schedule_send_state_task(state_to_send, json_pos_to_send):
+            asyncio.ensure_future(self.send_state(state_to_send, json_pos_to_send), loop=self._loop)
+
+        self._loop.call_soon_threadsafe(
+            self._loop.call_later,
+            0.5,
+            _schedule_send_state_task,
+            self.state,
+            self.json_position
+        )
+
+    async def on_exit(self) -> None:
+        """Stop on exit."""
+        await self.stop(on_exit=True)
+
+    async def stop(self, on_exit=False) -> None:
+        if self._movement_thread and self._movement_thread.is_alive():
+            self._stop_event.set()
+            self._movement_thread.join(timeout=0.5)
+            self._open_relay.turn_off()
+            self._close_relay.turn_off()
+            self._current_operation = IDLE
+            if not on_exit:
+                await self.send_state(self.state, self.json_position)
+
+    async def open(self) -> None:
+        if self._position >= 100:
+            return
+        _LOGGER.info("Opening cover %s.", self._id)
+        await self.run_cover(current_operation=OPENING)
+        self._send_message(topic=f"{self._send_topic}/state", payload=OPENING)
+
+    async def close(self) -> None:
+        if self._position <= 0:
+            return
+        _LOGGER.info("Closing cover %s.", self._id)
+        await self.run_cover(current_operation=CLOSING)
+        self._send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
+
+    async def set_cover_position(self, position: int) -> None:
+        if not 0 <= position <= 100:
+            raise ValueError("Pozycja musi być w zakresie od 0 do 100.")
+
+        if abs(self._position - position) < 1:
+            return
+
+        if position > self._position:
+            await self.run_cover(current_operation=OPENING, target_position=position)
+        elif position < self._position:
+            await self.run_cover(current_operation=CLOSING, target_position=position)
+
+    async def toggle(self) -> None:
+        _LOGGER.debug("Toggle cover %s from input.", self._id)
+        if self._position > 50:
+            await self.close()
+        else:
+            await self.open()
+
+    async def toggle_open(self) -> None:
+        _LOGGER.debug("Toggle open cover %s from input.", self._id)
+        if self._current_operation != IDLE:
+            await self.stop()
+        else:
+            await self.open()
+
+    async def toggle_close(self) -> None:
+        _LOGGER.debug("Toggle close cover %s from input.", self._id)
+        if self._current_operation != IDLE:
+            await self.stop()
+        else:
+            await self.close()
+
+
+    @property
+    def state(self) -> str:
+        if self._current_operation == OPENING:
+            return OPENING
+        elif self._current_operation == CLOSING:
+            return CLOSING
+        else:
+            return CLOSED if self._position == 0 else OPEN
+
+    @property
+    def position(self) -> int:
+        return round(self._position, 0)
+
+    @property
+    def json_position(self) -> PositionDict:
+        return {"position": self.position}
+
+    @property
+    def current_operation(self) -> str:
+        return self._current_operation
+
+    @property
+    def last_timestamp(self) -> float:
+        return self._last_timestamp
+
+    async def send_state(self, state: str, json_position: PositionDict = None) -> None:
+        event = CoverState(
+            id=self.id,
+            name=self.name,
+            state=state,
+            kind=self.kind,
+            timestamp=self._last_timestamp,
+            current_operation=self._current_operation,
+            **json_position
+        )
+        await self._event_bus.async_trigger_event(event_type="cover", entity_id=self.id, event=event)
+        self._send_message(topic=f"{self._send_topic}/state", payload=state)
+        self._send_message(topic=f"{self._send_topic}/pos", payload=json_position)
+
+    async def send_state_and_save(self, json_position: PositionDict):
+        await self.send_state(self.state, json_position)
+        self._state_save(json_position)

boneio/{cover.py → cover/previous.py}

@@ -24,7 +24,7 @@ from boneio.models import CoverState
 from boneio.relay import MCPRelay
 
 _LOGGER = logging.getLogger(__name__)
-
+DEFAULT_RESTORED_STATE = {"position": 100}
 COVER_COMMANDS = {
     OPEN: "open_cover",
     CLOSE: "close_cover",
@@ -53,7 +53,7 @@ class RelayHelper:
         return self._steps
 
 
-class Cover(BasicMqtt):
+class PreviousCover(BasicMqtt):
     """Cover class of boneIO"""
 
     def __init__(
@@ -65,7 +65,7 @@ class Cover(BasicMqtt):
         open_time: TimePeriod,
         close_time: TimePeriod,
         event_bus: EventBus,
-        restored_state: int = 100,
+        restored_state: dict = DEFAULT_RESTORED_STATE,
         **kwargs,
     ) -> None:
         """Initialize cover class."""
@@ -78,7 +78,7 @@ class Cover(BasicMqtt):
         self._close = RelayHelper(relay=close_relay, time=close_time)
         self._set_position = None
         self._current_operation = IDLE
-        self._position = restored_state
+        self._position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
         self._requested_closing = True
         self._event_bus = event_bus
         self._timer_handle = None
@@ -142,6 +142,7 @@ class Cover(BasicMqtt):
             name=self.name,
             state=self.state,
             position=round(self._position, 0),
+            kind=self.kind,
             timestamp=self.last_timestamp,
             current_operation=self._current_operation,
         )
@@ -153,8 +154,8 @@ class Cover(BasicMqtt):
             topic=f"{self._send_topic}/state", payload=self.state
         )
         pos = round(self._position, 0)
-        self._send_message(topic=f"{self._send_topic}/pos", payload=str(pos))
-        self._state_save(position=pos)
+        self._send_message(topic=f"{self._send_topic}/pos", payload={ "position": str(pos) })
+        self._state_save(value={"position": pos})
 
     def _stop_cover(self, on_exit=False) -> None:
         """Stop cover."""
@@ -200,7 +201,7 @@ class Cover(BasicMqtt):
                 rounded_pos = 100
             elif rounded_pos < 0:
                 rounded_pos = 0
-        self._send_message(topic=f"{self._send_topic}/pos", payload=rounded_pos)
+        self._send_message(topic=f"{self._send_topic}/pos", payload={"position": str(rounded_pos)})
         asyncio.create_task(self.async_send_state())
         if rounded_pos == self._set_position or (
             self._set_position is None
@@ -307,3 +308,11 @@ class Cover(BasicMqtt):
     @property
     def current_operation(self) -> str:
         return self._current_operation
+
+    @property
+    def kind(self) -> str:
+        return "previous"
+    
+    def update_config_times(self, config: dict) -> None:
+        self._open_duration = config.get("open_duration", self._open_duration)
+        self._close_duration = config.get("close_duration", self._close_duration)

boneio/cover/time_based.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+import time
+from typing import Callable, Optional
+
+from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
+from boneio.cover.cover import BaseCover
+from boneio.helper.events import EventBus
+from boneio.helper.timeperiod import TimePeriod
+from boneio.relay import MCPRelay
+
+_LOGGER = logging.getLogger(__name__)
+DEFAULT_RESTORED_STATE = {"position": 100}
+
+class TimeBasedCover(BaseCover):
+    """Time-based cover algorithm similar to ESPHome."""
+    def __init__(
+        self,
+        open_relay: MCPRelay,
+        close_relay: MCPRelay,
+        state_save: Callable,
+        open_time: TimePeriod,
+        close_time: TimePeriod,
+        event_bus: EventBus,
+        restored_state: dict = DEFAULT_RESTORED_STATE,
+        **kwargs,
+    ) -> None:
+        position = int(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
+        super().__init__(
+            open_relay=open_relay,
+            close_relay=close_relay,
+            state_save=state_save,
+            open_time=open_time,
+            close_time=close_time,
+            event_bus=event_bus,
+            position=position,
+            **kwargs,
+        )
+
+
+    def _move_cover(self, direction: str, duration: float, target_position: Optional[int] = None):
+        """Metoda uruchamiana w oddzielnym wątku do fizycznego ruchu rolety."""
+        if direction == OPEN:
+            relay = self._open_relay
+            total_steps = 100 - self._position
+        elif direction == CLOSE:
+            relay = self._close_relay
+            total_steps = self._position
+        else:
+            return
+
+        if total_steps == 0 or duration == 0:
+            self._current_operation = IDLE
+            self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
+            return
+
+        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
+
+            if direction == OPEN:
+                self._position = min(100.0, self._initial_position + progress * 100)
+            elif direction == CLOSE:
+                self._position = max(0.0, self._initial_position - progress * 100)
+
+            self._last_timestamp = current_time # Użyj pobranego czasu
+            if current_time - self._last_update_time >= 1:
+                self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
+                self._last_update_time = current_time
+
+            if target_position is not None:
+                if (direction == OPEN and self._position >= target_position) or \
+                   (direction == CLOSE and self._position <= target_position):
+                    break
+
+            if progress >= 1.0:
+                break
+
+            time.sleep(0.05)  # Małe opóźnienie, aby nie blokować CPU
+        relay.turn_off()
+        self._current_operation = IDLE
+        self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.async_state_save(self.json_position), self._loop)
+        self._loop.call_soon_threadsafe(asyncio.run_coroutine_threadsafe, self.send_state(self.state, self.json_position), self._loop)
+        self._last_update_time = time.monotonic() # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
+
+    async def run_cover(self, current_operation: str, target_position: Optional[int] = None) -> None:
+        if self._movement_thread and self._movement_thread.is_alive() or current_operation == STOP:
+            _LOGGER.warning("Ruch rolety już trwa. Najpierw zatrzymaj.")
+            await self.stop()
+
+        self._current_operation = current_operation
+        self._initial_position = self._position
+        self._stop_event.clear()
+        self._last_update_time = time.monotonic() - 1 # Inicjalizacja czasu ostatniej aktualizacji
+
+        if current_operation == OPENING:
+            self._movement_thread = threading.Thread(target=self._move_cover, args=("open", self._open_time, target_position))
+            self._movement_thread.start()
+        elif current_operation == CLOSING:
+            self._movement_thread = threading.Thread(target=self._move_cover, args=("close", self._close_time, target_position))
+            self._movement_thread.start()
+
+
+    @property
+    def kind(self) -> str:
+        return "time"
+
+    def update_config_times(self, config: dict) -> None:
+        self._open_duration = config.get("open_duration", self._open_duration)
+        self._close_duration = config.get("close_duration", self._close_duration)
+