ramses-rf 0.22.40__py3-none-any.whl → 0.51.1__py3-none-any.whl

ramses_cli/discovery.py

@@ -0,0 +1,405 @@
+#!/usr/bin/env python3
+"""RAMSES RF - discovery scripts."""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import json
+import logging
+import re
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Final
+
+from ramses_rf import exceptions as exc
+from ramses_rf.const import SZ_SCHEDULE, SZ_ZONE_IDX
+from ramses_rf.device import Fakeable
+from ramses_tx import CODES_SCHEMA, Command, DeviceIdT, Priority
+from ramses_tx.opentherm import OTB_DATA_IDS
+
+# Beware, none of this is reliable - it is all subject to random change
+# However, these serve as examples how to use the other modules
+
+
+from ramses_rf.const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
+    I_,
+    RP,
+    RQ,
+    W_,
+    Code,
+)
+
+if TYPE_CHECKING:
+    from ramses_rf import Gateway, IndexT
+
+
+EXEC_CMD: Final = "exec_cmd"
+GET_FAULTS: Final = "get_faults"
+GET_SCHED: Final = "get_schedule"
+SET_SCHED: Final = "set_schedule"
+
+EXEC_SCR: Final = "exec_scr"
+SCAN_DISC: Final = "scan_disc"
+SCAN_FULL: Final = "scan_full"
+SCAN_HARD: Final = "scan_hard"
+SCAN_XXXX: Final = "scan_xxxx"
+
+# DEVICE_ID_REGEX = re.compile(DEVICE_ID_REGEX.ANY)
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def script_decorator(fnc: Callable[..., Any]) -> Callable[..., Any]:
+    @functools.wraps(fnc)
+    def wrapper(gwy: Gateway, *args: Any, **kwargs: Any) -> None:
+        gwy.send_cmd(
+            Command._puzzle(message="Script begins:"),
+            priority=Priority.HIGHEST,
+            num_repeats=3,
+        )
+
+        fnc(gwy, *args, **kwargs)
+
+        gwy.send_cmd(
+            Command._puzzle(message="Script done."),
+            priority=Priority.LOWEST,
+            num_repeats=3,
+        )
+
+        return None
+
+    return wrapper
+
+
+def spawn_scripts(gwy: Gateway, **kwargs: Any) -> list[asyncio.Task[None]]:
+    tasks = []
+
+    if kwargs.get(EXEC_CMD):
+        tasks += [asyncio.create_task(exec_cmd(gwy, **kwargs))]
+
+    if kwargs.get(GET_FAULTS):
+        tasks += [asyncio.create_task(get_faults(gwy, kwargs[GET_FAULTS]))]
+
+    elif kwargs.get(GET_SCHED) and kwargs[GET_SCHED][0]:
+        tasks += [asyncio.create_task(get_schedule(gwy, *kwargs[GET_SCHED]))]
+
+    elif kwargs.get(SET_SCHED) and kwargs[SET_SCHED][0]:
+        tasks += [asyncio.create_task(set_schedule(gwy, *kwargs[SET_SCHED]))]
+
+    elif kwargs.get(EXEC_SCR):
+        script = SCRIPTS.get(f"{kwargs[EXEC_SCR][0]}")
+        if script is None:
+            _LOGGER.warning(f"Script: {kwargs[EXEC_SCR][0]}() - unknown script")
+        else:
+            _LOGGER.info(f"Script: {kwargs[EXEC_SCR][0]}().- starts...")
+            tasks += [asyncio.create_task(script(gwy, kwargs[EXEC_SCR][1]))]
+
+    gwy._tasks.extend(tasks)
+    return tasks
+
+
+async def exec_cmd(gwy: Gateway, **kwargs: Any) -> None:
+    cmd = Command.from_cli(kwargs[EXEC_CMD])
+    await gwy.async_send_cmd(cmd, priority=Priority.HIGH, wait_for_reply=True)
+
+
+# @script_decorator
+# async def script_scan_001(gwy: Gateway, dev_id: DeviceIdT):
+#     _LOGGER.warning("scan_001() invoked - expect a lot of nonsense")
+#     for idx in range(0x10):
+#         gwy.send_cmd(Command.from_attrs(W_, dev_id, Code._000E, f"{idx:02X}0050"))
+#         gwy.send_cmd(Command.from_attrs(RQ, dev_id, Code._000E, f"{idx:02X}00C8"))
+
+
+async def get_faults(
+    gwy: Gateway, ctl_id: DeviceIdT, start: int = 0, limit: int = 0x3F
+) -> None:
+    ctl = gwy.get_device(ctl_id)
+
+    try:
+        await ctl.tcs.get_faultlog(start=start, limit=limit)  # 0418
+    except exc.ExpiredCallbackError as err:
+        _LOGGER.error("get_faults(): Function timed out: %s", err)
+
+
+async def get_schedule(gwy: Gateway, ctl_id: DeviceIdT, zone_idx: str) -> None:
+    zone = gwy.get_device(ctl_id).tcs.get_htg_zone(zone_idx)
+
+    try:
+        await zone.get_schedule()
+    except exc.ExpiredCallbackError as err:
+        _LOGGER.error("get_schedule(): Function timed out: %s", err)
+
+
+async def set_schedule(gwy: Gateway, ctl_id: DeviceIdT, schedule: str) -> None:
+    schedule_ = json.loads(schedule)
+    zone_idx = schedule_[SZ_ZONE_IDX]
+
+    zone = gwy.get_device(ctl_id).tcs.get_htg_zone(zone_idx)
+
+    try:
+        await zone.set_schedule(schedule_[SZ_SCHEDULE])  # 0404
+    except exc.ExpiredCallbackError as err:
+        _LOGGER.error("set_schedule(): Function timed out: %s", err)
+
+
+async def script_bind_req(
+    gwy: Gateway, dev_id: DeviceIdT, code: Code = Code._2309
+) -> None:
+    dev = gwy.get_device(dev_id)
+    assert isinstance(dev, Fakeable)  # mypy
+    dev._make_fake()
+    await dev._initiate_binding_process([code])
+
+
+async def script_bind_wait(
+    gwy: Gateway, dev_id: DeviceIdT, code: Code = Code._2309, idx: IndexT = "00"
+) -> None:
+    dev = gwy.get_device(dev_id)
+    assert isinstance(dev, Fakeable)  # mypy
+    dev._make_fake()
+    await dev._wait_for_binding_request([code], idx=idx)
+
+
+def script_poll_device(gwy: Gateway, dev_id: DeviceIdT) -> list[asyncio.Task[None]]:
+    async def periodic_send(
+        gwy: Gateway,
+        cmd: Command,
+        count: int = 1,
+        interval: float | None = None,
+    ) -> None:
+        async def periodic_(interval_: float) -> None:
+            await asyncio.sleep(interval_)
+            gwy.send_cmd(cmd, priority=Priority.LOW)
+
+        if interval is None:
+            interval = 0 if count == 1 else 60
+
+        if count <= 0:
+            while True:
+                await periodic_(interval)
+        else:
+            for _ in range(count):
+                await periodic_(interval)
+
+    _LOGGER.warning("poll_device() invoked...")
+
+    tasks = []
+
+    for code in (Code._0016, Code._1FC9):
+        cmd = Command.from_attrs(RQ, dev_id, code, "00")
+        tasks.append(asyncio.create_task(periodic_send(gwy, cmd, count=0)))
+
+    gwy._tasks.extend(tasks)
+    return tasks
+
+
+@script_decorator
+async def script_scan_disc(gwy: Gateway, dev_id: DeviceIdT) -> None:
+    _LOGGER.warning("scan_disc() invoked...")
+
+    await gwy.get_device(dev_id).discover()  # discover_flag=Discover.DEFAULT)
+
+
+@script_decorator
+async def script_scan_full(gwy: Gateway, dev_id: DeviceIdT) -> None:
+    _LOGGER.warning("scan_full() invoked - expect a lot of Warnings")
+
+    gwy.send_cmd(Command.from_attrs(RQ, dev_id, Code._0016, "0000"), num_repeats=3)
+
+    for code in sorted(CODES_SCHEMA):
+        if code == Code._0005:
+            for zone_type in range(20):  # known up to 18
+                gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, f"00{zone_type:02X}"))
+
+        elif code == Code._000C:
+            for zone_idx in range(16):  # also: FA-FF?
+                gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, f"{zone_idx:02X}00"))
+
+        elif code == Code._0016:
+            continue
+
+        elif code in (Code._01D0, Code._01E9):
+            for zone_idx in ("00", "01", "FC"):  # type: ignore[assignment]
+                gwy.send_cmd(Command.from_attrs(W_, dev_id, code, f"{zone_idx}00"))
+                gwy.send_cmd(Command.from_attrs(W_, dev_id, code, f"{zone_idx}03"))
+
+        elif code == Code._0404:  # FIXME
+            gwy.send_cmd(Command.get_schedule_fragment(dev_id, "HW", 1, 0))
+            gwy.send_cmd(Command.get_schedule_fragment(dev_id, "00", 1, 0))
+
+        elif code == Code._0418:
+            for log_idx in range(2):
+                gwy.send_cmd(Command.get_system_log_entry(dev_id, log_idx))
+
+        elif code == Code._1100:
+            gwy.send_cmd(Command.get_tpi_params(dev_id))
+
+        elif code == Code._2E04:
+            gwy.send_cmd(Command.get_system_mode(dev_id))
+
+        elif code == Code._3220:
+            for data_id in (0, 3):  # these are mandatory READ_DATA data_ids
+                gwy.send_cmd(Command.get_opentherm_data(dev_id, data_id))
+
+        elif code == Code._PUZZ:
+            continue
+
+        elif (
+            code in CODES_SCHEMA
+            and RQ in CODES_SCHEMA[code]
+            and re.match(CODES_SCHEMA[code][RQ], "00")
+        ):
+            gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, "00"))
+
+        else:
+            gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, "0000"))
+
+    # these are possible/difficult codes
+    for code in (Code._0150, Code._2389):
+        gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, "0000"))
+
+
+@script_decorator
+async def script_scan_hard(
+    gwy: Gateway, dev_id: DeviceIdT, *, start_code: None | int = None
+) -> None:
+    _LOGGER.warning("scan_hard() invoked - expect some Warnings")
+
+    start_code = start_code or 0
+
+    for code in range(start_code, 0x5000):
+        await gwy.async_send_cmd(
+            Command.from_attrs(RQ, dev_id, f"{code:04X}", "0000"),  # type:ignore[arg-type]
+            priority=Priority.LOW,
+        )
+
+
+@script_decorator
+async def script_scan_fan(gwy: Gateway, dev_id: DeviceIdT) -> None:
+    _LOGGER.warning("scan_fan() invoked - expect a lot of nonsense")
+
+    from ramses_tx.ramses import _DEV_KLASSES_HVAC
+
+    OUT_CODES = (
+        Code._0016,
+        Code._1470,
+    )
+
+    OLD_CODES = dict.fromkeys(
+        c for k in _DEV_KLASSES_HVAC.values() for c in k if c not in OUT_CODES
+    )
+    for code in OLD_CODES:
+        gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, "00"))
+
+    NEW_CODES = (
+        Code._0150,
+        Code._042F,
+        Code._1030,
+        Code._10D0,
+        Code._10E1,
+        Code._2210,
+        Code._22B0,
+        Code._22E0,
+        Code._22E5,
+        Code._22E9,
+        Code._22F1,
+        Code._22F2,
+        Code._22F3,
+        Code._22F4,
+        Code._22F7,
+        Code._22F8,
+        Code._2400,
+        Code._2410,
+        Code._2420,
+        Code._313E,
+        Code._3221,
+        Code._3222,
+    )
+
+    for code in NEW_CODES:
+        if code not in OLD_CODES and code not in OUT_CODES:
+            gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, "00"))
+
+
+@script_decorator
+async def script_scan_otb(gwy: Gateway, dev_id: DeviceIdT) -> None:
+    _LOGGER.warning("script_scan_otb_full invoked - expect a lot of nonsense")
+
+    for msg_id in OTB_DATA_IDS:
+        gwy.send_cmd(Command.get_opentherm_data(dev_id, msg_id))
+
+
+@script_decorator
+async def script_scan_otb_hard(gwy: Gateway, dev_id: DeviceIdT) -> None:
+    _LOGGER.warning("script_scan_otb_hard invoked - expect a lot of nonsense")
+
+    for msg_id in range(0x80):
+        gwy.send_cmd(Command.get_opentherm_data(dev_id, msg_id), priority=Priority.LOW)
+
+
+@script_decorator
+async def script_scan_otb_map(
+    gwy: Gateway, dev_id: DeviceIdT
+) -> None:  # Tested only upon a R8820A
+    _LOGGER.warning("script_scan_otb_map invoked - expect a lot of nonsense")
+
+    RAMSES_TO_OPENTHERM = {
+        Code._22D9: "01",  # boiler setpoint         / ControlSetpoint
+        Code._3EF1: "11",  # rel. modulation level   / RelativeModulationLevel
+        Code._1300: "12",  # cv water pressure       / CHWaterPressure
+        Code._12F0: "13",  # dhw_flow_rate           / DHWFlowRate
+        Code._3200: "19",  # boiler output temp      / BoilerWaterTemperature
+        Code._1260: "1A",  # dhw temp                / DHWTemperature
+        Code._1290: "1B",  # outdoor temp            / OutsideTemperature
+        Code._3210: "1C",  # boiler return temp      / ReturnWaterTemperature
+        Code._10A0: "38",  # dhw params[SZ_SETPOINT] / DHWSetpoint
+        Code._1081: "39",  # max ch setpoint         / MaxCHWaterSetpoint
+    }
+
+    for code, msg_id in RAMSES_TO_OPENTHERM.items():
+        gwy.send_cmd(Command.from_attrs(RQ, dev_id, code, "00"), priority=Priority.LOW)
+        gwy.send_cmd(Command.get_opentherm_data(dev_id, msg_id), priority=Priority.LOW)
+
+
+@script_decorator
+async def script_scan_otb_ramses(
+    gwy: Gateway, dev_id: DeviceIdT
+) -> None:  # Tested only upon a R8820A
+    _LOGGER.warning("script_scan_otb_ramses invoked - expect a lot of nonsense")
+
+    _CODES = (
+        Code._042F,
+        Code._10E0,  # device_info
+        Code._10E1,  # device_id
+        Code._1FD0,
+        Code._2400,
+        Code._2401,
+        Code._2410,
+        Code._2420,
+        Code._1300,  # cv water pressure      / CHWaterPressure
+        Code._1081,  # max ch setpoint        / MaxCHWaterSetpoint
+        Code._10A0,  # dhw params[SZ_SETPOINT] / DHWSetpoint
+        Code._22D9,  # boiler setpoint        / ControlSetpoint
+        Code._1260,  # dhw temp               / DHWTemperature
+        Code._1290,  # outdoor temp           / OutsideTemperature
+        Code._3200,  # boiler output temp     / BoilerWaterTemperature
+        Code._3210,  # boiler return temp     / ReturnWaterTemperature
+        Code._0150,
+        Code._12F0,  # dhw flow rate          / DHWFlowRate
+        Code._1098,
+        Code._10B0,
+        Code._3221,
+        Code._3223,
+        Code._3EF0,  # rel. modulation level  / RelativeModulationLevel (also, below)
+        Code._3EF1,  # rel. modulation level  / RelativeModulationLevel
+    )  # excl. 3220
+
+    for c in _CODES:
+        gwy.send_cmd(Command.from_attrs(RQ, dev_id, c, "00"), priority=Priority.LOW)
+
+
+SCRIPTS = {
+    k[7:]: v for k, v in locals().items() if callable(v) and k.startswith("script_")
+}

