python-qube-heatpump 1.2.3__py3-none-any.whl → 1.3.0__py3-none-any.whl

python_qube_heatpump/__init__.py

@@ -1,3 +1,39 @@
+"""Python library for Qube Heat Pump Modbus communication."""
+
 from .client import QubeClient
+from .const import (
+    DataType,
+    ModbusType,
+    StatusCode,
+    STATUS_CODE_MAP,
+    get_status_code,
+)
+from .entities import (
+    BINARY_SENSORS,
+    EntityDef,
+    InputType,
+    Platform,
+    SENSORS,
+    SWITCHES,
+)
+from .models import QubeState
 
-__all__ = ["QubeClient"]
+__all__ = [
+    # Client
+    "QubeClient",
+    # State
+    "QubeState",
+    # Entity definitions
+    "BINARY_SENSORS",
+    "EntityDef",
+    "InputType",
+    "Platform",
+    "SENSORS",
+    "SWITCHES",
+    # Constants
+    "DataType",
+    "ModbusType",
+    "StatusCode",
+    "STATUS_CODE_MAP",
+    "get_status_code",
+]

python_qube_heatpump/client.py

@@ -1,12 +1,16 @@
 """Client for Qube Heat Pump."""
 
+from __future__ import annotations
+
 import logging
 import struct
-from typing import Optional
+from typing import Any
 
 from pymodbus.client import AsyncModbusTcpClient
 
 from . import const
+from .entities import BINARY_SENSORS, SENSORS, SWITCHES, EntityDef
+from .entities.base import DataType, InputType
 from .models import QubeState
 
 _LOGGER = logging.getLogger(__name__)
@@ -76,7 +80,7 @@ class QubeClient:
 
         return state
 
-    async def read_value(self, definition: tuple) -> Optional[float]:
+    async def read_value(self, definition: tuple) -> float | None:
         """Read a single value based on the constant definition."""
         address, reg_type, data_type, scale, offset = definition
 
@@ -156,3 +160,255 @@ class QubeClient:
         except Exception as e:
             _LOGGER.error("Exception reading address %s: %s", address, e)
             return None
