* Добавил полный функционал управления elica через esp32 по MQTT * Добавил в прошивку принудительную блокировку внешнего винтелятора при работающей вытяжке * Добавил веб-панели для управления вытяжкой
312 lines
12 KiB
Python
312 lines
12 KiB
Python
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._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()
|
||
|
||
# ------------------------------------------------------------------
|
||
# 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._service.press_speed()
|
||
state = await self._wait_state(
|
||
lambda value: value.power and value.speed == 1,
|
||
"speed 1",
|
||
)
|
||
|
||
# После физического отпускания кнопки Elica нужен
|
||
# небольшой гарантированный интервал до следующего
|
||
# нажатия. Иначе при быстром наборе 2/3/4 контроллер
|
||
# вытяжки иногда воспринимает два импульса как одно
|
||
# длинное нажатие или просто игнорирует следующий.
|
||
if speed != 1 and self._speed_inter_press_delay > 0:
|
||
await asyncio.sleep(self._speed_inter_press_delay)
|
||
|
||
# Если питание уже было включено, но индикатор скорости ещё
|
||
# не успел синхронизироваться, ждём корректное значение 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._service.press_speed()
|
||
|
||
state = await self._wait_state(
|
||
lambda value, expected=expected_speed: (
|
||
value.power and value.speed == expected
|
||
),
|
||
f"speed {expected_speed}",
|
||
)
|
||
|
||
current_speed = expected_speed
|
||
|
||
# Не нажимаем Speed повторно сразу после отпускания
|
||
# предыдущего импульса. Это особенно важно для переходов
|
||
# на 4-ю скорость, где требуется несколько нажатий подряд.
|
||
if current_speed != speed and self._speed_inter_press_delay > 0:
|
||
await asyncio.sleep(self._speed_inter_press_delay)
|
||
|
||
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") |