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

ramses_rf/device/hvac.py

@@ -1,53 +1,52 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-"""RAMSES RF - a RAMSES-II protocol decoder & analyser.
+"""RAMSES RF - devices from the HVAC domain."""
 
-HVAC devices.
-"""
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
-from ..const import (
-    DEV_TYPE,
-    FAN_MODE,
+from ramses_rf import exceptions as exc
+from ramses_rf.const import (
     SZ_AIR_QUALITY,
-    SZ_AIR_QUALITY_BASE,
+    SZ_AIR_QUALITY_BASIS,
     SZ_BOOST_TIMER,
+    SZ_BYPASS_MODE,
     SZ_BYPASS_POSITION,
+    SZ_BYPASS_STATE,
     SZ_CO2_LEVEL,
     SZ_EXHAUST_FAN_SPEED,
     SZ_EXHAUST_FLOW,
-    SZ_EXHAUST_TEMPERATURE,
+    SZ_EXHAUST_TEMP,
     SZ_FAN_INFO,
+    SZ_FAN_MODE,
+    SZ_FAN_RATE,
     SZ_INDOOR_HUMIDITY,
-    SZ_INDOOR_TEMPERATURE,
+    SZ_INDOOR_TEMP,
     SZ_OUTDOOR_HUMIDITY,
-    SZ_OUTDOOR_TEMPERATURE,
+    SZ_OUTDOOR_TEMP,
     SZ_POST_HEAT,
     SZ_PRE_HEAT,
     SZ_PRESENCE_DETECTED,
-    SZ_REMAINING_TIME,
-    SZ_SPEED_CAP,
+    SZ_REMAINING_DAYS,
+    SZ_REMAINING_MINS,
+    SZ_REMAINING_PERCENT,
+    SZ_SPEED_CAPABILITIES,
     SZ_SUPPLY_FAN_SPEED,
     SZ_SUPPLY_FLOW,
-    SZ_SUPPLY_TEMPERATURE,
+    SZ_SUPPLY_TEMP,
     SZ_TEMPERATURE,
-    __dev_mode__,
+    DevType,
 )
-from ..entity_base import class_by_attr
-from ..helpers import shrink
-from ..protocol import Address, Message
-from ..protocol.command import Command
-from ..protocol.const import SZ_BINDINGS
-from ..protocol.ramses import CODES_OF_HVAC_DOMAIN_ONLY, HVAC_KLASS_BY_VC_PAIR
-from ..schemas import SCH_VCS, SZ_REMOTES, SZ_SENSORS
-from .base import BatteryState, Device, DeviceHvac, Fakeable
-
-# skipcq: PY-W2000
-from ..const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
+from ramses_rf.entity_base import class_by_attr
+from ramses_rf.helpers import shrink
+from ramses_rf.schemas import SCH_VCS, SZ_REMOTES, SZ_SENSORS
+from ramses_tx import Address, Command, Message, Packet, Priority
+from ramses_tx.ramses import CODES_OF_HVAC_DOMAIN_ONLY, HVAC_KLASS_BY_VC_PAIR
+
+from .base import BatteryState, DeviceHvac, Fakeable
+
+from ramses_rf.const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
     I_,
     RP,
     RQ,
@@ -55,12 +54,19 @@ from ..const import (  # noqa: F401, isort: skip, pylint: disable=unused-import
     Code,
 )
 
+# TODO: Switch this module to utilise the (run-time) decorator design pattern...
+# - https://refactoring.guru/design-patterns/decorator/python/example
+# - will probably need setattr()?
+# BaseComponents: FAN (HRU, PIV, EXT), SENsor (CO2, HUM, TEMp), SWItch (RF gateway?)
+# - a device could be a combination of above (e.g. Spider Gateway)
+# Track binding for SWI (HA service call) & SEN (HA trigger) to FAN/other
+
+# Challenges:
+# - may need two-tier system (HVAC -> FAN|SEN|SWI -> command class)
+# - thus, Composite design pattern may be more appropriate
 
-DEV_MODE = __dev_mode__  # and False
 
 _LOGGER = logging.getLogger(__name__)
-if DEV_MODE:
-    _LOGGER.setLevel(logging.DEBUG)
 
 
 _HvacRemoteBaseT = TypeVar("_HvacRemoteBaseT", bound="HvacRemoteBase")
@@ -75,33 +81,22 @@ class HvacSensorBase(DeviceHvac):
     pass
 
 
-class CarbonDioxide(Fakeable, HvacSensorBase):  # 1298
+class CarbonDioxide(HvacSensorBase):  # 1298
     """The CO2 sensor (cardinal code is 1298)."""
 
-    def _bind(self):
-        # .I --- 29:181813 63:262142 --:------ 1FC9 030 00-31E0-76C635 01-31E0-76C635 00-1298-76C635 67-10E0-76C635 00-1FC9-76C635
-        # .W --- 32:155617 29:181813 --:------ 1FC9 012 00-31D9-825FE1 00-31DA-825FE1  # The HRU
-        # .I --- 29:181813 32:155617 --:------ 1FC9 001 00
-
-        def callback(msg):
-            """Use the accept pkt to determine the zone/domain 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._1298, Code._31E0), callback=callback)
-
     @property
-    def co2_level(self) -> None | float:
+    def co2_level(self) -> int | None:  # 1298
         return self._msg_value(Code._1298, key=SZ_CO2_LEVEL)
 
-    # @check_faking_enabled
     @co2_level.setter
-    def co2_level(self, value) -> None:
-        if not self._faked:
-            raise RuntimeError(f"Faking is not enabled for {self}")
-        self._send_cmd(Command.put_co2_level(self.id, value))
-        # lf._send_cmd(Command.get_co2_level(...))
+    def co2_level(self, value: int | None) -> None:
+        """Fake the CO2 level of the sensor."""
+
+        if not self.is_faked:
+            raise exc.DeviceNotFaked(f"{self}: Faking is not enabled")
+
+        cmd = Command.put_co2_level(self.id, value)
+        self._gwy.send_cmd(cmd, num_repeats=2, priority=Priority.HIGH)
 
     @property
     def status(self) -> dict[str, Any]:
@@ -111,33 +106,22 @@ class CarbonDioxide(Fakeable, HvacSensorBase):  # 1298
         }
 
 
-class IndoorHumidity(Fakeable, HvacSensorBase):  # 12A0
+class IndoorHumidity(HvacSensorBase):  # 12A0
     """The relative humidity sensor (12A0)."""
 
-    def _bind(self):
-        # .I ---
-        # .W ---
-        # .I ---
-
-        def callback(msg):
-            """Use the accept pkt to determine the zone/domain 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._12A0, Code._31E0), callback=callback)
-
     @property