+
+    async def read_entity(self, entity: EntityDef) -> Any:
+        """Read a single entity value based on EntityDef.
+
+        Args:
+            entity: The entity definition to read.
+
+        Returns:
+            The read value (float, int, or bool depending on entity type).
+        """
+        # Determine register count based on data type
+        if entity.data_type in (DataType.FLOAT32, DataType.UINT32, DataType.INT32):
+            count = 2
+        else:
+            count = 1
+
+        try:
+            # Read based on input type
+            if entity.input_type == InputType.COIL:
+                result = await self._client.read_coils(
+                    entity.address, count=1, slave=self.unit
+                )
+                if result.isError():
+                    _LOGGER.warning("Error reading coil %s", entity.address)
+                    return None
+                return bool(result.bits[0])
+
+            if entity.input_type == InputType.DISCRETE_INPUT:
+                result = await self._client.read_discrete_inputs(
+                    entity.address, count=1, slave=self.unit
+                )
+                if result.isError():
+                    _LOGGER.warning("Error reading discrete input %s", entity.address)
+                    return None
+                return bool(result.bits[0])
+
+            if entity.input_type == InputType.INPUT_REGISTER:
+                result = await self._client.read_input_registers(
+                    entity.address, count, slave=self.unit
+                )
+            else:  # HOLDING_REGISTER
+                result = await self._client.read_holding_registers(
+                    entity.address, count, slave=self.unit
+                )
+
+            if result.isError():
+                _LOGGER.warning("Error reading address %s", entity.address)
+                return None
+
+            regs = result.registers
+            val: float | int = 0
+
+            # Decode based on data type
+            if entity.data_type == DataType.FLOAT32:
+                int_val = (regs[1] << 16) | regs[0]
+                val = struct.unpack(">f", struct.pack(">I", int_val))[0]
+            elif entity.data_type == DataType.INT16:
+                val = regs[0]
+                if val > 32767:
+                    val -= 65536
+            elif entity.data_type == DataType.UINT16:
+                val = regs[0]
+            elif entity.data_type == DataType.UINT32:
+                val = (regs[1] << 16) | regs[0]
+            elif entity.data_type == DataType.INT32:
+                val = (regs[1] << 16) | regs[0]
+                if val > 2147483647:
+                    val -= 4294967296
+
+            # Apply scale and offset
+            if entity.scale is not None:
+                val = val * entity.scale
+            if entity.offset is not None:
+                val = val + entity.offset
+
+            return val
+
+        except Exception as e:
+            _LOGGER.error("Exception reading entity %s: %s", entity.key, e)
+            return None
+
+    async def read_sensor(self, key: str) -> float | int | None:
+        """Read a sensor value by key.
+
+        Args:
+            key: The sensor key (e.g., 'temp_supply').
+
+        Returns:
+            The sensor value, or None if not found or error.
+        """
+        entity = SENSORS.get(key)
+        if entity is None:
+            _LOGGER.warning("Unknown sensor key: %s", key)
+            return None
+        return await self.read_entity(entity)
+
+    async def read_binary_sensor(self, key: str) -> bool | None:
+        """Read a binary sensor value by key.
+
+        Args:
+            key: The binary sensor key (e.g., 'dout_srcpmp_val').
+
+        Returns:
+            The binary sensor value, or None if not found or error.
+        """
+        entity = BINARY_SENSORS.get(key)
+        if entity is None:
+            _LOGGER.warning("Unknown binary sensor key: %s", key)
+            return None
+        return await self.read_entity(entity)
+
+    async def read_switch(self, key: str) -> bool | None:
+        """Read a switch state by key.
+
+        Args:
+            key: The switch key (e.g., 'bms_summerwinter').
+
+        Returns:
+            The switch state, or None if not found or error.
+        """
+        entity = SWITCHES.get(key)
+        if entity is None:
+            _LOGGER.warning("Unknown switch key: %s", key)
+            return None
+        return await self.read_entity(entity)
+
+    async def read_all_sensors(self) -> dict[str, Any]:
+        """Read all sensor values.
+
+        Returns:
+            Dictionary mapping sensor keys to their values.
+        """
+        result: dict[str, Any] = {}
+        for key, entity in SENSORS.items():
+            result[key] = await self.read_entity(entity)
+        return result
+
+    async def read_all_binary_sensors(self) -> dict[str, bool | None]:
+        """Read all binary sensor values.
+
+        Returns:
+            Dictionary mapping binary sensor keys to their values.
+        """
+        result: dict[str, bool | None] = {}
+        for key, entity in BINARY_SENSORS.items():
+            result[key] = await self.read_entity(entity)
+        return result
+
+    async def read_all_switches(self) -> dict[str, bool | None]:
+        """Read all switch states.
+
+        Returns:
+            Dictionary mapping switch keys to their states.
+        """
+        result: dict[str, bool | None] = {}
+        for key, entity in SWITCHES.items():
+            result[key] = await self.read_entity(entity)
+        return result
+
+    async def write_switch(self, key: str, value: bool) -> bool:
+        """Write a switch state by key.
+
+        Args:
+            key: The switch key (e.g., 'bms_summerwinter').
+            value: True to turn on, False to turn off.
+
+        Returns:
+            True if write succeeded, False otherwise.
+        """
+        entity = SWITCHES.get(key)
+        if entity is None:
+            _LOGGER.warning("Unknown switch key: %s", key)
+            return False
+
+        if not entity.writable:
+            _LOGGER.warning("Switch %s is not writable", key)
+            return False
+
+        try:
+            result = await self._client.write_coil(
+                entity.address, value, slave=self.unit
+            )
+            if result.isError():
+                _LOGGER.warning("Error writing switch %s", key)
+                return False
+            return True
+        except Exception as e:
+            _LOGGER.error("Exception writing switch %s: %s", key, e)
+            return False
+
+    async def write_setpoint(self, key: str, value: float) -> bool:
+        """Write a setpoint value by key.
+
+        Args:
+            key: The sensor key for the setpoint (e.g., 'setpoint_dhw').
+            value: The value to write.
+
+        Returns:
+            True if write succeeded, False otherwise.
+        """
+        entity = SENSORS.get(key)
+        if entity is None:
+            _LOGGER.warning("Unknown sensor key: %s", key)
+            return False
+
+        if not entity.writable:
+            _LOGGER.warning("Sensor %s is not writable", key)
+            return False
+
+        if entity.input_type != InputType.HOLDING_REGISTER:
+            _LOGGER.warning("Sensor %s is not a holding register", key)
+            return False
+
+        try:
+            # Reverse scale/offset if needed
+            write_value = value
+            if entity.offset is not None:
+                write_value = write_value - entity.offset
+            if entity.scale is not None:
+                write_value = write_value / entity.scale
+
+            # Encode based on data type
+            if entity.data_type == DataType.FLOAT32:
+                # Pack as big-endian float, then split into two registers
+                packed = struct.pack(">f", write_value)
+                int_val = struct.unpack(">I", packed)[0]
+                regs = [int_val & 0xFFFF, (int_val >> 16) & 0xFFFF]
+                result = await self._client.write_registers(
+                    entity.address, regs, slave=self.unit
+                )
+            elif entity.data_type == DataType.INT16:
+                if write_value < 0:
+                    write_value = int(write_value) + 65536
+                result = await self._client.write_register(
+                    entity.address, int(write_value), slave=self.unit
+                )
+            elif entity.data_type == DataType.UINT16:
+                result = await self._client.write_register(
+                    entity.address, int(write_value), slave=self.unit
+                )
+            else:
+                _LOGGER.warning("Unsupported data type for writing: %s", entity.data_type)
+                return False
+
+            if result.isError():
+                _LOGGER.warning("Error writing setpoint %s", key)
+                return False
+            return True
+
+        except Exception as e:
+            _LOGGER.error("Exception writing setpoint %s: %s", key, e)
+            return False

