import asyncio from datetime import datetime from app.auto.co2_policy import Co2SpeedPolicy from app.auto.temperature_policy import TemperaturePolicy from app.my_dataclasses import MAX_TARGET_TEMP from app.auto.elica_assist import ( ElicaAssistMode, ElicaAutoAssistState, ) class AutoController: def __init__( self, schedule_service, qingping_service, tion_service, elica_controller=None, policy: Co2SpeedPolicy | None = None, temperature_policy: TemperaturePolicy | None = None, elica_assist: ElicaAutoAssistState | None = None, interval: float = 5.0, ): self._schedule = schedule_service self._qingping = qingping_service self._tion = tion_service self._elica = elica_controller self._policy = policy self._temperature_policy = temperature_policy self._elica_assist = elica_assist self._interval = interval self._task: asyncio.Task | None = None self._state = "inactive" self._reason: str | None = None self._target_speed: int | None = None self._auto_speed: int | None = None self._target_heater: bool | None = None self._auto_heater: bool | None = None self._target_temperature: int | None = None self._temperature: float | int | None = None self._temperature_source: str | None = None # -------------------------------------------------- # Ручное управление обогревом. # # Эти значения описывают желание пользователя, # а не текущее физическое состояние Tion. # -------------------------------------------------- self._manual_heater_enabled: bool | None = None self._manual_target_temperature: int | None = None # Фактическое решение нашего внешнего # температурного регулятора. self._manual_heating: bool | None = None self._last_error: str | None = None async def start(self) -> None: if self._task is not None: return self._task = asyncio.create_task( self._loop() ) async def stop(self) -> None: if self._task is None: return self._task.cancel() try: await self._task except asyncio.CancelledError: pass finally: self._task = None async def _loop(self) -> None: while True: try: await self._process() except asyncio.CancelledError: raise except Exception as exc: self._last_error = str(exc) await asyncio.sleep( self._interval ) async def _process(self) -> None: now = datetime.now() resolution = self._schedule.resolve(now) # ---------------------------------------------- # Расписание поставлено на паузу. # # Это полноценный ручной режим: # AUTO вообще не имеет права управлять Tion. # ---------------------------------------------- if getattr( self._schedule, "paused", False, ): self._state = "suspended" self._reason = "schedule_paused" # После перехода в ручной режим пользователь # может изменить эти параметры напрямую. # Поэтому старые значения AUTO больше # нельзя считать достоверными. self._target_speed = None self._auto_speed = None self._auto_heater = None self._temperature = None self._temperature_source = None await self._process_manual_heater() self._last_error = None await self._release_elica_assist() return # ---------------------------------------------- # Активен ручной override. # # Пока пользователь вручную управляет Tion, # AUTO вообще не вмешивается. # ---------------------------------------------- if self._schedule.override_active: self._state = "suspended" self._reason = "manual_override" # AUTO больше не может считать, # что знает реальное состояние speed/heater: # пользователь мог изменить их вручную. self._target_speed = None self._auto_speed = None self._target_heater = None self._auto_heater = None self._target_temperature = None self._temperature = None self._temperature_source = None self._last_error = None await self._release_elica_assist() return # ---------------------------------------------- # AUTO сейчас не активен # ---------------------------------------------- if ( not resolution.enabled or not resolution.auto_active ): self._state = "inactive" self._reason = None # Управление возвращается ScheduleService. # После этого AUTO уже не знает фактическое # состояние speed/heater, поэтому забываем его. self._target_speed = None self._auto_speed = None self._target_heater = None self._auto_heater = None self._target_temperature = None self._temperature = None self._temperature_source = None self._last_error = None await self._release_elica_assist() return fallback_speed = resolution.auto_fallback_speed if fallback_speed is None: raise RuntimeError( "AUTO is active but " "fallback speed is missing" ) # ---------------------------------------------- # CO2 policy недоступна. # # Например, auto.yaml не загрузился. # AUTO работает в аварийном fallback-only режиме. # ---------------------------------------------- if self._policy is None: self._state = "fallback" self._reason = "auto_policy_unavailable" self._auto_speed = None await self._set_speed(fallback_speed) await self._update_elica_assist(fallback_speed) if self._temperature_policy is not None: await self._process_heater(resolution) self._last_error = None return qingping_state = self._qingping.state # ---------------------------------------------- # Qingping исправен # ---------------------------------------------- if ( self._qingping.online and qingping_state.co2 is not None ): target_speed = ( self._policy.select_speed( co2=qingping_state.co2, current_speed=self._auto_speed, ) ) self._state = "active" self._reason = None await self._set_speed(target_speed) await self._update_elica_assist(target_speed) self._auto_speed = target_speed if self._temperature_policy is not None: await self._process_heater(resolution) self._last_error = None return # ---------------------------------------------- # AUTO не может работать. # Переходим на fallback. # ---------------------------------------------- if not self._qingping.online: reason = "qingping_offline" else: reason = "co2_missing" self._state = "fallback" self._reason = reason self._auto_speed = None await self._set_speed(fallback_speed) await self._update_elica_assist(fallback_speed) if self._temperature_policy is not None: await self._process_heater( resolution ) self._last_error = None async def _process_heater(self, resolution) -> None: # -------------------------------------------------- # Берём целевую температуру из накопленных # настроек расписания. # # Например: # # SET target_temp=20 # AUTO # # Во время AUTO target_temp остаётся 20. # -------------------------------------------------- target_temp = resolution.auto_target_temp # -------------------------------------------------- # Получаем фактическую температуру. # # _get_temperature() сам выбирает: # # 1. Qingping # 2. Tion как резерв # 3. None, если оба источника недоступны # -------------------------------------------------- temperature, source = self._get_temperature() self._temperature = temperature self._temperature_source = source # -------------------------------------------------- # Нет температурной policy. # # AUTO не умеет безопасно принять решение # о нагреве → выключаем heater. # -------------------------------------------------- if self._temperature_policy is None: await self._set_heater(False) self._auto_heater = False return # -------------------------------------------------- # Нет целевой температуры. # # Непонятно, до какой температуры греть. # Поэтому heater OFF. # -------------------------------------------------- if target_temp is None: await self._set_heater(False) self._auto_heater = False return # -------------------------------------------------- # Нет достоверной фактической температуры. # # Ни Qingping, ни резервный датчик Tion # использовать нельзя. # # Heater OFF. # -------------------------------------------------- if temperature is None: await self._set_heater(False) self._auto_heater = False return # -------------------------------------------------- # Есть всё необходимое: # # - фактическая температура; # - target_temp; # - TemperaturePolicy. # # Policy решает, нужно ли сейчас греть. # -------------------------------------------------- heater_required = ( self._temperature_policy .heater_required( temperature=temperature, target_temp=target_temp, heater_on=( self._auto_heater is True ), ) ) if heater_required: # Наш внешний регулятор решил, что нужно греть. # # Сначала поднимаем внутреннюю уставку Tion # до максимума, чтобы встроенный термостат # не заблокировал нагрев по своему in_temp. await self._set_target_temperature(MAX_TARGET_TEMP) # После этого разрешаем нагреватель. await self._set_heater(True) else: # Целевая температура по внешнему датчику # достигнута — нагрев запрещаем. await self._set_heater(False) self._auto_heater = heater_required async def _process_manual_heater( self, ) -> None: """ Управление обогревом в полном ручном режиме. Приоритет: 1. Qingping -> внешний регулятор. 2. Qingping недоступен -> штатный термостат Tion. """ enabled = self._manual_heater_enabled target_temp = ( self._manual_target_temperature ) # -------------------------------------------------- # Пользователь явно выключил обогрев. # -------------------------------------------------- if enabled is False: await self._set_heater(False) self._manual_heating = False return # Состояние ручного управления ещё # не инициализировано. if enabled is None: self._manual_heating = None return # -------------------------------------------------- # Heater разрешён, но нет пользовательской цели. # # Греть без уставки нельзя. # -------------------------------------------------- if target_temp is None: await self._set_heater(False) self._manual_heating = False return qingping_state = self._qingping.state qingping_temperature = getattr( qingping_state, "temperature", None, ) # -------------------------------------------------- # Qingping недоступен. # # Возвращаем управление встроенному # термостату Tion: # # target = пользовательская температура # heater = ON # # Дальше Tion сам решает, когда реально греть. # -------------------------------------------------- if ( not self._qingping.online or qingping_temperature is None or self._temperature_policy is None ): await self._set_target_temperature( target_temp ) await self._set_heater(True) self._manual_heating = None # Это только диагностическое значение. # Решение по нему мы НЕ принимаем. tion_state = self._tion.state if ( self._tion.online and tion_state is not None and tion_state.in_temp is not None ): self._temperature = ( tion_state.in_temp ) self._temperature_source = "tion" else: self._temperature = None self._temperature_source = None return # -------------------------------------------------- # Qingping доступен. # # Именно его температура становится основной. # -------------------------------------------------- self._temperature = qingping_temperature self._temperature_source = "qingping" heater_required = ( self._temperature_policy .heater_required( temperature=qingping_temperature, target_temp=target_temp, heater_on=( self._manual_heating is True ), ) ) # -------------------------------------------------- # Пока управляем по комнатному датчику, # внутренний термостат Tion не должен # выключить нагрев раньше нас. # # Поэтому физическая уставка всегда MAX. # -------------------------------------------------- await self._set_target_temperature( MAX_TARGET_TEMP ) await self._set_heater( heater_required ) self._manual_heating = heater_required def _get_temperature(self) -> tuple[float | int | None, str | None]: # -------------------------------------------------- # Основной источник — Qingping. # # Используем температуру Qingping только если # сам поток данных датчика сейчас считается online. # -------------------------------------------------- qingping_state = self._qingping.state if ( self._qingping.online and qingping_state.temperature is not None ): return ( qingping_state.temperature, "qingping", ) # -------------------------------------------------- # Qingping недоступен или температура отсутствует. # # Пробуем резервный датчик температуры Tion. # # Важно проверять tion.online: # TionService может хранить последнее состояние, # даже если связь с устройством уже потеряна. # -------------------------------------------------- tion_state = self._tion.state if ( self._tion.online and tion_state is not None and tion_state.in_temp is not None ): return ( tion_state.in_temp, "tion", ) # -------------------------------------------------- # Достоверной температуры нет вообще. # -------------------------------------------------- return None, None async def _update_elica_assist( self, speed: int, ) -> None: if self._elica_assist is None: return target_speed = ( self._elica_assist.set_tion_speed( speed ) ) if self._elica is None: return service = self._elica.service # Без достоверной обратной связи # никаких действий с Elica. if ( not service.running or not service.state.mqtt_connected or not service.state.device_online or not service.feedback_ready ): return state = self._elica.state # Сначала проверяем фактическое состояние. # # Если Elica уже была включена пользователем # или пользователь вмешался в OWNED-сессию, # state machine сама перейдёт в SUPPRESSED. self._elica_assist.observe_elica( power=state.power, speed=state.speed, timer=state.timer, ) mode = self._elica_assist.mode # -------------------------------------------------- # SUPPRESSED # # Пользовательская Elica. # Ничего не делаем. # -------------------------------------------------- if mode == ElicaAssistMode.SUPPRESSED: return # -------------------------------------------------- # IDLE # # Elica свободна. # Пока здесь только первый захват. # -------------------------------------------------- if mode == ElicaAssistMode.IDLE: if target_speed is None: return # Дополнительная страховка. # После observe_elica() включённая Elica # уже должна была стать SUPPRESSED. if state.power: return result = await self._elica.set_speed( target_speed ) # Владение получаем только после # подтверждённого результата. self._elica_assist.mark_owned( result.speed ) self._elica_assist.observe_elica( power=result.power, speed=result.speed, timer=result.timer, ) return # -------------------------------------------------- # OWNED # # Эту Elica включила автоматика. # Теперь ей разрешено менять скорость. # -------------------------------------------------- if mode == ElicaAssistMode.OWNED: expected_speed = ( self._elica_assist.expected_speed ) # -------------------------------------------------- # Tion вышел из диапазона, где нужна Elica. # # Выключать её можно ТОЛЬКО если фактическое # состояние всё ещё полностью совпадает с тем, # которым владеет автоматика. # -------------------------------------------------- if target_speed is None: current = self._elica.state # Пользователь уже выключил Elica сам. # # Ничего дополнительно не нажимаем. if not current.power: self._elica_assist.reset() return # Состояние изменилось относительно нашего. # # Значит пользователь вмешался: # Elica больше не наша и выключать её нельзя. if ( current.speed != expected_speed or current.timer ): self._elica_assist.suppress( "manual_intervention" ) return # -------------------------------------------------- # Elica всё ещё находится ровно в том состоянии, # которое установила автоматика. # # Значит её безопасно выключить. # -------------------------------------------------- result = await self._elica.power_off() # Владение заканчивается только после # подтверждённого выключения. if not result.power: self._elica_assist.reset() return # -------------------------------------------------- # Elica по-прежнему нужна. # -------------------------------------------------- # Уже нужная скорость. if target_speed == expected_speed: return # -------------------------------------------------- # Автоматическое изменение скорости. # # set_speed() выполняет всю последовательность # целиком, например: # # 2 -> 3 -> 4 -> 1 # # Промежуточные состояния здесь не передаются # в observe_elica(). # -------------------------------------------------- result = await self._elica.set_speed( target_speed ) # Обновляем владение только после # подтверждённой конечной скорости. self._elica_assist.mark_owned( result.speed ) self._elica_assist.observe_elica( power=result.power, speed=result.speed, timer=result.timer, ) async def _release_elica_assist(self) -> None: """ Завершает текущую сессию Elica Auto Assist. Если Elica принадлежит автоматике, безопасно выключает её. Если Elica пользовательская (SUPPRESSED), устройство не трогаем. Если обратная связь недоступна, OWNED не забываем: попробуем освободить Elica позже. """ if self._elica_assist is None: return mode = self._elica_assist.mode # -------------------------------------------------- # IDLE # Ничего не захвачено. # -------------------------------------------------- if mode == ElicaAssistMode.IDLE: self._elica_assist.reset() return # -------------------------------------------------- # SUPPRESSED # # Elica принадлежит пользователю. # Просто забываем текущий AUTO-цикл. # Саму Elica не трогаем. # -------------------------------------------------- if mode == ElicaAssistMode.SUPPRESSED: self._elica_assist.reset() return # -------------------------------------------------- # OWNED # # Elica была включена автоматикой. # -------------------------------------------------- if self._elica is None: # Не забываем владение. return service = self._elica.service # Без достоверной обратной связи нельзя решать, # можно ли выключать Elica. # # OWNED сохраняем, чтобы попробовать позже. if ( not service.running or not service.state.mqtt_connected or not service.state.device_online or not service.feedback_ready ): return current = self._elica.state # -------------------------------------------------- # Если Elica уже выключена, работа закончена. # -------------------------------------------------- if not current.power: self._elica_assist.reset() return # -------------------------------------------------- # Проверяем, что пользователь не вмешался. # -------------------------------------------------- self._elica_assist.observe_elica( power=current.power, speed=current.speed, timer=current.timer, ) # Если observe_elica() обнаружил ручное # вмешательство, Elica больше не наша. if ( self._elica_assist.mode == ElicaAssistMode.SUPPRESSED ): self._elica_assist.reset() return expected_speed = ( self._elica_assist.expected_speed ) # Дополнительная страховка. if ( current.speed != expected_speed or current.timer ): self._elica_assist.reset() return # -------------------------------------------------- # Elica всё ещё находится ровно в нашем # состоянии. Можно выключать. # -------------------------------------------------- result = await self._elica.power_off() # Владение заканчиваем только после # подтверждённого выключения. if not result.power: self._elica_assist.reset() async def _set_speed(self, speed: int) -> None: if self._target_speed == speed: return await self._tion.execute( lambda controller: controller.set_speed(speed) ) self._target_speed = speed async def _set_heater(self,enabled: bool) -> None: # Если AutoController уже установил именно такое # состояние нагревателя, повторную команду не шлём. if self._target_heater == enabled: return if enabled: await self._tion.execute( lambda controller: controller.heater_on() ) else: await self._tion.execute( lambda controller: controller.heater_off() ) # Запоминаем состояние только после того, # как команда успешно выполнилась. self._target_heater = enabled async def _set_target_temperature( self, temperature: int, ) -> None: if self._target_temperature == temperature: return await self._tion.execute( lambda controller: controller.set_target_temperature( temperature ) ) self._target_temperature = temperature def set_manual_heater_enabled(self, enabled: bool) -> None: """ Запоминает, хочет ли пользователь использовать обогрев в ручном режиме. Саму команду Tion этот метод пока не отправляет. """ self._manual_heater_enabled = enabled self._target_heater = None if not enabled: self._manual_heating = False def set_manual_target_temperature(self, temperature: int) -> None: """ Запоминает желаемую температуру помещения для ручного режима. """ self._manual_target_temperature = temperature self._target_temperature = None def clear_manual_heater_control(self) -> None: """ Забываем состояние ручного температурного регулятора при возврате к расписанию. """ self._manual_heater_enabled = None self._manual_target_temperature = None self._manual_heating = None @property def manual_heater_enabled(self) -> bool | None: return self._manual_heater_enabled @property def manual_target_temperature(self) -> int | None: return self._manual_target_temperature def status(self) -> dict: return { "state": self._state, "reason": self._reason, "target_speed": self._target_speed, "auto_speed": self._auto_speed, "target_heater": self._target_heater, "auto_heater": self._auto_heater, "temperature": self._temperature, "temperature_source": self._temperature_source, "elica_assist": ( self._elica_assist.status() if self._elica_assist is not None else None ), "manual_heater": { "enabled": self._manual_heater_enabled, "target_temp": self._manual_target_temperature, "heating": self._manual_heating, }, "last_error": self._last_error, }