fix: v1.5.7 исправил архитектуру управления температурой. Теперь отдельный контроллер отвечает за нагрев для всех режимов авто ручной или временный ручной. Раньше в каждом режиме была своя логика.

This commit is contained in:
2026-09-29 22:55:36 +03:00
parent 075690a98b
commit 5fc2149755
42 changed files with 1635 additions and 2771 deletions
+4
View File
@@ -1,7 +1,9 @@
from .config import (
AutoConfig,
AutoConfigComponents,
Co2Config,
load_auto_config,
load_auto_config_components,
)
from .co2_policy import (
@@ -19,4 +21,6 @@ __all__ = [
"load_auto_config",
"Co2SpeedPolicy",
"AutoController",
"AutoConfigComponents",
"load_auto_config_components",
]
+211 -113
View File
@@ -57,6 +57,20 @@ class AutoConfig:
elica_assist: ElicaAssistConfig
@dataclass(
frozen=True,
slots=True,
)
class AutoConfigComponents:
version: int
check_interval: float
co2: Co2Config | None
temperature: TemperatureConfig | None
elica_assist: ElicaAssistConfig | None
errors: dict[str, str]
def _require_dict(name: str, value: Any) -> dict:
if not isinstance(value, dict):
@@ -262,111 +276,32 @@ def _parse_co2(value: Any) -> Co2Config:
thresholds=thresholds,
)
def load_auto_config(path: str | Path) -> AutoConfig:
path = Path(path)
with path.open(
"r",
encoding="utf-8",
) as file:
raw = yaml.safe_load(file)
def _parse_temperature(value: Any) -> TemperatureConfig:
data = _require_dict(
"AUTO config",
raw,
)
unknown = set(data) - {
"version",
"check_interval",
"co2",
"temperature",
"elica_assist",
}
if unknown:
raise ValueError(
f"Unknown AUTO config fields: "
f"{sorted(unknown)}"
)
version = data.get("version")
if version != 1:
raise ValueError(
f"Unsupported AUTO config "
f"version: {version!r}"
)
check_interval = data.get(
"check_interval"
value,
)
if (
type(check_interval) not in {
int,
float,
}
):
raise ValueError(
"check_interval must be a number"
)
if check_interval <= 0:
raise ValueError(
"check_interval must be > 0"
)
# --------------------------------------------------
# CO2
# --------------------------------------------------
if "co2" not in data:
raise ValueError(
"co2 config is required"
)
co2 = _parse_co2(
data["co2"]
)
# --------------------------------------------------
# Temperature
# --------------------------------------------------
if "temperature" not in data:
raise ValueError(
"temperature config is required"
)
temperature_data = _require_dict(
"temperature",
data["temperature"],
)
unknown_temperature = (
set(temperature_data)
unknown = (
set(data)
- {
"hysteresis",
}
)
if unknown_temperature:
if unknown:
raise ValueError(
f"Unknown temperature config fields: "
f"{sorted(unknown_temperature)}"
f"{sorted(unknown)}"
)
temperature_hysteresis = (
temperature_data.get(
"hysteresis"
)
hysteresis = data.get(
"hysteresis"
)
if (
type(temperature_hysteresis)
type(hysteresis)
not in {
int,
float,
@@ -377,45 +312,40 @@ def load_auto_config(path: str | Path) -> AutoConfig:
"must be a number"
)
temperature_hysteresis = float(
temperature_hysteresis
)
hysteresis = float(hysteresis)
if temperature_hysteresis < 0:
if hysteresis < 0:
raise ValueError(
"temperature.hysteresis "
"must be >= 0"
)
temperature = TemperatureConfig(
hysteresis=temperature_hysteresis,
return TemperatureConfig(
hysteresis=hysteresis,
)
def _parse_elica_assist(value: Any) -> ElicaAssistConfig:
# --------------------------------------------------
# Elica Auto Assist
# --------------------------------------------------
if "elica_assist" not in data:
raise ValueError("elica_assist config is required")
elica_data = _require_dict(
data = _require_dict(
"elica_assist",
data["elica_assist"],
value,
)
unknown_elica = (
set(elica_data)
unknown = (
set(data)
- {
"enabled",
"speed_map",
}
)
if unknown_elica:
raise ValueError(f"Unknown elica_assist config fields: {sorted(unknown_elica)}")
if unknown:
raise ValueError(
"Unknown elica_assist config fields: "
f"{sorted(unknown)}"
)
enabled = elica_data.get("enabled")
enabled = data.get("enabled")
if type(enabled) is not bool:
raise ValueError(
@@ -423,19 +353,25 @@ def load_auto_config(path: str | Path) -> AutoConfig:
"must be a boolean"
)
speed_map_data = elica_data.get("speed_map")
speed_map_data = data.get(
"speed_map"
)
if not isinstance(
speed_map_data,
dict,
):
raise ValueError("elica_assist.speed_map must be an object")
raise ValueError(
"elica_assist.speed_map "
"must be an object"
)
speed_map = []
for tion_speed, elica_speed in (
speed_map_data.items()
):
if type(tion_speed) is not int:
raise ValueError(
"elica_assist.speed_map keys "
@@ -478,21 +414,183 @@ def load_auto_config(path: str | Path) -> AutoConfig:
speed_map.sort()
elica_assist = ElicaAssistConfig(
return ElicaAssistConfig(
enabled=enabled,
speed_map=tuple(speed_map),
)
def _load_auto_root(path: str | Path) -> tuple[dict, int, float]:
path = Path(path)
with path.open(
"r",
encoding="utf-8",
) as file:
raw = yaml.safe_load(file)
data = _require_dict(
"AUTO config",
raw,
)
unknown = set(data) - {
"version",
"check_interval",
"co2",
"temperature",
"elica_assist",
}
if unknown:
raise ValueError(
f"Unknown AUTO config fields: "
f"{sorted(unknown)}"
)
version = data.get("version")
if version != 1:
raise ValueError(
f"Unsupported AUTO config "
f"version: {version!r}"
)
check_interval = data.get(
"check_interval"
)
if (
type(check_interval)
not in {int,float,}
):
raise ValueError(
"check_interval must be a number"
)
if check_interval <= 0:
raise ValueError(
"check_interval must be > 0"
)
return (data, version, float(check_interval))
def load_auto_config(
path: str | Path,
) -> AutoConfig:
(
data,
version,
check_interval,
) = _load_auto_root(path)
# --------------------------------------------------
# Result
# CO2
# --------------------------------------------------
if "co2" not in data:
raise ValueError("co2 config is required")
co2 = _parse_co2(data["co2"])
# --------------------------------------------------
# Temperature
# --------------------------------------------------
if "temperature" not in data:
raise ValueError("temperature config is required")
temperature = _parse_temperature(data["temperature"])
# --------------------------------------------------
# Elica Auto Assist
# --------------------------------------------------
if "elica_assist" not in data:
raise ValueError("elica_assist config is required")
elica_assist = _parse_elica_assist(data["elica_assist"])
return AutoConfig(
version=version,
check_interval=float(check_interval),
check_interval=check_interval,
co2=co2,
temperature=temperature,
elica_assist=elica_assist,
)
def load_auto_config_components(path: str | Path) -> AutoConfigComponents:
( data,
version,
check_interval,
) = _load_auto_root(path)
errors: dict[str, str] = {}
# --------------------------------------------------
# CO2
# --------------------------------------------------
co2 = None
if "co2" not in data:
errors["co2"] = "ValueError: co2 config is required"
else:
try:
co2 = _parse_co2(data["co2"])
except Exception as exc:
errors["co2"] = (
f"{type(exc).__name__}: {exc}"
)
# --------------------------------------------------
# Temperature
# --------------------------------------------------
temperature = None
if "temperature" not in data:
errors["temperature"] = "ValueError: temperature config is required"
else:
try:
temperature = _parse_temperature(data["temperature"])
except Exception as exc:
errors["temperature"] = (
f"{type(exc).__name__}: {exc}"
)
# --------------------------------------------------
# Elica Assist
# --------------------------------------------------
elica_assist = None
if "elica_assist" not in data:
errors["elica_assist"] = "ValueError: elica_assist config is required"
else:
try:
elica_assist = _parse_elica_assist(data["elica_assist"])
except Exception as exc:
errors["elica_assist"] = (
f"{type(exc).__name__}: {exc}"
)
return AutoConfigComponents(
version=version,
check_interval=check_interval,
co2=co2,
temperature=temperature,
elica_assist=elica_assist,
errors=errors,
)
+263 -347
View File
@@ -1,4 +1,5 @@
import asyncio
from dataclasses import dataclass
from datetime import datetime
from app.auto.co2_policy import Co2SpeedPolicy
from app.auto.temperature_policy import TemperaturePolicy
@@ -8,6 +9,12 @@ from app.auto.elica_assist import (
ElicaAutoAssistState,
)
@dataclass(frozen=True, slots=True)
class EffectiveTemperatureConfig:
heater_enabled: bool | None
target_temp: int | None
class AutoController:
def __init__(
@@ -46,6 +53,11 @@ class AutoController:
self._temperature: float | int | None = None
self._temperature_source: str | None = None
# Последнее решение единого внешнего
# температурного регулятора.
self._temperature_heating: bool | None = None
# --------------------------------------------------
# Ручное управление обогревом.
#
@@ -103,19 +115,45 @@ class AutoController:
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()
# --------------------------------------------------
# Температурный контур работает ВСЕГДА:
#
# Это полноценный ручной режим:
# AUTO вообще не имеет права управлять Tion.
# ----------------------------------------------
# SET
# AUTO
# PAUSE
# temporary override
# --------------------------------------------------
temperature_config = (
self._get_effective_temperature_config(resolution)
)
await self._process_temperature(temperature_config)
# --------------------------------------------------
# PAUSE
# --------------------------------------------------
if getattr(
self._schedule,
@@ -125,19 +163,13 @@ class AutoController:
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._manual_heating = (
self._temperature_heating
)
self._last_error = None
@@ -145,69 +177,28 @@ class AutoController:
return
# ----------------------------------------------
# Активен ручной override.
# В режимах расписания результат относится
# к общему температурному контуру.
self._manual_heating = None
self._auto_heater = (
self._temperature_heating
)
# --------------------------------------------------
# Temporary override.
#
# Пока пользователь вручную управляет Tion,
# AUTO вообще не вмешивается.
# ----------------------------------------------
# Температура уже обработана выше.
# AUTO скоростью во время override
# по-прежнему не управляет.
# --------------------------------------------------
if self._schedule.override_active:
self._state = "suspended"
self._reason = "manual_override"
# AUTO скоростью больше не управляет.
self._target_speed = None
self._auto_speed = None
# AUTO-регулятор температуры также
# больше не используется.
self._auto_heater = None
override = self._schedule.override_settings
# --------------------------------------------------
# Температура, установленная пользователем,
# становится целью ручного регулятора.
# --------------------------------------------------
if override.target_temp is not None:
self.set_manual_target_temperature(
override.target_temp
)
# Если пользователь меняет температуру,
# считаем, что термостат ему нужен.
#
# Явный heater=off ниже имеет приоритет.
if override.heater is None:
self.set_manual_heater_enabled(
True
)
# --------------------------------------------------
# Явная команда heater ON/OFF имеет
# максимальный приоритет.
# --------------------------------------------------
if override.heater is not None:
self.set_manual_heater_enabled(
override.heater
)
# --------------------------------------------------
# Если override касается температуры/heater,
# применяем тот же регулятор, что и в PAUSE:
#
# Qingping -> основной
# Tion thermostat -> fallback
# --------------------------------------------------
if (
self._manual_heater_enabled is not None
or self._manual_target_temperature is not None
):
await self._process_manual_heater()
self._last_error = None
await self._release_elica_assist()
@@ -215,68 +206,56 @@ class AutoController:
return
# --------------------------------------------------
# Override закончился.
# Его ручную температурную сессию забываем.
# Не AUTO.
#
# Температура уже обработана выше.
# Здесь просто нечего делать с AUTO-скоростью.
# --------------------------------------------------
if (
self._manual_heater_enabled is not None
or self._manual_target_temperature is not None
):
self.clear_manual_heater_control()
# ----------------------------------------------
# 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
# --------------------------------------------------
# Ниже остаётся только AUTO-управление скоростью.
# --------------------------------------------------
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._reason = (
"auto_policy_unavailable"
)
self._auto_speed = None
await self._set_speed(fallback_speed)
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)
await self._update_elica_assist(
fallback_speed
)
self._last_error = None
@@ -284,10 +263,7 @@ class AutoController:
qingping_state = self._qingping.state
# ----------------------------------------------
# Qingping исправен
# ----------------------------------------------
# Qingping исправен.
if (
self._qingping.online
and qingping_state.co2 is not None
@@ -302,27 +278,23 @@ class AutoController:
self._state = "active"
self._reason = None
await self._set_speed(target_speed)
await self._set_speed(
target_speed
)
await self._update_elica_assist(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.
# ----------------------------------------------
# Qingping недоступен для CO2.
if not self._qingping.online:
reason = "qingping_offline"
else:
reason = "co2_missing"
@@ -331,169 +303,142 @@ class AutoController:
self._auto_speed = None
await self._set_speed(fallback_speed)
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
)
await self._update_elica_assist(
fallback_speed
)
self._last_error = None
async def _process_heater(self, resolution) -> None:
def _get_effective_temperature_config(
self,
resolution,
) -> EffectiveTemperatureConfig:
# --------------------------------------------------
# Берём целевую температуру из накопленных
# настроек расписания.
# PAUSE.
#
# Например:
#
# 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 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
)
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
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._manual_heating = False
self._temperature_heating = False
return
# Состояние ручного управления ещё
# не инициализировано.
if enabled is None:
self._manual_heating = None
return
# --------------------------------------------------
# Heater разрешён, но нет пользовательской цели.
# Heater вообще не определён.
#
# Греть без уставки нельзя.
# Ничего физически не меняем.
# --------------------------------------------------
if enabled is None:
self._temperature_heating = None
return
# --------------------------------------------------
# Heater разрешён, но цели нет.
#
# Безопасное состояние — OFF.
# --------------------------------------------------
if target_temp is None:
await self._set_heater(False)
self._manual_heating = False
self._temperature_heating = False
return
@@ -506,119 +451,73 @@ class AutoController:
)
# --------------------------------------------------
# Qingping недоступен.
# Qingping доступен и TemperaturePolicy работает.
#
# Возвращаем управление встроенному
# термостату Tion:
#
# target = пользовательская температура
# heater = ON
#
# Дальше Tion сам решает, когда реально греть.
# Решение принимаем ТОЛЬКО по Qingping.
# --------------------------------------------------
if (
not self._qingping.online
or qingping_temperature is None
or self._temperature_policy is None
self._qingping.online
and qingping_temperature is not None
and self._temperature_policy is not None
):
await self._set_target_temperature(
target_temp
self._temperature = (
qingping_temperature
)
await self._set_heater(True)
self._temperature_source = (
"qingping"
)
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
heater_required = (
self._temperature_policy
.heater_required(
temperature=(
qingping_temperature
),
target_temp=target_temp,
heater_on=(
self._temperature_heating
is True
),
)
self._temperature_source = "tion"
else:
self._temperature = None
self._temperature_source = None
)
# Встроенный термостат Tion
# не должен мешать внешнему регулятору.
await self._set_target_temperature(
MAX_TARGET_TEMP
)
await self._set_heater(
heater_required
)
self._temperature_heating = (
heater_required
)
return
# --------------------------------------------------
# Qingping доступен.
# Qingping недоступен либо отсутствует
# TemperaturePolicy.
#
# Именно его температура становится основной.
# --------------------------------------------------
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 не должен
# выключить нагрев раньше нас.
# Никаких решений по Tion.in_temp!
#
# Поэтому физическая уставка всегда MAX.
# Возвращаем управление штатному
# термостату Tion.
# --------------------------------------------------
await self._set_target_temperature(
MAX_TARGET_TEMP
target_temp
)
await self._set_heater(
heater_required
)
await self._set_heater(True)
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 может хранить последнее состояние,
# даже если связь с устройством уже потеряна.
# --------------------------------------------------
self._temperature_heating = None
# Tion.in_temp здесь только для диагностики.
tion_state = self._tion.state
if (
@@ -626,16 +525,19 @@ class AutoController:
and tion_state is not None
and tion_state.in_temp is not None
):
return (
tion_state.in_temp,
"tion",
self._temperature = (
tion_state.in_temp
)
# --------------------------------------------------
# Достоверной температуры нет вообще.
# --------------------------------------------------
self._temperature_source = "tion"
else:
self._temperature = None
self._temperature_source = None
return None, None
async def _update_elica_assist(
self,
@@ -1028,6 +930,20 @@ class AutoController:
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,