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

ramses_rf/device/heat.py

@@ -1,27 +1,22 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-"""RAMSES RF - a RAMSES-II protocol decoder & analyser.
+"""RAMSES RF - devices from the CH/DHW (heat) domain."""
 
-Heating devices.
-"""
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Callable
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Final
 
-from ..const import (
+from ramses_rf import exceptions as exc
+from ramses_rf.const import (
     DEV_ROLE_MAP,
-    DEV_TYPE,
     DEV_TYPE_MAP,
     DOMAIN_TYPE_MAP,
     SZ_DEVICES,
     SZ_DOMAIN_ID,
     SZ_HEAT_DEMAND,
     SZ_PRESSURE,
-    SZ_PRIORITY,
     SZ_RELAY_DEMAND,
-    SZ_RETRIES,
     SZ_SETPOINT,
     SZ_TEMPERATURE,
     SZ_UFH_IDX,
@@ -30,92 +25,100 @@ from ..const import (
     SZ_ZONE_MASK,
     SZ_ZONE_TYPE,
     ZON_ROLE_MAP,
-    __dev_mode__,
+    DevType,
 )
-from ..entity_base import Entity, Parent, class_by_attr
-from ..helpers import shrink
-from ..protocol.address import NON_DEV_ADDR
-from ..protocol.command import Command, Priority, _mk_cmd
-from ..protocol.const import SZ_BINDINGS
-from ..protocol.exceptions import InvalidPayloadError
-from ..protocol.opentherm import (
-    MSG_ID,
-    MSG_NAME,
-    MSG_TYPE,
-    PARAMS_MSG_IDS,
-    SCHEMA_MSG_IDS,
-    STATUS_MSG_IDS,
-    VALUE,
+from ramses_rf.device import Device
+from ramses_rf.entity_base import Child, Entity, Parent, class_by_attr
+from ramses_rf.helpers import shrink
+from ramses_rf.schemas import SCH_TCS, SZ_ACTUATORS, SZ_CIRCUITS
+from ramses_tx import NON_DEV_ADDR, Command, Priority
+from ramses_tx.const import SZ_NUM_REPEATS, SZ_PRIORITY, MsgId
+from ramses_tx.opentherm import (
+    PARAMS_DATA_IDS,
+    SCHEMA_DATA_IDS,
+    STATUS_DATA_IDS,
+    SZ_MSG_ID,
+    SZ_MSG_NAME,
+    SZ_MSG_TYPE,
+    SZ_VALUE,
     OtMsgType,
 )
-from ..protocol.ramses import CODES_OF_HEAT_DOMAIN_ONLY, CODES_ONLY_FROM_CTL
-from ..schemas import SCH_TCS, SZ_ACTUATORS, SZ_CIRCUITS
-from .base import BatteryState, Device, DeviceHeat, Fakeable
+from ramses_tx.ramses import CODES_OF_HEAT_DOMAIN_ONLY, CODES_ONLY_FROM_CTL
+from ramses_tx.typed_dicts import PayDictT
 
-# skipcq: PY-W2000
-from ..const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
-    I_,
-    RP,
-    RQ,
-    W_,
+from .base import BatteryState, DeviceHeat, Fakeable
+
+from ramses_rf.const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
     F9,
     FA,
     FC,
     FF,
+)
+
+from ramses_rf.const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
+    I_,
+    RP,
+    RQ,
+    W_,
     Code,
 )
 
+from ramses_tx.const import (
+    SZ_BOILER_OUTPUT_TEMP,
+    SZ_BOILER_RETURN_TEMP,
+    SZ_BOILER_SETPOINT,
+    SZ_BURNER_FAILED_STARTS,
+    SZ_BURNER_HOURS,
+    SZ_BURNER_STARTS,
+    SZ_CH_ACTIVE,
+    SZ_CH_ENABLED,
+    SZ_CH_MAX_SETPOINT,
+    SZ_CH_PUMP_HOURS,
+    SZ_CH_PUMP_STARTS,
+    SZ_CH_SETPOINT,
+    SZ_CH_WATER_PRESSURE,
+    SZ_COOLING_ACTIVE,
+    SZ_COOLING_ENABLED,
+    SZ_DHW_ACTIVE,
+    SZ_DHW_BLOCKING,
+    SZ_DHW_BURNER_HOURS,
+    SZ_DHW_BURNER_STARTS,
+    SZ_DHW_ENABLED,
+    SZ_DHW_FLOW_RATE,
+    SZ_DHW_PUMP_HOURS,
+    SZ_DHW_PUMP_STARTS,
+    SZ_DHW_SETPOINT,
+    SZ_DHW_TEMP,
+    SZ_FAULT_PRESENT,
+    SZ_FLAME_ACTIVE,
+    SZ_FLAME_SIGNAL_LOW,
+    SZ_MAX_REL_MODULATION,
+    SZ_OEM_CODE,
+    SZ_OTC_ACTIVE,
+    SZ_OUTSIDE_TEMP,
+    SZ_REL_MODULATION_LEVEL,
+    SZ_SUMMER_MODE,
+)
+
 if TYPE_CHECKING:
-    from ..protocol import Address, Message
-    from ..system import Zone
-
-
-SZ_BURNER_HOURS = "burner_hours"
-SZ_BURNER_STARTS = "burner_starts"
-SZ_BURNER_FAILED_STARTS = "burner_failed_starts"
-SZ_CH_PUMP_HOURS = "ch_pump_hours"
-SZ_CH_PUMP_STARTS = "ch_pump_starts"
-SZ_DHW_BURNER_HOURS = "dhw_burner_hours"
-SZ_DHW_BURNER_STARTS = "dhw_burner_starts"
-SZ_DHW_PUMP_HOURS = "dhw_pump_hours"
-SZ_DHW_PUMP_STARTS = "dhw_pump_starts"
-SZ_FLAME_SIGNAL_LOW = "flame_signal_low"
-
-SZ_BOILER_OUTPUT_TEMP = "boiler_output_temp"
-SZ_BOILER_RETURN_TEMP = "boiler_return_temp"
-SZ_BOILER_SETPOINT = "boiler_setpoint"
-SZ_CH_MAX_SETPOINT = "ch_max_setpoint"
-SZ_CH_SETPOINT = "ch_setpoint"
-SZ_CH_WATER_PRESSURE = "ch_water_pressure"
-SZ_DHW_FLOW_RATE = "dhw_flow_rate"
-SZ_DHW_SETPOINT = "dhw_setpoint"
-SZ_DHW_TEMP = "dhw_temp"
-SZ_MAX_REL_MODULATION = "max_rel_modularion"
-SZ_OEM_CODE = "oem_code"
-SZ_OUTSIDE_TEMP = "outside_temp"
-SZ_REL_MODULATION_LEVEL = "rel_modulation_level"
-
-SZ_CH_ACTIVE = "ch_active"
-SZ_CH_ENABLED = "ch_enabled"
-SZ_COOLING_ACTIVE = "cooling_active"
-SZ_COOLING_ENABLED = "cooling_enabled"
-SZ_DHW_ACTIVE = "dhw_active"
-SZ_DHW_BLOCKING = "dhw_blocking"
-SZ_DHW_ENABLED = "dhw_enabled"
-SZ_FAULT_PRESENT = "fault_present"
-SZ_FLAME_ACTIVE = "flame_active"
-SZ_SUMMER_MODE = "summer_mode"
-SZ_OTC_ACTIVE = "otc_active"
-
-
-DEV_MODE = __dev_mode__  # and False
+    from ramses_rf.system import Evohome, Zone
+    from ramses_tx import Address, Message, Packet
+    from ramses_tx.opentherm import OtDataId
+
+
+QOS_LOW = {SZ_PRIORITY: Priority.LOW}  # FIXME:  deprecate QoS in kwargs
+QOS_MID = {SZ_PRIORITY: Priority.HIGH}  # FIXME: deprecate QoS in kwargs
+QOS_MAX = {SZ_PRIORITY: Priority.HIGH, SZ_NUM_REPEATS: 3}  # FIXME: deprecate QoS...
+
+#
+# NOTE: All debug flags should be False for deployment to end-users
+_DBG_ENABLE_DEPRECATION: Final[bool] = False
+_DBG_EXTRA_OTB_DISCOVERY: Final[bool] = False
 
 _LOGGER = logging.getLogger(__name__)
-if DEV_MODE:
-    _LOGGER.setLevel(logging.DEBUG)
 
 
-class Actuator(Fakeable, DeviceHeat):  # 3EF0, 3EF1 (for 10:/13:)
+class Actuator(DeviceHeat):  # 3EF0, 3EF1 (for 10:/13:)
     # .I --- 13:109598 --:------ 13:109598 3EF0 003 00C8FF                # event-driven, 00/C8
     # RP --- 13:109598 18:002563 --:------ 0008 002 00C8                  # 00/C8, as abobe
     # RP --- 13:109598 18:002563 --:------ 3EF1 007 0000BF-00BFC8FF       # 00/C8, as above
@@ -127,10 +130,10 @@ class Actuator(Fakeable, DeviceHeat):  # 3EF0, 3EF1 (for 10:/13:)
     # RP --- 10:138926 34:010253 --:------ 3EF0 006 002E11-0000FF         # 10:s only RP
     # .I --- 13:209679 --:------ 13:209679 3EF0 003 00C8FF                # 13:s only  I
 
-    ACTUATOR_CYCLE = "actuator_cycle"
-    ACTUATOR_ENABLED = "actuator_enabled"  # boolean
-    ACTUATOR_STATE = "actuator_state"
-    MODULATION_LEVEL = "modulation_level"  # percentage (0.0-1.0)
+    ACTUATOR_CYCLE: Final = "actuator_cycle"
+    ACTUATOR_ENABLED: Final = "actuator_enabled"  # boolean
+    ACTUATOR_STATE: Final = "actuator_state"
+    MODULATION_LEVEL: Final = "modulation_level"  # percentage (0.0-1.0)
 
     def _handle_msg(self, msg: Message) -> None:  # NOTE: active
         super()._handle_msg(msg)
@@ -138,22 +141,22 @@ class Actuator(Fakeable, DeviceHeat):  # 3EF0, 3EF1 (for 10:/13:)
         if isinstance(self, OtbGateway):
             return
 
-        if (
-            msg.code == Code._3EF0
-            and msg.verb == I_  # will be a 13:
-            and not self._faked
-            and not self._gwy.config.disable_discovery
-            and not self._gwy.config.disable_sending
-        ):
-            # self._make_cmd(Code._0008, qos={SZ_PRIORITY: Priority.LOW, SZ_RETRIES: 1})
-            self._make_cmd(Code._3EF1, qos={SZ_PRIORITY: Priority.LOW, SZ_RETRIES: 1})
+        if self._gwy.config.disable_discovery:
+            return
+
+        # TODO: why are we doing this here? Should simply use dscovery poller!
+        if msg.code == Code._3EF0 and msg.verb == I_ and not self.is_faked:
+            # lf._send_cmd(Command.get_relay_demand(self.id), qos=QOS_LOW)
+            self._send_cmd(
+                Command.from_attrs(RQ, self.id, Code._3EF1, "00"), **QOS_LOW
+            )  # actuator cycle
 
     @property
-    def actuator_cycle(self) -> None | dict:  # 3EF1
+    def actuator_cycle(self) -> dict | None:  # 3EF1
         return self._msg_value(Code._3EF1)
 
     @property
-    def actuator_state(self) -> None | dict:  # 3EF0
+    def actuator_state(self) -> dict | None:  # 3EF0
         return self._msg_value(Code._3EF0)
 
     @property
@@ -166,11 +169,10 @@ class Actuator(Fakeable, DeviceHeat):  # 3EF0, 3EF1 (for 10:/13:)
 
 
 class HeatDemand(DeviceHeat):  # 3150
-
-    HEAT_DEMAND = SZ_HEAT_DEMAND  # percentage valve open (0.0-1.0)
+    HEAT_DEMAND: Final = SZ_HEAT_DEMAND  # percentage valve open (0.0-1.0)
 
     @property
-    def heat_demand(self) -> None | float:  # 3150
+    def heat_demand(self) -> float | None:  # 3150
         return self._msg_value(Code._3150, key=self.HEAT_DEMAND)
 
     @property
@@ -182,11 +184,10 @@ class HeatDemand(DeviceHeat):  # 3150
 
 
 class Setpoint(DeviceHeat):  # 2309
-
-    SETPOINT = SZ_SETPOINT  # degrees Celsius
+    SETPOINT: Final = SZ_SETPOINT  # degrees Celsius
 
     @property
-    def setpoint(self) -> None | float:  # 2309
+    def setpoint(self) -> float | None:  # 2309
         return self._msg_value(Code._2309, key=self.SETPOINT)
 
     @property
@@ -197,35 +198,22 @@ class Setpoint(DeviceHeat):  # 2309
         }
 
 
