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 self._received_input_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 # ------------------------------------------------------------------ # Подписки сервиса # ------------------------------------------------------------------ #Статус _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._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._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: """Отслеживает скорость и мигание индикатора таймера.""" 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(), "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_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), ) @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)