537 lines
16 KiB
Python
537 lines
16 KiB
Python
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
|
|
|
|
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
|
|
|
|
|
|
@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")
|
|
|
|
# ------------------------------------------------------------------
|
|
# Подписки сервиса
|
|
# ------------------------------------------------------------------
|
|
|
|
#Статус
|
|
_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._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),
|
|
)
|
|
# ------------------------------------------------------------------
|
|
# 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._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:
|
|
"""Отслеживает скорость и мигание индикатора таймера."""
|
|
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."""
|
|
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]
|
|
|
|
# ------------------------------------------------------------------
|
|
# 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(),
|
|
**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)
|
|
await self.wait_relay_state(relay, True)
|
|
await asyncio.sleep(duration_ms / 1000)
|
|
self.set_relay(relay, False)
|
|
await self.wait_relay_state(relay, False)
|
|
|
|
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."""
|
|
return ElicaPanelState(
|
|
speed_leds=(
|
|
self.input_state(self._config.speed_1_input),
|
|
self.input_state(self._config.speed_2_input),
|
|
self.input_state(self._config.speed_3_input),
|
|
self.input_state(self._config.speed_4_input),
|
|
),
|
|
power_led=self.input_state(self._config.power_input),
|
|
)
|