python_qube_heatpump/const.py

@@ -20,6 +20,42 @@ class DataType(str, Enum):
     UINT32 = "uint32"
 
 
+class StatusCode(str, Enum):
+    """Heat pump status codes."""
+
+    STANDBY = "standby"
+    ALARM = "alarm"
+    KEYBOARD_OFF = "keyboard_off"
+    COMPRESSOR_STARTUP = "compressor_startup"
+    COMPRESSOR_SHUTDOWN = "compressor_shutdown"
+    COOLING = "cooling"
+    HEATING = "heating"
+    START_FAIL = "start_fail"
+    HEATING_DHW = "heating_dhw"
+    UNKNOWN = "unknown"
+
+
+# Map numeric status codes to StatusCode enum values
+STATUS_CODE_MAP: dict[int, StatusCode] = {
+    1: StatusCode.STANDBY,
+    2: StatusCode.ALARM,
+    6: StatusCode.KEYBOARD_OFF,
+    8: StatusCode.COMPRESSOR_STARTUP,
+    9: StatusCode.COMPRESSOR_SHUTDOWN,
+    14: StatusCode.STANDBY,
+    15: StatusCode.COOLING,
+    16: StatusCode.HEATING,
+    17: StatusCode.START_FAIL,
+    18: StatusCode.STANDBY,
+    22: StatusCode.HEATING_DHW,
+}
+
+
+def get_status_code(code: int) -> StatusCode:
+    """Convert numeric status code to StatusCode enum."""
+    return STATUS_CODE_MAP.get(code, StatusCode.UNKNOWN)
+
+
 # Register definitions (Address, Type, Data Type, Scale, Offset)
 # Scale/Offset are None if not used.
 # Format: KEY = (Address, ModbusType, DataType, Scale, Offset)

python_qube_heatpump/entities/__init__.py

@@ -0,0 +1,16 @@
+"""Entity definitions for Qube Heat Pump."""
+
+from .base import DataType, EntityDef, InputType, Platform
+from .binary_sensors import BINARY_SENSORS
+from .sensors import SENSORS
+from .switches import SWITCHES
+
+__all__ = [
+    "BINARY_SENSORS",
+    "DataType",
+    "EntityDef",
+    "InputType",
+    "Platform",
+    "SENSORS",
+    "SWITCHES",
+]

python_qube_heatpump/entities/base.py

