import asyncio from collections.abc import Callable from .models import ElicaLogicalState from .service import ElicaService class ElicaController: """ Высокоуровневый контроллер вытяжки Elica. ElicaService отвечает за ESP32, MQTT, реле и входы. ElicaController работает уже с понятиями самой вытяжки: питание, скорость, таймер и свет. """ def __init__( self, service: ElicaService, state_timeout: float = 3.0, poll_interval: float = 0.05, speed_inter_press_delay: float = 0.4, ): self._service = service self._state_timeout = state_timeout self._poll_interval = poll_interval self._speed_inter_press_delay = max(0.0, speed_inter_press_delay) self._last_speed_press_finished_at: float | None = None # Не допускаем одновременное выполнение нескольких # последовательностей нажатий кнопок. self._lock = asyncio.Lock() self._external_fan_lock = asyncio.Lock() @property def service(self) -> ElicaService: return self._service @property def state(self) -> ElicaLogicalState: return self._service.logical_state # ------------------------------------------------------------------ # Internal helpers # ------------------------------------------------------------------ def _ensure_available(self) -> None: if not self._service.running: raise RuntimeError("Elica service is not running") if not self._service.state.mqtt_connected: raise RuntimeError("Elica MQTT is not connected") if not self._service.state.device_online: raise RuntimeError("ESP32 Elica controller is offline") async def _wait_state( self, predicate: Callable[[ElicaLogicalState], bool], description: str, timeout: float | None = None, ) -> ElicaLogicalState: """Ждёт подтверждения требуемого состояния по обратной связи.""" timeout = self._state_timeout if timeout is None else timeout deadline = asyncio.get_running_loop().time() + timeout while True: self._ensure_available() self._ensure_feedback_ready() state = self.state if predicate(state): return state if asyncio.get_running_loop().time() >= deadline: raise TimeoutError( f"Elica did not reach expected state: {description}; " f"current state: {state}" ) await asyncio.sleep(self._poll_interval) async def _power_on_locked(self) -> ElicaLogicalState: """Включает вытяжку. Вызывается только под self._lock.""" await self._ensure_ready() state = self.state if state.power: return state await self._service.press_power() return await self._wait_state( lambda value: value.power, "power on", ) async def _power_off_locked(self) -> ElicaLogicalState: """Выключает вытяжку. Вызывается только под self._lock.""" await self._ensure_ready() state = self.state if not state.power: return state await self._service.press_power() return await self._wait_state( lambda value: not value.power, "power off", ) # ------------------------------------------------------------------ # Power # ------------------------------------------------------------------ async def power_on(self) -> ElicaLogicalState: async with self._lock: return await self._power_on_locked() async def power_off(self) -> ElicaLogicalState: async with self._lock: return await self._power_off_locked() async def _press_speed_locked(self) -> None: """ Нажимает Speed с гарантированным минимальным интервалом после предыдущего нажатия. Интервал соблюдается и между разными вызовами set_speed(). """ loop = asyncio.get_running_loop() if ( self._last_speed_press_finished_at is not None and self._speed_inter_press_delay > 0 ): elapsed = ( loop.time() - self._last_speed_press_finished_at ) remaining = ( self._speed_inter_press_delay - elapsed ) if remaining > 0: await asyncio.sleep( remaining ) await self._service.press_speed() self._last_speed_press_finished_at = ( loop.time() ) # ------------------------------------------------------------------ # Speed # ------------------------------------------------------------------ async def set_speed(self, speed: int) -> ElicaLogicalState: """Устанавливает скорость 1-4 последовательными нажатиями Speed. У Elica одна кнопка скорости и фиксированный цикл: 1 -> 2 -> 3 -> 4 -> 1 Поэтому сначала определяем текущую скорость по индикаторам, вычисляем точное число нажатий и после каждого нажатия ждём подтверждения следующей скорости. """ if not 1 <= speed <= 4: raise ValueError("Elica speed must be between 1 and 4") async with self._lock: await self._ensure_ready() state = self.state if not state.power: # У Elica кнопка Speed сама включает вытяжку. Первое # нажатие из состояния OFF запускает её на скорости 1. # Поэтому при выборе скорости Power здесь не нажимаем. await self._press_speed_locked() state = await self._wait_state( lambda value: value.power and value.speed == 1, "speed 1", ) # Если питание уже было включено, но индикатор скорости ещё # не успел синхронизироваться, ждём корректное значение 1-4. if not 1 <= state.speed <= 4: state = await self._wait_state( lambda value: value.power and 1 <= value.speed <= 4, "initial speed", ) current_speed = state.speed presses = (speed - current_speed) % 4 for _ in range(presses): expected_speed = current_speed % 4 + 1 await self._press_speed_locked() state = await self._wait_state( lambda value, expected=expected_speed: ( value.power and value.speed == expected ), f"speed {expected_speed}", ) current_speed = expected_speed return state # ------------------------------------------------------------------ # Timer # ------------------------------------------------------------------ async def set_timer(self, enabled: bool) -> ElicaLogicalState: """ Включает или выключает таймер. Состояние подтверждается по миганию индикатора скорости. """ async with self._lock: await self._ensure_ready() state = self.state if not enabled and not state.power: return state if enabled and not state.power: state = await self._power_on_locked() if state.timer == enabled: return state await self._service.press_timer() # При выключении таймера logical_state.timer остаётся True, # пока не истечёт blink_hold_s после последнего мигания. timeout = max( self._state_timeout, self._service.config.blink_hold_s + 1.5, ) return await self._wait_state( lambda value: value.timer == enabled, f"timer {'on' if enabled else 'off'}", timeout=timeout, ) async def timer_on(self) -> ElicaLogicalState: return await self.set_timer(True) async def timer_off(self) -> ElicaLogicalState: return await self.set_timer(False) # ------------------------------------------------------------------ # Light # ------------------------------------------------------------------ async def toggle_light(self) -> None: """ Переключает свет. Обратной связи о состоянии света сейчас нет, поэтому light_on/light_off реализовать достоверно нельзя. """ async with self._lock: await self._ensure_ready() await self._service.press_light() # ------------------------------------------------------------------ # External fan (OUT5 / NC contact) # ------------------------------------------------------------------ async def set_external_fan(self, enabled: bool) -> bool: """ Управляет внешним вентилятором через OUT5. Вентилятор подключён к NC-контакту, поэтому для включения вентилятора катушка реле должна быть выключена, а для выключения — включена. Физическая инверсия скрыта внутри этого метода. """ async with self._external_fan_lock: self._ensure_available() relay = self._service.config.external_fan_relay await self._service.wait_relay_feedback_ready( relay, timeout=self._state_timeout, ) relay_enabled = ( not enabled if self._service.config.external_fan_normally_closed else enabled ) if self._service.relay_state(relay) != relay_enabled: self._service.set_relay(relay, relay_enabled) await self._service.wait_relay_state( relay, relay_enabled, timeout=self._state_timeout, ) state = self._service.external_fan_state if state.on is None: raise RuntimeError("External fan state is unavailable") return state.on async def external_fan_on(self) -> bool: return await self.set_external_fan(True) async def external_fan_off(self) -> bool: return await self.set_external_fan(False) # ------------------------------------------------------------------ # Синхронизация начального состояния # ------------------------------------------------------------------ async def _ensure_ready(self) -> None: """Проверяет доступность и ждёт исходной синхронизации feedback.""" self._ensure_available() await self._service.wait_feedback_ready(timeout=self._state_timeout) self._ensure_available() def _ensure_feedback_ready(self) -> None: if not self._service.feedback_ready: raise RuntimeError("Elica feedback is not synchronized")