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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-qube-heatpump
-Version: 1.2.1
+Version: 1.2.3
 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 → python_qube_heatpump-1.2.3}/pyproject.toml

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

python_qube_heatpump-1.2.3/src/python_qube_heatpump/client.py

@@ -0,0 +1,158 @@
+"""Client for Qube Heat Pump."""
+
+import logging
+import struct
+from typing import Optional
+
+from pymodbus.client import AsyncModbusTcpClient
+
+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 temperature sensors
+        state.temp_supply = await _read(const.TEMP_SUPPLY)
+        state.temp_return = await _read(const.TEMP_RETURN)
+        state.temp_source_in = await _read(const.TEMP_SOURCE_IN)
+        state.temp_source_out = await _read(const.TEMP_SOURCE_OUT)
+        state.temp_room = await _read(const.TEMP_ROOM)
+        state.temp_dhw = await _read(const.TEMP_DHW)
+        state.temp_outside = await _read(const.TEMP_OUTSIDE)
+
+        # Fetch power and energy sensors
+        state.power_thermic = await _read(const.POWER_THERMIC)
+        state.power_electric = await _read(const.POWER_ELECTRIC_CALC)
+        state.energy_total_electric = await _read(const.ENERGY_ELECTRIC_TOTAL)
+        state.energy_total_thermic = await _read(const.ENERGY_THERMIC_TOTAL)
+        state.cop_calc = await _read(const.COP_CALC)
+
+        # Fetch operation sensors
+        state.status_code = await _read(const.STATUS_CODE)
+        state.compressor_speed = await _read(const.COMPRESSOR_SPEED)
+        state.flow_rate = await _read(const.FLOW_RATE)
+
+        # Fetch setpoints (holding registers)
+        state.setpoint_room_heat_day = await _read(const.SETPOINT_HEAT_DAY)
+        state.setpoint_room_heat_night = await _read(const.SETPOINT_HEAT_NIGHT)
+        state.setpoint_room_cool_day = await _read(const.SETPOINT_COOL_DAY)
+        state.setpoint_room_cool_night = await _read(const.SETPOINT_COOL_NIGHT)
+        state.setpoint_dhw = await _read(const.USER_DHW_SETPOINT)
+
+        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
+
+            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

{python_qube_heatpump-1.2.1 → python_qube_heatpump-1.2.3}/src/python_qube_heatpump/const.py

@@ -16,6 +16,8 @@ class DataType(str, Enum):
     FLOAT32 = "float32"
     INT16 = "int16"
     UINT16 = "uint16"
+    INT32 = "int32"
+    UINT32 = "uint32"
 
 
 # Register definitions (Address, Type, Data Type, Scale, Offset)

python_qube_heatpump-1.2.3/tests/test_client.py

@@ -0,0 +1,73 @@
+"""Test the Qube Heat Pump client."""
+
+from unittest.mock import AsyncMock, MagicMock
+import pytest
+from python_qube_heatpump import QubeClient
+
+
+@pytest.mark.asyncio
+async def test_connect(mock_modbus_client):
+    """Test connection."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    mock_instance.connect.return_value = True
+    mock_instance.connected = False
+    assert await client.connect() is True
+    mock_modbus_client.assert_called_with("1.2.3.4", port=502)
+
+
+@pytest.mark.asyncio
+async def test_read_value(mock_modbus_client):
+    """Test reading values."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    mock_instance.connected = True
+
+    # Mock response for reading holding registers (FLOAT32)
+    # 24.5 = 0x41C40000 -> 16836 (0x41C4), 0 (0x0000) (Big Endian)
+    # Our decoder expects [0, 16836] for Little Endian Word Order?
+    # Logic in client.py: int_val = (regs[1] << 16) | regs[0]
+    # To get 0x41C40000: regs[1]=0x41C4, regs[0]=0x0000
+    mock_resp = MagicMock()
+    mock_resp.isError.return_value = False
+    mock_resp.registers = [0, 16836]
+
+    mock_instance.read_holding_registers = AsyncMock(return_value=mock_resp)
+    client._client = mock_instance
+
+    # Test reading a FLOAT32 holding register
+    # definition = (address, reg_type, data_type, scale, offset)
+    # We use a dummy definition
+    from python_qube_heatpump import const
+
+    definition = (10, const.ModbusType.HOLDING, const.DataType.FLOAT32, None, None)
+
+    result = await client.read_value(definition)
+
+    # Verify result is approximately 24.5
+    assert result is not None
+    assert round(result, 1) == 24.5
+
+    mock_instance.read_holding_registers.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_read_value_int16(mock_modbus_client):
+    """Test reading INT16 value."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+
+    # Mock response for -10 (0xFFF6 = 65526)
+    mock_resp = MagicMock()
+    mock_resp.isError.return_value = False
+    mock_resp.registers = [65526]
+
+    mock_instance.read_input_registers = AsyncMock(return_value=mock_resp)
+    client._client = mock_instance
+
+    from python_qube_heatpump import const
+
+    definition = (20, const.ModbusType.INPUT, const.DataType.INT16, None, None)
+
+    result = await client.read_value(definition)
+    assert result == -10

python_qube_heatpump-1.2.1/src/python_qube_heatpump/client.py

@@ -1,105 +0,0 @@
-"""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/tests/test_client.py

@@ -1,49 +0,0 @@
-"""Test the Qube Heat Pump client."""
-
-from unittest.mock import AsyncMock, MagicMock
-import pytest
-from python_qube_heatpump import QubeClient
-
-
-@pytest.mark.asyncio
-async def test_connect(mock_modbus_client):
-    """Test connection."""
-    client = QubeClient("1.2.3.4", 502)
-    mock_instance = mock_modbus_client.return_value
-    mock_instance.connect.return_value = True
-    mock_instance.connected = False
-    assert await client.connect() is True
-    mock_modbus_client.assert_called_with("1.2.3.4", port=502)
-
-
-@pytest.mark.asyncio
-async def test_read_registers(mock_modbus_client):
-    """Test reading registers."""
-    client = QubeClient("1.2.3.4", 502)
-    mock_instance = mock_modbus_client.return_value
-    mock_instance.connected = True
-    # Mock response
-    mock_resp = MagicMock()
-    mock_resp.isError.return_value = False
-    mock_resp.registers = [123]
-    # Setup the read_holding_registers method on the mock
-    mock_instance.read_holding_registers = AsyncMock(return_value=mock_resp)
-    # We need to manually set the client on the wrapper if we bypass connect
-    client._client = mock_instance
-    result = await client.read_registers(10, 1)
-    assert result == [123]
-    mock_instance.read_holding_registers.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_decode_registers():
-    """Test Register Decoding."""
-    # float32: 24.5 = 0x41C40000 -> 16836, 0 (Big Endian)
-    # struct.unpack('>f', struct.pack('>HH', 16836, 0)) -> 24.5
-    regs = [16836, 0]
-    val = QubeClient.decode_registers(regs, "float32")
-    assert round(val, 1) == 24.5
-    # int16 (negative): -10 = 0xFFF6 = 65526
-    regs = [65526]
-    val = QubeClient.decode_registers(regs, "int16")
-    assert val == -10