@@ -0,0 +1,77 @@
+"""Base classes and enums for entity definitions."""
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class InputType(str, Enum):
+    """Modbus input type for reading values."""
+
+    COIL = "coil"
+    DISCRETE_INPUT = "discrete_input"
+    INPUT_REGISTER = "input"
+    HOLDING_REGISTER = "holding"
+
+
+class DataType(str, Enum):
+    """Data type for register values."""
+
+    FLOAT32 = "float32"
+    INT16 = "int16"
+    UINT16 = "uint16"
+    INT32 = "int32"
+    UINT32 = "uint32"
+
+
+class Platform(str, Enum):
+    """Home Assistant platform type."""
+
+    SENSOR = "sensor"
+    BINARY_SENSOR = "binary_sensor"
+    SWITCH = "switch"
+
+
+@dataclass(frozen=True)
+class EntityDef:
+    """Definition of a Qube heat pump entity.
+
+    This dataclass defines the protocol-level properties of an entity.
+    Home Assistant-specific metadata (device_class, state_class, etc.)
+    should be added by the integration, not here.
+    """
+
+    # Identity
+    key: str
+    """Unique identifier, e.g., 'temp_supply'."""
+
+    name: str
+    """Human-readable name, e.g., 'Supply temperature'."""
+
+    # Modbus specifics
+    address: int
+    """Register or coil address."""
+
+    input_type: InputType
+    """How to read from device (coil, discrete_input, input, holding)."""
+
+    data_type: DataType | None = None
+    """Data type for registers. None for coils/discrete inputs."""
+
+    # Platform hint
+    platform: Platform = Platform.SENSOR
+    """Which HA platform this entity belongs to."""
+
+    # Value transformation
+    scale: float | None = None
+    """Multiply raw value by this factor."""
+
+    offset: float | None = None
+    """Add this to the scaled value."""
+
+    # Unit (protocol-level)
+    unit: str | None = None
+    """Unit of measurement, e.g., '°C', 'kWh', 'W'."""
+
+    # Write capability
+    writable: bool = False
+    """Whether this entity can be written to."""

python_qube_heatpump/entities/binary_sensors.py

