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
+223 -208
View File
@@ -33,7 +33,7 @@ from app.my_dataclasses import (
from app.auto import (
AutoController,
Co2SpeedPolicy,
load_auto_config,
load_auto_config_components,
)
from app.auto.temperature_policy import TemperaturePolicy
@@ -138,42 +138,118 @@ async def lifespan(app: FastAPI):
schedule_load_error = None
try:
auto_config = load_auto_config(AUTO_CONFIG_FILE)
auto_config = load_auto_config_components(AUTO_CONFIG_FILE)
elica_assist = ElicaAutoAssistState(auto_config.elica_assist)
auto_interval = auto_config.check_interval
auto_policy = Co2SpeedPolicy(
base_speed=(
auto_config.co2.base_speed
),
thresholds=(
auto_config.co2.thresholds
),
hysteresis=(
auto_config.co2.hysteresis
),
)
auto_errors = dict(auto_config.errors)
temperature_policy = TemperaturePolicy(auto_config.temperature)
auto_interval = (auto_config.check_interval)
auto_load_error = None
except Exception as exc:
# --------------------------------------------------
# CO2 policy
# --------------------------------------------------
auto_policy = None
if auto_config.co2 is not None:
try:
auto_policy = Co2SpeedPolicy(
base_speed=(
auto_config.co2.base_speed
),
thresholds=(
auto_config.co2.thresholds
),
hysteresis=(
auto_config.co2.hysteresis
),
)
except Exception as exc:
auto_errors["co2_policy"] = (
f"{type(exc).__name__}: {exc}"
)
# --------------------------------------------------
# Temperature policy
# --------------------------------------------------
temperature_policy = None
if (
auto_config.temperature
is not None
):
try:
temperature_policy = TemperaturePolicy(auto_config.temperature)
except Exception as exc:
auto_errors[
"temperature_policy"
] = (
f"{type(exc).__name__}: {exc}"
)
# --------------------------------------------------
# Elica Assist
# --------------------------------------------------
elica_assist = None
if (
auto_config.elica_assist
is not None
):
try:
elica_assist = ElicaAutoAssistState(auto_config.elica_assist)
except Exception as exc:
auto_errors[
"elica_assist"
] = (
f"{type(exc).__name__}: {exc}"
)
# --------------------------------------------------
# Общая диагностика
# --------------------------------------------------
if auto_errors:
auto_load_error = "; ".join(
(
f"{name}: {error}"
)
for name, error
in auto_errors.items()
)
else:
auto_load_error = None
except Exception as exc:
# Здесь остаются только ошибки,
# из-за которых невозможно разобрать
# auto.yaml вообще.
auto_policy = None
temperature_policy = None
elica_assist = None
# Безопасный встроенный интервал нужен,
# потому что auto.yaml сейчас недоступен.
auto_interval = 5.0
auto_load_error = (
f"{type(exc).__name__}: {exc}"
)
# --------------------------------------------------
# AutoController создаётся даже если, например,
# CO2 policy не загрузилась.
#
# policy=None даст fallback скорости,
# но TemperaturePolicy при этом может работать.
# --------------------------------------------------
auto_controller = AutoController(
schedule_service=schedule_service,
qingping_service=qingping_service,
@@ -341,53 +417,25 @@ def get_status() -> dict:
if (
tion_status is not None
and schedule_service is not None
and schedule_service.paused
and auto_controller is not None
):
temperature_config = (auto_controller.effective_temperature_config())
if (
auto_controller.manual_heater_enabled
temperature_config.heater_enabled
is not None
):
tion_status["heater"] = (
auto_controller
.manual_heater_enabled
temperature_config.heater_enabled
)
if (
auto_controller.manual_target_temperature
temperature_config.target_temp
is not None
):
tion_status["target_temp"] = (
auto_controller
.manual_target_temperature
temperature_config.target_temp
)
elif tion_status is not None:
schedule = schedule_service
if schedule is not None:
# Ручной override имеет приоритет над AUTO.
if (
schedule.override_active
and schedule.override_settings.target_temp
is not None
):
tion_status["target_temp"] = (
schedule.override_settings.target_temp
)
else:
resolution = schedule.resolve()
if (
resolution.enabled
and resolution.auto_active
and resolution.auto_target_temp
is not None
):
tion_status["target_temp"] = (
resolution.auto_target_temp
)
@@ -457,27 +505,15 @@ def get_effective_speed() -> int:
def get_effective_temperature() -> int:
if (
schedule_service is not None
and schedule_service.paused
and auto_controller is not None
and auto_controller.manual_target_temperature is not None
):
return (
if auto_controller is not None:
config = (
auto_controller
.manual_target_temperature
.effective_temperature_config()
)
if (
schedule_service is not None
and schedule_service.override_active
and schedule_service.override_settings.target_temp is not None
):
return (
schedule_service
.override_settings
.target_temp
)
if config.target_temp is not None:
return config.target_temp
state = service.state
@@ -529,6 +565,60 @@ async def execute_command(operation, override: ScheduledSettings | None = None):
return get_status()
async def execute_temperature_command(
operation,
settings: ScheduledSettings,
):
try:
if (
auto_controller is not None
and schedule_service is not None
and schedule_service.running
and schedule_service.config.enabled
):
# ------------------------------------------
# PAUSE = полноценный ручной режим.
# ------------------------------------------
if schedule_service.paused:
if settings.heater is not None:
auto_controller.set_manual_heater_enabled(settings.heater)
if settings.target_temp is not None:
auto_controller.set_manual_target_temperature(settings.target_temp)
# ------------------------------------------
# SET / AUTO = temporary override.
# ------------------------------------------
else:
await schedule_service.apply_override(settings)
# Не ждём следующего 5-секундного цикла.
await auto_controller.reconcile_temperature()
else:
# Fallback, если расписание/AutoController
# вообще не работают.
await service.execute(operation)
except Exception as exc:
raise HTTPException(
status_code=503,
detail={
"message": "Tion unavailable",
"error": (
f"{type(exc).__name__}: {exc}"
),
},
) from exc
return get_status()
def occurrence_to_dict(occurrence) -> dict | None:
@@ -676,7 +766,6 @@ def get_auto_status() -> dict:
# ----------------------------------------------------------------------
# Status
# ----------------------------------------------------------------------
@app.get("/api/status")
async def status():
return get_status()
@@ -685,7 +774,6 @@ async def status():
# ----------------------------------------------------------------------
# Elica / exhaust
# ----------------------------------------------------------------------
@app.get("/api/elica/status")
async def elica_status():
return get_elica_status()
@@ -734,7 +822,6 @@ async def set_external_fan(state: Literal["on", "off"]):
# ----------------------------------------------------------------------
# Power
# ----------------------------------------------------------------------
@app.post("/api/tion/power/{state}")
async def set_power(state: Literal["on", "off"]):
@@ -754,7 +841,6 @@ async def set_power(state: Literal["on", "off"]):
# ----------------------------------------------------------------------
# Fan speed increase / decrease
# ----------------------------------------------------------------------
@app.post("/api/tion/speed/increase")
async def increase_speed():
@@ -816,116 +902,57 @@ async def set_speed(
# ----------------------------------------------------------------------
# Heater
# ----------------------------------------------------------------------
@app.post("/api/tion/heater/{state}")
async def set_heater(state: Literal["on", "off"]):
async def set_heater(
state: Literal["on", "off"],
):
enabled = state == "on"
if enabled:
operation = lambda tion: tion.heater_on()
else:
operation = lambda tion: tion.heater_off()
operation = (
(lambda tion: tion.heater_on())
if enabled
else
(lambda tion: tion.heater_off())
)
await execute_command(operation, ScheduledSettings(heater=enabled))
if (
schedule_service is not None
and schedule_service.paused
and auto_controller is not None
):
auto_controller.set_manual_heater_enabled(
enabled
)
return get_status()
# ----------------------------------------------------------------------
# Target temperature increase / decrease
# ----------------------------------------------------------------------
@app.post("/api/tion/temperature/increase")
async def increase_temperature():
current_temperature = get_effective_temperature()
new_temperature = min(current_temperature + 1, MAX_TARGET_TEMP)
if new_temperature == current_temperature:
return get_status()
await execute_command(
lambda tion:
tion.set_target_temperature(
new_temperature
),
return await execute_temperature_command(
operation,
ScheduledSettings(
target_temp=new_temperature,
heater=enabled,
),
)
if (
schedule_service is not None
and schedule_service.paused
and auto_controller is not None
):
auto_controller.set_manual_target_temperature(new_temperature)
return get_status()
@app.post("/api/tion/temperature/{temperature}")
async def set_temperature(
temperature: int,
):
await execute_command(
lambda tion:
tion.set_target_temperature(
temperature
),
ScheduledSettings(
target_temp=temperature,
),
)
if (
schedule_service is not None
and schedule_service.paused
and auto_controller is not None
):
auto_controller.set_manual_target_temperature(
temperature
)
return get_status()
# ----------------------------------------------------------------------
# Target temperature
# ----------------------------------------------------------------------
@app.post("/api/tion/temperature/{temperature}")
async def set_temperature(
temperature: Annotated[
int,
Path(
ge=MIN_TARGET_TEMP,
le=MAX_TARGET_TEMP,
),
],):
int,
Path(
ge=MIN_TARGET_TEMP,
le=MAX_TARGET_TEMP,
),
],
):
return await execute_command(
return await execute_temperature_command(
lambda tion:
tion.set_target_temperature(temperature),
ScheduledSettings(target_temp=temperature),
tion.set_target_temperature(
temperature
),
ScheduledSettings(
target_temp=temperature,
),
)
# ----------------------------------------------------------------------
# Air mode
# ----------------------------------------------------------------------
@app.post("/api/tion/mode/{mode}")
async def set_mode(
mode: str,
@@ -957,7 +984,6 @@ async def set_mode(
# ----------------------------------------------------------------------
# Sound
# ----------------------------------------------------------------------
@app.post("/api/tion/sound/{value}")
async def set_sound(
value: Literal["on", "off"],
@@ -980,7 +1006,6 @@ async def set_sound(
# ----------------------------------------------------------------------
# Light
# ----------------------------------------------------------------------
@app.post("/api/tion/light/{value}")
async def set_light(
value: Literal["on", "off"],
@@ -1002,7 +1027,6 @@ async def set_light(
# ----------------------------------------------------------------------
# Переход в auto
# ----------------------------------------------------------------------
@app.get("/api/schedule/config")
async def get_schedule_config():
try:
@@ -1092,6 +1116,9 @@ async def clear_schedule_override():
await schedule_service.clear_override()
if auto_controller is not None:
await auto_controller.reconcile_temperature()
return {
"ok": True,
"schedule": get_schedule_status(),
@@ -1110,56 +1137,42 @@ async def pause_schedule():
detail="Schedule service unavailable",
)
state = service.state
# ВАЖНО:
# получаем логические настройки ДО pause(),
# потому что там ещё действует SET/AUTO/override.
temperature_config = None
manual_target = None
if state is not None:
manual_target = state.target_temp
resolution = schedule_service.resolve()
# Если выходим в manual прямо из AUTO,
# физическая уставка Tion могла быть 30°C.
# Пользователю нужна настоящая AUTO-цель.
if (
resolution.auto_active
and resolution.auto_target_temp
is not None
):
manual_target = (
resolution.auto_target_temp
)
# Temporary override имеет ещё больший
# приоритет.
if (
schedule_service.override_active
and schedule_service
.override_settings
.target_temp is not None
):
manual_target = (
schedule_service
.override_settings
.target_temp
)
if auto_controller is not None:
temperature_config = (
auto_controller
.effective_temperature_config()
)
await schedule_service.pause()
if (
auto_controller is not None
and state is not None
and temperature_config is not None
):
auto_controller.set_manual_heater_enabled(
state.heater
)
if manual_target is not None:
auto_controller.set_manual_target_temperature(
manual_target
if (
temperature_config.heater_enabled
is not None
):
auto_controller.set_manual_heater_enabled(
temperature_config.heater_enabled
)
if (
temperature_config.target_temp
is not None
):
auto_controller.set_manual_target_temperature(
temperature_config.target_temp
)
await auto_controller.reconcile_temperature()
return {
"ok": True,
"schedule": get_schedule_status(),
@@ -1182,6 +1195,8 @@ async def resume_schedule():
if auto_controller is not None:
auto_controller.clear_manual_heater_control()
await auto_controller.reconcile_temperature()
return {
"ok": True,
"schedule": get_schedule_status(),
+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,