448 lines
9.5 KiB
Python
448 lines
9.5 KiB
Python
import asyncio
|
|
import os
|
|
|
|
import paho.mqtt.client as mqtt
|
|
|
|
from app.auto.config import load_auto_config
|
|
from app.auto.elica_assist import ElicaAutoAssistState
|
|
|
|
from app.elica import (
|
|
ElicaConfig,
|
|
ElicaController,
|
|
ElicaService,
|
|
)
|
|
|
|
from app.my_dataclasses import (
|
|
ELICA_MQTT_HOST,
|
|
ELICA_MQTT_PORT,
|
|
)
|
|
|
|
|
|
AUTO_CONFIG = "config/auto.yaml"
|
|
|
|
ELICA_READY_TIMEOUT = 15.0
|
|
|
|
|
|
class TestElicaService(ElicaService):
|
|
async def start(self) -> None:
|
|
if self._running:
|
|
return
|
|
|
|
client_id = (
|
|
f"climatcontroller-elica-down-test-{os.getpid()}"
|
|
)
|
|
|
|
print(
|
|
"Test MQTT client_id:",
|
|
client_id,
|
|
)
|
|
|
|
client = mqtt.Client(
|
|
callback_api_version=(
|
|
mqtt.CallbackAPIVersion.VERSION2
|
|
),
|
|
client_id=client_id,
|
|
)
|
|
|
|
client.on_connect = self._on_connect
|
|
client.on_disconnect = self._on_disconnect
|
|
client.on_message = self._on_message
|
|
|
|
client.reconnect_delay_set(
|
|
min_delay=1,
|
|
max_delay=30,
|
|
)
|
|
|
|
self._client = client
|
|
self._running = True
|
|
|
|
client.connect_async(
|
|
self._config.mqtt_host,
|
|
self._config.mqtt_port,
|
|
keepalive=60,
|
|
)
|
|
|
|
client.loop_start()
|
|
|
|
|
|
async def wait_for_elica(
|
|
service: ElicaService,
|
|
) -> None:
|
|
loop = asyncio.get_running_loop()
|
|
|
|
deadline = (
|
|
loop.time()
|
|
+ ELICA_READY_TIMEOUT
|
|
)
|
|
|
|
while True:
|
|
state = service.state
|
|
|
|
if (
|
|
state.mqtt_connected
|
|
and state.device_online
|
|
and service.feedback_ready
|
|
):
|
|
return
|
|
|
|
if loop.time() >= deadline:
|
|
raise RuntimeError(
|
|
"Elica did not become ready"
|
|
)
|
|
|
|
await asyncio.sleep(0.1)
|
|
|
|
|
|
async def set_speed_with_trace(
|
|
controller: ElicaController,
|
|
service: ElicaService,
|
|
target_speed: int,
|
|
):
|
|
"""
|
|
Выполняет обычный controller.set_speed(),
|
|
параллельно записывая фактические скорости Elica.
|
|
|
|
Это позволяет увидеть реальный цикл:
|
|
2 -> 3 -> 4 -> 1
|
|
"""
|
|
|
|
path: list[int] = []
|
|
|
|
initial = service.logical_state
|
|
|
|
if (
|
|
initial.power
|
|
and 1 <= initial.speed <= 4
|
|
):
|
|
path.append(initial.speed)
|
|
|
|
task = asyncio.create_task(
|
|
controller.set_speed(
|
|
target_speed
|
|
)
|
|
)
|
|
|
|
while not task.done():
|
|
state = service.logical_state
|
|
|
|
if (
|
|
state.power
|
|
and 1 <= state.speed <= 4
|
|
):
|
|
if (
|
|
not path
|
|
or path[-1] != state.speed
|
|
):
|
|
path.append(
|
|
state.speed
|
|
)
|
|
|
|
await asyncio.sleep(0.02)
|
|
|
|
result = await task
|
|
|
|
# На всякий случай фиксируем конечное
|
|
# подтверждённое состояние.
|
|
if (
|
|
result.power
|
|
and 1 <= result.speed <= 4
|
|
and (
|
|
not path
|
|
or path[-1] != result.speed
|
|
)
|
|
):
|
|
path.append(
|
|
result.speed
|
|
)
|
|
|
|
return result, path
|
|
|
|
|
|
async def main() -> None:
|
|
service = TestElicaService(
|
|
ElicaConfig(
|
|
mqtt_host=ELICA_MQTT_HOST,
|
|
mqtt_port=ELICA_MQTT_PORT,
|
|
)
|
|
)
|
|
|
|
controller = ElicaController(
|
|
service
|
|
)
|
|
|
|
print(
|
|
"Starting Elica service..."
|
|
)
|
|
|
|
await service.start()
|
|
|
|
try:
|
|
print(
|
|
f"Connecting to MQTT "
|
|
f"{ELICA_MQTT_HOST}:"
|
|
f"{ELICA_MQTT_PORT}..."
|
|
)
|
|
|
|
await wait_for_elica(
|
|
service
|
|
)
|
|
|
|
print(
|
|
"Elica connected and "
|
|
"feedback ready"
|
|
)
|
|
|
|
state = controller.state
|
|
|
|
print()
|
|
print(
|
|
"Initial Elica:",
|
|
{
|
|
"power": state.power,
|
|
"speed": state.speed,
|
|
"timer": state.timer,
|
|
},
|
|
)
|
|
|
|
# Для чистоты начинаем с OFF.
|
|
if state.power:
|
|
raise RuntimeError(
|
|
"Elica must be OFF before this test"
|
|
)
|
|
|
|
config = load_auto_config(
|
|
AUTO_CONFIG
|
|
)
|
|
|
|
assist = ElicaAutoAssistState(
|
|
config.elica_assist
|
|
)
|
|
|
|
# ==================================================
|
|
# ЭТАП 1
|
|
#
|
|
# Tion AUTO = 5
|
|
# Elica target = 2
|
|
#
|
|
# Получаем OWNED на скорости 2.
|
|
# ==================================================
|
|
|
|
target_2 = assist.set_tion_speed(
|
|
5
|
|
)
|
|
|
|
print()
|
|
print(
|
|
"Tion AUTO speed:",
|
|
5,
|
|
)
|
|
|
|
print(
|
|
"Elica target:",
|
|
target_2,
|
|
)
|
|
|
|
if target_2 != 2:
|
|
raise RuntimeError(
|
|
f"Expected Elica target 2, "
|
|
f"got {target_2}"
|
|
)
|
|
|
|
assist.observe_elica(
|
|
power=state.power,
|
|
speed=state.speed,
|
|
timer=state.timer,
|
|
)
|
|
|
|
result_2 = await controller.set_speed(
|
|
target_2
|
|
)
|
|
|
|
assist.mark_owned(
|
|
result_2.speed
|
|
)
|
|
|
|
assist.observe_elica(
|
|
power=result_2.power,
|
|
speed=result_2.speed,
|
|
timer=result_2.timer,
|
|
)
|
|
|
|
print()
|
|
print(
|
|
"Elica acquired:",
|
|
{
|
|
"power": result_2.power,
|
|
"speed": result_2.speed,
|
|
"timer": result_2.timer,
|
|
},
|
|
)
|
|
|
|
print(
|
|
"Assist:",
|
|
assist.status(),
|
|
)
|
|
|
|
if (
|
|
assist.mode.value != "owned"
|
|
or result_2.speed != 2
|
|
):
|
|
raise RuntimeError(
|
|
"Failed to acquire Elica "
|
|
"at speed 2"
|
|
)
|
|
|
|
# ==================================================
|
|
# ЭТАП 2
|
|
#
|
|
# Tion AUTO падает:
|
|
#
|
|
# 5 -> 4
|
|
#
|
|
# Новая цель Elica:
|
|
#
|
|
# 2 -> 1
|
|
#
|
|
# Но физически Elica должна пройти:
|
|
#
|
|
# 2 -> 3 -> 4 -> 1
|
|
# ==================================================
|
|
|
|
target_1 = assist.set_tion_speed(
|
|
4
|
|
)
|
|
|
|
print()
|
|
print(
|
|
"Tion AUTO speed:",
|
|
4,
|
|
)
|
|
|
|
print(
|
|
"New Elica target:",
|
|
target_1,
|
|
)
|
|
|
|
print(
|
|
"Assist before speed change:",
|
|
assist.status(),
|
|
)
|
|
|
|
if target_1 != 1:
|
|
raise RuntimeError(
|
|
f"Expected Elica target 1, "
|
|
f"got {target_1}"
|
|
)
|
|
|
|
# ВАЖНО:
|
|
#
|
|
# Здесь НЕ вызываем observe_elica()
|
|
# во время промежуточных скоростей.
|
|
#
|
|
# 3 и 4 являются частью нашей
|
|
# собственной команды set_speed(1),
|
|
# а не действиями пользователя.
|
|
|
|
result_1, speed_path = (
|
|
await set_speed_with_trace(
|
|
controller,
|
|
service,
|
|
target_1,
|
|
)
|
|
)
|
|
|
|
print()
|
|
print(
|
|
"Observed speed path:",
|
|
speed_path,
|
|
)
|
|
|
|
print(
|
|
"Confirmed Elica:",
|
|
{
|
|
"power": result_1.power,
|
|
"speed": result_1.speed,
|
|
"timer": result_1.timer,
|
|
},
|
|
)
|
|
|
|
# Только ПОСЛЕ завершения всей нашей
|
|
# последовательности обновляем владение.
|
|
assist.mark_owned(
|
|
result_1.speed
|
|
)
|
|
|
|
assist.observe_elica(
|
|
power=result_1.power,
|
|
speed=result_1.speed,
|
|
timer=result_1.timer,
|
|
)
|
|
|
|
print()
|
|
print(
|
|
"Assist after speed change:",
|
|
assist.status(),
|
|
)
|
|
|
|
# ==================================================
|
|
# ПРОВЕРКИ
|
|
# ==================================================
|
|
|
|
if speed_path != [2, 3, 4, 1]:
|
|
raise RuntimeError(
|
|
"Unexpected Elica speed path: "
|
|
f"{speed_path}; "
|
|
"expected [2, 3, 4, 1]"
|
|
)
|
|
|
|
if result_1.speed != 1:
|
|
raise RuntimeError(
|
|
"Elica did not reach speed 1"
|
|
)
|
|
|
|
if assist.mode.value != "owned":
|
|
raise RuntimeError(
|
|
"Auto Assist lost OWNED "
|
|
"during automatic speed change"
|
|
)
|
|
|
|
if assist.expected_speed != 1:
|
|
raise RuntimeError(
|
|
"Auto Assist expected_speed "
|
|
"was not updated to 1"
|
|
)
|
|
|
|
print()
|
|
print(
|
|
"TEST PASSED"
|
|
)
|
|
|
|
print(
|
|
"Automatic Elica transition:"
|
|
)
|
|
|
|
print(
|
|
"2 -> 3 -> 4 -> 1"
|
|
)
|
|
|
|
print(
|
|
"Auto Assist kept OWNED."
|
|
)
|
|
|
|
print()
|
|
print(
|
|
"Turn Elica off manually "
|
|
"after the test."
|
|
)
|
|
|
|
finally:
|
|
print()
|
|
print(
|
|
"Stopping Elica service..."
|
|
)
|
|
|
|
await service.stop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main()) |