-class Weather(Fakeable, DeviceHeat):  # 0002
-
-    TEMPERATURE = SZ_TEMPERATURE  # degrees Celsius
-
-    def _bind(self):
-        #
-        #
-        #
-
-        def callback(msg):
-            pass
-
-        super()._bind()
-        self._bind_request(Code._0002, callback=callback)
+class Weather(DeviceHeat):  # 0002
+    TEMPERATURE: Final = SZ_TEMPERATURE  # TODO: deprecate
 
     @property
-    def temperature(self) -> None | float:  # 0002
-        return self._msg_value(Code._0002, key=self.TEMPERATURE)
+    def temperature(self) -> float | None:  # 0002
+        return self._msg_value(Code._0002, key=SZ_TEMPERATURE)
 
-    # @check_faking_enabled
     @temperature.setter
-    def temperature(self, value) -> None:  # 0002
-        if not self._faked:
-            raise RuntimeError(f"Faking is not enabled for {self}")
+    def temperature(self, value: float | None) -> None:
+        """Fake the outdoor temperature of the sensor."""
+
+        if not self.is_faked:
+            raise exc.DeviceNotFaked(f"{self}: Faking is not enabled")
+
         cmd = Command.put_outdoor_temp(self.id, value)
-        # cmd = Command.put_zone_temp(
-        #     self._gwy.hgi.id if self == self._gwy.hgi._faked_thm else self.id, value
-        # )
-        self._send_cmd(cmd)
+        self._gwy.send_cmd(cmd, num_repeats=2, priority=Priority.HIGH)
 
     @property
     def status(self) -> dict[str, Any]:
@@ -235,7 +223,11 @@ class Weather(Fakeable, DeviceHeat):  # 0002
         }
 
 
-class RelayDemand(Fakeable, DeviceHeat):  # 0008
+class RelayDemand(DeviceHeat):  # 0008
+    # .I --- 01:054173 --:------ 01:054173 1FC9 018 03-0008-04D39D FC-3B00-04D39D 03-1FC9-04D39D
+    # .W --- 13:123456 01:054173 --:------ 1FC9 006 00-3EF0-35E240
+    # .I --- 01:054173 13:123456 --:------ 1FC9 006 00-FFFF-04D39D
+
     # Some either 00/C8, others 00-C8
     # .I --- 01:145038 --:------ 01:145038 0008 002 0314  # ZON valve zone (ELE too?)
     # .I --- 01:145038 --:------ 01:145038 0008 002 F914  # HTG valve
@@ -245,72 +237,16 @@ class RelayDemand(Fakeable, DeviceHeat):  # 0008
     # RP --- 13:109598 18:199952 --:------ 0008 002 0000
     # RP --- 13:109598 18:199952 --:------ 0008 002 00C8
 
-    RELAY_DEMAND = SZ_RELAY_DEMAND  # percentage (0.0-1.0)
+    RELAY_DEMAND: Final = SZ_RELAY_DEMAND  # percentage (0.0-1.0)
 
     def _setup_discovery_cmds(self) -> None:
         super()._setup_discovery_cmds()
 
-        if not self._faked:  # discover_flag & Discover.STATUS and
+        if not self.is_faked:  # discover_flag & Discover.STATUS and
             self._add_discovery_cmd(Command.get_relay_demand(self.id), 60 * 15)
 
-    def _handle_msg(self, msg: Message) -> None:  # NOTE: active
-        if msg.src.id == self.id:
-            super()._handle_msg(msg)
-            return
-
-        if (
-            self._gwy.config.disable_sending
-            or not self._faked
-            or self._child_id is None
-            or self._child_id
-            not in (
-                v for k, v in msg.payload.items() if k in (SZ_DOMAIN_ID, SZ_ZONE_IDX)
-            )
-        ):
-            return
-
-        if msg.code == Code._3EF0 and msg.verb == I_:  # NOT RP
-            # should't use for RP as RQ's might be polled quite often
-            cmd = Command.get_relay_demand(self.id)
-            self._send_cmd(cmd, qos={SZ_PRIORITY: Priority.LOW, SZ_RETRIES: 1})
-
-        # elif msg.code == Code._0009:  # can only be I, from a controller
-        # elif msg.code == Code._3B00...:
-
-        if not self._faked or msg.verb != RQ:  # duplicated, above
-            return
-
-        # TODO: handle relay_failsafe, reply to RQs
-        if msg.code == Code._0008 and msg.verb == RQ:  # NOTE: WIP for FAKING
-            # 076  I --- 01:054173 --:------ 01:054173 0008 002 037C
-            mod_level = msg.payload[self.RELAY_DEMAND]
-            if mod_level is not None:
-                mod_level = 1.0 if mod_level > 0 else 0
-
-            cmd = Command.put_actuator_state(self.id, mod_level)
-            qos = {SZ_PRIORITY: Priority.HIGH, SZ_RETRIES: 3}
-            [self._send_cmd(cmd, **qos) for _ in range(1)]  # type: ignore[func-returns-value]
-
-        elif msg.code == Code._3EF1 and msg.verb == RQ:  # NOTE: WIP for FAKING
-            mod_level = 1.0
-
-            cmd = Command.put_actuator_cycle(self.id, msg.src.id, mod_level, 600, 600)
-            qos = {SZ_PRIORITY: Priority.HIGH, SZ_RETRIES: 3}
-            [self._send_cmd(cmd, **qos) for _ in range(1)]  # type: ignore[func-returns-value]
-
-    def _bind(self):
-        # .I --- 01:054173 --:------ 01:054173 1FC9 018 03-0008-04D39D FC-3B00-04D39D 03-1FC9-04D39D
-        # .W --- 13:123456 01:054173 --:------ 1FC9 006 00-3EF0-35E240
-        # .I --- 01:054173 13:123456 --:------ 1FC9 006 00-FFFF-04D39D
-
-        def callback(msg):
-            pass
-
-        super()._bind()
-        self._bind_waiting(Code._3EF0, callback=callback)
-
     @property
-    def relay_demand(self) -> None | float:  # 0008
+    def relay_demand(self) -> float | None:  # 0008
         return self._msg_value(Code._0008, key=self.RELAY_DEMAND)
 
     @property
@@ -321,32 +257,22 @@ class RelayDemand(Fakeable, DeviceHeat):  # 0008
         }
 
 
-class DhwTemperature(Fakeable, DeviceHeat):  # 1260
-
-    TEMPERATURE = SZ_TEMPERATURE  # degrees Celsius
-
-    def _bind(self):
-        #
-        #
-        #
-
-        def callback(msg):
-            self.set_parent(msg.src, child_id=FA, is_sensor=True)
-
-        super()._bind()
-        self._bind_request(Code._1260, callback=callback)
+class DhwTemperature(DeviceHeat):  # 1260
+    TEMPERATURE: Final = SZ_TEMPERATURE  # TODO: deprecate
 
     @property
-    def temperature(self) -> None | float:  # 1260
-        return self._msg_value(Code._1260, key=self.TEMPERATURE)
+    def temperature(self) -> float | None:  # 1260
+        return self._msg_value(Code._1260, key=SZ_TEMPERATURE)
 
-    # @check_faking_enabled
     @temperature.setter
-    def temperature(self, value) -> None:  # 1260
-        if not self._faked:
-            raise RuntimeError(f"Faking is not enabled for {self}")
-        self._send_cmd(Command.put_dhw_temp(value))
-        # lf._send_cmd(Command.get_dhw_temp(self.ctl.id, self.zone.idx))
+    def temperature(self, value: float | None) -> None:
+        """Fake the DHW temperature of the sensor."""
+
+        if not self.is_faked:
+            raise exc.DeviceNotFaked(f"{self}: Faking is not enabled")
+
+        cmd = Command.put_dhw_temp(self.id, value)
+        self._gwy.send_cmd(cmd, num_repeats=2, priority=Priority.HIGH)
 
     @property
     def status(self) -> dict[str, Any]:
@@ -356,31 +282,23 @@ class DhwTemperature(Fakeable, DeviceHeat):  # 1260
         }
 
 
-class Temperature(Fakeable, DeviceHeat):  # 30C9
-    def _bind(self):
-        # .I --- 34:145039 --:------ 34:145039 1FC9 012 00-30C9-8A368F 00-1FC9-8A368F
-        # .W --- 01:054173 34:145039 --:------ 1FC9 006 03-2309-04D39D  # real CTL
-        # .I --- 34:145039 01:054173 --:------ 1FC9 006 00-30C9-8A368F
-
-        def callback(msg):  # TODO: needs work
-            """Use the accept pkt to determine the zone/domain id."""
-            child_id = msg.payload[SZ_BINDINGS][0][0]
-            self.set_parent(msg.src, child_id=child_id, is_sensor=True)
-
-        super()._bind()
-        self._bind_request(Code._30C9, callback=callback)
-
+class Temperature(DeviceHeat):  # 30C9
+    # .I --- 34:145039 --:------ 34:145039 1FC9 012 00-30C9-8A368F 00-1FC9-8A368F
+    # .W --- 01:054173 34:145039 --:------ 1FC9 006 03-2309-04D39D  # real CTL
+    # .I --- 34:145039 01:054173 --:------ 1FC9 006 00-30C9-8A368F
     @property
