work: добавил автоматику управления вытяжкой. Скорости сопоставляются в auto.yaml. Сейчас 4 тион 1 элика, 5 - 2; 6 -3.

This commit is contained in:
2026-09-27 19:59:36 +03:00
parent e197e924ae
commit f161d98746
18 changed files with 4981 additions and 33 deletions
+112 -3
View File
@@ -30,6 +30,21 @@ class Co2Config:
class TemperatureConfig:
hysteresis: float
@dataclass(
frozen=True,
slots=True,
)
class ElicaAssistConfig:
enabled: bool
# (скорость Tion, скорость Elica)
speed_map: tuple[
tuple[int, int],
...
]
@dataclass(
frozen=True,
slots=True,
@@ -39,6 +54,7 @@ class AutoConfig:
check_interval: float
co2: Co2Config
temperature: TemperatureConfig
elica_assist: ElicaAssistConfig
def _require_dict(name: str, value: Any) -> dict:
@@ -267,6 +283,7 @@ def load_auto_config(path: str | Path) -> AutoConfig:
"check_interval",
"co2",
"temperature",
"elica_assist",
}
if unknown:
@@ -374,16 +391,108 @@ def load_auto_config(path: str | Path) -> AutoConfig:
hysteresis=temperature_hysteresis,
)
# --------------------------------------------------
# Elica Auto Assist
# --------------------------------------------------
if "elica_assist" not in data:
raise ValueError("elica_assist config is required")
elica_data = _require_dict(
"elica_assist",
data["elica_assist"],
)
unknown_elica = (
set(elica_data)
- {
"enabled",
"speed_map",
}
)
if unknown_elica:
raise ValueError(f"Unknown elica_assist config fields: {sorted(unknown_elica)}")
enabled = elica_data.get("enabled")
if type(enabled) is not bool:
raise ValueError(
"elica_assist.enabled "
"must be a boolean"
)
speed_map_data = elica_data.get("speed_map")
if not isinstance(
speed_map_data,
dict,
):
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 "
"must be integers"
)
if not (
MIN_FAN_SPEED
<= tion_speed
<= MAX_FAN_SPEED
):
raise ValueError(
"Tion speed in "
"elica_assist.speed_map "
f"must be between "
f"{MIN_FAN_SPEED} and "
f"{MAX_FAN_SPEED}"
)
if type(elica_speed) is not int:
raise ValueError(
"Elica speed in "
"elica_assist.speed_map "
"must be an integer"
)
if not 1 <= elica_speed <= 4:
raise ValueError(
"Elica speed in "
"elica_assist.speed_map "
"must be between 1 and 4"
)
speed_map.append(
(
tion_speed,
elica_speed,
)
)
speed_map.sort()
elica_assist = ElicaAssistConfig(
enabled=enabled,
speed_map=tuple(speed_map),
)
# --------------------------------------------------
# Result
# --------------------------------------------------
return AutoConfig(
version=version,
check_interval=float(
check_interval
),
check_interval=float(check_interval),
co2=co2,
temperature=temperature,
elica_assist=elica_assist,
)
+326 -3
View File
@@ -3,6 +3,10 @@ from datetime import datetime
from app.auto.co2_policy import Co2SpeedPolicy
from app.auto.temperature_policy import TemperaturePolicy
from app.my_dataclasses import MAX_TARGET_TEMP
from app.auto.elica_assist import (
ElicaAssistMode,
ElicaAutoAssistState,
)
class AutoController:
@@ -11,15 +15,19 @@ class AutoController:
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
@@ -120,6 +128,8 @@ class AutoController:
self._last_error = None
self._release_elica_assist()
return
# ----------------------------------------------
@@ -146,6 +156,8 @@ class AutoController:
self._last_error = None
self._release_elica_assist()
return
# ----------------------------------------------
@@ -173,6 +185,8 @@ class AutoController:
self._last_error = None
self._release_elica_assist()
return
fallback_speed = resolution.auto_fallback_speed
@@ -195,6 +209,8 @@ class AutoController:
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)
@@ -222,9 +238,9 @@ 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)
self._auto_speed = target_speed
@@ -253,6 +269,8 @@ class AutoController:
await self._set_speed(fallback_speed)
self._update_elica_assist(fallback_speed)
if self._temperature_policy is not None:
await self._process_heater(
resolution
@@ -417,6 +435,305 @@ class AutoController:
return None, None
async def _update_elica_assist(
self,
speed: int,
) -> None:
if self._elica_assist is None:
return
target_speed = (
self._elica_assist.set_tion_speed(
speed
)
)
if self._elica is None:
return
service = self._elica.service
# Без достоверной обратной связи
# никаких действий с Elica.
if (
not service.running
or not service.state.mqtt_connected
or not service.state.device_online
or not service.feedback_ready
):
return
state = self._elica.state
# Сначала проверяем фактическое состояние.
#
# Если Elica уже была включена пользователем
# или пользователь вмешался в OWNED-сессию,
# state machine сама перейдёт в SUPPRESSED.
self._elica_assist.observe_elica(
power=state.power,
speed=state.speed,
timer=state.timer,
)
mode = self._elica_assist.mode
# --------------------------------------------------
# SUPPRESSED
#
# Пользовательская Elica.
# Ничего не делаем.
# --------------------------------------------------
if mode == ElicaAssistMode.SUPPRESSED:
return
# --------------------------------------------------
# IDLE
#
# Elica свободна.
# Пока здесь только первый захват.
# --------------------------------------------------
if mode == ElicaAssistMode.IDLE:
if target_speed is None:
return
# Дополнительная страховка.
# После observe_elica() включённая Elica
# уже должна была стать SUPPRESSED.
if state.power:
return
result = await self._elica.set_speed(
target_speed
)
# Владение получаем только после
# подтверждённого результата.
self._elica_assist.mark_owned(
result.speed
)
self._elica_assist.observe_elica(
power=result.power,
speed=result.speed,
timer=result.timer,
)
return
# --------------------------------------------------
# OWNED
#
# Эту Elica включила автоматика.
# Теперь ей разрешено менять скорость.
# --------------------------------------------------
if mode == ElicaAssistMode.OWNED:
expected_speed = (
self._elica_assist.expected_speed
)
# --------------------------------------------------
# Tion вышел из диапазона, где нужна Elica.
#
# Выключать её можно ТОЛЬКО если фактическое
# состояние всё ещё полностью совпадает с тем,
# которым владеет автоматика.
# --------------------------------------------------
if target_speed is None:
current = self._elica.state
# Пользователь уже выключил Elica сам.
#
# Ничего дополнительно не нажимаем.
if not current.power:
self._elica_assist.reset()
return
# Состояние изменилось относительно нашего.
#
# Значит пользователь вмешался:
# Elica больше не наша и выключать её нельзя.
if (
current.speed != expected_speed
or current.timer
):
self._elica_assist.suppress(
"manual_intervention"
)
return
# --------------------------------------------------
# Elica всё ещё находится ровно в том состоянии,
# которое установила автоматика.
#
# Значит её безопасно выключить.
# --------------------------------------------------
result = await self._elica.power_off()
# Владение заканчивается только после
# подтверждённого выключения.
if not result.power:
self._elica_assist.reset()
return
# --------------------------------------------------
# Elica по-прежнему нужна.
# --------------------------------------------------
# Уже нужная скорость.
if target_speed == expected_speed:
return
# --------------------------------------------------
# Автоматическое изменение скорости.
#
# set_speed() выполняет всю последовательность
# целиком, например:
#
# 2 -> 3 -> 4 -> 1
#
# Промежуточные состояния здесь не передаются
# в observe_elica().
# --------------------------------------------------
result = await self._elica.set_speed(
target_speed
)
# Обновляем владение только после
# подтверждённой конечной скорости.
self._elica_assist.mark_owned(
result.speed
)
self._elica_assist.observe_elica(
power=result.power,
speed=result.speed,
timer=result.timer,
)
async def _release_elica_assist(self) -> None:
"""
Завершает текущую сессию Elica Auto Assist.
Если Elica принадлежит автоматике, безопасно
выключает её.
Если Elica пользовательская (SUPPRESSED),
устройство не трогаем.
Если обратная связь недоступна, OWNED не
забываем: попробуем освободить Elica позже.
"""
if self._elica_assist is None:
return
mode = self._elica_assist.mode
# --------------------------------------------------
# IDLE
# Ничего не захвачено.
# --------------------------------------------------
if mode == ElicaAssistMode.IDLE:
self._elica_assist.reset()
return
# --------------------------------------------------
# SUPPRESSED
#
# Elica принадлежит пользователю.
# Просто забываем текущий AUTO-цикл.
# Саму Elica не трогаем.
# --------------------------------------------------
if mode == ElicaAssistMode.SUPPRESSED:
self._elica_assist.reset()
return
# --------------------------------------------------
# OWNED
#
# Elica была включена автоматикой.
# --------------------------------------------------
if self._elica is None:
# Не забываем владение.
return
service = self._elica.service
# Без достоверной обратной связи нельзя решать,
# можно ли выключать Elica.
#
# OWNED сохраняем, чтобы попробовать позже.
if (
not service.running
or not service.state.mqtt_connected
or not service.state.device_online
or not service.feedback_ready
):
return
current = self._elica.state
# --------------------------------------------------
# Если Elica уже выключена, работа закончена.
# --------------------------------------------------
if not current.power:
self._elica_assist.reset()
return
# --------------------------------------------------
# Проверяем, что пользователь не вмешался.
# --------------------------------------------------
self._elica_assist.observe_elica(
power=current.power,
speed=current.speed,
timer=current.timer,
)
# Если observe_elica() обнаружил ручное
# вмешательство, Elica больше не наша.
if (
self._elica_assist.mode
== ElicaAssistMode.SUPPRESSED
):
self._elica_assist.reset()
return
expected_speed = (
self._elica_assist.expected_speed
)
# Дополнительная страховка.
if (
current.speed != expected_speed
or current.timer
):
self._elica_assist.reset()
return
# --------------------------------------------------
# Elica всё ещё находится ровно в нашем
# состоянии. Можно выключать.
# --------------------------------------------------
result = await self._elica.power_off()
# Владение заканчиваем только после
# подтверждённого выключения.
if not result.power:
self._elica_assist.reset()
async def _set_speed(self, speed: int) -> None:
@@ -485,6 +802,12 @@ class AutoController:
"temperature": self._temperature,
"temperature_source": self._temperature_source,
"elica_assist": (
self._elica_assist.status()
if self._elica_assist is not None
else None
),
"last_error": self._last_error,
}
+181
View File
@@ -0,0 +1,181 @@
from dataclasses import dataclass
from enum import Enum
from .config import ElicaAssistConfig
class ElicaAssistMode(str, Enum):
IDLE = "idle"
OWNED = "owned"
SUPPRESSED = "suppressed"
@dataclass(slots=True)
class ElicaAssistRuntime:
mode: ElicaAssistMode = ElicaAssistMode.IDLE
reason: str | None = None
tion_speed: int | None = None
target_speed: int | None = None
# Скорость, которую автоматика считает
# установленной ею самой.
expected_speed: int | None = None
class ElicaAutoAssistState:
def __init__(
self,
config: ElicaAssistConfig,
):
self._config = config
self._speed_map = dict(
config.speed_map
)
self._runtime = ElicaAssistRuntime()
@property
def mode(self) -> ElicaAssistMode:
return self._runtime.mode
@property
def target_speed(self) -> int | None:
return self._runtime.target_speed
@property
def expected_speed(self) -> int | None:
return self._runtime.expected_speed
def set_tion_speed(self, tion_speed: int) -> int | None:
"""
Обновляет текущую AUTO-скорость Tion
и вычисляет требуемую скорость Elica.
Никаких команд Elica здесь нет.
"""
self._runtime.tion_speed = tion_speed
if not self._config.enabled:
target = None
else:
target = self._speed_map.get(tion_speed)
self._runtime.target_speed = target
# Если потребность в Elica закончилась,
# SUPPRESSED можно сбросить:
# следующий подъём Tion будет уже
# новым циклом.
if (
target is None
and self._runtime.mode
== ElicaAssistMode.SUPPRESSED
):
self._runtime.mode = (
ElicaAssistMode.IDLE
)
self._runtime.reason = None
self._runtime.expected_speed = None
return target
def mark_owned(self, speed: int) -> None:
"""
Будем вызывать позже только после того,
как автоматика действительно успешно
включила Elica.
"""
self._runtime.mode = ElicaAssistMode.OWNED
self._runtime.reason = None
self._runtime.expected_speed = speed
def suppress(self, reason: str) -> None:
"""
Elica принадлежит пользователю.
До конца текущего AUTO-цикла
автоматика её не трогает.
"""
self._runtime.mode = ElicaAssistMode.SUPPRESSED
self._runtime.reason = reason
self._runtime.expected_speed = None
def reset(self) -> None:
self._runtime = ElicaAssistRuntime()
def status(self) -> dict:
return {
"mode": self._runtime.mode.value,
"reason": self._runtime.reason,
"tion_speed": self._runtime.tion_speed,
"target_speed": self._runtime.target_speed,
"expected_speed": self._runtime.expected_speed,
}
def observe_elica(
self,
power: bool,
speed: int,
timer: bool = False,
) -> None:
"""
Передаёт state machine фактическое состояние Elica.
Пока никаких команд вытяжке не отправляет.
"""
target = self._runtime.target_speed
# Сейчас Elica для AUTO вообще не требуется.
if target is None:
return
# --------------------------------------------------
# IDLE
#
# Tion уже требует помощи Elica, но вытяжка
# оказалась включена ещё до того, как автоматика
# получила над ней управление.
#
# Значит считаем её пользовательской и не трогаем
# до конца текущего цикла.
# --------------------------------------------------
if self._runtime.mode == ElicaAssistMode.IDLE:
if power:
self.suppress(
"elica_already_on"
)
return
# --------------------------------------------------
# OWNED
#
# Позже в это состояние будем переходить после
# успешной автоматической команды.
#
# Если фактическое состояние перестало совпадать
# с тем, которое установила автоматика,
# считаем это ручным вмешательством.
# --------------------------------------------------
if self._runtime.mode == ElicaAssistMode.OWNED:
expected = (
self._runtime.expected_speed
)
if (
not power
or speed != expected
or timer
):
self.suppress(
"manual_intervention"
)