python-qube-heatpump 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

python_qube_heatpump/client.py

@@ -1,166 +1,136 @@
-"""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 . 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
-
-    @property
-    def is_connected(self) -> bool:
-        """Return True if connected."""
-        return bool(self._client and getattr(self._client, "connected", 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.
+
+        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))
 
-        try:
-            infos = await asyncio.get_running_loop().getaddrinfo(
-                self._host,
-                None,
-                type=socket.SOCK_STREAM,
-            )
-        except OSError:
+            if result.isError():
+                _LOGGER.warning("Error reading address %s", address)
+                return None
+
+            regs = result.registers
+            val = 0
+
+            # Manual decoding to avoid pymodbus.payload dependencies
+            # Assuming Little Endian Word Order for 32-bit values [LSW, MSW] per standard Modbus often used
+            # But the original code used Endian.Little WordOrder.
+            # Decoder: byteorder=Endian.Big, wordorder=Endian.Little
+            # Big Endian Bytes: [H, L]
+            # Little Endian Words: [Reg0, Reg1] -> [LSW, MSW]
+            #
+            # Example Float32: 123.456
+            # Reg0 (LSW)
+            # Reg1 (MSW)
+            # Full 32-bit int: (Reg1 << 16) | Reg0
+            # Then pack as >I (Big Endian 32-bit int) and unpack as >f (Big Endian float)?
+            #
+            # Wait, PyModbus BinaryPayloadDecoder.fromRegisters(registers, byteorder=Endian.Big, wordorder=Endian.Little)
+            # ByteOrder Big: Normal network byte order per register.
+            # WordOrder Little: The first register is the least significant word.
+            #
+            # So:
+            # 32-bit value = (regs[1] << 16) | regs[0]
+            # Then interpret that 32-bit integer as a float.
+            # To interpret int bits as float in Python: struct.unpack('!f', struct.pack('!I', int_val))[0]
+
+            if data_type == const.DataType.FLOAT32:
+                # Combine 2 registers, Little Endian Word Order
+                int_val = (regs[1] << 16) | regs[0]
+                val = struct.unpack(">f", struct.pack(">I", int_val))[0]
+            elif data_type == const.DataType.INT16:
+                val = regs[0]
+                # Signed 16-bit
+                if val > 32767:
+                    val -= 65536
+            elif data_type == const.DataType.UINT16:
+                val = regs[0]
+            elif data_type == const.DataType.UINT32:
+                val = (regs[1] << 16) | regs[0]
+            elif data_type == const.DataType.INT32:
+                val = (regs[1] << 16) | regs[0]
+                if val > 2147483647:
+                    val -= 4294967296
+            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
-
-        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

python_qube_heatpump/const.py

@@ -0,0 +1,73 @@
+"""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"
+    INT32 = "int32"
+    UINT32 = "uint32"
+
+
+# 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.2.0.dist-info → python_qube_heatpump-1.2.2.dist-info}/METADATA

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

@@ -0,0 +1,8 @@
+python_qube_heatpump/__init__.py,sha256=eW8_tyAweg7YTOI599pi8gf3mt7aXW0SCw5ZyrBVJpU,57
+python_qube_heatpump/client.py,sha256=sndRUFheuv54A7ghH9HgJKg77PTTD7UxRcSzleKUr9c,4863
+python_qube_heatpump/const.py,sha256=sXvXRcDb1uvBgzH2lV67Me_XtUErKA3fXMLO9gEGrlQ,3680
+python_qube_heatpump/models.py,sha256=3I5U9_rEe1r73hwY4sNAMXfIxyPjBOtx06c_mAURLDk,1141
+python_qube_heatpump-1.2.2.dist-info/METADATA,sha256=YPOSKN5eTRec_yDqkQaUSli5h42JnbqFVYO-D5Wi0Hw,950
+python_qube_heatpump-1.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_qube_heatpump-1.2.2.dist-info/licenses/LICENSE,sha256=qpuQXN7QwpILG9GYcmqrd3Ax5CxBZUBoT295xTgKnOM,1062
+python_qube_heatpump-1.2.2.dist-info/RECORD,,

python_qube_heatpump-1.2.0.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.2.0.dist-info/METADATA,sha256=6vXJXkd1y9LEuEMTHAMjv1RB-75i0xNxnvLJBsQi6Sg,950
-python_qube_heatpump-1.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-python_qube_heatpump-1.2.0.dist-info/licenses/LICENSE,sha256=qpuQXN7QwpILG9GYcmqrd3Ax5CxBZUBoT295xTgKnOM,1062
-python_qube_heatpump-1.2.0.dist-info/RECORD,,