-    def indoor_humidity(self) -> None | float:
+    def indoor_humidity(self) -> float | None:  # 12A0
         return self._msg_value(Code._12A0, key=SZ_INDOOR_HUMIDITY)
 
-    # @check_faking_enabled
     @indoor_humidity.setter
-    def indoor_humidity(self, value) -> None:
-        if not self._faked:
-            raise RuntimeError(f"Faking is not enabled for {self}")
-        self._send_cmd(Command.put_indoor_humidity(self.id, value))
-        # lf._send_cmd(Command.get_indoor_humidity(...))
+    def indoor_humidity(self, value: float | None) -> None:
+        """Fake the indoor humidity of the sensor."""
+
+        if not self.is_faked:
+            raise exc.DeviceNotFaked(f"{self}: Faking is not enabled")
+
+        cmd = Command.put_indoor_humidity(self.id, value)
+        self._gwy.send_cmd(cmd, num_repeats=2, priority=Priority.HIGH)
 
     @property
     def status(self) -> dict[str, Any]:
@@ -147,33 +131,26 @@ class IndoorHumidity(Fakeable, HvacSensorBase):  # 12A0
         }
 
 
-class PresenceDetect(Fakeable, HvacSensorBase):  # 2E10
+class PresenceDetect(HvacSensorBase):  # 2E10
     """The presence sensor (2E10/31E0)."""
 