-    def temperature(self) -> None | float:  # degrees Celsius
+    def temperature(self) -> float | None:  # 30C9
         return self._msg_value(Code._30C9, key=SZ_TEMPERATURE)
 
-    # @check_faking_enabled
     @temperature.setter
-    def temperature(self, value) -> None:
-        if not self._faked:
-            raise RuntimeError(f"Faking is not enabled for {self}")
-        self._send_cmd(Command.put_sensor_temp(self.id, value))
-        # lf._send_cmd(Command.get_zone_temp(self.ctl.id, self.zone.idx))
+    def temperature(self, value: float | None) -> None:
+        """Fake the indoor temperature of the sensor."""
+
+        if not self.is_faked:
+            raise exc.DeviceNotFaked(f"{self}: Faking is not enabled")
+
+        cmd = Command.put_sensor_temp(self.id, value)
+        self._gwy.send_cmd(cmd, num_repeats=2, priority=Priority.HIGH)
 
     @property
     def status(self) -> dict[str, Any]:
@@ -393,15 +311,19 @@ class Temperature(Fakeable, DeviceHeat):  # 30C9
 class RfgGateway(DeviceHeat):  # RFG (30:)
     """The RFG100 base class."""
 
-    _SLUG: str = DEV_TYPE.RFG
+    _SLUG = DevType.RFG
+    _STATE_ATTR = None
 
 
 class Controller(DeviceHeat):  # CTL (01):
     """The Controller base class."""
 
-    _SLUG: str = DEV_TYPE.CTL
+    HEAT_DEMAND: Final = SZ_HEAT_DEMAND
 
-    def __init__(self, *args, **kwargs) -> None:
+    _SLUG = DevType.CTL
+    _STATE_ATTR = HEAT_DEMAND
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         # self.ctl = None
@@ -413,10 +335,12 @@ class Controller(DeviceHeat):  # CTL (01):
 
         self.tcs._handle_msg(msg)
 
-    def _make_tcs_controller(self, *, msg=None, **schema) -> None:  # CH/DHW
+    def _make_tcs_controller(
+        self, *, msg: Message | None = None, **schema: Any
+    ) -> None:  # CH/DHW
         """Attach a TCS (create/update as required) after passing it any msg."""
 
-        def get_system(*, msg=None, **schema) -> Any:  # System:
+        def get_system(*, msg: Message | None = None, **schema: Any) -> Evohome:
             """Return a TCS (temperature control system), create it if required.
 
             Use the schema to create/update it, then pass it any msg to handle.
@@ -425,7 +349,7 @@ class Controller(DeviceHeat):  # CTL (01):
             If a TCS is created, attach it to this device (which should be a CTL).
             """
 
-            from ..system import system_factory
+            from ramses_rf.system import system_factory
 
             schema = shrink(SCH_TCS(schema))
 
@@ -447,17 +371,21 @@ class Controller(DeviceHeat):  # CTL (01):
 class Programmer(Controller):  # PRG (23):
     """The Controller base class."""
 
-    _SLUG: str = DEV_TYPE.PRG
+    _SLUG = DevType.PRG
 
 
 class UfhController(Parent, DeviceHeat):  # UFC (02):
     """The UFC class, the HCE80 that controls the UFH zones."""
 
-    _SLUG: str = DEV_TYPE.UFC
+    HEAT_DEMAND: Final = SZ_HEAT_DEMAND
 
-    HEAT_DEMAND = SZ_HEAT_DEMAND
+    _SLUG = DevType.UFC
+    _STATE_ATTR = HEAT_DEMAND
 
-    _STATE_ATTR = SZ_HEAT_DEMAND
+    _child_id = FA
+    _iz_controller = True
+
+    childs: list[UfhCircuit]  # TODO: check (code so complex, not sure if this is true)
 
     # 12:27:24.398 067  I --- 02:000921 --:------ 01:191718 3150 002 0360
     # 12:27:24.546 068  I --- 02:000921 --:------ 01:191718 3150 002 065A
@@ -465,44 +393,38 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
     # 12:27:24.824 059  I --- 01:191718 --:------ 01:191718 3150 002 FC5C
     # 12:27:24.857 067  I --- 02:000921 --:------ 02:000921 3150 006 0060-015A-025C
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
-        self._child_id = FA  # NOTE: domain_id, HACK: UFC
-
         self.circuit_by_id = {f"{i:02X}": {} for i in range(8)}
 
-        self._setpoints: Message = None  # type: ignore[assignment]
-        self._heat_demand: Message = None  # type: ignore[assignment]
-        self._heat_demands: Message = None  # type: ignore[assignment]
-        self._relay_demand: Message = None  # type: ignore[assignment]
-        self._relay_demand_fa: Message = None  # type: ignore[assignment]
-
-        self._iz_controller = True
+        self._setpoints: Message | None = None
+        self._heat_demand: Message | None = None
+        self._heat_demands: Message | None = None
+        self._relay_demand: Message | None = None
+        self._relay_demand_fa: Message | None = None
 
     def _setup_discovery_cmds(self) -> None:
         super()._setup_discovery_cmds()
 
         # Only RPs are: 0001, 0005/000C, 10E0, 000A/2309 & 22D0
 
-        self._add_discovery_cmd(
-            _mk_cmd(RQ, Code._0005, f"00{DEV_ROLE_MAP.UFH}", self.id), 60 * 60 * 24
-        )
+        cmd = Command.from_attrs(RQ, self.id, Code._0005, f"00{DEV_ROLE_MAP.UFH}")
+        self._add_discovery_cmd(cmd, 60 * 60 * 24)
+
         # TODO: this needs work
         # if discover_flag & Discover.PARAMS:  # only 2309 has any potential?
         for ufc_idx in self.circuit_by_id:
-            self._add_discovery_cmd(
-                _mk_cmd(RQ, Code._000A, ufc_idx, self.id), 60 * 60 * 6
-            )
-            self._add_discovery_cmd(
-                _mk_cmd(RQ, Code._2309, ufc_idx, self.id), 60 * 60 * 6
-            )
+            cmd = Command.get_zone_config(self.id, ufc_idx)
+            self._add_discovery_cmd(cmd, 60 * 60 * 6)
+
+            cmd = Command.get_zone_setpoint(self.id, ufc_idx)
+            self._add_discovery_cmd(cmd, 60 * 60 * 6)
 
-        for ufc_idx in range(8):  # type: ignore[assignment]
+        for ufc_idx in range(8):
             payload = f"{ufc_idx:02X}{DEV_ROLE_MAP.UFH}"
-            self._add_discovery_cmd(
-                _mk_cmd(RQ, Code._000C, payload, self.id), 60 * 60 * 24
-            )
+            cmd = Command.from_attrs(RQ, self.id, Code._000C, payload)
+            self._add_discovery_cmd(cmd, 60 * 60 * 24)
 
     def _handle_msg(self, msg: Message) -> None:
         super()._handle_msg(msg)
@@ -521,8 +443,12 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
                 ufh_idx = f"{idx:02X}"
                 if not flag:
                     self.circuit_by_id[ufh_idx] = {SZ_ZONE_IDX: None}
-                elif SZ_ZONE_IDX not in self.circuit_by_id[ufh_idx]:
-                    self._make_cmd(Code._000C, payload=f"{ufh_idx}{DEV_ROLE_MAP.UFH}")
+                # FIXME: this causing tests to fail when read-only protocol
+                # elif SZ_ZONE_IDX not in self.circuit_by_id[ufh_idx]:
+                #     cmd = Command.from_attrs(
+                #         RQ, self.ctl.id, Code._000C, f"{ufh_idx}{DEV_ROLE_MAP.UFH}"
+                #     )
+                #     self._send_cmd(cmd)
 
         elif msg.code == Code._0008:  # relay_demand, TODO: use msg DB?
             if msg.payload.get(SZ_DOMAIN_ID) == FC:
@@ -545,7 +471,7 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
                     # child_id=msg.payload[SZ_ZONE_IDX],
                 )
 
-        elif msg.code == Code._22C9:  # ufh_setpoints
+        elif msg.code == Code._22C9:  # setpoint_bounds
             # .I --- 02:017205 --:------ 02:017205 22C9 024 00076C0A280101076C0A28010...
             # .I --- 02:017205 --:------ 02:017205 22C9 006 04076C0A2801
             self._setpoints = msg
@@ -557,6 +483,7 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
                 self._heat_demand = msg
             elif (
                 (zone_idx := msg.payload.get(SZ_ZONE_IDX))
+                and isinstance(msg.dst, Device)
                 and (tcs := msg.dst.tcs)
                 and (zone := tcs.zone_by_idx.get(zone_idx))
             ):
@@ -567,7 +494,10 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
 
         # "0008|FA/FC", "22C9|array", "22D0|none", "3150|ZZ/array(/FC?)"
 
