python-qube-heatpump 1.12.0__tar.gz → 1.14.0__tar.gz

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install ".[test]" ruff
+        pip install ".[test]" ruff==0.14.14
     - name: Lint with ruff
       run: |
         ruff check .

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-qube-heatpump
-Version: 1.12.0
+Version: 1.14.0
 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
@@ -53,6 +53,7 @@ asyncio.run(main())
 - **Entity definitions** for sensors, binary sensors, and switches
 - **FLOAT32 decoding** with big endian (ABCD) byte order
 - **Type-safe dataclasses** for entity definitions
+- **Monotonic clamping with reset detection** for the energy totals: sub-kWh jitter is clamped, while a drop of more than 1 kWh that persists for 3 consecutive reads is accepted as a counter reset (logged as a warning); `clear_monotonic_cache()` forgets all baselines
 
 ## Entity Definitions
 

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/README.md

@@ -34,6 +34,7 @@ asyncio.run(main())
 - **Entity definitions** for sensors, binary sensors, and switches
 - **FLOAT32 decoding** with big endian (ABCD) byte order
 - **Type-safe dataclasses** for entity definitions
+- **Monotonic clamping with reset detection** for the energy totals: sub-kWh jitter is clamped, while a drop of more than 1 kWh that persists for 3 consecutive reads is accepted as a counter reset (logged as a warning); `clear_monotonic_cache()` forgets all baselines
 
 ## Entity Definitions
 

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/pyproject.toml

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

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/src/python_qube_heatpump/client.py

@@ -18,6 +18,112 @@ from .models import QubeState
 
 _LOGGER = logging.getLogger(__name__)
 