-    def _bind(self):
-        # .I --- 37:154011 --:------ 37:154011 1FC9 030 00-31E0-96599B 00-1298-96599B 00-2E10-96599B 01-10E0-96599B 00-1FC9-96599B              # CO2, idx|10E0 == 01
-        # .W --- 28:126620 37:154011 --:------ 1FC9 012 00-31D9-49EE9C 00-31DA-49EE9C                                                     # FAN, BRDG-02A55
-        # .I --- 37:154011 28:126620 --:------ 1FC9 001 00                                                                            # CO2, incl. integrated control, PIR
-
-        def callback(msg):
-            """Use the accept pkt to determine the zone/domain 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._2E10, Code._31E0), callback=callback)
+    # .I --- 37:154011 --:------ 37:154011 1FC9 030 00-31E0-96599B 00-1298-96599B 00-2E10-96599B 01-10E0-96599B 00-1FC9-96599B    # CO2, idx|10E0 == 01
+    # .W --- 28:126620 37:154011 --:------ 1FC9 012 00-31D9-49EE9C 00-31DA-49EE9C                                                 # FAN, BRDG-02A55
+    # .I --- 37:154011 28:126620 --:------ 1FC9 001 00                                                                            # CO2, incl. integrated control, PIR
 
     @property
-    def presence_detected(self) -> None | float:
+    def presence_detected(self) -> bool | None:
         return self._msg_value(Code._2E10, key=SZ_PRESENCE_DETECTED)
 
-    # @check_faking_enabled
     @presence_detected.setter
-    def presence_detected(self, value) -> None:
-        if not self._faked:
-            raise RuntimeError(f"Faking is not enabled for {self}")
-        self._send_cmd(Command.put_presence_detected(self.id, value))
-        # lf._send_cmd(Command.get_presence_detected(...))
+    def presence_detected(self, value: bool | None) -> None:
+        """Fake the presence state of the sensor."""
+
+        if not self.is_faked:
+            raise exc.DeviceNotFaked(f"{self}: Faking is not enabled")
+
+        cmd = Command.put_presence_detected(self.id, value)
+        self._gwy.send_cmd(cmd, num_repeats=2, priority=Priority.HIGH)
 
     @property
     def status(self) -> dict[str, Any]:
@@ -194,16 +171,24 @@ class FilterChange(DeviceHvac):  # FAN: 10D0
         )
 
     @property
-    def filter_remaining(self) -> Optional[int]:
-        return self._msg_value(Code._10D0, key="days_remaining")
+    def filter_remaining(self) -> int | None:
+        _val = self._msg_value(Code._10D0, key=SZ_REMAINING_DAYS)
+        assert isinstance(_val, (int | type(None)))
+        return _val
+
+    @property
+    def filter_remaining_percent(self) -> float | None:
+        _val = self._msg_value(Code._10D0, key=SZ_REMAINING_PERCENT)
+        assert isinstance(_val, (float | type(None)))
+        return _val
 
 
 class RfsGateway(DeviceHvac):  # RFS: (spIDer gateway)
     """The spIDer gateway base class."""
 
-    _SLUG: str = DEV_TYPE.RFS
+    _SLUG: str = DevType.RFS
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         self.ctl = None
@@ -211,20 +196,20 @@ class RfsGateway(DeviceHvac):  # RFS: (spIDer gateway)
         self.tcs = None
 
 
-class HvacHumiditySensor(BatteryState, IndoorHumidity):  # HUM: I/12A0
+class HvacHumiditySensor(BatteryState, IndoorHumidity, Fakeable):  # HUM: I/12A0
     """The class for a humidity sensor.
 
     The cardinal code is 12A0.
     """
 
-    _SLUG: str = DEV_TYPE.HUM
+    _SLUG: str = DevType.HUM
 
     @property
-    def temperature(self) -> None | float:  # Celsius
+    def temperature(self) -> float | None:  # Celsius
         return self._msg_value(Code._12A0, key=SZ_TEMPERATURE)
 
     @property
-    def dewpoint_temp(self) -> None | float:  # Celsius
+    def dewpoint_temp(self) -> float | None:  # Celsius
         return self._msg_value(Code._12A0, key="dewpoint_temp")
 
     @property
@@ -236,13 +221,22 @@ class HvacHumiditySensor(BatteryState, IndoorHumidity):  # HUM: I/12A0
         }
 
 
-class HvacCarbonDioxideSensor(CarbonDioxide):  # CO2: I/1298
+class HvacCarbonDioxideSensor(CarbonDioxide, Fakeable):  # CO2: I/1298
     """The class for a CO2 sensor.
 
     The cardinal code is 1298.
     """
 
-    _SLUG: str = DEV_TYPE.CO2
+    _SLUG: str = DevType.CO2
+
+    # .I --- 29:181813 63:262142 --:------ 1FC9 030 00-31E0-76C635 01-31E0-76C635 00-1298-76C635 67-10E0-76C635 00-1FC9-76C635
+    # .W --- 32:155617 29:181813 --:------ 1FC9 012 00-31D9-825FE1 00-31DA-825FE1  # The HRU
+    # .I --- 29:181813 32:155617 --:------ 1FC9 001 00
+
+    async def initiate_binding_process(self) -> Packet:
+        return await super()._initiate_binding_process(
+            (Code._31E0, Code._1298, Code._2E10)
+        )
 
 
 class HvacRemote(BatteryState, Fakeable, HvacRemoteBase):  # REM: I/22F[138]
@@ -251,48 +245,48 @@ class HvacRemote(BatteryState, Fakeable, HvacRemoteBase):  # REM: I/22F[138]
     The cardinal codes are 22F1, 22F3 (also 22F8?).
     """
 
