python-qube-heatpump 1.0.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

python_qube_heatpump/client.py

@@ -1,166 +1,105 @@
-"""Qube Heat Pump Client Library."""
+"""Client for Qube Heat Pump."""
 
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import ipaddress
 import logging
-import socket
-import struct
-from typing import Any
+from typing import Optional
 
 from pymodbus.client import AsyncModbusTcpClient
-from pymodbus.exceptions import ModbusException
-from pymodbus.pdu import ExceptionResponse
+from pymodbus.payload import BinaryPayloadDecoder
+from pymodbus.constants import Endian
+
+from . import const
+from .models import QubeState
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class QubeClient:
-    """Qube Heat Pump Client."""
-
-    def __init__(
-        self,
-        host: str,
-        port: int,
-        unit_id: int = 1,
-    ) -> None:
-        """Initialize the client."""
-        self._host = host
-        self._port = port
-        self._unit = unit_id
-        self._client: AsyncModbusTcpClient | None = None
-        self._io_timeout_s: float = 3.0
-
-    @property
-    def host(self) -> str:
-        """Return host."""
-        return self._host
-
-    @property
-    def port(self) -> int:
-        """Return port."""
-        return self._port
-
-    @property
-    def unit(self) -> int:
-        """Return unit ID."""
-        return self._unit
-
-    def set_unit_id(self, unit_id: int) -> None:
-        """Set unit ID."""
-        self._unit = int(unit_id)
+    """Qube Modbus Client."""
+
+    def __init__(self, host: str, port: int = 502, unit_id: int = 1):
+        """Initialize."""
+        self.host = host
+        self.port = port
+        self.unit = unit_id
+        self._client = AsyncModbusTcpClient(host, port=port)
+        self._connected = False
 
     async def connect(self) -> bool:
         """Connect to the Modbus server."""
-        if self._client is None:
-            self._client = AsyncModbusTcpClient(self._host, port=self._port)
+        if not self._connected:
+            self._connected = await self._client.connect()
+        return self._connected
 
-        if self.is_connected:
-            return True
+    async def close(self) -> None:
+        """Close connection."""
+        self._client.close()
+        self._connected = False
 
-        try:
-            return await asyncio.wait_for(
-                self._client.connect(), timeout=self._io_timeout_s
-            )
-        except Exception as exc:  # pylint: disable=broad-except  # noqa: BLE001
-            logging.getLogger(__name__).debug("Failed to connect: %s", exc)
-            return False
+    async def get_all_data(self) -> QubeState:
+        """Fetch all definition data and return a state object."""
+        # Note: In a real implementation you might want to optimize this
+        # by reading contiguous blocks instead of one-by-one.
+        # For now, we wrap the individual reads for abstraction.
 
-    @property
-    def is_connected(self) -> bool:
-        """Return True if connected."""
-        return bool(self._client and getattr(self._client, "connected", False))
+        state = QubeState()
+
+        # Helper to read and assign
+        async def _read(const_def):
+            return await self.read_value(const_def)
+
+        # Fetch basic sensors
+        state.temp_supply = await _read(const.TEMP_SUPPLY)
+        state.temp_return = await _read(const.TEMP_RETURN)
+        state.temp_outside = await _read(const.TEMP_OUTSIDE)
+        state.temp_dhw = await _read(const.TEMP_DHW)
+
+        return state
+
+    async def read_value(self, definition: tuple) -> Optional[float]:
+        """Read a single value based on the constant definition."""
+        address, reg_type, data_type, scale, offset = definition
+
+        count = (
+            2
+            if data_type
+            in (const.DataType.FLOAT32, const.DataType.UINT32, const.DataType.INT32)
+            else 1
+        )
 
-    async def close(self) -> None:
-        """Close the connection."""
-        if self._client:
-            with contextlib.suppress(Exception):
-                self._client.close()
-            self._client = None
-
-    async def _call(self, method: str, **kwargs: Any) -> Any:
-        if self._client is None:
-            raise ModbusException("Client not connected")
-        func = getattr(self._client, method)
-        # Try with 'slave' then 'unit', finally without either
         try:
-            resp = await asyncio.wait_for(
-                func(**{**kwargs, "slave": self._unit}), timeout=self._io_timeout_s
-            )
-        except TypeError:
-            try:
-                resp = await asyncio.wait_for(
-                    func(**{**kwargs, "unit": self._unit}), timeout=self._io_timeout_s
+            if reg_type == const.ModbusType.INPUT:
+                result = await self._client.read_input_registers(
+                    address, count, slave=self.unit
                 )
-            except TypeError:
-                resp = await asyncio.wait_for(
-                    func(**kwargs), timeout=self._io_timeout_s
+            else:
+                result = await self._client.read_holding_registers(
+                    address, count, slave=self.unit
                 )
-        # Normalize error checking
-        if isinstance(resp, ExceptionResponse) or (
-            hasattr(resp, "isError") and resp.isError()
-        ):
-            raise ModbusException(f"Modbus error on {method} with {kwargs}")
-        return resp
-
-    async def read_registers(
-        self, address: int, count: int, input_type: str = "holding"
-    ) -> list[int]:
-        """Read registers from the device."""
-        if input_type == "input":
-            rr = await self._call("read_input_registers", address=address, count=count)
-        else:
-            rr = await self._call(
-                "read_holding_registers", address=address, count=count
-            )
 
-        regs = getattr(rr, "registers", None)
-        if regs is None:
-            raise ModbusException("No registers returned")
-        return list(regs)
-
-    @staticmethod
-    def decode_registers(regs: list[int], data_type: str | None) -> float | int:
-        """Decode registers to a value."""
-        # All decoding assumes big-endian word and byte order.
-        if data_type == "float32":
-            raw = struct.pack(">HH", int(regs[0]) & 0xFFFF, int(regs[1]) & 0xFFFF)
-            return float(struct.unpack(">f", raw)[0])
-        if data_type == "int16":
-            v = int(regs[0]) & 0xFFFF
-            return v - 0x10000 if v & 0x8000 else v
-        if data_type == "uint16":
-            return int(regs[0]) & 0xFFFF
-        if data_type == "uint32":
-            return ((int(regs[0]) & 0xFFFF) << 16) | (int(regs[1]) & 0xFFFF)
-        if data_type == "int32":
-            u = ((int(regs[0]) & 0xFFFF) << 16) | (int(regs[1]) & 0xFFFF)
-            return u - 0x1_0000_0000 if u & 0x8000_0000 else u
-        # Fallback to first register as unsigned 16-bit
-        return int(regs[0]) & 0xFFFF
-
-    async def resolve_ip(self) -> str | None:
-        """Resolve the host to an IP address."""
-        with contextlib.suppress(ValueError):
-            return str(ipaddress.ip_address(self._host))
+            if result.isError():
+                _LOGGER.warning("Error reading address %s", address)
+                return None
 
-        try:
-            infos = await asyncio.get_running_loop().getaddrinfo(
-                self._host,
-                None,
-                type=socket.SOCK_STREAM,
+            decoder = BinaryPayloadDecoder.fromRegisters(
+                result.registers, byteorder=Endian.Big, wordorder=Endian.Little
             )
-        except OSError:
-            return None
 
-        for family, _, _, _, sockaddr in infos:
-            if not sockaddr:
-                continue
-            addr = sockaddr[0]
-            if not isinstance(addr, str):
-                continue
-            if family == socket.AF_INET6 and addr.startswith("::ffff:"):
-                addr = addr.removeprefix("::ffff:")
-            return addr
-
-        return None
+            if data_type == const.DataType.FLOAT32:
+                val = decoder.decode_32bit_float()
+            elif data_type == const.DataType.INT16:
+                val = decoder.decode_16bit_int()
+            elif data_type == const.DataType.UINT16:
+                val = decoder.decode_16bit_uint()
+            else:
+                val = 0
+
+            if scale is not None:
+                val *= scale
+            if offset is not None:
+                val += offset
+
+            return val
+
+        except Exception as e:
+            _LOGGER.error("Exception reading address %s: %s", address, e)
+            return None

python_qube_heatpump/const.py

@@ -0,0 +1,71 @@
+"""Constants for Qube Heat Pump."""
+
+from enum import Enum
+
+
+class ModbusType(str, Enum):
+    """Modbus register type."""
+
+    HOLDING = "holding"
+    INPUT = "input"
+
+
+class DataType(str, Enum):
+    """Data type."""
+
+    FLOAT32 = "float32"
+    INT16 = "int16"
+    UINT16 = "uint16"
+
+
+# Register definitions (Address, Type, Data Type, Scale, Offset)
+# Scale/Offset are None if not used.
+# Format: KEY = (Address, ModbusType, DataType, Scale, Offset)
+
+# --- Sensors (Input Registers) ---
+PCT_USER_PUMP = (4, ModbusType.INPUT, DataType.FLOAT32, -1, 100)
+PCT_SOURCE_PUMP = (6, ModbusType.INPUT, DataType.FLOAT32, -1, 100)
+PCT_SOURCE_VALVE = (8, ModbusType.INPUT, DataType.FLOAT32, None, None)
+REQ_DHW = (14, ModbusType.INPUT, DataType.FLOAT32, None, None)
+REQ_COMPRESSOR = (16, ModbusType.INPUT, DataType.FLOAT32, None, None)
+FLOW_RATE = (18, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_SUPPLY = (20, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_RETURN = (22, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_SOURCE_IN = (24, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_SOURCE_OUT = (26, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_ROOM = (28, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_DHW = (30, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_OUTSIDE = (32, ModbusType.INPUT, DataType.FLOAT32, None, None)
+COP_CALC = (34, ModbusType.INPUT, DataType.FLOAT32, None, None)
+POWER_THERMIC = (36, ModbusType.INPUT, DataType.FLOAT32, None, None)
+STATUS_CODE = (38, ModbusType.INPUT, DataType.UINT16, None, None)
+TEMP_REG_SETPOINT = (39, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_COOL_SETPOINT = (41, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_HEAT_SETPOINT = (43, ModbusType.INPUT, DataType.FLOAT32, None, None)
+COMPRESSOR_SPEED = (45, ModbusType.INPUT, DataType.FLOAT32, 60, None)  # RPM
+TEMP_DHW_SETPOINT = (47, ModbusType.INPUT, DataType.FLOAT32, None, None)
+HOURS_DHW = (50, ModbusType.INPUT, DataType.INT16, None, None)
+HOURS_HEAT = (52, ModbusType.INPUT, DataType.INT16, None, None)
+HOURS_COOL = (54, ModbusType.INPUT, DataType.INT16, None, None)
+HOURS_HEATER_1 = (56, ModbusType.INPUT, DataType.INT16, None, None)
+HOURS_HEATER_2 = (58, ModbusType.INPUT, DataType.INT16, None, None)
+HOURS_HEATER_3 = (60, ModbusType.INPUT, DataType.INT16, None, None)
+POWER_ELECTRIC_CALC = (61, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_PLANT_SETPOINT = (65, ModbusType.INPUT, DataType.FLOAT32, None, None)
+ENERGY_ELECTRIC_TOTAL = (69, ModbusType.INPUT, DataType.FLOAT32, None, None)
+ENERGY_THERMIC_TOTAL = (71, ModbusType.INPUT, DataType.FLOAT32, None, None)
+TEMP_ROOM_MODBUS = (75, ModbusType.INPUT, DataType.FLOAT32, None, None)
+
+# --- Configuration (Holding Registers) ---
+SETPOINT_HEAT_DAY = (27, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+SETPOINT_HEAT_NIGHT = (29, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+SETPOINT_COOL_DAY = (31, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+SETPOINT_COOL_NIGHT = (33, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+DT_DHW = (43, ModbusType.HOLDING, DataType.INT16, None, None)
+MIN_TEMP_DHW = (44, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+TEMP_DHW_PROG = (46, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+MIN_SETPOINT_BUFFER = (99, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+USER_HEAT_SETPOINT = (101, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+USER_COOL_SETPOINT = (103, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+MAX_SETPOINT_BUFFER = (169, ModbusType.HOLDING, DataType.FLOAT32, None, None)
+USER_DHW_SETPOINT = (173, ModbusType.HOLDING, DataType.FLOAT32, None, None)

python_qube_heatpump/models.py

@@ -0,0 +1,37 @@
+"""Models for Qube Heat Pump."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class QubeState:
+    """Representation of the Qube Heat Pump state."""
+
+    # 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
+
+    # 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
+
+    # Operation
+    status_code: Optional[int] = None
+    compressor_speed: Optional[float] = None
+    flow_rate: Optional[float] = 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

{python_qube_heatpump-1.0.1.dist-info → python_qube_heatpump-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-qube-heatpump
-Version: 1.0.1
+Version: 1.2.1
 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.2.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+python_qube_heatpump/__init__.py,sha256=eW8_tyAweg7YTOI599pi8gf3mt7aXW0SCw5ZyrBVJpU,57
+python_qube_heatpump/client.py,sha256=XNVCydP6uKIlUbH28FjcA9oXYumNRy5NBCqPrVMCX60,3360
+python_qube_heatpump/const.py,sha256=bAFNIN8uwXIdQ5VGgSYdFrQYUNDcDXlxr0OkBxlKUYw,3638
+python_qube_heatpump/models.py,sha256=3I5U9_rEe1r73hwY4sNAMXfIxyPjBOtx06c_mAURLDk,1141
+python_qube_heatpump-1.2.1.dist-info/METADATA,sha256=nqZty88ZKHR7RvM4F1TsxsuFpQoBetXHva29iOv8n1Q,950
+python_qube_heatpump-1.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_qube_heatpump-1.2.1.dist-info/licenses/LICENSE,sha256=qpuQXN7QwpILG9GYcmqrd3Ax5CxBZUBoT295xTgKnOM,1062
+python_qube_heatpump-1.2.1.dist-info/RECORD,,

python_qube_heatpump-1.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-python_qube_heatpump/__init__.py,sha256=eW8_tyAweg7YTOI599pi8gf3mt7aXW0SCw5ZyrBVJpU,57
-python_qube_heatpump/client.py,sha256=ubYFve5PH_i4Euxyq1vWy5HLcNA00lispL-3c_csH84,5414
-python_qube_heatpump-1.0.1.dist-info/METADATA,sha256=wKluByryCOKQC6SSpeKk6miN_yjgvZ2Unbw6t71VioM,950
-python_qube_heatpump-1.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-python_qube_heatpump-1.0.1.dist-info/licenses/LICENSE,sha256=qpuQXN7QwpILG9GYcmqrd3Ax5CxBZUBoT295xTgKnOM,1062
-python_qube_heatpump-1.0.1.dist-info/RECORD,,