-    def get_circuit(self, cct_idx, *, msg=None, **schema) -> Any:
+    # TODO: should be a private method
+    def get_circuit(
+        self, cct_idx: str, *, msg: Message | None = None, **schema: Any
+    ) -> Any:
         """Return a UFH circuit, create it if required.
 
         First, use the schema to create/update it, then pass it any msg to handle.
@@ -578,7 +508,7 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
 
         schema = {}  # shrink(SCH_CCT(schema))
 
-        cct = self.child_by_id.get(cct_idx)
+        cct: UfhCircuit = self.child_by_id.get(cct_idx)
         if not cct:
             cct = UfhCircuit(self, cct_idx)
             self.child_by_id[cct_idx] = cct
@@ -596,26 +526,26 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
     #     return self.circuit_by_id
 
     @property
-    def heat_demand(self) -> None | float:  # 3150|FC (there is also 3150|FA)
+    def heat_demand(self) -> float | None:  # 3150|FC (there is also 3150|FA)
         return self._msg_value_msg(self._heat_demand, key=self.HEAT_DEMAND)
 
     @property
-    def heat_demands(self) -> None | dict:  # 3150|ufh_idx array
+    def heat_demands(self) -> dict | None:  # 3150|ufh_idx array
         # return self._heat_demands.payload if self._heat_demands else None
         return self._msg_value_msg(self._heat_demands)
 
     @property
-    def relay_demand(self) -> None | dict:  # 0008|FC
+    def relay_demand(self) -> dict | None:  # 0008|FC
         return self._msg_value_msg(self._relay_demand, key=SZ_RELAY_DEMAND)
 
     @property
-    def relay_demand_fa(self) -> None | dict:  # 0008|FA
+    def relay_demand_fa(self) -> dict | None:  # 0008|FA
         return self._msg_value_msg(self._relay_demand_fa, key=SZ_RELAY_DEMAND)
 
     @property
-    def setpoints(self) -> None | dict:  # 22C9|ufh_idx array
+    def setpoints(self) -> dict | None:  # 22C9|ufh_idx array
         if self._setpoints is None:
-            return
+            return None
 
         return {
             c[SZ_UFH_IDX]: {
@@ -648,17 +578,15 @@ class UfhController(Parent, DeviceHeat):  # UFC (02):
         }
 
 
-class DhwSensor(DhwTemperature, BatteryState):  # DHW (07): 10A0, 1260
+class DhwSensor(DhwTemperature, BatteryState, Fakeable):  # DHW (07): 10A0, 1260
     """The DHW class, such as a CS92."""
 
-    _SLUG: str = DEV_TYPE.DHW
+    DHW_PARAMS: Final = "dhw_params"
 
-    DHW_PARAMS = "dhw_params"
-    TEMPERATURE = SZ_TEMPERATURE
-
-    _STATE_ATTR = SZ_TEMPERATURE
+    _SLUG: str = DevType.DHW
+    _STATE_ATTR = DhwTemperature.TEMPERATURE
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         self._child_id = FA  # NOTE: domain_id
@@ -666,13 +594,20 @@ class DhwSensor(DhwTemperature, BatteryState):  # DHW (07): 10A0, 1260
     def _handle_msg(self, msg: Message) -> None:  # NOTE: active
         super()._handle_msg(msg)
 
-        # The following is required, as CTLs don't send such every sync_cycle
-        if msg.code == Code._1260 and self.ctl and not self._gwy.config.disable_sending:
+        if self._gwy.config.disable_discovery:
+            return
+
+        # TODO: why are we doing this here? Should simply use dscovery poller!
+        # The following is required, as CTLs don't send spontaneously
+        if msg.code == Code._1260 and self.ctl:
             # update the controller DHW temp
             self._send_cmd(Command.get_dhw_temp(self.ctl.id))
 
+    async def initiate_binding_process(self) -> Packet:
+        return await super()._initiate_binding_process(Code._1260)
+
     @property
-    def dhw_params(self) -> None | dict:  # 10A0
+    def dhw_params(self) -> PayDictT._10A0 | None:
         return self._msg_value(Code._10A0)
 
     @property
@@ -683,95 +618,111 @@ class DhwSensor(DhwTemperature, BatteryState):  # DHW (07): 10A0, 1260
         }
 
 
-class OutSensor(Weather):  # OUT: 17
+class OutSensor(Weather, Fakeable):  # OUT: 17
     """The OUT class (external sensor), such as a HB85/HB95."""
 
-    _SLUG: str = DEV_TYPE.OUT
-
     # LUMINOSITY = "luminosity"  # lux
     # WINDSPEED = "windspeed"  # km/h
 
+    _SLUG = DevType.OUT
     _STATE_ATTR = SZ_TEMPERATURE
 
+    # async def initiate_binding_process(self) -> Packet:
+    #     return await super()._initiate_binding_process(...)
 
+
+def _to_msg_id(data_id: OtDataId) -> MsgId:
+    return f"{data_id:02X}"
+
+
+# NOTE: config.use_native_ot should enforces sends, but not reads from _msgz DB
 class OtbGateway(Actuator, HeatDemand):  # OTB (10): 3220 (22D9, others)
     """The OTB class, specifically an OpenTherm Bridge (R8810A Bridge)."""
 
     # see: https://www.opentherm.eu/request-details/?post_ids=2944
     # see: https://www.automatedhome.co.uk/vbulletin/showthread.php?6400-(New)-cool-mode-in-Evohome
 
-    _SLUG: str = DEV_TYPE.OTB
-
+    _SLUG = DevType.OTB
     _STATE_ATTR = SZ_REL_MODULATION_LEVEL
 
-    OT_TO_RAMSES = {
-        "00": Code._3EF0,  # master/slave status (actuator_state)
-        "01": Code._22D9,  # boiler_setpoint
-        "0E": Code._3EF0,  # max_rel_modulation_level (is a PARAM?)
-        "11": Code._3EF0,  # rel_modulation_level (actuator_state, also Code._3EF1)
-        "12": Code._1300,  # ch_water_pressure
-        "13": Code._12F0,  # dhw_flow_rate
-        "19": Code._3200,  # boiler_output_temp
-        "1A": Code._1260,  # dhw_temp
-        "1B": Code._1290,  # outside_temp
-        "1C": Code._3210,  # boiler_return_temp
-        "38": Code._10A0,  # dhw_setpoint (is a PARAM)
-        "39": Code._1081,  # ch_max_setpoint (is a PARAM)
+    OT_TO_RAMSES: dict[MsgId, Code] = {  # TODO: move to opentherm.py
+        MsgId._00: Code._3EF0,  # master/slave status (actuator_state)
+        MsgId._01: Code._22D9,  # boiler_setpoint
+        MsgId._0E: Code._3EF0,  # max_rel_modulation_level (is a PARAM?)
+        MsgId._11: Code._3EF0,  # rel_modulation_level (actuator_state, also Code._3EF1)
+        MsgId._12: Code._1300,  # ch_water_pressure
+        MsgId._13: Code._12F0,  # dhw_flow_rate
+        MsgId._19: Code._3200,  # boiler_output_temp
+        MsgId._1A: Code._1260,  # dhw_temp
+        MsgId._1B: Code._1290,  # outside_temp
+        MsgId._1C: Code._3210,  # boiler_return_temp
+        MsgId._38: Code._10A0,  # dhw_setpoint (is a PARAM)
+        MsgId._39: Code._1081,  # ch_max_setpoint (is a PARAM)
     }
-    RAMSES_TO_OT = {v: k for k, v in OT_TO_RAMSES.items() if v != Code._3EF0}
+    RAMSES_TO_OT: dict[Code, MsgId] = {
+        v: k for k, v in OT_TO_RAMSES.items() if v != Code._3EF0
+    }  # also 10A0?
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         self._child_id = FC  # NOTE: domain_id
 
-        self._msgz[str(Code._3220)] = {RP: {}}  # self._msgz[Code._3220][RP][msg_id]
+        self._msgz[Code._3220] = {RP: {}}  # _msgz[Code._3220][RP][msg_id]
 
         # lf._use_ot = self._gwy.config.use_native_ot
-        self._msgs_ot: dict[str, Message] = {}
+        self._msgs_ot: dict[MsgId, Message] = {}
         # lf._msgs_ot_ctl_polled = {}
 
     def _setup_discovery_cmds(self) -> None:
-        def which_cmd(use_native_ot: str, msg_id: str) -> None | Command:
+        def which_cmd(use_native_ot: str, msg_id: MsgId) -> Command | None:
             """Create a OT cmd, or its RAMSES equivalent, depending."""
             # we know RQ|3220 is an option, question is: use that, or RAMSES or nothing?
             if use_native_ot in ("always", "prefer"):
                 return Command.get_opentherm_data(self.id, msg_id)
             if msg_id in self.OT_TO_RAMSES:  # is: in ("avoid", "never")
-                return _mk_cmd(RQ, self.OT_TO_RAMSES[msg_id], "00", self.id)
+                return Command.from_attrs(RQ, self.id, self.OT_TO_RAMSES[msg_id], "00")
             if use_native_ot == "avoid":
                 return Command.get_opentherm_data(self.id, msg_id)
             return None  # use_native_ot == "never"
 
         super()._setup_discovery_cmds()
 
-        # always send RQ|3EF0 and RQ|3220|00 (status), regardless of use_native_ot
-        self._add_discovery_cmd(Command.get_opentherm_data(self.id, "00"), 60)
-        self._add_discovery_cmd(_mk_cmd(RQ, Code._3EF0, "00", self.id), 60)
+        # always send at least one of RQ|3EF0 or RQ|3220|00 (status)
+        if self._gwy.config.use_native_ot != "never":
+            self._add_discovery_cmd(Command.get_opentherm_data(self.id, MsgId._00), 60)
 
-        for msg_id in SCHEMA_MSG_IDS:  # From OT v2.2: version numbers
-            if cmd := which_cmd(self._gwy.config.use_native_ot, msg_id):
-                self._add_discovery_cmd(cmd, 24 * 3600, delay=180)
+        if self._gwy.config.use_native_ot != "always":
+            self._add_discovery_cmd(
+                Command.from_attrs(RQ, self.id, Code._3EF0, "00"), 60
+            )
+            self._add_discovery_cmd(  # NOTE: this code is a WIP
+                Command.from_attrs(RQ, self.id, Code._2401, "00"), 60
+            )
 
-        for msg_id in PARAMS_MSG_IDS:  # params or L/T state
-            if cmd := which_cmd(self._gwy.config.use_native_ot, msg_id):
+        for data_id in SCHEMA_DATA_IDS:  # From OT v2.2: version numbers
+            if cmd := which_cmd(self._gwy.config.use_native_ot, _to_msg_id(data_id)):
+                self._add_discovery_cmd(cmd, 6 * 3600, delay=180)
+
+        for data_id in PARAMS_DATA_IDS:  # params or L/T state
+            if cmd := which_cmd(self._gwy.config.use_native_ot, _to_msg_id(data_id)):
                 self._add_discovery_cmd(cmd, 3600, delay=90)
 
-        for msg_id in STATUS_MSG_IDS:  # except "00", see above
-            if msg_id == "00":
+        for data_id in STATUS_DATA_IDS:  # except "00", see above
+            if data_id == 0x00:
                 continue
-            if cmd := which_cmd(self._gwy.config.use_native_ot, msg_id):
+            if cmd := which_cmd(self._gwy.config.use_native_ot, _to_msg_id(data_id)):
                 self._add_discovery_cmd(cmd, 300, delay=15)
 
-        if DEV_MODE:  # TODO: these are WIP, but do vary in payload
+        if _DBG_EXTRA_OTB_DISCOVERY:  # TODO: these are WIP, but do vary in payload
             for code in (
                 Code._2401,  # WIP - modulation_level + flags?
                 Code._3221,  # R8810A/20A
                 Code._3223,  # R8810A/20A
             ):
-                self._add_discovery_cmd(_mk_cmd(RQ, code, "00", self.id), 60)
+                self._add_discovery_cmd(Command.from_attrs(RQ, self.id, code, "00"), 60)
 
-        if False and DEV_MODE:  # TODO: these are WIP, appear FIXED in payload
+        if _DBG_EXTRA_OTB_DISCOVERY:  # TODO: these are WIP, appear FIXED in payload
             for code in (
                 Code._0150,  # payload always "000000", R8820A only?
                 Code._1098,  # payload always "00C8",   R8820A only?
@@ -781,89 +732,92 @@ class OtbGateway(Actuator, HeatDemand):  # OTB (10): 3220 (22D9, others)
                 Code._2410,  # payload always "000000000000000000000000010000000100000C"
                 Code._2420,  # payload always "0000001000000...
             ):  # TODO: to test against BDR91T
-                cmd = _mk_cmd(RQ, code, "00", self.id)
-                self._add_discovery_cmd(cmd, 300, delay=300)
+                self._add_discovery_cmd(
+                    Command.from_attrs(RQ, self.id, code, "00"), 300
+                )
 
     def _handle_msg(self, msg: Message) -> None:
         super()._handle_msg(msg)
 
-        (self._handle_3220 if msg.code == Code._3220 else self._handle_code)(msg)
+        if msg.verb not in (I_, RP):
+            return
+
+        if msg.code == Code._3220:
+            self._handle_3220(msg)
+        elif msg.code in self.RAMSES_TO_OT:
+            self._handle_code(msg)
 
     def _handle_3220(self, msg: Message) -> None:
-        if msg.payload[MSG_TYPE] == OtMsgType.RESERVED:  # workaround
+        """Handle 3220-based messages."""
+
+        # NOTE: Reserved msgs have null data, but that msg_id may later be OK!
+        if msg.payload[SZ_MSG_TYPE] == OtMsgType.RESERVED:
+            return
+
+        # NOTE: Some msgs have invalid data, but that msg_id may later be OK!
+        if msg.payload.get(SZ_VALUE) is None:
             return
 
-        msg_id = f"{msg.payload[MSG_ID]:02X}"
+        # msg_id is int in msg payload/opentherm.py, but MsgId (str) is in this module
+        msg_id = _to_msg_id(msg.payload[SZ_MSG_ID])
         self._msgs_ot[msg_id] = msg
 
-        if DEV_MODE:  # here to follow state changes
-            self._send_cmd(_mk_cmd(RQ, Code._2401, "00", self.id))  # oem code
-            if msg_id != "73":
-                self._send_cmd(Command.get_opentherm_data(self.id, "73"))  # oem code
+        if not _DBG_ENABLE_DEPRECATION:  # FIXME: data gaps
+            return
 
-            # TODO: this is development code - will be rationalised, eventually
-            if self._gwy.config.use_native_ot and (
-                code := self.OT_TO_RAMSES.get(msg_id)
-            ):
-                self._send_cmd(_mk_cmd(RQ, code, "00", self.id))
+        reset = msg.payload[SZ_MSG_TYPE] not in (
+            OtMsgType.DATA_INVALID,
+            OtMsgType.UNKNOWN_DATAID,
+            OtMsgType.RESERVED,  # but some are ?always reserved
+        )
+        self._deprecate_code_ctx(msg._pkt, ctx=msg_id, reset=reset)
 
-        if msg._pkt.payload[6:] == "47AB" or msg._pkt.payload[4:] == "121980":
-            self.deprecate_cmd(msg._pkt, ctx=msg_id)
+    def _handle_code(self, msg: Message) -> None:
+        """Handle non-3220-based messages."""
 
-        else:
-            # 18:50:32.524 ... RQ --- 18:013393 10:048122 --:------ 3220 005 0080730000
-            # 18:50:32.547 ... RP --- 10:048122 18:013393 --:------ 3220 005 00B0730000  # -reserved-
-            # 18:55:32.601 ... RQ --- 18:013393 10:048122 --:------ 3220 005 0080730000
-            # 18:55:32.630 ... RP --- 10:048122 18:013393 --:------ 3220 005 00C07300CB  # Read-Ack, 'value': 203
-            reset = msg.payload[MSG_TYPE] not in (
-                OtMsgType.DATA_INVALID,
-                OtMsgType.UNKNOWN_DATAID,
-                # OtMsgType.RESERVED,  # some always reserved, others sometimes so
-            )
-            self.deprecate_cmd(msg._pkt, ctx=msg_id, reset=reset)
+        if msg.code == Code._3EF0 and msg.verb == I_:
+            # NOTE: this is development/discovery code  # chasing flags
+            # self._send_cmd(
+            #     Command.get_opentherm_data(self.id, MsgId._00), **QOS_MID
+            # )  # FIXME: deprecate QoS in kwargs
+            return
 
-    def _handle_code(self, msg: Message) -> None:
-        if msg.code == Code._3EF0 and msg.verb == I_:  # chasing flags
-            self._send_cmd(
-                Command.get_opentherm_data(self.id, "00"),
-                qos={SZ_PRIORITY: Priority.HIGH, SZ_RETRIES: 1},
-            )
+        if msg.code in (Code._10A0, Code._3EF1):
             return
 
-        if msg.code in (Code._10A0, Code._3EF1) or msg.len != 3:
+        if not _DBG_ENABLE_DEPRECATION:  # FIXME: data gaps
             return
 
+        # TODO: can be temporarily 7FFF?
         if msg._pkt.payload[2:] == "7FFF" or (
             msg.code == Code._1300 and msg._pkt.payload[2:] == "09F6"
-        ):
-            self.deprecate_cmd(msg._pkt)
+        ):  # latter is CH water pressure
+            self._deprecate_code_ctx(msg._pkt)
         else:
-            self.deprecate_cmd(msg._pkt, reset=True)
+            self._deprecate_code_ctx(msg._pkt, reset=True)
 
-    def _ot_msg_flag(self, msg_id, flag_idx) -> None | bool:
-        if flags := self._ot_msg_value(msg_id):
-            return bool(flags[flag_idx])
-        return None
+    def _ot_msg_flag(self, msg_id: MsgId, flag_idx: int) -> bool | None:
+        flags: list = self._ot_msg_value(msg_id)
+        return bool(flags[flag_idx]) if flags else None
 
     @staticmethod
-    def _ot_msg_name(msg) -> str:
+    def _ot_msg_name(msg: Message) -> str:  # TODO: remove
         return (
-            msg.payload[MSG_NAME]
-            if isinstance(msg.payload[MSG_NAME], str)
-            else f"{msg.payload[MSG_ID]:02X}"
+            msg.payload[SZ_MSG_NAME]
+            if isinstance(msg.payload[SZ_MSG_NAME], str)
+            else f"{msg.payload[SZ_MSG_ID]:02X}"
         )
 
-    def _ot_msg_value(self, msg_id) -> None | int | float | list:
-        if (
-            self.is_pollable_cmd(Code._3220, ctx=msg_id)
-            and self._msgs_ot.get(msg_id)
-            and not self._msgs_ot[msg_id]._expired
-        ):
-            return self._msgs_ot[msg_id].payload.get(VALUE)  # TODO: value_hb/_lb
+    def _ot_msg_value(self, msg_id: MsgId) -> int | float | list | None:
+        # data_id = int(msg_id, 16)
+        if (msg := self._msgs_ot.get(msg_id)) and not msg._expired:
+            # TODO: value_hb/_lb
+            return msg.payload.get(SZ_VALUE)  # type: ignore[no-any-return]
+        return None
 
     def _result_by_callback(
-        self, cbk_ot: None | Callable, cbk_ramses: None | Callable
-    ) -> None | Any:
+        self, cbk_ot: Callable | None, cbk_ramses: Callable | None
+    ) -> Any | None:
         """Return a value using OpenTherm or RAMSES as per `config.use_native_ot`."""
 
         if self._gwy.config.use_native_ot == "always":
@@ -877,279 +831,297 @@ class OtbGateway(Actuator, HeatDemand):  # OTB (10): 3220 (22D9, others)
             return cbk_ot() if cbk_ot else None
         return result_ramses  # incl. use_native_ot == "never"
 
-    def _result_by_lookup(self, code, *args, **kwargs) -> None | Any:
+    def _result_by_lookup(
+        self,
+        code: Code,
+        /,
+        *,
+        key: str,
+    ) -> Any | None:
         """Return a value using OpenTherm or RAMSES as per `config.use_native_ot`."""
         # assert code in self.RAMSES_TO_OT and kwargs.get("key"):
 
         if self._gwy.config.use_native_ot == "always":
             return self._ot_msg_value(self.RAMSES_TO_OT[code])
+
         if self._gwy.config.use_native_ot == "prefer":
             if (result_ot := self._ot_msg_value(self.RAMSES_TO_OT[code])) is not None:
                 return result_ot
 
-        result_ramses = self._msg_value(code, *args, **kwargs)
+        result_ramses = self._msg_value(code, key=key)
         if self._gwy.config.use_native_ot == "avoid" and result_ramses is None:
             return self._ot_msg_value(self.RAMSES_TO_OT[code])
+
         return result_ramses  # incl. use_native_ot == "never"
 
     def _result_by_value(
-        self, result_ot: None | Any, result_ramses: None | Any
-    ) -> None | Any:
+        self, result_ot: Any | None, result_ramses: Any | None
+    ) -> Any | None:
         """Return a value using OpenTherm or RAMSES as per `config.use_native_ot`."""
+        #
 
         if self._gwy.config.use_native_ot == "always":
             return result_ot
+
         if self._gwy.config.use_native_ot == "prefer":
             if result_ot is not None:
                 return result_ot
 
+        #
         elif self._gwy.config.use_native_ot == "avoid" and result_ramses is None:
             return result_ot
+
         return result_ramses  # incl. use_native_ot == "never"
 
     @property  # TODO
-    def bit_2_4(self) -> None | bool:  # 2401 - WIP
+    def bit_2_4(self) -> bool | None:  # 2401 - WIP
         return self._msg_flag(Code._2401, "_flags_2", 4)
 
     @property  # TODO
-    def bit_2_5(self) -> None | bool:  # 2401 - WIP
+    def bit_2_5(self) -> bool | None:  # 2401 - WIP
         return self._msg_flag(Code._2401, "_flags_2", 5)
 
     @property  # TODO
-    def bit_2_6(self) -> None | bool:  # 2401 - WIP
+    def bit_2_6(self) -> bool | None:  # 2401 - WIP
         return self._msg_flag(Code._2401, "_flags_2", 6)
 
     @property  # TODO
-    def bit_2_7(self) -> None | bool:  # 2401 - WIP
+    def bit_2_7(self) -> bool | None:  # 2401 - WIP
         return self._msg_flag(Code._2401, "_flags_2", 7)
 
     @property  # TODO
-    def bit_3_7(self) -> None | bool:  # 3EF0 (byte 3, only OTB)
+    def bit_3_7(self) -> bool | None:  # 3EF0 (byte 3, only OTB)
         return self._msg_flag(Code._3EF0, "_flags_3", 7)
 
     @property  # TODO
-    def bit_6_6(self) -> None | bool:  # 3EF0 ?dhw_enabled (byte 3, only R8820A?)
-        return self._msg_flag(Code._3EF0, "_flags_3", 6)
+    def bit_6_6(self) -> bool | None:  # 3EF0 ?dhw_enabled (byte 3, only R8820A?)
+        return self._msg_flag(Code._3EF0, "_flags_6", 6)
 
     @property  # TODO
-    def percent(self) -> None | float:  # 2401 - WIP
-        return self._msg_value(Code._2401, key="_percent_3")
+    def percent(self) -> float | None:  # 2401 - WIP (~3150|FC)
+        return self._msg_value(Code._2401, key=SZ_HEAT_DEMAND)
 
     @property  # TODO
-    def value(self) -> None | int:  # 2401 - WIP
+    def value(self) -> int | None:  # 2401 - WIP
         return self._msg_value(Code._2401, key="_value_2")
 
     @property
-    def boiler_output_temp(self) -> None | float:  # 3220|19, or 3200
+    def boiler_output_temp(self) -> float | None:  # 3220|19, or 3200
+        # _LOGGER.warning(
+        #     "code=%s, 3220=%s, both=%s",
+        #     self._msg_value(Code._3200, key=SZ_TEMPERATURE),
+        #     self._ot_msg_value(str(self.RAMSES_TO_OT[Code._3200])),
+        #     self._result_by_lookup(Code._3200, key=SZ_TEMPERATURE),
+        # )
+
         return self._result_by_lookup(Code._3200, key=SZ_TEMPERATURE)
 
     @property
-    def boiler_return_temp(self) -> None | float:  # 3220|1C, or 3210
+    def boiler_return_temp(self) -> float | None:  # 3220|1C, or 3210
         return self._result_by_lookup(Code._3210, key=SZ_TEMPERATURE)
 
     @property
-    def boiler_setpoint(self) -> None | float:  # 3220|01, or 22D9
+    def boiler_setpoint(self) -> float | None:  # 3220|01, or 22D9
         return self._result_by_lookup(Code._22D9, key=SZ_SETPOINT)
 
     @property
-    def ch_max_setpoint(self) -> None | float:  # 3220|39, or 1081
+    def ch_max_setpoint(self) -> float | None:  # 3220|39, or 1081
         return self._result_by_lookup(Code._1081, key=SZ_SETPOINT)
 
-    @property  # TODO
-    def ch_setpoint(self) -> None | float:  # 3EF0 (byte 7, only R8820A?), TODO: no OT
+    @property  # TODO: no OT equivalent
+    def ch_setpoint(self) -> float | None:  # 3EF0 (byte 7, only R8820A?)
         return self._result_by_value(
             None, self._msg_value(Code._3EF0, key=SZ_CH_SETPOINT)
         )
 
     @property
-    def ch_water_pressure(self) -> None | float:  # 3220|12, or 1300
-        result = self._result_by_lookup(Code._1300, key=SZ_PRESSURE)
-        return None if result == 25.5 else result  # HACK: to make more rigourous
+    def ch_water_pressure(self) -> float | None:  # 3220|12, or 1300
+        return self._result_by_lookup(Code._1300, key=SZ_PRESSURE)
 
     @property
-    def dhw_flow_rate(self) -> None | float:  # 3220|13, or 12F0
+    def dhw_flow_rate(self) -> float | None:  # 3220|13, or 12F0
         return self._result_by_lookup(Code._12F0, key=SZ_DHW_FLOW_RATE)
 
     @property
-    def dhw_setpoint(self) -> None | float:  # 3220|38, or 10A0
+    def dhw_setpoint(self) -> float | None:  # 3220|38, or 10A0
         return self._result_by_lookup(Code._10A0, key=SZ_SETPOINT)
 
     @property
-    def dhw_temp(self) -> None | float:  # 3220|1A, or 1260
+    def dhw_temp(self) -> float | None:  # 3220|1A, or 1260
         return self._result_by_lookup(Code._1260, key=SZ_TEMPERATURE)
 
-    @property  # TODO
-    def max_rel_modulation(
-        self,
-    ) -> None | float:  # 3220|0E, or 3EF0 (byte 8, only R8820A?)
-        if self._gwy.config.use_native_ot == "prefer":  # HACK
+    @property  # TODO: no reliable OT equivalent?
+    def max_rel_modulation(self) -> float | None:  # 3220|0E, or 3EF0 (byte 8)
+        if self._gwy.config.use_native_ot == "prefer":  # HACK: there'll always be 3EF0
             return self._msg_value(Code._3EF0, key=SZ_MAX_REL_MODULATION)
         return self._result_by_value(
-            self._ot_msg_value("0E"),
+            self._ot_msg_value(MsgId._0E),  # NOTE: not reliable?
             self._msg_value(Code._3EF0, key=SZ_MAX_REL_MODULATION),
         )
 
     @property
-    def oem_code(self) -> None | float:  # 3220|73, no known RAMSES equivalent
-        return self._ot_msg_value("73")
+    def oem_code(self) -> float | None:  # 3220|73, no known RAMSES equivalent
+        return self._ot_msg_value(MsgId._73)
 
     @property
-    def outside_temp(self) -> None | float:  # 3220|1B, 1290
+    def outside_temp(self) -> float | None:  # 3220|1B, 1290
         return self._result_by_lookup(Code._1290, key=SZ_TEMPERATURE)
 
-    @property  # HACK
-    def rel_modulation_level(self) -> None | float:  # 3220|11, or 3EF0/3EF1
-        if self._gwy.config.use_native_ot == "prefer":  # HACK (there'll always be 3EF0)
+    @property  # TODO: no reliable OT equivalent?
+    def rel_modulation_level(self) -> float | None:  # 3220|11, or 3EF0/3EF1
+        if self._gwy.config.use_native_ot == "prefer":  # HACK: there'll always be 3EF0
             return self._msg_value((Code._3EF0, Code._3EF1), key=self.MODULATION_LEVEL)
         return self._result_by_value(
-            self._ot_msg_value("11"),
+            self._ot_msg_value(MsgId._11),  # NOTE: not reliable?
             self._msg_value((Code._3EF0, Code._3EF1), key=self.MODULATION_LEVEL),
         )
 
-    @property  # HACK
-    def ch_active(self) -> None | bool:  # 3220|00, or 3EF0 (byte 3, only R8820A?)
-        if self._gwy.config.use_native_ot == "prefer":  # HACK (there'll always be 3EF0)
+    @property  # TODO: no reliable OT equivalent?
+    def ch_active(self) -> bool | None:  # 3220|00, or 3EF0 (byte 3)
+        if self._gwy.config.use_native_ot == "prefer":  # HACK: there'll always be 3EF0
             return self._msg_value(Code._3EF0, key=SZ_CH_ACTIVE)
         return self._result_by_value(
-            self._ot_msg_flag("00", 8 + 1),
+            self._ot_msg_flag(MsgId._00, 8 + 1),  # NOTE: not reliable?
             self._msg_value(Code._3EF0, key=SZ_CH_ACTIVE),
         )
 
-    @property  # HACK
-    def ch_enabled(self) -> None | bool:  # 3220|00, or 3EF0 (byte 6, only R8820A?)
-        if self._gwy.config.use_native_ot == "prefer":  # HACK (there'll always be 3EF0)
+    @property  # TODO: no reliable OT equivalent?
+    def ch_enabled(self) -> bool | None:  # 3220|00, or 3EF0 (byte 6)
+        if self._gwy.config.use_native_ot == "prefer":  # HACK: there'll always be 3EF0
             return self._msg_value(Code._3EF0, key=SZ_CH_ENABLED)
         return self._result_by_value(
-            self._ot_msg_flag("00", 0),
+            self._ot_msg_flag(MsgId._00, 0),  # NOTE: not reliable?
             self._msg_value(Code._3EF0, key=SZ_CH_ENABLED),
         )
 
     @property
-    def cooling_active(self) -> None | bool:  # 3220|00, TODO: no known RAMSES
-        return self._result_by_value(self._ot_msg_flag("00", 8 + 4), None)
+    def cooling_active(self) -> bool | None:  # 3220|00, TODO: no known RAMSES
+        return self._result_by_value(self._ot_msg_flag(MsgId._00, 8 + 4), None)
 
     @property
-    def cooling_enabled(self) -> None | bool:  # 3220|00, TODO: no known RAMSES
-        return self._result_by_value(self._ot_msg_flag("00", 2), None)
+    def cooling_enabled(self) -> bool | None:  # 3220|00, TODO: no known RAMSES
+        return self._result_by_value(self._ot_msg_flag(MsgId._00, 2), None)
 
-    @property  # HACK
-    def dhw_active(self) -> None | bool:  # 3220|00, or 3EF0 (byte 3, only OTB)
-        if self._gwy.config.use_native_ot == "prefer":  # HACK (there'll always be 3EF0)
+    @property  # TODO: no reliable OT equivalent?
+    def dhw_active(self) -> bool | None:  # 3220|00, or 3EF0 (byte 3)
+        if self._gwy.config.use_native_ot == "prefer":  # HACK: there'll always be 3EF0
             return self._msg_value(Code._3EF0, key=SZ_DHW_ACTIVE)
         return self._result_by_value(
-            self._ot_msg_flag("00", 8 + 2),
+            self._ot_msg_flag(MsgId._00, 8 + 2),  # NOTE: not reliable?
             self._msg_value(Code._3EF0, key=SZ_DHW_ACTIVE),
         )
 
     @property
-    def dhw_blocking(self) -> None | bool:  # 3220|00, TODO: no known RAMSES
-        return self._result_by_value(self._ot_msg_flag("00", 6), None)
+    def dhw_blocking(self) -> bool | None:  # 3220|00, TODO: no known RAMSES
+        return self._result_by_value(self._ot_msg_flag(MsgId._00, 6), None)
 
     @property
-    def dhw_enabled(self) -> None | bool:  # 3220|00, TODO: no known RAMSES
-        return self._result_by_value(self._ot_msg_flag("00", 1), None)
+    def dhw_enabled(self) -> bool | None:  # 3220|00, TODO: no known RAMSES
+        return self._result_by_value(self._ot_msg_flag(MsgId._00, 1), None)
 
     @property
-    def fault_present(self) -> None | bool:  # 3220|00, TODO: no known RAMSES
-        return self._result_by_value(self._ot_msg_flag("00", 8), None)
+    def fault_present(self) -> bool | None:  # 3220|00, TODO: no known RAMSES
+        return self._result_by_value(self._ot_msg_flag(MsgId._00, 8), None)
 
-    @property  # HACK
-    def flame_active(self) -> None | bool:  # 3220|00, or 3EF0 (byte 3, only OTB)
-        if self._gwy.config.use_native_ot == "prefer":  # HACK (there'll always be 3EF0)
-            return self._msg_value(Code._3EF0, key=SZ_FLAME_ACTIVE)
+    @property  # TODO: no reliable OT equivalent?
+    def flame_active(self) -> bool | None:  # 3220|00, or 3EF0 (byte 3)
+        if self._gwy.config.use_native_ot == "prefer":  # HACK: there'll always be 3EF0
+            return self._msg_value(Code._3EF0, key="flame_on")
         return self._result_by_value(
-            self._ot_msg_flag("00", 8 + 3),
-            self._msg_value(Code._3EF0, key=SZ_FLAME_ACTIVE),
+            self._ot_msg_flag(MsgId._00, 8 + 3),  # NOTE: not reliable?
+            self._msg_value(Code._3EF0, key="flame_on"),
         )
 
     @property
-    def otc_active(self) -> None | bool:  # 3220|00, TODO: no known RAMSES
-        return self._result_by_value(self._ot_msg_flag("00", 3), None)
+    def otc_active(self) -> bool | None:  # 3220|00, TODO: no known RAMSES
+        return self._result_by_value(self._ot_msg_flag(MsgId._00, 3), None)
 
     @property
-    def summer_mode(self) -> None | bool:  # 3220|00, TODO: no known RAMSES
-        return self._result_by_value(self._ot_msg_flag("00", 5), None)
+    def summer_mode(self) -> bool | None:  # 3220|00, TODO: no known RAMSES
+        return self._result_by_value(self._ot_msg_flag(MsgId._00, 5), None)
 
     @property
-    def opentherm_schema(self) -> dict:
-        result = {
+    def opentherm_schema(self) -> dict[str, Any]:
+        result: dict[str, Any] = {
             self._ot_msg_name(v): v.payload
             for k, v in self._msgs_ot.items()
-            if self._supported_cmds_ctx.get(int(k, 16)) and int(k, 16) in SCHEMA_MSG_IDS
+            if self._supported_cmds_ctx.get(k) and int(k, 16) in SCHEMA_DATA_IDS
         }
         return {
-            m: {k: v for k, v in p.items() if k.startswith(VALUE)}
+            m: {k: v for k, v in p.items() if k.startswith(SZ_VALUE)}
             for m, p in result.items()
         }
 
     @property
-    def opentherm_counters(self) -> dict:
-        # for msg_id in ("71", "72", ...):
+    def opentherm_counters(self) -> dict[str, Any]:  # all are U16
         return {
-            SZ_BURNER_HOURS: self._ot_msg_value("78"),
-            SZ_BURNER_STARTS: self._ot_msg_value("74"),
-            SZ_BURNER_FAILED_STARTS: self._ot_msg_value("71"),
-            SZ_CH_PUMP_HOURS: self._ot_msg_value("79"),
-            SZ_CH_PUMP_STARTS: self._ot_msg_value("75"),
-            SZ_DHW_BURNER_HOURS: self._ot_msg_value("7B"),
-            SZ_DHW_BURNER_STARTS: self._ot_msg_value("77"),
-            SZ_DHW_PUMP_HOURS: self._ot_msg_value("7A"),
-            SZ_DHW_PUMP_STARTS: self._ot_msg_value("76"),
-            SZ_FLAME_SIGNAL_LOW: self._ot_msg_value("72"),
-        }  # 0x73 is OEM diagnostic code...
+            SZ_BURNER_HOURS: self._ot_msg_value(MsgId._78),
+            SZ_BURNER_STARTS: self._ot_msg_value(MsgId._74),
+            SZ_BURNER_FAILED_STARTS: self._ot_msg_value(MsgId._71),
+            SZ_CH_PUMP_HOURS: self._ot_msg_value(MsgId._79),
+            SZ_CH_PUMP_STARTS: self._ot_msg_value(MsgId._75),
+            SZ_DHW_BURNER_HOURS: self._ot_msg_value(MsgId._7B),
+            SZ_DHW_BURNER_STARTS: self._ot_msg_value(MsgId._77),
+            SZ_DHW_PUMP_HOURS: self._ot_msg_value(MsgId._7A),
+            SZ_DHW_PUMP_STARTS: self._ot_msg_value(MsgId._76),
+            SZ_FLAME_SIGNAL_LOW: self._ot_msg_value(MsgId._72),
+        }  # 0x73 is not a counter: is OEM diagnostic code...
 
     @property
-    def opentherm_params(self) -> dict:
+    def opentherm_params(self) -> dict[str, Any]:  # F8_8, U8, {"hb": S8, "lb": S8}
         result = {
             self._ot_msg_name(v): v.payload
             for k, v in self._msgs_ot.items()
-            if self._supported_cmds_ctx.get(int(k, 16)) and int(k, 16) in PARAMS_MSG_IDS
+            if self._supported_cmds_ctx.get(k) and int(k, 16) in PARAMS_DATA_IDS
         }
         return {
-            m: {k: v for k, v in p.items() if k.startswith(VALUE)}
+            m: {k: v for k, v in p.items() if k.startswith(SZ_VALUE)}
             for m, p in result.items()
         }
 
     @property
-    def opentherm_status(self) -> dict:
-        return {
-            SZ_BOILER_OUTPUT_TEMP: self._ot_msg_value("19"),
-            SZ_BOILER_RETURN_TEMP: self._ot_msg_value("1C"),
-            SZ_BOILER_SETPOINT: self._ot_msg_value("01"),
-            SZ_CH_MAX_SETPOINT: self._ot_msg_value("39"),
-            SZ_CH_WATER_PRESSURE: self._ot_msg_value("12"),
-            SZ_DHW_FLOW_RATE: self._ot_msg_value("13"),
-            SZ_DHW_SETPOINT: self._ot_msg_value("38"),
-            SZ_DHW_TEMP: self._ot_msg_value("1A"),
-            SZ_OEM_CODE: self._ot_msg_value("73"),
-            SZ_OUTSIDE_TEMP: self._ot_msg_value("1B"),
-            SZ_REL_MODULATION_LEVEL: self._ot_msg_value("11"),
+    def opentherm_status(self) -> dict[str, Any]:  # F8_8, U16 (only OEM_CODE) or bool
+        return {  # most these are in: STATUS_DATA_IDS
+            SZ_BOILER_OUTPUT_TEMP: self._ot_msg_value(MsgId._19),
+            SZ_BOILER_RETURN_TEMP: self._ot_msg_value(MsgId._1C),
+            SZ_BOILER_SETPOINT: self._ot_msg_value(MsgId._01),
+            # SZ_CH_MAX_SETPOINT: self._ot_msg_value(MsgId._39),  # in PARAMS_DATA_IDS
+            SZ_CH_WATER_PRESSURE: self._ot_msg_value(MsgId._12),
+            SZ_DHW_FLOW_RATE: self._ot_msg_value(MsgId._13),
+            # SZ_DHW_SETPOINT: self._ot_msg_value(MsgId._38),  # in PARAMS_DATA_IDS
+            SZ_DHW_TEMP: self._ot_msg_value(MsgId._1A),
+            SZ_OEM_CODE: self._ot_msg_value(MsgId._73),
+            SZ_OUTSIDE_TEMP: self._ot_msg_value(MsgId._1B),
+            SZ_REL_MODULATION_LEVEL: self._ot_msg_value(MsgId._11),
+            #
+            # SZ...: self._ot_msg_value(MsgId._05),  # in STATUS_DATA_IDS
+            # SZ...: self._ot_msg_value(MsgId._18),  # in STATUS_DATA_IDS
             #
-            SZ_CH_ACTIVE: self._ot_msg_flag("00", 8 + 1),
-            SZ_CH_ENABLED: self._ot_msg_flag("00", 0),
-            SZ_COOLING_ACTIVE: self._ot_msg_flag("00", 8 + 4),
-            SZ_COOLING_ENABLED: self._ot_msg_flag("00", 2),
-            SZ_DHW_ACTIVE: self._ot_msg_flag("00", 8 + 2),
-            SZ_DHW_BLOCKING: self._ot_msg_flag("00", 6),
-            SZ_DHW_ENABLED: self._ot_msg_flag("00", 1),
-            SZ_FAULT_PRESENT: self._ot_msg_flag("00", 8),
-            SZ_FLAME_ACTIVE: self._ot_msg_flag("00", 8 + 3),
-            SZ_SUMMER_MODE: self._ot_msg_flag("00", 5),
-            SZ_OTC_ACTIVE: self._ot_msg_flag("00", 3),
+            SZ_CH_ACTIVE: self._ot_msg_flag(MsgId._00, 8 + 1),
+            SZ_CH_ENABLED: self._ot_msg_flag(MsgId._00, 0),
+            SZ_COOLING_ACTIVE: self._ot_msg_flag(MsgId._00, 8 + 4),
+            SZ_COOLING_ENABLED: self._ot_msg_flag(MsgId._00, 2),
+            SZ_DHW_ACTIVE: self._ot_msg_flag(MsgId._00, 8 + 2),
+            SZ_DHW_BLOCKING: self._ot_msg_flag(MsgId._00, 6),
+            SZ_DHW_ENABLED: self._ot_msg_flag(MsgId._00, 1),
+            SZ_FAULT_PRESENT: self._ot_msg_flag(MsgId._00, 8),
+            SZ_FLAME_ACTIVE: self._ot_msg_flag(MsgId._00, 8 + 3),
+            SZ_SUMMER_MODE: self._ot_msg_flag(MsgId._00, 5),
+            SZ_OTC_ACTIVE: self._ot_msg_flag(MsgId._00, 3),
         }
 
     @property
-    def ramses_schema(self) -> dict:
+    def ramses_schema(self) -> PayDictT.EMPTY:
         return {}
 
     @property
-    def ramses_params(self) -> dict:
+    def ramses_params(self) -> dict[str, float | None]:
         return {
             SZ_MAX_REL_MODULATION: self.max_rel_modulation,
         }
 
     @property
-    def ramses_status(self) -> dict:
+    def ramses_status(self) -> dict[str, Any]:
         return {
             SZ_BOILER_OUTPUT_TEMP: self._msg_value(Code._3200, key=SZ_TEMPERATURE),
             SZ_BOILER_RETURN_TEMP: self._msg_value(Code._3210, key=SZ_TEMPERATURE),
@@ -1230,11 +1202,10 @@ class OtbGateway(Actuator, HeatDemand):  # OTB (10): 3220 (22D9, others)
         }
 
 
-class Thermostat(BatteryState, Setpoint, Temperature):  # THM (..):
+class Thermostat(BatteryState, Setpoint, Temperature, Fakeable):  # THM (..):
     """The THM/STA class, such as a TR87RF."""
 
-    _SLUG: str = DEV_TYPE.THM
-
+    _SLUG = DevType.THM
     _STATE_ATTR = SZ_TEMPERATURE
 
     def _handle_msg(self, msg: Message) -> None:
@@ -1274,25 +1245,29 @@ class Thermostat(BatteryState, Setpoint, Temperature):  # THM (..):
             elif self._iz_controller is False:  # TODO: raise CorruptStateError
                 _LOGGER.error(f"{msg!r} # IS_CONTROLLER (21): was FALSE, now True")
 
+    async def initiate_binding_process(self) -> Packet:
+        return await super()._initiate_binding_process(
+            (Code._2309, Code._30C9, Code._0008)
+        )
+
 
 class BdrSwitch(Actuator, RelayDemand):  # BDR (13):
     """The BDR class, such as a BDR91.
 
