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
+7
View File
@@ -11,6 +11,7 @@ from pathlib import Path as FilePath
from app.qingping.service import QingpingService
from app.metrics import PrometheusMetricsService
from app.elica import ElicaConfig, ElicaController, ElicaService
from app.auto.elica_assist import ElicaAutoAssistState
from app.my_dataclasses import (
TION_MAC,
@@ -139,6 +140,8 @@ async def lifespan(app: FastAPI):
try:
auto_config = load_auto_config(AUTO_CONFIG_FILE)
elica_assist = ElicaAutoAssistState(auto_config.elica_assist)
auto_policy = Co2SpeedPolicy(
base_speed=(
auto_config.co2.base_speed
@@ -161,6 +164,8 @@ async def lifespan(app: FastAPI):
auto_policy = None
temperature_policy = None
elica_assist = None
# Безопасный встроенный интервал нужен,
# потому что auto.yaml сейчас недоступен.
auto_interval = 5.0
@@ -173,8 +178,10 @@ async def lifespan(app: FastAPI):
schedule_service=schedule_service,
qingping_service=qingping_service,
tion_service=service,
elica_controller=elica_controller,
policy=auto_policy,
temperature_policy=temperature_policy,
elica_assist=elica_assist,
interval=auto_interval,
)
+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"
)
+40 -17
View File
@@ -20,11 +20,13 @@ class ElicaController:
state_timeout: float = 3.0,
poll_interval: float = 0.05,
speed_inter_press_delay: float = 0.4,
):
self._service = service
self._state_timeout = state_timeout
self._poll_interval = poll_interval
self._speed_inter_press_delay = max(0.0, speed_inter_press_delay)
self._last_speed_press_finished_at: float | None = None
# Не допускаем одновременное выполнение нескольких
# последовательностей нажатий кнопок.
@@ -111,7 +113,6 @@ class ElicaController:
# ------------------------------------------------------------------
# Power
# ------------------------------------------------------------------
async def power_on(self) -> ElicaLogicalState:
async with self._lock:
return await self._power_on_locked()
@@ -120,10 +121,45 @@ class ElicaController:
async with self._lock:
return await self._power_off_locked()
async def _press_speed_locked(self) -> None:
"""
Нажимает Speed с гарантированным минимальным
интервалом после предыдущего нажатия.
Интервал соблюдается и между разными
вызовами set_speed().
"""
loop = asyncio.get_running_loop()
if (
self._last_speed_press_finished_at is not None
and self._speed_inter_press_delay > 0
):
elapsed = (
loop.time()
- self._last_speed_press_finished_at
)
remaining = (
self._speed_inter_press_delay
- elapsed
)
if remaining > 0:
await asyncio.sleep(
remaining
)
await self._service.press_speed()
self._last_speed_press_finished_at = (
loop.time()
)
# ------------------------------------------------------------------
# Speed
# ------------------------------------------------------------------
async def set_speed(self, speed: int) -> ElicaLogicalState:
"""Устанавливает скорость 1-4 последовательными нажатиями Speed.
@@ -145,20 +181,12 @@ class ElicaController:
# У Elica кнопка Speed сама включает вытяжку. Первое
# нажатие из состояния OFF запускает её на скорости 1.
# Поэтому при выборе скорости Power здесь не нажимаем.
await self._service.press_speed()
await self._press_speed_locked()
state = await self._wait_state(
lambda value: value.power and value.speed == 1,
"speed 1",
)
# После физического отпускания кнопки Elica нужен
# небольшой гарантированный интервал до следующего
# нажатия. Иначе при быстром наборе 2/3/4 контроллер
# вытяжки иногда воспринимает два импульса как одно
# длинное нажатие или просто игнорирует следующий.
if speed != 1 and self._speed_inter_press_delay > 0:
await asyncio.sleep(self._speed_inter_press_delay)
# Если питание уже было включено, но индикатор скорости ещё
# не успел синхронизироваться, ждём корректное значение 1-4.
if not 1 <= state.speed <= 4:
@@ -173,7 +201,7 @@ class ElicaController:
for _ in range(presses):
expected_speed = current_speed % 4 + 1
await self._service.press_speed()
await self._press_speed_locked()
state = await self._wait_state(
lambda value, expected=expected_speed: (
@@ -184,11 +212,6 @@ class ElicaController:
current_speed = expected_speed
# Не нажимаем Speed повторно сразу после отпускания
# предыдущего импульса. Это особенно важно для переходов
# на 4-ю скорость, где требуется несколько нажатий подряд.
if current_speed != speed and self._speed_inter_press_delay > 0:
await asyncio.sleep(self._speed_inter_press_delay)
return state
+51 -9
View File
@@ -524,26 +524,68 @@ class ElicaService:
async def pulse_relay(self, relay: int, pulse_ms: int | None = None) -> None:
"""
Кратковременно включает реле и затем выключает его.
Используется для эмуляции нажатия кнопок Elica.
Перед первой командой обязательно ждём
синхронизации MQTT-feedback этого реле.
"""
if not 1 <= relay <= 8:
raise ValueError("Relay number must be between 1 and 8")
raise ValueError(
"Relay number must be between 1 and 8"
)
duration_ms = pulse_ms if pulse_ms is not None else self._config.pulse_ms
duration_ms = (
pulse_ms
if pulse_ms is not None
else self._config.pulse_ms
)
self.set_relay(relay, True)
# --------------------------------------------------
# ВАЖНО:
# после MQTT connect состояния входов панели
# и состояний реле приходят независимо.
#
# Нельзя начинать импульс, пока мы не получили
# хотя бы первое достоверное состояние именно
# этого OUT.
# --------------------------------------------------
await self.wait_relay_feedback_ready(relay)
# --------------------------------------------------
# Перед новым импульсом реле обязано быть OFF.
#
# Это дополнительно восстанавливает состояние,
# если предыдущая операция была аварийно
# прервана на включённом реле.
# --------------------------------------------------
if self.relay_state(relay):
self.set_relay(relay,False)
await self.wait_relay_state(relay,False)
# --------------------------------------------------
# Нажатие
# --------------------------------------------------
self.set_relay(relay,True)
try:
await self.wait_relay_state(relay, True)
await self.wait_relay_state(relay,True)
await asyncio.sleep(duration_ms / 1000)
finally:
# Relay обязательно пытаемся отпустить,
# даже если подтверждение ON не пришло.
try:
self.set_relay(relay, False)
except Exception:
logger.exception("Failed to release Elica relay %s", relay)
self.set_relay(relay,False)
await self.wait_relay_state(relay, False)
except Exception:
logger.exception("Failed to release Elica relay %s",relay)
# И ждём подтверждённого отпускания.
await self.wait_relay_state(relay,False)