-    _SLUG: str = DEV_TYPE.REM
+    _SLUG: str = DevType.REM
 
-    def _bind(self):
-        # .I --- 37:155617 --:------ 37:155617 1FC9 024 0022F1965FE10022F3965FE16710E0965FE1001FC9965FE1
-        # .W --- 32:155617 37:155617 --:------ 1FC9 012 0031D9825FE10031DA825FE1
+    async def initiate_binding_process(self) -> Packet:
+        # .I --- 37:155617 --:------ 37:155617 1FC9 024 00-22F1-965FE1 00-22F3-965FE1 67-10E09-65FE1 00-1FC9-965FE1
+        # .W --- 32:155617 37:155617 --:------ 1FC9 012 00-31D9-825FE1 00-31DA-825FE1
         # .I --- 37:155617 32:155617 --:------ 1FC9 001 00
 
-        def callback(msg):  # TODO: set_parent()
-            """Use the accept pkt to determine the zone/domain 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._22F1, Code._22F3), callback=callback)
+        return await super()._initiate_binding_process(
+            Code._22F1 if self._scheme == "nuaire" else (Code._22F1, Code._22F3)
+        )
 
     @property
-    def fan_rate(self) -> None | str:
+    def fan_rate(self) -> str | None:  # 22F1
+        # NOTE: WIP: rate can be int or str
         return self._msg_value(Code._22F1, key="rate")
 
-    # @check_faking_enabled
     @fan_rate.setter
-    def fan_rate(self, rate) -> None:  # I/22F1
-        if not self._faked:
-            raise RuntimeError(f"Faking is not enabled for {self}")
-        for _ in range(3):
-            self._send_cmd(
-                Command.set_fan_mode(self.id, int(4 * rate), 4, src_id=self.id)
-            )  # TODO: needs checking
+    def fan_rate(self, value: int) -> None:  # NOTE: value can be int or str, not None
+        """Fake a fan rate from a remote (to a FAN, is a WIP)."""
+
+        if not self.is_faked:  # NOTE: some remotes are stateless (i.e. except seqn)
+            raise exc.DeviceNotFaked(f"{self}: Faking is not enabled")
+
+        # TODO: num_repeats=2, or wait_for_reply=True ?
+
+        # NOTE: this is not completely understood (i.e. diffs between vendor schemes)
+        cmd = Command.set_fan_mode(self.id, int(4 * value), src_id=self.id)
+        self._gwy.send_cmd(cmd, num_repeats=2, priority=Priority.HIGH)
 
     @property
-    def fan_mode(self) -> None | str:
-        return self._msg_value(Code._22F1, key=FAN_MODE)
+    def fan_mode(self) -> str | None:
+        return self._msg_value(Code._22F1, key=SZ_FAN_MODE)
 
     @property
-    def boost_timer(self) -> Optional[int]:
+    def boost_timer(self) -> int | None:
         return self._msg_value(Code._22F3, key=SZ_BOOST_TIMER)
 
     @property
     def status(self) -> dict[str, Any]:
         return {
             **super().status,
-            FAN_MODE: self.fan_mode,
+            SZ_FAN_MODE: self.fan_mode,
             SZ_BOOST_TIMER: self.boost_timer,
         }
 
@@ -300,23 +294,33 @@ class HvacRemote(BatteryState, Fakeable, HvacRemoteBase):  # REM: I/22F[138]
 class HvacDisplayRemote(HvacRemote):  # DIS
     """The DIS (display switch)."""
 
-    _SLUG: str = DEV_TYPE.DIS
+    _SLUG: str = DevType.DIS
+
+    # async def initiate_binding_process(self) -> Packet:
+    #     return await super()._initiate_binding_process(
+    #         (Code._31E0, Code._1298, Code._2E10)
+    #     )
 
 
 class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A]
     """The FAN (ventilation) class.
 