-    BDR91s can be used in six disctinct modes, including:
+    BDR91s can be used in six distinct modes, including:
     - x2 boiler controller (FC/TPI): either traditional, or newer heat pump-aware
     - x1 electric heat zones (0x/ELE)
     - x1 zone valve zones (0x/VAL)
     - x2 DHW thingys (F9/DHW, FA/DHW)
     """
 
-    _SLUG: str = DEV_TYPE.BDR
-
-    ACTIVE = "active"
-    TPI_PARAMS = "tpi_params"
+    ACTIVE: Final = "active"
+    TPI_PARAMS: Final = "tpi_params"
 
+    _SLUG = DevType.BDR
     _STATE_ATTR = "active"
 
-    # def __init__(self, *args, **kwargs) -> None:
+    # def __init__(self, *args: Any, **kwargs: Any) -> None:
     #     super().__init__(*args, **kwargs)
 
     #     if kwargs.get(SZ_DOMAIN_ID) == FC:  # TODO: F9/FA/FC, zone_idx
@@ -1316,41 +1291,42 @@ class BdrSwitch(Actuator, RelayDemand):  # BDR (13):
 
         super()._setup_discovery_cmds()
 
-        if self._faked:
+        if self.is_faked:
             return
 
         self._add_discovery_cmd(Command.get_tpi_params(self.id), 6 * 3600)  # params
         self._add_discovery_cmd(
-            _mk_cmd(RQ, Code._3EF1, "00", self.id),
+            Command.from_attrs(RQ, self.id, Code._3EF1, "00"),
             60 if self._child_id in (F9, FA, FC) else 300,
         )  # status
 
     @property
-    def active(self) -> None | bool:  # 3EF0, 3EF1
+    def active(self) -> bool | None:  # 3EF0, 3EF1
         """Return the actuator's current state."""
         result = self._msg_value((Code._3EF0, Code._3EF1), key=self.MODULATION_LEVEL)
         return None if result is None else bool(result)
 
     @property
