work: добавил автоматику управления вытяжкой. Скорости сопоставляются в auto.yaml. Сейчас 4 тион 1 элика, 5 - 2; 6 -3.
This commit is contained in:
@@ -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
@@ -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
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
@@ -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
@@ -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
@@ -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)
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user