python-qube-heatpump 1.0.1__tar.gz → 1.2.1__tar.gz

python_qube_heatpump-1.2.1/.gitignore

@@ -0,0 +1,139 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# IDEs
+.idea/
+.vscode/

{python_qube_heatpump-1.0.1 → python_qube_heatpump-1.2.1}/PKG-INFO

@@ -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.0.1 → python_qube_heatpump-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-qube-heatpump"
-version = "1.0.1"
+version = "1.2.1"
 authors = [
   { name="MattieGit", email="6250046+MattieGit@users.noreply.github.com" },
 ]

python_qube_heatpump-1.2.1/src/python_qube_heatpump/client.py

@@ -0,0 +1,105 @@
+"""Client for Qube Heat Pump."""
+
+import logging
+from typing import Optional
+
+from pymodbus.client import AsyncModbusTcpClient
+from pymodbus.payload import BinaryPayloadDecoder
+from pymodbus.constants import Endian
+
+from . import const
+from .models import QubeState
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class QubeClient:
+    """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 not self._connected:
+            self._connected = await self._client.connect()
+        return self._connected
+
+    async def close(self) -> None:
+        """Close connection."""
+        self._client.close()
+        self._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
+        )
+
+        try:
+            if reg_type == const.ModbusType.INPUT:
+                result = await self._client.read_input_registers(
+                    address, count, slave=self.unit
+                )
+            else:
+                result = await self._client.read_holding_registers(
+                    address, count, slave=self.unit
+                )
+
+            if result.isError():
+                _LOGGER.warning("Error reading address %s", address)
+                return None
+
+            decoder = BinaryPayloadDecoder.fromRegisters(
+                result.registers, byteorder=Endian.Big, wordorder=Endian.Little
+            )
+
+            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-1.2.1/src/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-1.2.1/src/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/src/python_qube_heatpump/client.py

@@ -1,166 +0,0 @@
-"""Qube Heat Pump Client Library."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import ipaddress
-import logging
-import socket
-import struct
-from typing import Any
-
-from pymodbus.client import AsyncModbusTcpClient
-from pymodbus.exceptions import ModbusException
-from pymodbus.pdu import ExceptionResponse
-
-
-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)
-
-    async def connect(self) -> bool:
-        """Connect to the Modbus server."""
-        if self._client is None:
-            self._client = AsyncModbusTcpClient(self._host, port=self._port)
-
-        if self.is_connected:
-            return True
-
-        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 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
-                )
-            except TypeError:
-                resp = await asyncio.wait_for(
-                    func(**kwargs), timeout=self._io_timeout_s
-                )
-        # 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:
-            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