-    def role(self) -> None | str:
+    def role(self) -> str | None:
         """Return the role of the BDR91A (there are six possibilities)."""
 
         # TODO: use self._parent?
         if self._child_id in DOMAIN_TYPE_MAP:
             return DOMAIN_TYPE_MAP[self._child_id]
-        elif self._parent:
-            return self._parent.heating_type  # TODO: only applies to zones
+        elif self._parent and isinstance(self._parent, Zone):
+            # TODO: remove need for isinstance
+            return self._parent.heating_type
 
-        # if Code._3B00 in self._msgs and self._msgs[Code._3B00].verb == I_:
+        # if Code._3B00 in _msgs and _msgs[Code._3B00].verb == I_:
         #     self._is_tpi = True
-        # if Code._1FC9 in self._msgs and self._msgs[Code._1FC9].verb == RP:
-        #     if Code._3B00 in self._msgs[Code._1FC9].raw_payload:
+        # if Code._1FC9 in _msgs and _msgs[Code._1FC9].verb == RP:
+        #     if Code._3B00 in _msgs[Code._1FC9].raw_payload:
         #         self._is_tpi = True
 
         return None
 
     @property
-    def tpi_params(self) -> None | dict:  # 1100
+    def tpi_params(self) -> PayDictT._10A0 | None:
         return self._msg_value(Code._1100)
 
     @property