-    The cardinal code are 31D9, 31DA.  Signature is RP/31DA.
+    The cardinal codes are 31D9, 31DA.  Signature is RP/31DA.
     """
 
     # Itho Daalderop (NL)
     # Heatrae Sadia (UK)
     # Nuaire (UK), e.g. DRI-ECO-PIV
     # Orcon/Ventiline
+    # ClimaRad (NL)
+    # Vasco (B)
 
-    _SLUG: str = DEV_TYPE.FAN
+    _SLUG: str = DevType.FAN
 
-    def _update_schema(self, **schema):
+    def _handle_msg(self, *args: Any, **kwargs: Any) -> None:
+        return super()._handle_msg(*args, **kwargs)
+
+    def _update_schema(self, **schema: Any) -> None:
         """Update a FAN with new schema attrs.
 
         Raise an exception if the new schema is not a superset of the existing schema.
@@ -324,11 +328,11 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A]
 
         schema = shrink(SCH_VCS(schema))
 
-        for dev_id in schema.get(SZ_REMOTES, {}).keys():
-            self._gwy.get_device(self._gwy, dev_id)
+        for dev_id in schema.get(SZ_REMOTES, {}):
+            self._gwy.get_device(dev_id)
 
-        for dev_id in schema.get(SZ_SENSORS, {}).keys():
-            self._gwy.get_device(self._gwy, dev_id)
+        for dev_id in schema.get(SZ_SENSORS, {}):
+            self._gwy.get_device(dev_id)
 
     def _setup_discovery_cmds(self) -> None:
         super()._setup_discovery_cmds()
@@ -357,80 +361,186 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A]
             )
 
     @property
-    def air_quality(self) -> None | float:
+    def air_quality(self) -> float | None:
         return self._msg_value(Code._31DA, key=SZ_AIR_QUALITY)
 
     @property
-    def air_quality_base(self) -> None | float:
-        return self._msg_value(Code._31DA, key=SZ_AIR_QUALITY_BASE)
+    def air_quality_base(self) -> float | None:
+        return self._msg_value(Code._31DA, key=SZ_AIR_QUALITY_BASIS)
 
     @property
-    def bypass_position(self) -> Optional[int]:
-        return self._msg_value(Code._31DA, key=SZ_BYPASS_POSITION)
+    def bypass_mode(self) -> str | None:
+        """
+        :return: bypass mode as on|off|auto
+        """
+        return self._msg_value(Code._22F7, key=SZ_BYPASS_MODE)
 
     @property
-    def co2_level(self) -> Optional[int]:
-        return self._msg_value(Code._31DA, key=SZ_CO2_LEVEL)
+    def bypass_position(self) -> float | str | None:
+        """
+        Position info is found in 22F7 and in 31DA. Both are picked up, ignoring None.
+        :return: bypass position as percentage: 0.0 (closed) or 1.0 (open), on error: "x_faulted"
+        """
+        for code in [c for c in (Code._22F7, Code._31DA) if c in self._msgs]:
+            if v := self._msgs[code].payload.get(SZ_BYPASS_POSITION):
+                if v is not None:  # skip none (to fetch other code)
+                    assert isinstance(v, (float | str))
+                    return v
+                # if both packets exist and both have the key, return the most recent
+        return None
+
+    @property
+    def bypass_state(self) -> str | None:
+        """
+        Orcon, others?
+        :return: bypass position as on/off
+        """
+        return self._msg_value(Code._22F7, key=SZ_BYPASS_STATE)
 
     @property
-    def exhaust_fan_speed(self) -> None | float:  # was from: (Code._31D9, Code._31DA)
-        return self._msg_value(Code._31DA, key=SZ_EXHAUST_FAN_SPEED)
+    def co2_level(self) -> int | None:
+        return self._msg_value(Code._31DA, key=SZ_CO2_LEVEL)
 
     @property
