Files
ClimatController/app/auto/controller.py

976 lines
30 KiB
Python

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,
}