ramses_cli/utils/cat_slow.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+import argparse
+from time import sleep
+
+# python utils/cat_slow.py -i packet.log | tee /dev/pts/0
+# cat packet.log | cut -d ' ' -f 2- | unix2dos | pv --quiet --line-mode --rate-limit 1 | tee /dev/pts/3
+
+parser = argparse.ArgumentParser(description="Echo a file slowly")
+parser.add_argument("-i", "--input-file", type=argparse.FileType("r"), default="-")
+parser.add_argument("-d", "--delay-in-ms", type=int, default="100")
+args = parser.parse_args()
+
+for line in args.input_file:
+    if "RQ" in line:
+        continue
+    print(line.rstrip()[27:])
+    sleep(args.delay_in_ms / 1000.0)

ramses_cli/utils/convert.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""RAMSES RF - a RAMSES-II protocol decoder & analyser.
+
+WIP - Utility to a configuration file from JSON to YAML & back.
+"""
+
+import argparse
+import json
+
+import yaml
+
+from ramses_rf.helpers import shrink
+from ramses_rf.schemas import load_config
+
+parser = argparse.ArgumentParser(description="Convert a file JSON <-> YAML")
+parser.add_argument("-i", "--input-file", type=argparse.FileType("r"), default="-")
+args = parser.parse_args()
+
+
+def convert_json_to_yaml(data: dict) -> str:
+    """Convert from json (client.py -C config.json) to yaml (HA configuration.yaml)."""
+    (config, schema, include, exclude) = load_config("/dev/ttyMOCK", None, **data)
+
+    config = vars(config)
+    config["use_regex"]["inbound"].pop("( 03:.* 03:.* (1060|2389|30C9) 003) ..")  # HACK
+
+    result = {
+        "serial_port": "/dev/ttyMOCK",
+        "packet_log": None,
+        "restore_cache": False,
+        "ramses_rf": shrink(config),
+        "schema": shrink(schema),
+        "known_list": {k: shrink(v) for k, v in include.items()},
+        "block_list": shrink(exclude),
+    }
+
+    print(yaml.dump({"ramses_cc": result}, sort_keys=False))
+
+
+def convert_yaml_to_json(data: dict) -> str:
+    """Convert from yaml (HA configuration.yaml) to json (client.py -C config.json)."""
+
+    result = data["ramses_cc"]
+    result["config"] = result.pop("ramses_rf", {})
+    result.update(result.pop("schema", {}))
+
+    result["orphans_heat"] = {}
+    result["orphans_hvac"] = {}
+    result["known_list"] = result.pop("known_list", {})
+    result["block_list"] = result.pop("block_list", {})
+
+    print(json.dumps(result, indent=4))
+
+
+data_file = args.input_file.read()
+
+try:
+    convert_json_to_yaml(json.loads(data_file))
+except json.JSONDecodeError:
+    convert_yaml_to_json(yaml.safe_load(data_file))

ramses_rf/__init__.py

@@ -1,6 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
 """RAMSES RF - a RAMSES-II protocol decoder & analyser.
 
 Works with (amongst others):