-    def exhaust_flow(self) -> None | float:
+    def exhaust_fan_speed(
+        self,
+    ) -> float | None:
+        """
+        Some fans (Vasco, Itho) use Code._31D9 for speed + mode,
+        Orcon sends SZ_EXHAUST_FAN_SPEED in 31DA. See parser for details.
+        :return: speed as percentage
+        """
+        speed: float = -1
+        for code in [c for c in (Code._31D9, Code._31DA) if c in self._msgs]:
+            if v := self._msgs[code].payload.get(SZ_EXHAUST_FAN_SPEED):
+                # if both packets exist and both have the key, use the highest value
+                if v is not None:
+                    speed = max(v, speed)
+        if speed >= 0:
+            return speed
+        return None
+
+    @property
+    def exhaust_flow(self) -> float | None:
         return self._msg_value(Code._31DA, key=SZ_EXHAUST_FLOW)
 
     @property
-    def exhaust_temperature(self) -> None | float:
-        return self._msg_value(Code._31DA, key=SZ_EXHAUST_TEMPERATURE)
+    def exhaust_temp(self) -> float | None:
+        if Code._12A0 in self._msgs and isinstance(
+            self._msgs[Code._12A0].payload, list
+        ):  # FAN Ventura sends RH/temps as a list, use element [2] for exhaust temp
+            if v := self._msgs[Code._12A0].payload[2].get(SZ_TEMPERATURE):
+                assert isinstance(v, (float | type(None)))
+                return v
+            return None
+        return self._msg_value(Code._31DA, key=SZ_EXHAUST_TEMP)
 
     @property
-    def fan_info(self) -> None | str:
-        return self._msg_value(Code._31DA, key=SZ_FAN_INFO)
+    def fan_rate(self) -> str | None:
+        """
+        Lookup fan mode description from _22F4  message payload, e.g. "low", "medium", "boost".
+        For manufacturers Orcon, Vasco, ClimaRad.
+
+        :return: int or str describing rate of fan
+        """
+        return self._msg_value(Code._22F4, key=SZ_FAN_RATE)
 
     @property
-    def indoor_humidity(self) -> None | float:
-        return self._msg_value(Code._31DA, key=SZ_INDOOR_HUMIDITY)
+    def fan_mode(self) -> str | None:
+        """
+        Lookup fan mode description from _22F4  message payload, e.g. "auto", "manual", "off".
+        For manufacturers Orcon, Vasco, ClimaRad.
+
+        :return: a string describing mode
+        """
+        return self._msg_value(Code._22F4, key=SZ_FAN_MODE)
 
     @property
-    def indoor_temperature(self) -> None | float:
-        return self._msg_value(Code._31DA, key=SZ_INDOOR_TEMPERATURE)
+    def fan_info(self) -> str | None:
+        """
+        Extract fan info description from _31D9 or _31DA message payload, e.g. "speed 2, medium".
+        By its name, the result is automatically displayed in HA Climate UI.
+        Some manufacturers (Orcon, Vasco) include the fan mode (auto, manual), others don't (Itho).
+
+        :return: a string describing mode, speed
+        """
+        if Code._31D9 in self._msgs:
+            # Itho, Vasco D60 and ClimaRad (MiniBox fan) send mode/speed in _31D9
+            v: str
+            for k, v in self._msgs[Code._31D9].payload.items():
+                if k == SZ_FAN_MODE and len(v) > 2:  # prevent non-lookups to pass
+                    return v
+            # continue to 31DA
+        return str(self._msg_value(Code._31DA, key=SZ_FAN_INFO))  # Itho lookup
 
     @property
-    def outdoor_humidity(self) -> None | float:
+    def indoor_humidity(self) -> float | None:
+        """
+        Extract humidity value from _12A0 or _31DA JSON message payload
+
+        :return: percentage <= 1.0
+        """
+        if Code._12A0 in self._msgs and isinstance(
+            self._msgs[Code._12A0].payload, list
+        ):  # FAN Ventura sends a list, use element [0]
+            if v := self._msgs[Code._12A0].payload[0].get(SZ_INDOOR_HUMIDITY):
+                assert isinstance(v, (float | type(None)))
+                return v
+            return None  # prevent AttributeError: 'list' object has no attribute 'get'
+        for code in [c for c in (Code._12A0, Code._31DA) if c in self._msgs]:
+            if v := self._msgs[code].payload.get(SZ_INDOOR_HUMIDITY):
+                if v is not None:  # skip none (to check the other code)
+                    assert isinstance(v, float)
+                    return v
+        return None
+
+    @property
+    def indoor_temp(self) -> float | None:
+        if Code._12A0 in self._msgs and isinstance(
+            self._msgs[Code._12A0].payload, list
+        ):  # FAN Ventura sends RH/temps as a list; element [0] is indoor_temp
+            if v := self._msgs[Code._12A0].payload[0].get(SZ_TEMPERATURE):
+                assert isinstance(v, (float | type(None)))
+                return v
+        else:
+            return self._msg_value(Code._31DA, key=SZ_INDOOR_TEMP)
+        return None
+
+    @property
+    def outdoor_humidity(self) -> float | None:
         return self._msg_value(Code._31DA, key=SZ_OUTDOOR_HUMIDITY)
 
     @property
