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)