feat: v 1.4.0 Полный функционал для работы с вятяжкой
* Добавил полный функционал управления elica через esp32 по MQTT
* Добавил в прошивку принудительную блокировку внешнего винтелятора при работающей вытяжке
* Добавил веб-панели для управления вытяжкой
This commit is contained in:
@@ -0,0 +1,14 @@
|
||||
from .config import ElicaConfig
|
||||
from .controller import ElicaController
|
||||
from .models import ElicaLogicalState, ElicaPanelState, ElicaState, ExternalFanState
|
||||
from .service import ElicaService
|
||||
|
||||
__all__ = [
|
||||
"ElicaConfig",
|
||||
"ElicaController",
|
||||
"ElicaLogicalState",
|
||||
"ElicaPanelState",
|
||||
"ElicaService",
|
||||
"ElicaState",
|
||||
"ExternalFanState",
|
||||
]
|
||||
@@ -0,0 +1,88 @@
|
||||
from dataclasses import dataclass
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ElicaConfig:
|
||||
mqtt_host: str
|
||||
mqtt_port: int = 1883
|
||||
|
||||
# Корневой MQTT topic ESPHome-контроллера Elica
|
||||
topic: str = "elica"
|
||||
|
||||
# Длительность виртуального нажатия кнопки
|
||||
pulse_ms: int = 300
|
||||
|
||||
# Физические реле платы ESP32 Relay X8 Modbus.
|
||||
# OUT1-OUT4 используются для кнопок Elica.
|
||||
power_relay: int = 1
|
||||
speed_relay: int = 2
|
||||
light_relay: int = 3
|
||||
timer_relay: int = 4
|
||||
|
||||
# Внешний вытяжной вентилятор подключён к OUT5.
|
||||
# Нагрузка заведена через NC-контакт реле, поэтому логическое
|
||||
# состояние вентилятора инвертировано относительно катушки реле:
|
||||
# relay OFF -> NC замкнут -> fan ON; relay ON -> fan OFF.
|
||||
external_fan_relay: int = 5
|
||||
external_fan_normally_closed: bool = True
|
||||
|
||||
# Индикаторы Elica -> IN
|
||||
speed_1_input: int = 1
|
||||
speed_2_input: int = 2
|
||||
speed_3_input: int = 3
|
||||
speed_4_input: int = 4
|
||||
power_input: int = 5
|
||||
|
||||
# Определение мигания индикатора скорости.
|
||||
blink_max_off_s: float = 1.5
|
||||
blink_hold_s: float = 2.5
|
||||
|
||||
@property
|
||||
def status_topic(self) -> str:
|
||||
"""
|
||||
Доступность ESP32.
|
||||
|
||||
Payload:
|
||||
online
|
||||
offline
|
||||
"""
|
||||
return f"{self.topic}/status"
|
||||
|
||||
def relay_command_topic(self, relay: int) -> str:
|
||||
"""
|
||||
Команда конкретному реле.
|
||||
|
||||
Payload:
|
||||
ON
|
||||
OFF
|
||||
"""
|
||||
return f"{self.topic}/relay/{relay}/set"
|
||||
|
||||
def relay_state_topic(self, relay: int) -> str:
|
||||
"""
|
||||
Состояние конкретного реле.
|
||||
|
||||
Payload:
|
||||
ON
|
||||
OFF
|
||||
"""
|
||||
return f"{self.topic}/relay/{relay}/state"
|
||||
|
||||
def input_state_topic(self, input_number: int) -> str:
|
||||
"""
|
||||
Состояние физического входа IN1-IN8.
|
||||
|
||||
Payload:
|
||||
ON
|
||||
OFF
|
||||
"""
|
||||
return f"{self.topic}/input/{input_number}/state"
|
||||
|
||||
@property
|
||||
def relay_state_wildcard(self) -> str:
|
||||
return f"{self.topic}/relay/+/state"
|
||||
|
||||
@property
|
||||
def input_state_wildcard(self) -> str:
|
||||
return f"{self.topic}/input/+/state"
|
||||
|
||||
@@ -0,0 +1,312 @@
|
||||
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")
|
||||
@@ -0,0 +1,70 @@
|
||||
from dataclasses import asdict, dataclass
|
||||
from datetime import datetime
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ElicaState:
|
||||
mqtt_connected: bool = False
|
||||
device_online: bool = False
|
||||
|
||||
last_message_at: datetime | None = None
|
||||
|
||||
firmware: str | None = None
|
||||
uptime_seconds: int | None = None
|
||||
|
||||
wifi_rssi: int | None = None
|
||||
|
||||
# Фактические состояния OUT1-OUT8,
|
||||
# полученные от ESPHome через MQTT.
|
||||
relay_states: tuple[bool, ...] = (
|
||||
False, False, False, False,
|
||||
False, False, False, False,
|
||||
)
|
||||
# Состояния оптовходов IN1-IN8, полученные от ESPHome через MQTT.
|
||||
# True означает электрически активный вход платы. Для линий
|
||||
# индикаторов Elica это НЕ равно "LED включён": Elica активна LOW.
|
||||
input_states: tuple[bool, ...] = (
|
||||
False, False, False, False,
|
||||
False, False, False, False,
|
||||
)
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
result = asdict(self)
|
||||
|
||||
if result["last_message_at"] is not None:
|
||||
result["last_message_at"] = (
|
||||
result["last_message_at"].isoformat()
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ElicaPanelState:
|
||||
speed_leds: tuple[bool, bool, bool, bool] = (
|
||||
False, False, False, False
|
||||
)
|
||||
power_led: bool = False
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return asdict(self)
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ElicaLogicalState:
|
||||
power: bool = False
|
||||
speed: int = 0
|
||||
timer: bool = False
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return asdict(self)
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ExternalFanState:
|
||||
available: bool = False
|
||||
on: bool | None = None
|
||||
relay: int = 5
|
||||
relay_on: bool | None = None
|
||||
normally_closed: bool = True
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return asdict(self)
|
||||
@@ -0,0 +1,691 @@
|
||||
import time
|
||||
import asyncio
|
||||
import logging
|
||||
import paho.mqtt.client as mqtt
|
||||
from dataclasses import replace
|
||||
from datetime import datetime, timezone
|
||||
from .config import ElicaConfig
|
||||
from .models import ElicaState, ElicaPanelState, ElicaLogicalState, ExternalFanState
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class ElicaService:
|
||||
"""
|
||||
Низкоуровневый сервис связи с ESP32-контроллером Elica.
|
||||
|
||||
На данном этапе умеет:
|
||||
- подключаться к MQTT;
|
||||
- отслеживать online/offline ESP32;
|
||||
- получать состояния OUT1-OUT8;
|
||||
- включать и выключать любое реле.
|
||||
|
||||
Логика самой вытяжки здесь пока отсутствует.
|
||||
"""
|
||||
def __init__(self, config: ElicaConfig):
|
||||
|
||||
self._config = config
|
||||
|
||||
self._state = ElicaState()
|
||||
self._running = False
|
||||
self._client: mqtt.Client | None = None
|
||||
self._last_speed = 0
|
||||
self._speed_led_off_at: float | None = None
|
||||
self._last_blink_at: float | None = None
|
||||
self._received_input_mask = 0
|
||||
self._received_relay_mask = 0
|
||||
|
||||
|
||||
@property
|
||||
def config(self) -> ElicaConfig:
|
||||
return self._config
|
||||
|
||||
@property
|
||||
def state(self) -> ElicaState:
|
||||
return self._state
|
||||
|
||||
@property
|
||||
def running(self) -> bool:
|
||||
return self._running
|
||||
|
||||
async def start(self) -> None:
|
||||
if self._running:
|
||||
return
|
||||
|
||||
client = mqtt.Client(
|
||||
callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
|
||||
client_id="climatcontroller-elica",
|
||||
)
|
||||
|
||||
client.on_connect = self._on_connect
|
||||
client.on_disconnect = self._on_disconnect
|
||||
client.on_message = self._on_message
|
||||
|
||||
client.reconnect_delay_set(
|
||||
min_delay=1,
|
||||
max_delay=30,
|
||||
)
|
||||
|
||||
self._client = client
|
||||
self._running = True
|
||||
|
||||
client.connect_async(
|
||||
self._config.mqtt_host,
|
||||
self._config.mqtt_port,
|
||||
keepalive=60,
|
||||
)
|
||||
|
||||
client.loop_start()
|
||||
|
||||
|
||||
async def stop(self) -> None:
|
||||
if not self._running:
|
||||
return
|
||||
|
||||
self._running = False
|
||||
|
||||
if self._client is not None:
|
||||
self._client.disconnect()
|
||||
self._client.loop_stop()
|
||||
self._client = None
|
||||
|
||||
self._state = replace(
|
||||
self._state,
|
||||
mqtt_connected=False,
|
||||
device_online=False,
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# MQTT callbacks
|
||||
# ------------------------------------------------------------------
|
||||
def _on_connect(
|
||||
self,
|
||||
_client,
|
||||
_userdata,
|
||||
_flags,
|
||||
reason_code,
|
||||
_properties=None,
|
||||
) -> None:
|
||||
if reason_code != 0:
|
||||
logger.error("ESP32 elica MQTT connection failed: %s",reason_code)
|
||||
return
|
||||
|
||||
logger.info("ESP32 elica MQTT connected")
|
||||
|
||||
self._received_input_mask = 0
|
||||
self._received_relay_mask = 0
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Подписки сервиса
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
#Статус
|
||||
_client.subscribe(self._config.status_topic)
|
||||
|
||||
#широковещательная подписка статусов реле
|
||||
_client.subscribe(self._config.relay_state_wildcard)
|
||||
|
||||
# широковещательная подписка статусов входов
|
||||
_client.subscribe(self._config.input_state_wildcard)
|
||||
|
||||
self._state = replace(self._state, mqtt_connected=True)
|
||||
|
||||
|
||||
def _on_disconnect(
|
||||
self,
|
||||
_client,
|
||||
_userdata,
|
||||
_disconnect_flags,
|
||||
reason_code,
|
||||
_properties=None,
|
||||
) -> None:
|
||||
|
||||
if self._running:
|
||||
logger.warning("ESP32 Elica MQTT disconnected unexpectedly: %s",reason_code)
|
||||
else:
|
||||
logger.info("ESP32 Elica MQTT disconnected: %s",reason_code)
|
||||
|
||||
self._received_input_mask = 0
|
||||
self._received_relay_mask = 0
|
||||
|
||||
self._state = replace(
|
||||
self._state,
|
||||
mqtt_connected=False,
|
||||
device_online=False,
|
||||
)
|
||||
|
||||
|
||||
def _on_message(
|
||||
self,
|
||||
_client,
|
||||
_userdata,
|
||||
message,
|
||||
) -> None:
|
||||
|
||||
|
||||
|
||||
if message.topic == self._config.status_topic:
|
||||
self._handle_status(message)
|
||||
return
|
||||
|
||||
relay_prefix = f"{self._config.topic}/relay/"
|
||||
if message.topic.startswith(relay_prefix) and message.topic.endswith("/state"):
|
||||
self._handle_relay_state(message)
|
||||
return
|
||||
|
||||
input_prefix = f"{self._config.topic}/input/"
|
||||
if message.topic.startswith(input_prefix) and message.topic.endswith("/state"):
|
||||
self._handle_input_state(message)
|
||||
return
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Device status
|
||||
# ------------------------------------------------------------------
|
||||
def _handle_status(self, message) -> None:
|
||||
payload = message.payload.decode("utf-8").strip()
|
||||
|
||||
now = datetime.now(timezone.utc)
|
||||
|
||||
if payload.lower() == "online":
|
||||
device_online = True
|
||||
elif payload.lower() == "offline":
|
||||
device_online = False
|
||||
else:
|
||||
logger.warning("Unknown Exhaust LWT payload: %r",payload)
|
||||
return
|
||||
|
||||
self._state = replace(
|
||||
self._state,
|
||||
device_online=device_online,
|
||||
last_message_at=now,
|
||||
)
|
||||
# ------------------------------------------------------------------
|
||||
# Relay state
|
||||
# ------------------------------------------------------------------
|
||||
def _handle_relay_state(self, message) -> None:
|
||||
"""
|
||||
Обрабатывает сообщения:
|
||||
|
||||
elica/relay/1/state
|
||||
...
|
||||
elica/relay/8/state
|
||||
|
||||
Payload:
|
||||
ON
|
||||
OFF
|
||||
"""
|
||||
|
||||
prefix = f"{self._config.topic}/relay/"
|
||||
suffix = "/state"
|
||||
|
||||
relay_text = message.topic[
|
||||
len(prefix):-len(suffix)
|
||||
]
|
||||
|
||||
try:
|
||||
relay = int(relay_text)
|
||||
except ValueError:
|
||||
logger.warning("Invalid ESP32 Elica relay topic: %s",message.topic)
|
||||
return
|
||||
|
||||
if not 1 <= relay <= 8:
|
||||
logger.warning("ESP32 Elica relay number out of range: %s",relay)
|
||||
return
|
||||
|
||||
try:
|
||||
payload = message.payload.decode("utf-8").strip().upper()
|
||||
|
||||
except UnicodeDecodeError:
|
||||
logger.warning("Invalid ESP32 Elica relay payload")
|
||||
return
|
||||
|
||||
if payload == "ON":
|
||||
enabled = True
|
||||
|
||||
elif payload == "OFF":
|
||||
enabled = False
|
||||
|
||||
else:
|
||||
logger.warning("Unknown ESP32 Elica relay payload: %r",payload,)
|
||||
return
|
||||
|
||||
relay_states = list(self._state.relay_states)
|
||||
|
||||
relay_states[relay - 1] = enabled
|
||||
|
||||
self._state = replace(
|
||||
self._state,
|
||||
relay_states=tuple(relay_states),
|
||||
last_message_at=datetime.now(timezone.utc),
|
||||
)
|
||||
self._received_relay_mask |= 1 << (relay - 1)
|
||||
# ------------------------------------------------------------------
|
||||
# Input state
|
||||
# ------------------------------------------------------------------
|
||||
def _handle_input_state(self, message) -> None:
|
||||
"""
|
||||
Обрабатывает elica/input/1/state ... elica/input/8/state.
|
||||
Payload: ON / OFF.
|
||||
"""
|
||||
prefix = f"{self._config.topic}/input/"
|
||||
suffix = "/state"
|
||||
input_text = message.topic[len(prefix):-len(suffix)]
|
||||
|
||||
try:
|
||||
input_number = int(input_text)
|
||||
except ValueError:
|
||||
logger.warning("Invalid ESP32 Elica input topic: %s", message.topic)
|
||||
return
|
||||
|
||||
if not 1 <= input_number <= 8:
|
||||
logger.warning("ESP32 Elica input number out of range: %s", input_number)
|
||||
return
|
||||
|
||||
try:
|
||||
payload = message.payload.decode("utf-8").strip().upper()
|
||||
except UnicodeDecodeError:
|
||||
logger.warning("Invalid ESP32 Elica input payload")
|
||||
return
|
||||
|
||||
if payload == "ON":
|
||||
enabled = True
|
||||
elif payload == "OFF":
|
||||
enabled = False
|
||||
else:
|
||||
logger.warning("Unknown ESP32 Elica input payload: %r", payload)
|
||||
return
|
||||
|
||||
input_states = list(self._state.input_states)
|
||||
input_states[input_number - 1] = enabled
|
||||
|
||||
self._state = replace(
|
||||
self._state,
|
||||
input_states=tuple(input_states),
|
||||
last_message_at=datetime.now(timezone.utc),
|
||||
)
|
||||
|
||||
self._received_input_mask |= 1 << (input_number - 1)
|
||||
|
||||
self._update_panel_tracker()
|
||||
|
||||
def input_state(self, input_number: int) -> bool:
|
||||
"""Возвращает последнее известное состояние IN1-IN8."""
|
||||
if not 1 <= input_number <= 8:
|
||||
raise ValueError("Input number must be between 1 and 8")
|
||||
|
||||
return self._state.input_states[input_number - 1]
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Elica state tracking
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def _update_panel_tracker(self) -> None:
|
||||
"""Отслеживает скорость и мигание индикатора таймера."""
|
||||
# Пока не получили все пять входов панели, не пытаемся
|
||||
# интерпретировать их начальные значения. После инверсии Elica
|
||||
# значение False по умолчанию выглядело бы как включённый LED.
|
||||
if not self.feedback_ready:
|
||||
return
|
||||
|
||||
panel = self.panel_state
|
||||
now = time.monotonic()
|
||||
|
||||
if not panel.power_led:
|
||||
self._last_speed = 0
|
||||
self._speed_led_off_at = None
|
||||
self._last_blink_at = None
|
||||
return
|
||||
|
||||
active_speeds = [
|
||||
index + 1
|
||||
for index, enabled in enumerate(panel.speed_leds)
|
||||
if enabled
|
||||
]
|
||||
|
||||
if active_speeds:
|
||||
speed = active_speeds[0]
|
||||
|
||||
if speed != self._last_speed:
|
||||
self._last_speed = speed
|
||||
self._speed_led_off_at = None
|
||||
self._last_blink_at = None
|
||||
return
|
||||
|
||||
if self._speed_led_off_at is not None:
|
||||
off_time = now - self._speed_led_off_at
|
||||
|
||||
if off_time <= self._config.blink_max_off_s:
|
||||
self._last_blink_at = now
|
||||
|
||||
self._speed_led_off_at = None
|
||||
|
||||
return
|
||||
|
||||
if self._last_speed > 0 and self._speed_led_off_at is None:
|
||||
self._speed_led_off_at = now
|
||||
|
||||
@property
|
||||
def logical_state(self) -> ElicaLogicalState:
|
||||
"""Возвращает интерпретированное состояние вытяжки Elica."""
|
||||
if not self.feedback_ready:
|
||||
return ElicaLogicalState()
|
||||
|
||||
panel = self.panel_state
|
||||
now = time.monotonic()
|
||||
|
||||
if not panel.power_led:
|
||||
return ElicaLogicalState()
|
||||
|
||||
active_speeds = [
|
||||
index + 1
|
||||
for index, enabled in enumerate(panel.speed_leds)
|
||||
if enabled
|
||||
]
|
||||
|
||||
if active_speeds:
|
||||
speed = active_speeds[0]
|
||||
|
||||
elif (
|
||||
self._last_speed > 0
|
||||
and self._speed_led_off_at is not None
|
||||
and now - self._speed_led_off_at <= self._config.blink_max_off_s
|
||||
):
|
||||
speed = self._last_speed
|
||||
|
||||
else:
|
||||
speed = 0
|
||||
|
||||
timer = (
|
||||
speed > 0
|
||||
and self._last_blink_at is not None
|
||||
and now - self._last_blink_at <= self._config.blink_hold_s
|
||||
)
|
||||
|
||||
return ElicaLogicalState(
|
||||
power=True,
|
||||
speed=speed,
|
||||
timer=timer,
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# MQTT publish
|
||||
# ------------------------------------------------------------------
|
||||
def _publish(
|
||||
self,
|
||||
topic: str,
|
||||
payload: str,
|
||||
) -> None:
|
||||
|
||||
if not self._running:
|
||||
raise RuntimeError("Elica service is not running")
|
||||
|
||||
if self._client is None or not self._state.mqtt_connected:
|
||||
raise RuntimeError("ESP32 Elica MQTT is not connected")
|
||||
|
||||
result = self._client.publish(
|
||||
topic,
|
||||
payload,
|
||||
retain=False,
|
||||
)
|
||||
|
||||
if result.rc != mqtt.MQTT_ERR_SUCCESS:
|
||||
raise RuntimeError(f"MQTT publish failed: {result.rc}")
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Relay control
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def set_relay(
|
||||
self,
|
||||
relay: int,
|
||||
enabled: bool,
|
||||
) -> None:
|
||||
"""
|
||||
Устанавливает состояние физического реле OUT1-OUT8.
|
||||
Это низкоуровневая функция.
|
||||
Например:
|
||||
set_relay(1, True)
|
||||
отправит:
|
||||
elica/relay/1/set -> ON
|
||||
"""
|
||||
|
||||
if not 1 <= relay <= 8:
|
||||
raise ValueError("Relay number must be between 1 and 8")
|
||||
|
||||
topic = self._config.relay_command_topic(relay)
|
||||
payload = "ON" if enabled else "OFF"
|
||||
self._publish(topic, payload)
|
||||
|
||||
|
||||
def relay_state(
|
||||
self,
|
||||
relay: int,
|
||||
) -> bool:
|
||||
"""
|
||||
Возвращает последнее известное состояние реле.
|
||||
"""
|
||||
if not 1 <= relay <= 8:
|
||||
raise ValueError("Relay number must be between 1 and 8")
|
||||
|
||||
return self._state.relay_states[relay - 1]
|
||||
|
||||
def relay_feedback_ready(self, relay: int) -> bool:
|
||||
"""True, если после подключения уже получено состояние реле."""
|
||||
if not 1 <= relay <= 8:
|
||||
raise ValueError("Relay number must be between 1 and 8")
|
||||
|
||||
return bool(self._received_relay_mask & (1 << (relay - 1)))
|
||||
|
||||
@property
|
||||
def external_fan_state(self) -> ExternalFanState:
|
||||
"""Логическое состояние внешнего вентилятора на OUT5."""
|
||||
relay = self._config.external_fan_relay
|
||||
ready = self.relay_feedback_ready(relay)
|
||||
|
||||
if not ready:
|
||||
return ExternalFanState(
|
||||
available=False,
|
||||
on=None,
|
||||
relay=relay,
|
||||
relay_on=None,
|
||||
normally_closed=self._config.external_fan_normally_closed,
|
||||
)
|
||||
|
||||
relay_on = self.relay_state(relay)
|
||||
fan_on = (
|
||||
not relay_on
|
||||
if self._config.external_fan_normally_closed
|
||||
else relay_on
|
||||
)
|
||||
|
||||
return ExternalFanState(
|
||||
available=True,
|
||||
on=fan_on,
|
||||
relay=relay,
|
||||
relay_on=relay_on,
|
||||
normally_closed=self._config.external_fan_normally_closed,
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Public status
|
||||
# ------------------------------------------------------------------
|
||||
def status(self) -> dict:
|
||||
return {
|
||||
"running": self._running,
|
||||
"topic": self._config.topic,
|
||||
"pulse_ms": self._config.pulse_ms,
|
||||
"panel": self.panel_state.to_dict(),
|
||||
"elica": self.logical_state.to_dict(),
|
||||
"external_fan": self.external_fan_state.to_dict(),
|
||||
"feedback_ready": self.feedback_ready,
|
||||
"missing_feedback_inputs": self.missing_feedback_inputs,
|
||||
**self._state.to_dict(),
|
||||
}
|
||||
|
||||
async def pulse_relay(self, relay: int, pulse_ms: int | None = None) -> None:
|
||||
"""
|
||||
Кратковременно включает реле и затем выключает его.
|
||||
Используется для эмуляции нажатия кнопок Elica.
|
||||
"""
|
||||
if not 1 <= relay <= 8:
|
||||
raise ValueError("Relay number must be between 1 and 8")
|
||||
|
||||
duration_ms = pulse_ms if pulse_ms is not None else self._config.pulse_ms
|
||||
|
||||
self.set_relay(relay, True)
|
||||
|
||||
try:
|
||||
await self.wait_relay_state(relay, True)
|
||||
await asyncio.sleep(duration_ms / 1000)
|
||||
|
||||
finally:
|
||||
try:
|
||||
self.set_relay(relay, False)
|
||||
except Exception:
|
||||
logger.exception("Failed to release Elica relay %s", relay)
|
||||
|
||||
await self.wait_relay_state(relay, False)
|
||||
|
||||
|
||||
|
||||
|
||||
async def wait_relay_feedback_ready(
|
||||
self,
|
||||
relay: int,
|
||||
timeout: float = 3.0,
|
||||
poll_interval: float = 0.02,
|
||||
) -> None:
|
||||
"""Ждёт первого MQTT-состояния указанного реле после connect."""
|
||||
if not 1 <= relay <= 8:
|
||||
raise ValueError("Relay number must be between 1 and 8")
|
||||
|
||||
deadline = asyncio.get_running_loop().time() + timeout
|
||||
|
||||
while not self.relay_feedback_ready(relay):
|
||||
if not self._running:
|
||||
raise RuntimeError("Elica service is not running")
|
||||
if not self._state.mqtt_connected:
|
||||
raise RuntimeError("Elica MQTT is not connected")
|
||||
if not self._state.device_online:
|
||||
raise RuntimeError("ESP32 Elica controller is offline")
|
||||
if asyncio.get_running_loop().time() >= deadline:
|
||||
raise TimeoutError(
|
||||
f"Relay {relay} feedback synchronization timeout"
|
||||
)
|
||||
await asyncio.sleep(poll_interval)
|
||||
|
||||
|
||||
async def wait_relay_state(
|
||||
self,
|
||||
relay: int,
|
||||
expected: bool,
|
||||
timeout: float = 2.0,
|
||||
) -> None:
|
||||
"""
|
||||
Ждёт подтверждения состояния реле через MQTT.
|
||||
"""
|
||||
if not 1 <= relay <= 8:
|
||||
raise ValueError("Relay number must be between 1 and 8")
|
||||
|
||||
deadline = asyncio.get_running_loop().time() + timeout
|
||||
|
||||
while self.relay_state(relay) != expected:
|
||||
if asyncio.get_running_loop().time() >= deadline:
|
||||
state = self.relay_state(relay)
|
||||
raise TimeoutError(
|
||||
f"Relay {relay} did not reach state {expected}; current state: {state}"
|
||||
)
|
||||
|
||||
await asyncio.sleep(0.02)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Elica buttons
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
async def press_power(self) -> None:
|
||||
"""Эмулирует нажатие кнопки Power."""
|
||||
await self.pulse_relay(self._config.power_relay)
|
||||
|
||||
async def press_speed(self) -> None:
|
||||
"""Эмулирует нажатие кнопки Speed."""
|
||||
await self.pulse_relay(self._config.speed_relay)
|
||||
|
||||
async def press_light(self) -> None:
|
||||
"""Эмулирует нажатие кнопки Light."""
|
||||
await self.pulse_relay(self._config.light_relay)
|
||||
|
||||
async def press_timer(self) -> None:
|
||||
"""Эмулирует нажатие кнопки Timer."""
|
||||
await self.pulse_relay(self._config.timer_relay)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Elica panel feedback
|
||||
# ------------------------------------------------------------------
|
||||
@property
|
||||
def panel_state(self) -> ElicaPanelState:
|
||||
"""Возвращает фактическое состояние светодиодов панели Elica.
|
||||
|
||||
Входы обратной связи имеют обратную полярность относительно LED:
|
||||
высокий уровень на IN означает, что соответствующий индикатор
|
||||
Elica погашен, низкий уровень — что индикатор горит.
|
||||
|
||||
MQTT-состояние входа поэтому инвертируем именно здесь, на границе
|
||||
между электрическим состоянием IN и логическим состоянием панели.
|
||||
"""
|
||||
return ElicaPanelState(
|
||||
speed_leds=(
|
||||
not self.input_state(self._config.speed_1_input),
|
||||
not self.input_state(self._config.speed_2_input),
|
||||
not self.input_state(self._config.speed_3_input),
|
||||
not self.input_state(self._config.speed_4_input),
|
||||
),
|
||||
power_led=not self.input_state(self._config.power_input),
|
||||
)
|
||||
|
||||
@property
|
||||
def feedback_ready(self) -> bool:
|
||||
"""True, когда получены состояния всех входов, необходимых для Elica."""
|
||||
return not self.missing_feedback_inputs
|
||||
|
||||
|
||||
@property
|
||||
def missing_feedback_inputs(self) -> tuple[int, ...]:
|
||||
"""Возвращает номера входов Elica, состояние которых ещё не получено."""
|
||||
required = (
|
||||
self._config.speed_1_input,
|
||||
self._config.speed_2_input,
|
||||
self._config.speed_3_input,
|
||||
self._config.speed_4_input,
|
||||
self._config.power_input,
|
||||
)
|
||||
|
||||
return tuple(
|
||||
input_number
|
||||
for input_number in required
|
||||
if not self._received_input_mask & (1 << (input_number - 1))
|
||||
)
|
||||
|
||||
async def wait_feedback_ready(
|
||||
self,
|
||||
timeout: float = 3.0,
|
||||
poll_interval: float = 0.05,
|
||||
) -> None:
|
||||
"""Ждёт получения исходного состояния всех входов панели Elica."""
|
||||
deadline = asyncio.get_running_loop().time() + timeout
|
||||
|
||||
while not self.feedback_ready:
|
||||
if not self._running:
|
||||
raise RuntimeError("Elica service is not running")
|
||||
|
||||
if not self._state.mqtt_connected:
|
||||
raise RuntimeError("Elica MQTT is not connected")
|
||||
|
||||
if not self._state.device_online:
|
||||
raise RuntimeError("ESP32 Elica controller is offline")
|
||||
|
||||
if asyncio.get_running_loop().time() >= deadline:
|
||||
raise TimeoutError(
|
||||
f"Elica feedback synchronization timeout; "
|
||||
f"missing inputs: {self.missing_feedback_inputs}"
|
||||
)
|
||||
|
||||
await asyncio.sleep(poll_interval)
|
||||
Reference in New Issue
Block a user