import asyncio from dataclasses import dataclass 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, ) @dataclass(frozen=True, slots=True) class EffectiveTemperatureConfig: heater_enabled: bool | None target_temp: int | None 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 # Последнее решение единого внешнего # температурного регулятора. self._temperature_heating: bool | 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) # Ручная температурная конфигурация нужна # только во время PAUSE. if ( not getattr( self._schedule, "paused", False, ) and ( self._manual_heater_enabled is not None or self._manual_target_temperature is not None ) ): self.clear_manual_heater_control() # -------------------------------------------------- # Температурный контур работает ВСЕГДА: # # SET # AUTO # PAUSE # temporary override # -------------------------------------------------- temperature_config = ( self._get_effective_temperature_config(resolution) ) await self._process_temperature(temperature_config) # -------------------------------------------------- # PAUSE # -------------------------------------------------- if getattr( self._schedule, "paused", False, ): self._state = "suspended" self._reason = "schedule_paused" self._target_speed = None self._auto_speed = None self._auto_heater = None self._manual_heating = ( self._temperature_heating ) self._last_error = None await self._release_elica_assist() return # В режимах расписания результат относится # к общему температурному контуру. self._manual_heating = None self._auto_heater = ( self._temperature_heating ) # -------------------------------------------------- # Temporary override. # # Температура уже обработана выше. # AUTO скоростью во время override # по-прежнему не управляет. # -------------------------------------------------- if self._schedule.override_active: self._state = "suspended" self._reason = "manual_override" self._target_speed = None self._auto_speed = None self._last_error = None await self._release_elica_assist() return # -------------------------------------------------- # Не AUTO. # # Температура уже обработана выше. # Здесь просто нечего делать с AUTO-скоростью. # -------------------------------------------------- if ( not resolution.enabled or not resolution.auto_active ): self._state = "inactive" self._reason = None self._target_speed = None self._auto_speed = None self._last_error = None await self._release_elica_assist() return # -------------------------------------------------- # Ниже остаётся только AUTO-управление скоростью. # -------------------------------------------------- fallback_speed = (resolution.auto_fallback_speed) if fallback_speed is None: raise RuntimeError( "AUTO is active but " "fallback speed is missing" ) # CO2 policy недоступна. 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 ) 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 self._last_error = None return # Qingping недоступен для CO2. 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 ) self._last_error = None def _get_effective_temperature_config( self, resolution, ) -> EffectiveTemperatureConfig: # -------------------------------------------------- # PAUSE. # # Источник настроек — ручное состояние. # -------------------------------------------------- if getattr( self._schedule, "paused", False, ): return EffectiveTemperatureConfig( heater_enabled=( self._manual_heater_enabled ), target_temp=( self._manual_target_temperature ), ) # -------------------------------------------------- # Базовая конфигурация всегда приходит # из накопленных SET-настроек. # -------------------------------------------------- heater_enabled = ( resolution .scheduled_settings .heater ) target_temp = ( resolution .scheduled_settings .target_temp ) # -------------------------------------------------- # AUTO может иметь собственную температуру. # # Если её нет — остаётся температура # накопленного SET. # -------------------------------------------------- if ( resolution.auto_active and resolution.auto_target_temp is not None ): target_temp = ( resolution.auto_target_temp ) # -------------------------------------------------- # Temporary override — это НАЛОЖЕНИЕ # поверх текущей конфигурации. # # target_temp не включает heater автоматически. # -------------------------------------------------- if self._schedule.override_active: override = ( self._schedule.override_settings ) if override.heater is not None: heater_enabled = ( override.heater ) if override.target_temp is not None: target_temp = ( override.target_temp ) return EffectiveTemperatureConfig( heater_enabled=heater_enabled, target_temp=target_temp, ) async def _process_temperature( self, config: EffectiveTemperatureConfig, ) -> None: enabled = config.heater_enabled target_temp = config.target_temp # -------------------------------------------------- # heater=false имеет абсолютный приоритет. # -------------------------------------------------- if enabled is False: await self._set_heater(False) self._temperature_heating = False return # -------------------------------------------------- # Heater вообще не определён. # # Ничего физически не меняем. # -------------------------------------------------- if enabled is None: self._temperature_heating = None return # -------------------------------------------------- # Heater разрешён, но цели нет. # # Безопасное состояние — OFF. # -------------------------------------------------- if target_temp is None: await self._set_heater(False) self._temperature_heating = False return qingping_state = self._qingping.state qingping_temperature = getattr( qingping_state, "temperature", None, ) # -------------------------------------------------- # Qingping доступен и TemperaturePolicy работает. # # Решение принимаем ТОЛЬКО по Qingping. # -------------------------------------------------- if ( self._qingping.online and qingping_temperature is not None and self._temperature_policy is not None ): 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._temperature_heating is True ), ) ) # Встроенный термостат Tion # не должен мешать внешнему регулятору. await self._set_target_temperature( MAX_TARGET_TEMP ) await self._set_heater( heater_required ) self._temperature_heating = ( heater_required ) return # -------------------------------------------------- # Qingping недоступен либо отсутствует # TemperaturePolicy. # # Никаких решений по Tion.in_temp! # # Возвращаем управление штатному # термостату Tion. # -------------------------------------------------- await self._set_target_temperature( target_temp ) await self._set_heater(True) self._temperature_heating = None # Tion.in_temp здесь только для диагностики. 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 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 effective_temperature_config(self,) -> EffectiveTemperatureConfig: resolution = self._schedule.resolve() return self._get_effective_temperature_config(resolution) async def reconcile_temperature(self) -> None: """ Немедленно применить текущую логическую температурную конфигурацию. """ config = self.effective_temperature_config() await self._process_temperature(config) 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, }