@@ -0,0 +1,269 @@
+"""Binary sensor entity definitions for Qube Heat Pump."""
+
+from .base import EntityDef, InputType, Platform
+
+_BINARY_SENSOR_DEFS: tuple[EntityDef, ...] = (
+    EntityDef(
+        key="dout_srcpmp_val",
+        name="Source pump power supply",
+        address=0,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_usrpmp_val",
+        name="User pump power supply",
+        address=1,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_fourwayvlv_val",
+        name="Four-way valve control",
+        address=2,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_cooling_val",
+        name="Cooling active output",
+        address=3,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_threewayvlv_val",
+        name="Three-way valve output (CV/DHW)",
+        address=4,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_bufferpmp_val",
+        name="Buffer pump output",
+        address=5,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_heaterstep1_val",
+        name="Heater 1 output",
+        address=6,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_heaterstep2_val",
+        name="Heater 2 output",
+        address=7,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dout_heaterstep3_val",
+        name="Heater 3 output",
+        address=8,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="keybonoff",
+        name="Heat pump keypad status",
+        address=9,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="al_maxtime_antileg_active",
+        name="Alarm: Max time anti-legionella exceeded",
+        address=10,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="al_maxtime_dhw_active",
+        name="Alarm: Max time DHW exceeded",
+        address=11,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="al_dewpoint_active",
+        name="Alarm: Dewpoint activated",
+        address=12,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="al_underfloorsafety_active",
+        name="Alarm: Supply too hot (CV)",
+        address=13,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="alrm_flw",
+        name="Alarm: Flow CV",
+        address=15,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="usralrms",
+        name="Alarm: Collective alarm CV",
+        address=16,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="coolingalrms",
+        name="Alarm: Collective alarm cooling",
+        address=17,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="heatingalrms",
+        name="Alarm: Collective alarm heating",
+        address=18,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="alarmmng_al_workinghour",
+        name="Alarm: Working hours",
+        address=19,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="srsalrm",
+        name="Alarm: Collective alarm source",
+        address=20,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="glbal",
+        name="Global Alarm",
+        address=21,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="alarmmng_al_pwrplus",
+        name="Alarm: Collective alarm compressor",
+        address=22,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="roomprb_en",
+        name="Room sensor activated",
+        address=23,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="plantdemand",
+        name="Plant sensor demand",
+        address=25,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="en_dhwpid",
+        name="DHW controller enabled",
+        address=26,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="plantprb_en",
+        name="Plant sensor activated",
+        address=27,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="bufferprb_en",
+        name="Buffer sensor activated",
+        address=28,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="id_demand",
+        name="Digital input demand",
+        address=29,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="id_summerwinter",
+        name="Digital input summer mode activated",
+        address=30,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="dewpoint",
+        name="Digital input dewpoint activated",
+        address=31,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="boostersecurity",
+        name="Digital input booster activated",
+        address=32,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="srcflw",
+        name="Digital input source flow activated",
+        address=34,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="daynightmode",
+        name="Day/night mode status",
+        address=37,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="thermostatdemand",
+        name="Internal thermostat demand",
+        address=38,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="req_antileg_1",
+        name="Anti-legionella enabled",
+        address=39,
+        input_type=InputType.DISCRETE_INPUT,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    # Coil-based binary sensors
+    EntityDef(
+        key="bms_demand",
+        name="Heat demand active",
+        address=19,
+        input_type=InputType.COIL,
+        platform=Platform.BINARY_SENSOR,
+    ),
+    EntityDef(
+        key="surplus_pv",
+        name="PV surplus active",
+        address=64,
+        input_type=InputType.COIL,
+        platform=Platform.BINARY_SENSOR,
+    ),
+)
+
+# Export as dict for easy lookup by key
+BINARY_SENSORS: dict[str, EntityDef] = {e.key: e for e in _BINARY_SENSOR_DEFS}

python_qube_heatpump/entities/sensors.py

@@ -0,0 +1,468 @@
+"""Sensor entity definitions for Qube Heat Pump."""
+
+from .base import DataType, EntityDef, InputType, Platform
+
+_SENSOR_DEFS: tuple[EntityDef, ...] = (
+    # Holding register sensors (configuration/setpoints readable as sensors)
+    EntityDef(
+        key="thermostat_heatsetp_day",
+        name="Room setpoint heating (day)",
+        address=27,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="thermostat_heatsetp_night",
+        name="Room setpoint heating (night)",
+        address=29,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="thermostat_coolsetp_day",
+        name="Room setpoint cooling (day)",
+        address=31,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="thermostat_coolsetp_night",
+        name="Room setpoint cooling (night)",
+        address=33,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="tapw_timeprogram_dt_bms",
+        name="dT flow temperature DHW",
+        address=43,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.INT16,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="tapw_timeprogram_dhws",
+        name="Minimum temperature DHW",
+        address=44,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="tapw_timeprogram_dhws_prog",
+        name="DHW temperature (active program)",
+        address=46,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="regulation_buffersetp_min",
+        name="Minimum setpoint buffer regulation",
+        address=99,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="usr_pid_heatsetp",
+        name="Heat setpoint (no curve)",
+        address=101,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="usr_pid_coolsetp",
+        name="Cooling setpoint (no curve)",
+        address=103,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="regulation_buffersetp_max",
+        name="Max buffer setpoint (cooling)",
+        address=169,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="tapw_timeprogram_dhwsetp_nolinq",
+        name="User-defined DHW setpoint",
+        address=173,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+        writable=True,  # This setpoint can be written via Modbus
+    ),
+    # Input register sensors (read-only)
+    EntityDef(
+        key="aout_usrpmp_val",
+        name="User (CV) pump control %",
+        address=4,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="%",
+        scale=-1.0,
+        offset=100.0,
+    ),
+    EntityDef(
+        key="aout_srcpmp_val",
+        name="Source pump control %",
+        address=6,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="%",
+        scale=-1.0,
+        offset=100.0,
+    ),
+    EntityDef(
+        key="aout_srcvalve_val",
+        name="Source valve control %",
+        address=8,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="%",
+    ),
+    EntityDef(
+        key="dhw_regreq",
+        name="DHW regulation demand %",
+        address=14,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="%",
+    ),
+    EntityDef(
+        key="comppwrreq",
+        name="Compressor demand %",
+        address=16,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="%",
+    ),
+    EntityDef(
+        key="flow",
+        name="Measured Flow",
+        address=18,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="L/min",
+    ),
+    # Core temperature sensors (mapped to QubeState typed fields)
+    EntityDef(
+        key="temp_supply",
+        name="Supply temperature CV",
+        address=20,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="temp_return",
+        name="Return temperature CV",
+        address=22,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="temp_source_in",
+        name="Source temperature from roof",
+        address=24,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="temp_source_out",
+        name="Source temperature to roof",
+        address=26,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="temp_room",
+        name="Room temperature",
+        address=28,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="temp_dhw",
+        name="DHW temperature",
+        address=30,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="temp_outside",
+        name="Outside temperature",
+        address=32,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="cop_calc",
+        name="COP (calculated)",
+        address=34,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+    ),
+    EntityDef(
+        key="power_thermic",
+        name="Current power",
+        address=36,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="W",
+    ),
+    EntityDef(
+        key="status_code",
+        name="Status code",
+        address=38,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.UINT16,
+        platform=Platform.SENSOR,
+    ),
+    EntityDef(
+        key="regsetp",
+        name="Calculated heat pump setpoint",
+        address=39,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="coolsetp_1",
+        name="Cooling setpoint",
+        address=41,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="heatsetp_1",
+        name="Heating setpoint",
+        address=43,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="compressor_speed",
+        name="Current compressor speed",
+        address=45,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="rpm",
+        scale=60.0,
+    ),
+    EntityDef(
+        key="dhw_setp",
+        name="DHW calculated setpoint",
+        address=47,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="workinghours_dhw_hrsret",
+        name="Working hours DHW",
+        address=50,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.INT16,
+        platform=Platform.SENSOR,
+        unit="h",
+    ),
+    EntityDef(
+        key="workinghours_heat_hrsret",
+        name="Working hours heating",
+        address=52,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.INT16,
+        platform=Platform.SENSOR,
+        unit="h",
+    ),
+    EntityDef(
+        key="workinghours_cool_hrsret",
+        name="Working hours cooling",
+        address=54,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.INT16,
+        platform=Platform.SENSOR,
+        unit="h",
+    ),
+    EntityDef(
+        key="workinghours_heater1_hrs",
+        name="Working hours heater 1",
+        address=56,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.INT16,
+        platform=Platform.SENSOR,
+        unit="h",
+    ),
+    EntityDef(
+        key="workinghours_heater2_hrs",
+        name="Working hours heater 2",
+        address=58,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.INT16,
+        platform=Platform.SENSOR,
+        unit="h",
+    ),
+    EntityDef(
+        key="workinghours_heater3_hrs",
+        name="Working hours heater 3",
+        address=60,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.INT16,
+        platform=Platform.SENSOR,
+        unit="h",
+    ),
+    EntityDef(
+        key="power_electric",
+        name="Total electric power (calculated)",
+        address=61,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="W",
+    ),
+    EntityDef(
+        key="plantsetp",
+        name="Plant regulation setpoint",
+        address=65,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="energy_total_electric",
+        name="Total electric consumption (excl. standby)",
+        address=69,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="kWh",
+    ),
+    EntityDef(
+        key="energy_total_thermic",
+        name="Total thermic yield",
+        address=71,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="kWh",
+    ),
+    EntityDef(
+        key="modbus_roomtemp",
+        name="Linq room temperature",
+        address=75,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    # Aliases for QubeState compatibility (same addresses as core sensors)
+    EntityDef(
+        key="flow_rate",
+        name="Flow rate",
+        address=18,
+        input_type=InputType.INPUT_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="L/min",
+    ),
+    EntityDef(
+        key="setpoint_room_heat_day",
+        name="Room setpoint heating (day)",
+        address=27,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="setpoint_room_heat_night",
+        name="Room setpoint heating (night)",
+        address=29,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="setpoint_room_cool_day",
+        name="Room setpoint cooling (day)",
+        address=31,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="setpoint_room_cool_night",
+        name="Room setpoint cooling (night)",
+        address=33,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+    ),
+    EntityDef(
+        key="setpoint_dhw",
+        name="User-defined DHW setpoint",
+        address=173,
+        input_type=InputType.HOLDING_REGISTER,
+        data_type=DataType.FLOAT32,
+        platform=Platform.SENSOR,
+        unit="°C",
+        writable=True,
+    ),
+)
+
+# Export as dict for easy lookup by key
+SENSORS: dict[str, EntityDef] = {e.key: e for e in _SENSOR_DEFS}

python_qube_heatpump/entities/switches.py

@@ -0,0 +1,65 @@
+"""Switch entity definitions for Qube Heat Pump."""
+
+from .base import EntityDef, InputType, Platform
+
+_SWITCH_DEFS: tuple[EntityDef, ...] = (
+    EntityDef(
+        key="bms_summerwinter",
+        name="Enable summer mode (cooling)",
+        address=22,
+        input_type=InputType.COIL,
+        platform=Platform.SWITCH,
+        writable=True,
+    ),
+    EntityDef(
+        key="tapw_timeprogram_bms_forced",
+        name="Start DHW heating",
+        address=23,
+        input_type=InputType.COIL,
+        platform=Platform.SWITCH,
+        writable=True,
+    ),
+    EntityDef(
+        key="antilegionella_frcstart_ant",
+        name="Start anti-legionella",
+        address=45,
+        input_type=InputType.COIL,
+        platform=Platform.SWITCH,
+        writable=True,
+    ),
+    EntityDef(
+        key="en_plantsetp_compens",
+        name="Enable heating curve",
+        address=62,
+        input_type=InputType.COIL,
+        platform=Platform.SWITCH,
+        writable=True,
+    ),
+    EntityDef(
+        key="bms_sgready_a",
+        name="SG Ready A",
+        address=65,
+        input_type=InputType.COIL,
+        platform=Platform.SWITCH,
+        writable=True,
+    ),
+    EntityDef(
+        key="bms_sgready_b",
+        name="SG Ready B",
+        address=66,
+        input_type=InputType.COIL,
+        platform=Platform.SWITCH,
+        writable=True,
+    ),
+    EntityDef(
+        key="modbus_demand",
+        name="Activate heat demand",
+        address=67,
+        input_type=InputType.COIL,
+        platform=Platform.SWITCH,
+        writable=True,
+    ),
+)
+
+# Export as dict for easy lookup by key
+SWITCHES: dict[str, EntityDef] = {e.key: e for e in _SWITCH_DEFS}

python_qube_heatpump/models.py

@@ -1,37 +1,55 @@
 """Models for Qube Heat Pump."""
 
-from dataclasses import dataclass
-from typing import Optional
+from dataclasses import dataclass, field
+from typing import Any
 
 
 @dataclass
 class QubeState:
-    """Representation of the Qube Heat Pump state."""
+    """Representation of the Qube Heat Pump state.
+
+    Typed fields for core sensors (used by official HA integration).
+    Extended dict for additional entities (used by HACS integration).
+    """
 
     # Temperatures
-    temp_supply: Optional[float] = None
-    temp_return: Optional[float] = None
-    temp_source_in: Optional[float] = None
-    temp_source_out: Optional[float] = None
-    temp_room: Optional[float] = None
-    temp_dhw: Optional[float] = None
-    temp_outside: Optional[float] = None
+    temp_supply: float | None = None
+    temp_return: float | None = None
+    temp_source_in: float | None = None
+    temp_source_out: float | None = None
+    temp_room: float | None = None
+    temp_dhw: float | None = None
+    temp_outside: float | None = None
 
     # Power/Energy
-    power_thermic: Optional[float] = None
-    power_electric: Optional[float] = None
-    energy_total_electric: Optional[float] = None
-    energy_total_thermic: Optional[float] = None
-    cop_calc: Optional[float] = None
+    power_thermic: float | None = None
+    power_electric: float | None = None
+    energy_total_electric: float | None = None
+    energy_total_thermic: float | None = None
+    cop_calc: float | None = None
 
     # Operation
-    status_code: Optional[int] = None
-    compressor_speed: Optional[float] = None
-    flow_rate: Optional[float] = None
+    status_code: int | None = None
+    compressor_speed: float | None = None
+    flow_rate: float | None = None
 
     # Setpoints (Read/Write)
-    setpoint_room_heat_day: Optional[float] = None
-    setpoint_room_heat_night: Optional[float] = None
-    setpoint_room_cool_day: Optional[float] = None
-    setpoint_room_cool_night: Optional[float] = None
-    setpoint_dhw: Optional[float] = None
+    setpoint_room_heat_day: float | None = None
+    setpoint_room_heat_night: float | None = None
+    setpoint_room_cool_day: float | None = None
+    setpoint_room_cool_night: float | None = None
+    setpoint_dhw: float | None = None
+
+    # Extended dict for additional entities not covered by typed fields
+    _extended: dict[str, Any] = field(default_factory=dict)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a value by key, checking typed fields first, then _extended."""
+        if hasattr(self, key) and key != "_extended":
+            value = getattr(self, key)
+            return value if value is not None else default
+        return self._extended.get(key, default)
+
+    def set_extended(self, key: str, value: Any) -> None:
+        """Set a value in the extended dict."""
+        self._extended[key] = value

{python_qube_heatpump-1.2.3.dist-info → python_qube_heatpump-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-qube-heatpump
-Version: 1.2.3
+Version: 1.3.0
 Summary: Async Modbus client for Qube Heat Pumps
 Project-URL: Homepage, https://github.com/MattieGit/python-qube-heatpump
 Project-URL: Bug Tracker, https://github.com/MattieGit/python-qube-heatpump/issues

python_qube_heatpump-1.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+python_qube_heatpump/__init__.py,sha256=VnHFpnpnRzpxmNPAGM29FQkrcPcBAaIniWjHu68-7WA,669
+python_qube_heatpump/client.py,sha256=wg02PX5bIhXhgUKeJKtHKw6wPQOFUiZUoEVYxHEE30U,15158
+python_qube_heatpump/const.py,sha256=oAwKCIpmXPh5dRwX1dhdmGTJZKMlTVDnspUqAgYGZk0,4651
+python_qube_heatpump/models.py,sha256=vbJdY93JkQ6ea30qhGjuCknUxRJqTiz0mTjPsb2r4xk,1841
+python_qube_heatpump/entities/__init__.py,sha256=rGEqLY-KcsIlmEaM7LbriDMEqedn7NLA4sgKDI6sYM8,342
+python_qube_heatpump/entities/base.py,sha256=5itTSm6cxklHsPr1qz3UWmr1kYBeCVOAugk182ybf3s,1867
+python_qube_heatpump/entities/binary_sensors.py,sha256=lsYC0MEHjJ7JmJUgYzdHndkrZ1Ekxz4j9HqYDMEE_IA,7649
+python_qube_heatpump/entities/sensors.py,sha256=Lros4QS1xzapR26n40GeAUDyiBipKGPuHyWDUbzgIiw,13176
+python_qube_heatpump/entities/switches.py,sha256=MAaK-63dgVZEm9Ch_CW7umYM_mPqMoPYl8i0ZpZIaYE,1676
+python_qube_heatpump-1.3.0.dist-info/METADATA,sha256=QLiTaA-h8TeWQ7eFSIJKzftmMPGzp1-Rv7vhM1ezVDU,950
+python_qube_heatpump-1.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_qube_heatpump-1.3.0.dist-info/licenses/LICENSE,sha256=qpuQXN7QwpILG9GYcmqrd3Ax5CxBZUBoT295xTgKnOM,1062
+python_qube_heatpump-1.3.0.dist-info/RECORD,,

python_qube_heatpump-1.2.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-python_qube_heatpump/__init__.py,sha256=eW8_tyAweg7YTOI599pi8gf3mt7aXW0SCw5ZyrBVJpU,57
-python_qube_heatpump/client.py,sha256=BgCJbQBV57cfsWMfakjbs2VXgrQ8BZH8KnX1pnTke7k,6083
-python_qube_heatpump/const.py,sha256=sXvXRcDb1uvBgzH2lV67Me_XtUErKA3fXMLO9gEGrlQ,3680
-python_qube_heatpump/models.py,sha256=3I5U9_rEe1r73hwY4sNAMXfIxyPjBOtx06c_mAURLDk,1141
-python_qube_heatpump-1.2.3.dist-info/METADATA,sha256=P-_IjdAl1jsiU4xYN_6oqlYK6gPvN8mvxM3qwU5tGmY,950
-python_qube_heatpump-1.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-python_qube_heatpump-1.2.3.dist-info/licenses/LICENSE,sha256=qpuQXN7QwpILG9GYcmqrd3Ax5CxBZUBoT295xTgKnOM,1062
-python_qube_heatpump-1.2.3.dist-info/RECORD,,