-    def outdoor_temperature(self) -> None | float:
-        return self._msg_value(Code._31DA, key=SZ_OUTDOOR_TEMPERATURE)
+    def outdoor_temp(self) -> float | None:
+        return self._msg_value(Code._31DA, key=SZ_OUTDOOR_TEMP)
 
     @property
-    def post_heat(self) -> Optional[int]:
+    def post_heat(self) -> int | None:
         return self._msg_value(Code._31DA, key=SZ_POST_HEAT)
 
     @property
-    def pre_heat(self) -> Optional[int]:
+    def pre_heat(self) -> int | None:
         return self._msg_value(Code._31DA, key=SZ_PRE_HEAT)
 
     @property
-    def remaining_time(self) -> Optional[int]:
-        return self._msg_value(Code._31DA, key=SZ_REMAINING_TIME)
+    def remaining_mins(self) -> int | None:
+        return self._msg_value(Code._31DA, key=SZ_REMAINING_MINS)
 
     @property
-    def speed_cap(self) -> Optional[int]:
-        return self._msg_value(Code._31DA, key=SZ_SPEED_CAP)
+    def speed_cap(self) -> int | None:
+        return self._msg_value(Code._31DA, key=SZ_SPEED_CAPABILITIES)
 
     @property
-    def supply_fan_speed(self) -> None | float:
+    def supply_fan_speed(self) -> float | None:
         return self._msg_value(Code._31DA, key=SZ_SUPPLY_FAN_SPEED)
 
     @property
-    def supply_flow(self) -> None | float:
+    def supply_flow(self) -> float | None:
         return self._msg_value(Code._31DA, key=SZ_SUPPLY_FLOW)
 
     @property
-    def supply_temperature(self) -> None | float:
-        return self._msg_value(Code._31DA, key=SZ_SUPPLY_TEMPERATURE)
+    def supply_temp(self) -> float | None:
+        return self._msg_value(Code._31DA, key=SZ_SUPPLY_TEMP)
 
     @property
     def status(self) -> dict[str, Any]:
@@ -439,13 +549,17 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A]
             SZ_EXHAUST_FAN_SPEED: self.exhaust_fan_speed,
             **{
                 k: v
-                for code in (Code._31D9, Code._31DA)
+                for code in [c for c in (Code._31D9, Code._31DA) if c in self._msgs]
                 for k, v in self._msgs[code].payload.items()
-                if code in self._msgs
                 if k != SZ_EXHAUST_FAN_SPEED
             },
         }
 
+    @property
+    def temperature(self) -> float | None:  # Celsius
+        # ClimaRad minibox FAN sends (indoor) temp in 12A0
+        return self._msg_value(Code._12A0, key=SZ_TEMPERATURE)
+
 
 # class HvacFanHru(HvacVentilator):
 #     """A Heat recovery unit (aka: HRU, WTW)."""
@@ -458,12 +572,13 @@ class HvacVentilator(FilterChange):  # FAN: RP/31DA, I/31D[9A]
 #     _SLUG: str = DEV_TYPE.PIV
 
 
-HVAC_CLASS_BY_SLUG = class_by_attr(__name__, "_SLUG")  # e.g. HUM: HvacHumiditySensor
+# e.g. {"HUM": HvacHumiditySensor}
+HVAC_CLASS_BY_SLUG: dict[str, type[DeviceHvac]] = class_by_attr(__name__, "_SLUG")
 
 
 def class_dev_hvac(
-    dev_addr: Address, *, msg: Message = None, eavesdrop: bool = False
-) -> type[Device]:
+    dev_addr: Address, *, msg: Message | None = None, eavesdrop: bool = False
+) -> type[DeviceHvac]:
     """Return a device class, but only if the device must be from the HVAC group.
 
     May return a base clase, DeviceHvac, which will need promotion.