+# Entities read by get_all_data() (used by the official HA core integration).
+# These mirror the register definitions in `const` exactly (address, scale,
+# offset) so batching cannot change any value get_all_data() returns.
+# Note: some of these intentionally differ from the corresponding entries in
+# entities/sensors.py (e.g. compressor_speed has a x60 RPM scale here but not
+# there; cop_calc is unrounded here but rounded to 1 decimal there) — reusing
+# SENSORS would silently change get_all_data()'s output, so a dedicated table
+# is kept instead.
+# Format: (key, address, input_type, data_type, scale, offset)
+_CORE_STATE_REGISTERS: tuple[
+    tuple[str, int, InputType, DataType, float | None, float | None], ...
+] = (
+    ("temp_supply", 20, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_return", 22, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_source_in", 24, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_source_out", 26, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_room", 28, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_dhw", 30, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_outside", 32, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("power_thermic", 36, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("power_electric", 61, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    (
+        "energy_total_electric",
+        69,
+        InputType.INPUT_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "energy_total_thermic",
+        71,
+        InputType.INPUT_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    ("cop_calc", 34, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("status_code", 38, InputType.INPUT_REGISTER, DataType.UINT16, None, None),
+    ("compressor_speed", 45, InputType.INPUT_REGISTER, DataType.FLOAT32, 60, None),
+    ("flow_rate", 18, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    (
+        "setpoint_room_heat_day",
+        27,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "setpoint_room_heat_night",
+        29,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "setpoint_room_cool_day",
+        31,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "setpoint_room_cool_night",
+        33,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    ("setpoint_dhw", 173, InputType.HOLDING_REGISTER, DataType.FLOAT32, None, None),
+    (
+        "usr_pid_heatsetp",
+        101,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "usr_pid_coolsetp",
+        103,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    ("modbus_roomtemp", 75, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+)
+
+_CORE_STATE_ENTITIES: tuple[EntityDef, ...] = tuple(
+    EntityDef(
+        key=key,
+        name=key,
+        address=address,
+        input_type=input_type,
+        data_type=data_type,
+        scale=scale,
+        offset=offset,
+    )
+    for key, address, input_type, data_type, scale, offset in _CORE_STATE_REGISTERS
+)
+
 
 class QubeClient:
     """Qube Modbus Client."""
@@ -43,6 +149,9 @@ class QubeClient:
         self._next_connect_at: float = 0.0
         # Monotonic clamping for total_increasing counters
         self._monotonic_cache: dict[str, float] = {}
+        # Per-key count of consecutive reads that fell below the cached
+        # maximum by more than the reset threshold (see clamp_monotonic)
+        self._monotonic_reset_pending: dict[str, int] = {}
         # Reads that already produced a WARNING (transient failures are
         # logged once per target, then at DEBUG to avoid log spam)
         self._read_failures_warned: set[str] = set()
@@ -109,53 +218,27 @@ class QubeClient:
 
         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)
-        flow_rate = await _read(const.FLOW_RATE)
+        # Batch-read the core sensor fields plus all binary sensors together.
+        # _plan_blocks groups by input type (input/holding/discrete_input/coil)
+        # regardless of which list an entity came from, so combining both
+        # tables into a single read_entities_batched() call still yields one
+        # handful of block transactions instead of ~59 per-field reads.
+        entities = [*_CORE_STATE_ENTITIES, *BINARY_SENSORS.values()]
+        results = await self.read_entities_batched(entities)
+
+        for ent in _CORE_STATE_ENTITIES:
+            setattr(state, ent.key, results.get(ent.key))
+
+        flow_rate = state.flow_rate
         if flow_rate is not None and flow_rate < 0:
             flow_rate = 0.0
         state.flow_rate = 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)
-        state.usr_pid_heatsetp = await _read(const.USER_HEAT_SETPOINT)
-        state.usr_pid_coolsetp = await _read(const.USER_COOL_SETPOINT)
-
-        # LinQ thermostat room temperature (optional)
-        state.modbus_roomtemp = await _read(const.TEMP_ROOM_MODBUS)
-
         self._apply_monotonic_clamping(state)
 
-        # Fetch binary sensors
-        binary_data = await self.read_all_binary_sensors()
-        for key, value in binary_data.items():
+        for key in BINARY_SENSORS:
             if hasattr(state, key):
-                setattr(state, key, value)
+                setattr(state, key, results.get(key))
 
         # Compute unified status (status_code + anti-legionella override)
         state.status = const.resolve_status(state.status_code, state.req_antileg_1)
@@ -174,17 +257,48 @@ class QubeClient:
     def monotonic_cache(self, value: dict[str, float]) -> None:
         """Set the monotonic clamping cache (e.g. restored from disk)."""
         self._monotonic_cache = dict(value)
+        self._monotonic_reset_pending.clear()
+
+    def clear_monotonic_cache(self) -> None:
+        """Forget all monotonic baselines.
 
-    def clamp_monotonic(self, key: str, value: float | None) -> float | None:
+        The next reading of every counter is accepted as-is. Use this when
+        the controller's counters were reset on purpose and the clamped
+        values in the cache are known to be stale.
+        """
+        self._monotonic_cache.clear()
+        self._monotonic_reset_pending.clear()
+
+    # A drop below the cached maximum larger than this (in the counter's own
+    # unit: kWh for the energy totals) is treated as a counter reset rather
+    # than float32 jitter or a transient glitch...
+    MONOTONIC_RESET_THRESHOLD: float = 1.0
+    # ...but only after it has been seen on this many consecutive reads, so a
+    # single glitched zero read never drops a total_increasing counter.
+    MONOTONIC_RESET_CONFIRM_READS: int = 3
+
+    def clamp_monotonic(
+        self,
+        key: str,
+        value: float | None,
+        reset_threshold: float | None = None,
+    ) -> float | None:
         """Clamp a value to prevent decreases for total_increasing counters.
 
-        Returns the clamped value. If the new value is lower than the
-        previously seen value for this key, the previous value is returned.
-        None and non-finite values pass through unchanged.
+        If the new value is lower than the previously seen value for this
+        key by less than ``reset_threshold``, the previous value is returned
+        (jitter suppression). A larger drop is a counter-reset candidate: it
+        is still clamped until it has persisted for
+        ``MONOTONIC_RESET_CONFIRM_READS`` consecutive reads, after which the
+        low value is accepted as the new baseline and a warning is logged.
+        None and non-finite values pass through unchanged and do not affect
+        the reset detection.
 
         Args:
             key: Identifier for this counter (e.g. entity unique_id).
             value: The current reading.
+            reset_threshold: Drop size that counts as a reset; defaults to
+                ``MONOTONIC_RESET_THRESHOLD``.
 
         Returns:
             The clamped value, or None if input was None/non-finite.
@@ -192,8 +306,35 @@ class QubeClient:
         if value is None or not math.isfinite(value):
             return value
         previous = self._monotonic_cache.get(key)
-        if previous is not None and value < previous:
+        if previous is None or value >= previous:
+            self._monotonic_cache[key] = value
+            self._monotonic_reset_pending.pop(key, None)
+            return value
+
+        threshold = (
+            self.MONOTONIC_RESET_THRESHOLD
+            if reset_threshold is None
+            else reset_threshold
+        )
+        if previous - value < threshold:
+            # Sub-threshold jitter: clamp and forget any pending reset
+            self._monotonic_reset_pending.pop(key, None)
+            return previous
+
+        pending = self._monotonic_reset_pending.get(key, 0) + 1
+        if pending < self.MONOTONIC_RESET_CONFIRM_READS:
+            self._monotonic_reset_pending[key] = pending
             return previous
+
+        _LOGGER.warning(
+            "Counter reset detected for %s: value dropped from %s to %s on %d "
+            "consecutive reads; accepting it as the new baseline",
+            key,
+            previous,
+            value,
+            pending,
+        )
+        self._monotonic_reset_pending.pop(key, None)
         self._monotonic_cache[key] = value
         return value
 
@@ -427,6 +568,17 @@ class QubeClient:
                     )
                 if result.isError():
                     raise OSError(f"Modbus error response for block @{start}")
+                if input_type_str in ("coil", "discrete_input"):
+                    if len(result.bits) < count:
+                        raise OSError(
+                            f"Short bit response for block {input_type_str}@{start} "
+                            f"(got {len(result.bits)}, expected {count})"
+                        )
+                elif len(result.registers) < count:
+                    raise OSError(
+                        f"Short register response for block {input_type_str}@{start} "
+                        f"(got {len(result.registers)}, expected {count})"
+                    )
             except Exception as exc:
                 self._log_read_failure(
                     f"block {input_type_str}@{start} (count {count})", exc

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/src/python_qube_heatpump/entities/sensors.py

@@ -51,7 +51,7 @@ _SENSOR_DEFS: tuple[EntityDef, ...] = (
     ),
     EntityDef(
         key="tapw_timeprogram_dhws",
-        name="Minimum temperature DHW",
+        name="DHW setpoint (user)",
         address=44,
         input_type=InputType.HOLDING_REGISTER,
         data_type=DataType.FLOAT32,
@@ -60,7 +60,7 @@ _SENSOR_DEFS: tuple[EntityDef, ...] = (
     ),
     EntityDef(
         key="tapw_timeprogram_dhws_prog",
-        name="DHW temperature (active program)",
+        name="DHW setpoint (time program, Linq min.)",
         address=46,
         input_type=InputType.HOLDING_REGISTER,
         data_type=DataType.FLOAT32,
@@ -107,7 +107,7 @@ _SENSOR_DEFS: tuple[EntityDef, ...] = (
     ),
     EntityDef(
         key="tapw_timeprogram_dhwsetp_nolinq",
-        name="User-defined DHW setpoint",
+        name="DHW setpoint (Modbus)",
         address=173,
         input_type=InputType.HOLDING_REGISTER,
         data_type=DataType.FLOAT32,
@@ -299,7 +299,7 @@ _SENSOR_DEFS: tuple[EntityDef, ...] = (
     ),
     EntityDef(
         key="dhw_setp",
-        name="DHW calculated setpoint",
+        name="Active DHW setpoint",
         address=47,
         input_type=InputType.INPUT_REGISTER,
         data_type=DataType.FLOAT32,
@@ -453,7 +453,7 @@ _SENSOR_DEFS: tuple[EntityDef, ...] = (
     ),
     EntityDef(
         key="setpoint_dhw",
-        name="User-defined DHW setpoint",
+        name="DHW setpoint (Modbus)",
         address=173,
         input_type=InputType.HOLDING_REGISTER,
         data_type=DataType.FLOAT32,

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/tests/test_client.py

@@ -1,5 +1,6 @@
 """Test the Qube Heat Pump client."""
 
+import logging
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
@@ -331,12 +332,18 @@ async def test_get_all_data_auto_reconnects(mock_modbus_client):
     client._client = mock_instance
     client._connected = False
 
-    # Mock successful register reads
-    mock_resp = MagicMock()
-    mock_resp.isError.return_value = False
-    mock_resp.registers = [0, 0]
-    mock_instance.read_input_registers = AsyncMock(return_value=mock_resp)
-    mock_instance.read_holding_registers = AsyncMock(return_value=mock_resp)
+    # Mock successful register reads. Batched block reads request a
+    # variable number of registers per block, so the mock must honor the
+    # requested `count` (a real Modbus server would too), unlike a fixed
+    # 2-register response.
+    def _resp(address, count=1, **kwargs):
+        resp = MagicMock()
+        resp.isError.return_value = False
+        resp.registers = [0] * count
+        return resp
+
+    mock_instance.read_input_registers = AsyncMock(side_effect=_resp)
+    mock_instance.read_holding_registers = AsyncMock(side_effect=_resp)
 
     state = await client.get_all_data()
     assert state is not None
@@ -424,11 +431,16 @@ async def test_get_all_data_applies_clamping(mock_modbus_client):
     client._client = mock_instance
     client._connected = True
 
-    mock_resp = MagicMock()
-    mock_resp.isError.return_value = False
-    mock_resp.registers = [0, 0]
-    mock_instance.read_input_registers = AsyncMock(return_value=mock_resp)
-    mock_instance.read_holding_registers = AsyncMock(return_value=mock_resp)
+    # Batched block reads request a variable `count` of registers per
+    # block, so the mock must honor it (a real Modbus server would too).
+    def _resp(address, count=1, **kwargs):
+        resp = MagicMock()
+        resp.isError.return_value = False
+        resp.registers = [0] * count
+        return resp
+
+    mock_instance.read_input_registers = AsyncMock(side_effect=_resp)
+    mock_instance.read_holding_registers = AsyncMock(side_effect=_resp)
 
     state = await client.get_all_data()
     assert state is not None
@@ -580,3 +592,102 @@ async def test_read_entity_warns_again_per_entity(mock_modbus_client, caplog):
 
     warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
     assert len(warnings) == 2
+
+
+@pytest.mark.asyncio
+async def test_clamp_monotonic_reset_detected_after_confirmation(mock_modbus_client):
+    """A drop larger than the reset threshold becomes the new baseline once confirmed."""
+    client = QubeClient("1.2.3.4", 502)
+    assert client.clamp_monotonic("energy", 1000.0) == 1000.0
+
+    # First two low reads are still clamped (could be a transient glitch)
+    assert client.clamp_monotonic("energy", 3.0) == 1000.0
+    assert client.clamp_monotonic("energy", 3.1) == 1000.0
+    # Third consecutive low read confirms the reset
+    assert client.clamp_monotonic("energy", 3.2) == 3.2
+    assert client.monotonic_cache["energy"] == 3.2
+    # Counting resumes from the new baseline
+    assert client.clamp_monotonic("energy", 3.5) == 3.5
+
+
+@pytest.mark.asyncio
+async def test_clamp_monotonic_reset_logs_warning(mock_modbus_client, caplog):
+    """Confirming a reset logs a warning naming the key."""
+    client = QubeClient("1.2.3.4", 502)
+    client.clamp_monotonic("energy_total_thermic", 500.0)
+    with caplog.at_level(logging.WARNING):
+        for _ in range(QubeClient.MONOTONIC_RESET_CONFIRM_READS):
+            client.clamp_monotonic("energy_total_thermic", 0.0)
+    assert "Counter reset detected" in caplog.text
+    assert "energy_total_thermic" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_clamp_monotonic_transient_glitch_does_not_reset(mock_modbus_client):
+    """A single low read followed by recovery must not become a new baseline."""
+    client = QubeClient("1.2.3.4", 502)
+    client.clamp_monotonic("energy", 1000.0)
+
+    assert client.clamp_monotonic("energy", 0.0) == 1000.0
+    assert client.clamp_monotonic("energy", 0.0) == 1000.0
+    # Recovery cancels the pending reset
+    assert client.clamp_monotonic("energy", 1000.2) == 1000.2
+    # A fresh low read starts counting from scratch again
+    assert client.clamp_monotonic("energy", 0.0) == 1000.2
+    assert client.clamp_monotonic("energy", 0.0) == 1000.2
+    assert client.monotonic_cache["energy"] == 1000.2
+
+
+@pytest.mark.asyncio
+async def test_clamp_monotonic_sub_threshold_jitter_still_clamped(mock_modbus_client):
+    """Drops smaller than the threshold are jitter and stay clamped forever."""
+    client = QubeClient("1.2.3.4", 502)
+    client.clamp_monotonic("energy", 1000.0)
+    for _ in range(10):
+        assert client.clamp_monotonic("energy", 999.5) == 1000.0
+    assert client.monotonic_cache["energy"] == 1000.0
+    # Jitter reads do not count towards reset confirmation
+    assert client.clamp_monotonic("energy", 0.0) == 1000.0
+    assert client.clamp_monotonic("energy", 0.0) == 1000.0
+    assert client.clamp_monotonic("energy", 999.5) == 1000.0
+    assert client.clamp_monotonic("energy", 0.0) == 1000.0
+    assert client.clamp_monotonic("energy", 0.0) == 1000.0
+    assert client.monotonic_cache["energy"] == 1000.0
+
+
+@pytest.mark.asyncio
+async def test_clamp_monotonic_custom_threshold(mock_modbus_client):
+    """The reset threshold can be overridden per call."""
+    client = QubeClient("1.2.3.4", 502)
+    client.clamp_monotonic("hours", 100.0, reset_threshold=10.0)
+    # A 5-unit drop is below the custom threshold: clamped, never a reset
+    for _ in range(5):
+        assert client.clamp_monotonic("hours", 95.0, reset_threshold=10.0) == 100.0
+    # A 50-unit drop is a reset
+    for _ in range(QubeClient.MONOTONIC_RESET_CONFIRM_READS - 1):
+        assert client.clamp_monotonic("hours", 50.0, reset_threshold=10.0) == 100.0
+    assert client.clamp_monotonic("hours", 50.0, reset_threshold=10.0) == 50.0
+
+
+@pytest.mark.asyncio
+async def test_clear_monotonic_cache(mock_modbus_client):
+    """Clearing the cache forgets baselines and pending resets."""
+    client = QubeClient("1.2.3.4", 502)
+    client.clamp_monotonic("energy", 1000.0)
+    client.clamp_monotonic("energy", 0.0)  # pending reset
+    client.clear_monotonic_cache()
+    assert client.monotonic_cache == {}
+    # Next read is accepted as a fresh baseline
+    assert client.clamp_monotonic("energy", 5.0) == 5.0
+
+
+@pytest.mark.asyncio
+async def test_monotonic_cache_setter_discards_pending_resets(mock_modbus_client):
+    """Restoring a cache from disk resets the reset-confirmation counters."""
+    client = QubeClient("1.2.3.4", 502)
+    client.clamp_monotonic("energy", 1000.0)
+    client.clamp_monotonic("energy", 0.0)
+    client.clamp_monotonic("energy", 0.0)
+    client.monotonic_cache = {"energy": 1000.0}
+    # Only one low read so far after the restore: still clamped
+    assert client.clamp_monotonic("energy", 0.0) == 1000.0

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.14.0}/tests/test_client_batching.py

@@ -143,6 +143,41 @@ async def test_batched_block_failure_falls_back_to_individual_reads(
     assert round(results["temp_return"], 1) == 25.0
 
 
+@pytest.mark.asyncio
+async def test_batched_short_successful_response_falls_back_to_individual_reads(
+    mock_modbus_client,
+):
+    """A well-formed but too-short block response degrades gracefully.
+
+    A device can return isError()==False with fewer registers/bits than the
+    requested count (a malformed-but-"successful" response). Previously this
+    slipped past the isError() check and crashed with an uncaught IndexError
+    while decoding, instead of falling back to individual reads like a failed
+    block does. Since get_all_data() is now polled by HA core every 15s via
+    this same batching path, such a response must degrade the same way a
+    failed block does, not raise.
+    """
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    mock_instance.read_input_registers = AsyncMock(
+        side_effect=[
+            # Block read: isError() is False, but only 2 registers came back
+            # for a block that needs 4 (two float32 entities).
+            _register_response(_float32_regs(24.5)),
+            _register_response(_float32_regs(24.5)),  # individual read
+            _register_response(_float32_regs(25.0)),  # individual read
+        ]
+    )
+    client._client = mock_instance
+
+    entities = [SENSORS["temp_supply"], SENSORS["temp_return"]]
+    results = await client.read_entities_batched(entities)
+
+    assert mock_instance.read_input_registers.call_count == 3
+    assert round(results["temp_supply"], 1) == 24.5
+    assert round(results["temp_return"], 1) == 25.0
+
+
 @pytest.mark.asyncio
 async def test_get_all_entities_uses_batched_reads(mock_modbus_client):
     """get_all_entities reads all entities in a handful of transactions."""
@@ -172,3 +207,43 @@ async def test_get_all_entities_uses_batched_reads(mock_modbus_client):
         + mock_instance.read_holding_registers.call_count
     )
     assert total_calls <= 15
+
+
+@pytest.mark.asyncio
+async def test_get_all_data_uses_batched_reads(mock_modbus_client):
+    """get_all_data (used by HA core, polled every 15s) reads via block reads.
+
+    Previously get_all_data() performed one Modbus transaction per field
+    (~59 transactions: 23 core sensors + 37 binary sensors). It should now
+    use the same batched block-read infrastructure as get_all_entities(),
+    landing in a handful of transactions instead.
+    """
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+
+    def _bits(address, count=1, **kwargs):
+        return _bit_response([False] * count)
+
+    def _regs(address, count=1, **kwargs):
+        return _register_response([0] * count)
+
+    mock_instance.read_coils = AsyncMock(side_effect=_bits)
+    mock_instance.read_discrete_inputs = AsyncMock(side_effect=_bits)
+    mock_instance.read_input_registers = AsyncMock(side_effect=_regs)
+    mock_instance.read_holding_registers = AsyncMock(side_effect=_regs)
+    client._client = mock_instance
+    client._connected = True
+
+    state = await client.get_all_data()
+
+    assert state is not None
+    total_calls = (
+        mock_instance.read_coils.call_count
+        + mock_instance.read_discrete_inputs.call_count
+        + mock_instance.read_input_registers.call_count
+        + mock_instance.read_holding_registers.call_count
+    )
+    # Old per-register/per-entity path made ~59 transactions (23 core
+    # fields + 37 binary sensors). Batched block reads should collapse
+    # this into a handful of transactions.
+    assert total_calls <= 15