976 lines
30 KiB
Python
976 lines
30 KiB
Python
import asyncio
|
|
from dataclasses import dataclass
|
|
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,
|
|
)
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class EffectiveTemperatureConfig:
|
|
heater_enabled: bool | None
|
|
target_temp: int | None
|
|
|
|
|
|
class AutoController:
|
|
|
|
def __init__(
|
|
self,
|
|
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
|
|
|
|
self._task: asyncio.Task | None = None
|
|
|
|
self._state = "inactive"
|
|
self._reason: str | None = None
|
|
|
|
self._target_speed: int | None = None
|
|
self._auto_speed: int | None = None
|
|
|
|
self._target_heater: bool | None = None
|
|
self._auto_heater: bool | None = None
|
|
self._target_temperature: int | None = None
|
|
|
|
self._temperature: float | int | None = None
|
|
self._temperature_source: str | None = None
|
|
|
|
# Последнее решение единого внешнего
|
|
# температурного регулятора.
|
|
self._temperature_heating: bool | None = None
|
|
|
|
|
|
# --------------------------------------------------
|
|
# Ручное управление обогревом.
|
|
#
|
|
# Эти значения описывают желание пользователя,
|
|
# а не текущее физическое состояние Tion.
|
|
# --------------------------------------------------
|
|
|
|
self._manual_heater_enabled: bool | None = None
|
|
self._manual_target_temperature: int | None = None
|
|
|
|
# Фактическое решение нашего внешнего
|
|
# температурного регулятора.
|
|
self._manual_heating: bool | None = None
|
|
|
|
self._last_error: str | None = None
|
|
|
|
|
|
async def start(self) -> None:
|
|
|
|
if self._task is not None:
|
|
return
|
|
|
|
self._task = asyncio.create_task( self._loop() )
|
|
|
|
|
|
async def stop(self) -> None:
|
|
|
|
if self._task is None:
|
|
return
|
|
|
|
self._task.cancel()
|
|
|
|
try:
|
|
await self._task
|
|
|
|
except asyncio.CancelledError:
|
|
pass
|
|
|
|
finally:
|
|
self._task = None
|
|
|
|
|
|
async def _loop(self) -> None:
|
|
|
|
while True:
|
|
|
|
try:
|
|
await self._process()
|
|
|
|
except asyncio.CancelledError:
|
|
raise
|
|
|
|
except Exception as exc:
|
|
self._last_error = str(exc)
|
|
|
|
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()
|
|
|
|
# --------------------------------------------------
|
|
# Температурный контур работает ВСЕГДА:
|
|
#
|
|
# SET
|
|
# AUTO
|
|
# PAUSE
|
|
# temporary override
|
|
# --------------------------------------------------
|
|
|
|
temperature_config = (
|
|
self._get_effective_temperature_config(resolution)
|
|
)
|
|
|
|
await self._process_temperature(temperature_config)
|
|
|
|
# --------------------------------------------------
|
|
# PAUSE
|
|
# --------------------------------------------------
|
|
|
|
if getattr(
|
|
self._schedule,
|
|
"paused",
|
|
False,
|
|
):
|
|
self._state = "suspended"
|
|
self._reason = "schedule_paused"
|
|
|
|
self._target_speed = None
|
|
self._auto_speed = None
|
|
|
|
self._auto_heater = None
|
|
self._manual_heating = (
|
|
self._temperature_heating
|
|
)
|
|
|
|
self._last_error = None
|
|
|
|
await self._release_elica_assist()
|
|
|
|
return
|
|
|
|
# В режимах расписания результат относится
|
|
# к общему температурному контуру.
|
|
self._manual_heating = None
|
|
self._auto_heater = (
|
|
self._temperature_heating
|
|
)
|
|
|
|
# --------------------------------------------------
|
|
# Temporary override.
|
|
#
|
|
# Температура уже обработана выше.
|
|
# AUTO скоростью во время override
|
|
# по-прежнему не управляет.
|
|
# --------------------------------------------------
|
|
|
|
if self._schedule.override_active:
|
|
self._state = "suspended"
|
|
self._reason = "manual_override"
|
|
|
|
self._target_speed = None
|
|
self._auto_speed = None
|
|
|
|
self._last_error = None
|
|
|
|
await self._release_elica_assist()
|
|
|
|
return
|
|
|
|
# --------------------------------------------------
|
|
# Не AUTO.
|
|
#
|
|
# Температура уже обработана выше.
|
|
# Здесь просто нечего делать с AUTO-скоростью.
|
|
# --------------------------------------------------
|
|
|
|
if (
|
|
not resolution.enabled
|
|
or not resolution.auto_active
|
|
):
|
|
self._state = "inactive"
|
|
self._reason = None
|
|
|
|
self._target_speed = None
|
|
self._auto_speed = None
|
|
|
|
self._last_error = None
|
|
|
|
await self._release_elica_assist()
|
|
|
|
return
|
|
|
|
# --------------------------------------------------
|
|
# Ниже остаётся только AUTO-управление скоростью.
|
|
# --------------------------------------------------
|
|
|
|
fallback_speed = (resolution.auto_fallback_speed)
|
|
|
|
if fallback_speed is None:
|
|
raise RuntimeError(
|
|
"AUTO is active but "
|
|
"fallback speed is missing"
|
|
)
|
|
|
|
# CO2 policy недоступна.
|
|
if self._policy is None:
|
|
self._state = "fallback"
|
|
self._reason = (
|
|
"auto_policy_unavailable"
|
|
)
|
|
|
|
self._auto_speed = None
|
|
|
|
await self._set_speed(
|
|
fallback_speed
|
|
)
|
|
|
|
await self._update_elica_assist(
|
|
fallback_speed
|
|
)
|
|
|
|
self._last_error = None
|
|
|
|
return
|
|
|
|
qingping_state = self._qingping.state
|
|
|
|
# Qingping исправен.
|
|
if (
|
|
self._qingping.online
|
|
and qingping_state.co2 is not None
|
|
):
|
|
target_speed = (
|
|
self._policy.select_speed(
|
|
co2=qingping_state.co2,
|
|
current_speed=self._auto_speed,
|
|
)
|
|
)
|
|
|
|
self._state = "active"
|
|
self._reason = None
|
|
|
|
await self._set_speed(
|
|
target_speed
|
|
)
|
|
|
|
await self._update_elica_assist(
|
|
target_speed
|
|
)
|
|
|
|
self._auto_speed = target_speed
|
|
|
|
self._last_error = None
|
|
|
|
return
|
|
|
|
# Qingping недоступен для CO2.
|
|
if not self._qingping.online:
|
|
reason = "qingping_offline"
|
|
else:
|
|
reason = "co2_missing"
|
|
|
|
self._state = "fallback"
|
|
self._reason = reason
|
|
|
|
self._auto_speed = None
|
|
|
|
await self._set_speed(
|
|
fallback_speed
|
|
)
|
|
|
|
await self._update_elica_assist(
|
|
fallback_speed
|
|
)
|
|
|
|
self._last_error = None
|
|
|
|
def _get_effective_temperature_config(
|
|
self,
|
|
resolution,
|
|
) -> EffectiveTemperatureConfig:
|
|
|
|
# --------------------------------------------------
|
|
# PAUSE.
|
|
#
|
|
# Источник настроек — ручное состояние.
|
|
# --------------------------------------------------
|
|
|
|
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
|
|
)
|
|
|
|
target_temp = (
|
|
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._temperature_heating = False
|
|
|
|
return
|
|
|
|
# --------------------------------------------------
|
|
# Heater вообще не определён.
|
|
#
|
|
# Ничего физически не меняем.
|
|
# --------------------------------------------------
|
|
|
|
if enabled is None:
|
|
self._temperature_heating = None
|
|
|
|
return
|
|
|
|
# --------------------------------------------------
|
|
# Heater разрешён, но цели нет.
|
|
#
|
|
# Безопасное состояние — OFF.
|
|
# --------------------------------------------------
|
|
|
|
if target_temp is None:
|
|
await self._set_heater(False)
|
|
|
|
self._temperature_heating = False
|
|
|
|
return
|
|
|
|
qingping_state = self._qingping.state
|
|
|
|
qingping_temperature = getattr(
|
|
qingping_state,
|
|
"temperature",
|
|
None,
|
|
)
|
|
|
|
# --------------------------------------------------
|
|
# Qingping доступен и TemperaturePolicy работает.
|
|
#
|
|
# Решение принимаем ТОЛЬКО по Qingping.
|
|
# --------------------------------------------------
|
|
|
|
if (
|
|
self._qingping.online
|
|
and qingping_temperature is not None
|
|
and self._temperature_policy is not None
|
|
):
|
|
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._temperature_heating
|
|
is True
|
|
),
|
|
)
|
|
)
|
|
|
|
# Встроенный термостат Tion
|
|
# не должен мешать внешнему регулятору.
|
|
await self._set_target_temperature(
|
|
MAX_TARGET_TEMP
|
|
)
|
|
|
|
await self._set_heater(
|
|
heater_required
|
|
)
|
|
|
|
self._temperature_heating = (
|
|
heater_required
|
|
)
|
|
|
|
return
|
|
|
|
# --------------------------------------------------
|
|
# Qingping недоступен либо отсутствует
|
|
# TemperaturePolicy.
|
|
#
|
|
# Никаких решений по Tion.in_temp!
|
|
#
|
|
# Возвращаем управление штатному
|
|
# термостату Tion.
|
|
# --------------------------------------------------
|
|
|
|
await self._set_target_temperature(
|
|
target_temp
|
|
)
|
|
|
|
await self._set_heater(True)
|
|
|
|
self._temperature_heating = None
|
|
|
|
# Tion.in_temp здесь только для диагностики.
|
|
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
|
|
)
|
|
|
|
self._temperature_source = "tion"
|
|
|
|
else:
|
|
self._temperature = None
|
|
self._temperature_source = 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:
|
|
|
|
if self._target_speed == speed:
|
|
return
|
|
|
|
await self._tion.execute(
|
|
lambda controller:
|
|
controller.set_speed(speed)
|
|
)
|
|
|
|
self._target_speed = speed
|
|
|
|
async def _set_heater(self,enabled: bool) -> None:
|
|
|
|
# Если AutoController уже установил именно такое
|
|
# состояние нагревателя, повторную команду не шлём.
|
|
if self._target_heater == enabled:
|
|
return
|
|
|
|
if enabled:
|
|
await self._tion.execute(
|
|
lambda controller:
|
|
controller.heater_on()
|
|
)
|
|
else:
|
|
await self._tion.execute(
|
|
lambda controller:
|
|
controller.heater_off()
|
|
)
|
|
|
|
# Запоминаем состояние только после того,
|
|
# как команда успешно выполнилась.
|
|
self._target_heater = enabled
|
|
|
|
|
|
async def _set_target_temperature(
|
|
self,
|
|
temperature: int,
|
|
) -> None:
|
|
|
|
if self._target_temperature == temperature:
|
|
return
|
|
|
|
await self._tion.execute(
|
|
lambda controller:
|
|
controller.set_target_temperature(
|
|
temperature
|
|
)
|
|
)
|
|
|
|
self._target_temperature = temperature
|
|
|
|
def set_manual_heater_enabled(self, enabled: bool) -> None:
|
|
"""
|
|
Запоминает, хочет ли пользователь использовать
|
|
обогрев в ручном режиме.
|
|
|
|
Саму команду Tion этот метод пока не отправляет.
|
|
"""
|
|
self._manual_heater_enabled = enabled
|
|
|
|
self._target_heater = None
|
|
|
|
if not enabled:
|
|
self._manual_heating = False
|
|
|
|
def set_manual_target_temperature(self, temperature: int) -> None:
|
|
"""
|
|
Запоминает желаемую температуру помещения
|
|
для ручного режима.
|
|
"""
|
|
self._manual_target_temperature = temperature
|
|
self._target_temperature = None
|
|
|
|
def clear_manual_heater_control(self) -> None:
|
|
"""
|
|
Забываем состояние ручного температурного
|
|
регулятора при возврате к расписанию.
|
|
"""
|
|
self._manual_heater_enabled = None
|
|
self._manual_target_temperature = None
|
|
self._manual_heating = None
|
|
|
|
@property
|
|
def manual_heater_enabled(self) -> bool | None:
|
|
return self._manual_heater_enabled
|
|
|
|
@property
|
|
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,
|
|
"reason": self._reason,
|
|
|
|
"target_speed": self._target_speed,
|
|
"auto_speed": self._auto_speed,
|
|
|
|
"target_heater": self._target_heater,
|
|
"auto_heater": self._auto_heater,
|
|
|
|
"temperature": self._temperature,
|
|
"temperature_source": self._temperature_source,
|
|
|
|
"elica_assist": (
|
|
self._elica_assist.status()
|
|
if self._elica_assist is not None
|
|
else None
|
|
),
|
|
|
|
"manual_heater": {
|
|
"enabled": self._manual_heater_enabled,
|
|
"target_temp": self._manual_target_temperature,
|
|
"heating": self._manual_heating,
|
|
},
|
|
|
|
"last_error": self._last_error,
|
|
}
|
|
|