python-qube-heatpump 1.4.1__tar.gz → 1.4.3__tar.gz

{python_qube_heatpump-1.4.1 → python_qube_heatpump-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-qube-heatpump
-Version: 1.4.1
+Version: 1.4.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
@@ -10,7 +10,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.12
-Requires-Dist: pymodbus>=3.6.0
+Requires-Dist: pymodbus>=3.11.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-asyncio; extra == 'test'

{python_qube_heatpump-1.4.1 → python_qube_heatpump-1.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-qube-heatpump"
-version = "1.4.1"
+version = "1.4.3"
 authors = [
   { name="MattieGit", email="6250046+MattieGit@users.noreply.github.com" },
 ]
@@ -17,7 +17,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "pymodbus>=3.6.0",
+    "pymodbus>=3.11.0",
 ]
 
 [project.optional-dependencies]

{python_qube_heatpump-1.4.1 → python_qube_heatpump-1.4.3}/src/python_qube_heatpump/client.py

@@ -135,11 +135,11 @@ class QubeClient:
         try:
             if reg_type == const.ModbusType.INPUT:
                 result = await self._client.read_input_registers(
-                    address, count=count, slave=self.unit
+                    address, count=count, device_id=self.unit
                 )
             else:
                 result = await self._client.read_holding_registers(
-                    address, count=count, slave=self.unit
+                    address, count=count, device_id=self.unit
                 )
 
             if result.isError():
@@ -212,38 +212,47 @@ class QubeClient:
             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):
+        # Use string comparison to handle potential enum class differences
+        data_type_str = entity.data_type.value if entity.data_type else None
+        if data_type_str in ("float32", "uint32", "int32"):
             count = 2
         else:
             count = 1
 
+        _LOGGER.debug(
+            "read_entity: key=%s addr=%s input_type=%s data_type=%s count=%s",
+            entity.key, entity.address, entity.input_type, data_type_str, count
+        )
+
         try:
-            # Read based on input type
-            if entity.input_type == InputType.COIL:
+            # Read based on input type (use string comparison for safety)
+            input_type_str = entity.input_type.value if entity.input_type else None
+
+            if input_type_str == "coil":
                 result = await self._client.read_coils(
-                    entity.address, count=1, slave=self.unit
+                    entity.address, count=1, device_id=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:
+            if input_type_str == "discrete_input":
                 result = await self._client.read_discrete_inputs(
-                    entity.address, count=1, slave=self.unit
+                    entity.address, count=1, device_id=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:
+            if input_type_str == "input":
                 result = await self._client.read_input_registers(
-                    entity.address, count=count, slave=self.unit
+                    entity.address, count=count, device_id=self.unit
                 )
-            else:  # HOLDING_REGISTER
+            else:  # holding
                 result = await self._client.read_holding_registers(
-                    entity.address, count=count, slave=self.unit
+                    entity.address, count=count, device_id=self.unit
                 )
 
             if result.isError():
@@ -253,19 +262,27 @@ class QubeClient:
             regs = result.registers
             val: float | int = 0
 
-            # Decode based on data type
-            if entity.data_type == DataType.FLOAT32:
+            _LOGGER.debug(
+                "read_entity: key=%s raw_regs=%s", entity.key, regs
+            )
+
+            # Decode based on data type (use string comparison for safety)
+            if data_type_str == "float32":
                 int_val = (regs[1] << 16) | regs[0]
                 val = struct.unpack(">f", struct.pack(">I", int_val))[0]
-            elif entity.data_type == DataType.INT16:
+                _LOGGER.debug(
+                    "read_entity: key=%s float32 int_val=%s decoded=%s",
+                    entity.key, int_val, val
+                )
+            elif data_type_str == "int16":
                 val = regs[0]
                 if val > 32767:
                     val -= 65536
-            elif entity.data_type == DataType.UINT16:
+            elif data_type_str == "uint16":
                 val = regs[0]
-            elif entity.data_type == DataType.UINT32:
+            elif data_type_str == "uint32":
                 val = (regs[1] << 16) | regs[0]
-            elif entity.data_type == DataType.INT32:
+            elif data_type_str == "int32":
                 val = (regs[1] << 16) | regs[0]
                 if val > 2147483647:
                     val -= 4294967296
@@ -276,6 +293,11 @@ class QubeClient:
             if entity.offset is not None:
                 val = val + entity.offset
 
+            _LOGGER.debug(
+                "read_entity: key=%s final_value=%s (scale=%s, offset=%s)",
+                entity.key, val, entity.scale, entity.offset
+            )
+
             return val
 
         except Exception as e:
@@ -381,7 +403,7 @@ class QubeClient:
 
         try:
             result = await self._client.write_coil(
-                entity.address, value, slave=self.unit
+                entity.address, value, device_id=self.unit
             )
             if result.isError():
                 _LOGGER.warning("Error writing switch %s", key)
@@ -429,17 +451,17 @@ class QubeClient:
                 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
+                    entity.address, regs, device_id=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
+                    entity.address, int(write_value), device_id=self.unit
                 )
             elif entity.data_type == DataType.UINT16:
                 result = await self._client.write_register(
-                    entity.address, int(write_value), slave=self.unit
+                    entity.address, int(write_value), device_id=self.unit
                 )
             else:
                 _LOGGER.warning("Unsupported data type for writing: %s", entity.data_type)