@@ -8,30 +6,53 @@ Works with (amongst others):
 - sundial (up to 2 zones)
 - chronotherm (CM60xNG can do 4 zones)
 - hometronics (16? zones)
+- vision pro
 """
+
 from __future__ import annotations
 
 import logging
+from typing import TYPE_CHECKING
+
+from ramses_tx import Address, Command, Message, Packet  # noqa: F401
 
-from .const import __dev_mode__
+from .device import Device  # noqa: F401
 from .gateway import Gateway  # noqa: F401
-from .protocol import is_valid_dev_id  # noqa: F401
 from .version import VERSION  # noqa: F401
 
-# skipcq: PY-W2000
-from .protocol import (  # noqa: F401, isort: skip, pylint: disable=unused-import
+from .const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
     I_,
     RP,
     RQ,
     W_,
+    Code,
 )
 
-# skipcq: PY-W2000
-DEV_MODE = __dev_mode__ and False
+if TYPE_CHECKING:
+    from .const import IndexT, VerbT  # noqa: F401, pylint: disable=unused-import
+
+
+__all__ = [
+    "VERSION",
+    "Gateway",
+    #
+    "Address",
+    "Command",
+    "Device",
+    "Message",
+    "Packet",
+    #
+    "I_",
+    "RP",
+    "RQ",
+    "W_",
+    #
+    "Code",
+    "IndexT",
+    "VerbT",
+]
 
 _LOGGER = logging.getLogger(__name__)
-if DEV_MODE:
-    _LOGGER.setLevel(logging.DEBUG)
 
 
 class GracefulExit(SystemExit):