@@ -1378,21 +1354,20 @@ class BdrSwitch(Actuator, RelayDemand):  # BDR (13):
 class TrvActuator(BatteryState, HeatDemand, Setpoint, Temperature):  # TRV (04):
     """The TRV class, such as a HR92."""
 
-    _SLUG: str = DEV_TYPE.TRV
-
-    WINDOW_OPEN = SZ_WINDOW_OPEN  # boolean
+    WINDOW_OPEN: Final = SZ_WINDOW_OPEN
 
+    _SLUG = DevType.TRV
     _STATE_ATTR = SZ_HEAT_DEMAND
 
     @property
-    def heat_demand(self) -> None | float:  # 3150
+    def heat_demand(self) -> float | None:  # 3150
         if (heat_demand := super().heat_demand) is None:
             if self._msg_value(Code._3150) is None and self.setpoint is False:
                 return 0  # instead of None (no 3150s sent when setpoint is False)
         return heat_demand
 
     @property
-    def window_open(self) -> None | bool:  # 12B0
+    def window_open(self) -> bool | None:  # 12B0
         return self._msg_value(Code._12B0, key=self.WINDOW_OPEN)
 
     @property
@@ -1404,14 +1379,16 @@ class TrvActuator(BatteryState, HeatDemand, Setpoint, Temperature):  # TRV (04):
 
 
 class JimDevice(Actuator):  # BDR (08):
-    _SLUG: str = DEV_TYPE.JIM
+    _SLUG: str = DevType.JIM
+    _STATE_ATTR = None
 
 
 class JstDevice(RelayDemand):  # BDR (31):
-    _SLUG: str = DEV_TYPE.JST
+    _SLUG: str = DevType.JST
+    _STATE_ATTR = None
 
 
-class UfhCircuit(Entity):
+class UfhCircuit(Child, Entity):  # FIXME
     """The UFH circuit class (UFC:circuit is much like CTL/TCS:zone).
 
     NOTE: for circuits, there's a difference between :
@@ -1419,82 +1396,93 @@ class UfhCircuit(Entity):
      - `self.tcs.ctl`: the Evohome controller
     """
 
-    _SLUG: str = None  # type: ignore[assignment]
+    _SLUG: str = None
+    _STATE_ATTR = None
 
-    def __init__(self, ufc, ufh_idx: str) -> None:
+    def __init__(self, ufc: UfhController, ufh_idx: str) -> None:
         super().__init__(ufc._gwy)
 
+        # FIXME: ZZZ entities must know their parent device ID and their own idx
+        self._z_id = ufc.id
+        self._z_idx = ufh_idx
+
         self.id: str = f"{ufc.id}_{ufh_idx}"
 
         self.ufc: UfhController = ufc
         self._child_id = ufh_idx
 
         # TODO: _ctl should be: .ufc? .ctl?
-        self._ctl: Controller = None  # type: ignore[assignment]
-        self._zone: None | Zone = None
+        self._ctl: Controller = None
+        self._zone: Zone | None = None
 
     # def __str__(self) -> str:
     #     return f"{self.id} ({self._zone and self._zone._child_id})"
 
+    def _update_schema(self, **kwargs: Any) -> None:
+        raise NotImplementedError
+
     def _handle_msg(self, msg: Message) -> None:
         super()._handle_msg(msg)
 
-        # FIXME:
-        if msg.code == Code._000C and msg.payload[SZ_DEVICES]:  # zone_devices
+        if msg.code != Code._000C or not msg.payload[SZ_DEVICES]:  # zone_devices
+            return
 
-            if not (dev_ids := msg.payload[SZ_DEVICES]):
-                return
-            if len(dev_ids) != 1:
-                raise InvalidPayloadError("No devices")
+        # FIXME: is messy
+        if not (dev_ids := msg.payload[SZ_DEVICES]):
+            return
+        if len(dev_ids) != 1:
+            raise exc.PacketPayloadInvalid("No devices")
 
-            # ctl = self._gwy.device_by_id.get(dev_ids[0])
-            ctl = self._gwy.get_device(dev_ids[0])
-            if not ctl or (self._ctl and self._ctl is not ctl):
-                raise InvalidPayloadError("No CTL")
-            self._ctl = ctl
+        # ctl = self._gwy.device_by_id.get(dev_ids[0])
+        ctl: Controller = self._gwy.get_device(dev_ids[0])
+        if not ctl or (self._ctl and self._ctl is not ctl):
+            raise exc.PacketPayloadInvalid("No CTL")
+        self._ctl = ctl
 
-            ctl._make_tcs_controller()
-            # self.set_parent(ctl.tcs)
+        ctl._make_tcs_controller()
+        # self.set_parent(ctl.tcs)
 
-            zon = ctl.tcs.get_htg_zone(msg.payload[SZ_ZONE_IDX])
-            if not zon:
-                raise InvalidPayloadError("No Zone")
-            if self._zone and self._zone is not zon:
-                raise InvalidPayloadError("Wrong Zone")
-            self._zone = zon
+        zon = ctl.tcs.get_htg_zone(msg.payload[SZ_ZONE_IDX])
+        if not zon:
+            raise exc.PacketPayloadInvalid("No Zone")
+        if self._zone and self._zone is not zon:
+            raise exc.PacketPayloadInvalid("Wrong Zone")
+        self._zone = zon
 
-            if self not in self._zone.actuators:
-                schema = {SZ_ACTUATORS: [self.ufc.id], SZ_CIRCUITS: [self.id]}
-                self._zone._update_schema(**schema)
+        if self.ufc not in self._zone.actuators:
+            schema = {SZ_ACTUATORS: [self.ufc.id], SZ_CIRCUITS: [self.id]}
+            self._zone._update_schema(**schema)
 
     @property
     def ufx_idx(self) -> str:
         return self._child_id
 
     @property
-    def zone_idx(self) -> None | str:
+    def zone_idx(self) -> str | None:
         if self._zone:
             return self._zone._child_id
+        return None
 
 
-HEAT_CLASS_BY_SLUG = class_by_attr(__name__, "_SLUG")  # e.g. CTL: Controller
+# e.g. {"CTL": Controller}
+HEAT_CLASS_BY_SLUG: dict[str, type[DeviceHeat]] = class_by_attr(__name__, "_SLUG")
 
 _HEAT_VC_PAIR_BY_CLASS = {
-    DEV_TYPE.DHW: ((I_, Code._1260),),
-    DEV_TYPE.OTB: ((I_, Code._3220), (RP, Code._3220)),
+    DevType.DHW: ((I_, Code._1260),),
+    DevType.OTB: ((I_, Code._3220), (RP, Code._3220)),
 }
 
 
 def class_dev_heat(
-    dev_addr: Address, *, msg: Message = None, eavesdrop: bool = False
-) -> type[Device]:
+    dev_addr: Address, *, msg: Message | None = None, eavesdrop: bool = False
+) -> type[DeviceHeat]:
     """Return a device class, but only if the device must be from the CH/DHW group.
 
     May return a device class, DeviceHeat (which will need promotion).
     """
 
     if dev_addr.type in DEV_TYPE_MAP.THM_DEVICES:
-        return HEAT_CLASS_BY_SLUG[DEV_TYPE.THM]
+        return HEAT_CLASS_BY_SLUG[DevType.THM]
 
     try:
         slug = DEV_TYPE_MAP.slug(dev_addr.type)