Bump version to v1.1.4 — fix false "Write reversion detected" warnings (#358)

Root-caused in detail by alanmk (SPH 3600 driven by Predbat, which writes every
5 min). Any controller writing on a fixed cadence eventually collides with an
in-flight poll and trips this.

_fetch_data() assembles its snapshot over several seconds. A write landing in
that window is not reflected in the snapshot, so _check_for_cloud_overrides()
compared the tracked value against registers read BEFORE the write and reported
the pre-write value as a reversion. The entry was then popped on that first
mismatch, so the write was never re-checked and could never be vindicated — a
guaranteed false alarm plus the once-per-session persistent notification.

Signature was distinctive: every false warning reported an age of 0-2s, and the
"reverted to" value was always the previous locally-written value. Recorder
history confirmed the writes had held.

Changes:

- Poll timestamping. _async_update_data() records poll_start before the reads
  begin and passes it through. Any tracked write with write_time >= poll_start
  is left pending and evaluated on the next poll, which genuinely post-dates it.

- Debounce. _pending_write_checks entries carry a mismatch_count; a write must
  mismatch on two consecutive polls before being reported. A real revert
  persists, a timing artefact does not.

- Expiry raised and scaled. The old flat 120s could not confirm a genuine
  reversion even at the 60s default now that confirmation can need three cycles.
  Now max(240s, 4 * scan_interval), based on the normal interval rather than the
  temporary offline slow-poll interval so the latter cannot inflate it.

track_write()'s public 3-arg signature is unchanged; all 13 call sites across
number.py, select.py and time.py are unaffected. The 4-tuple is constructed in
one place and unpacked in one place.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: 0xAHA

README.md

@@ -3,7 +3,7 @@
 # Growatt Modbus Integration for Home Assistant ☀️
 
 ![HACS Badge](https://img.shields.io/badge/HACS-Custom-orange.svg)
-![Version](https://img.shields.io/badge/Version-1.1.3-blue.svg)
+![Version](https://img.shields.io/badge/Version-1.1.4-blue.svg)
 [![GitHub Issues](https://img.shields.io/github/issues/0xAHA/Growatt_ModbusTCP.svg)](https://github.com/0xAHA/Growatt_ModbusTCP/issues)
 [![GitHub Stars](https://img.shields.io/github/stars/0xAHA/Growatt_ModbusTCP.svg?style=social)](https://github.com/0xAHA/Growatt_ModbusTCP)
 

RELEASENOTES.md

@@ -4,6 +4,43 @@
 
 ---
 
+## v1.1.4
+
+Issues: #358
+
+- **Fix: false "Write reversion detected" warnings when a write lands mid-poll:**
+  Reported with a full root-cause analysis by @alanmk (SPH 3600 driven by Predbat, which
+  writes every 5 minutes). Any controller that writes on a fixed cadence eventually collides
+  with an in-flight poll and trips this.
+
+  `_fetch_data()` assembles its snapshot over several seconds. A write landing during that
+  window is not reflected in the snapshot, so the detector compared the tracked value
+  against registers read *before* the write and reported the pre-write value as a
+  "reversion". Worse, the entry was popped on that first mismatch, so the write was never
+  re-checked and could never be vindicated — a guaranteed false alarm, plus the
+  once-per-session persistent notification.
+
+  The signature was distinctive: every false warning reported an age of 0–2 seconds, and the
+  "reverted to" value was always the previous locally-written value. HA recorder history
+  confirmed the writes had actually held.
+
+  Three changes:
+  - **Poll timestamping.** `_async_update_data()` now records `poll_start` before the reads
+    begin. Any tracked write newer than that is left pending and evaluated on the next poll,
+    which genuinely post-dates it.
+  - **Debounce.** A write must mismatch on two consecutive polls before being reported. A
+    real cloud or firmware revert persists; a timing artefact vanishes on the next poll.
+  - **Expiry raised and scaled.** The old flat 120 s could not confirm a genuine reversion
+    even at the 60 s default, since confirmation can now need three cycles. It is now
+    `max(240 s, 4 × scan interval)`, so slow-polling setups get their reversions confirmed
+    rather than silently expired. Based on the configured interval, not the temporary
+    offline slow-poll interval.
+
+  Genuine cloud overrides are still detected — they persist across polls and are reported on
+  the second mismatch, with an accurate age.
+
+---
+
 ## v1.1.3
 
 Issues: #348

custom_components/growatt_modbus/coordinator.py

@@ -40,6 +40,12 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+# Floor for how long a tracked write stays pending verification (Issue #358).
+# Must cover: one poll skipped for pre-dating the write, plus two consecutive mismatching
+# polls to satisfy the debounce — three cycles at the default 60 s scan interval.
+# The effective value scales with the configured interval; see _check_for_cloud_overrides.
+_WRITE_CHECK_EXPIRY_S = 240
+
 def test_connection(config: dict) -> dict:
     """Test the connection to the Growatt inverter (TCP or Serial)."""
     try:
@@ -186,8 +192,9 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry,
         self._midnight_grace_expires: datetime | None = None
 
         # Cloud override detection: tracks recently written register values
-        # Format: {register_address: (expected_value, write_timestamp, control_name)}
-        self._pending_write_checks: dict[int, tuple[int, float, str]] = {}
+        # Format: {register_address: (expected_value, write_timestamp, control_name, mismatch_count)}
+        # mismatch_count debounces the check — see _check_for_cloud_overrides (Issue #358).
+        self._pending_write_checks: dict[int, tuple[int, float, str, int]] = {}
         self._cloud_override_notified: bool = False  # Only notify once per session
 
         # WIT: saves register 122 (export_limit_mode) before disabling control authority (30100=0).
@@ -220,26 +227,62 @@ def track_write(self, register: int, expected_value: int, control_name: str) ->
         _check_for_cloud_overrides() compares the tracked value against the fresh data.
         """
         import time as _time
-        self._pending_write_checks[register] = (expected_value, _time.time(), control_name)
+        self._pending_write_checks[register] = (expected_value, _time.time(), control_name, 0)
+
+    async def _check_for_cloud_overrides(self, data, poll_start: float | None = None) -> None:
+        """Check if any recently written register values have been overridden by the cloud.
+
+        Two guards prevent false positives (Issue #358):
+
+        1. Snapshot staleness. `data` is assembled over several seconds by _fetch_data().
+           A write that lands mid-poll is not reflected in that snapshot, so comparing
+           against it reports the *pre-write* value as a "reversion". Any write newer than
+           poll_start is therefore left pending and evaluated on the next poll, which
+           genuinely post-dates it.
 
-    async def _check_for_cloud_overrides(self, data) -> None:
-        """Check if any recently written register values have been overridden by the cloud."""
+        2. Debounce. A real cloud/firmware revert persists; a timing artefact does not.
+           An entry must mismatch on two consecutive polls before it is reported.
+
+        Without these, a controller writing on a fixed cadence (e.g. Predbat every 5 min)
+        eventually collides with an in-flight poll and produces a spurious warning whose
+        reported age is ~0 s — and because the entry was popped on first mismatch, the
+        write was never re-checked and never vindicated.
+        """
         if not self._pending_write_checks:
             return
 
         import time as _time
         current_time = _time.time()
         to_remove = []
+        to_update = {}
         overridden_controls = []
 
-        for register, (expected_value, write_time, control_name) in self._pending_write_checks.items():
+        for register, entry in self._pending_write_checks.items():
+            expected_value, write_time, control_name, mismatch_count = entry
             age = current_time - write_time
 
-            # Expire entries older than 120 seconds (roughly 2 poll cycles)
-            if age > 120:
+            # Expire stale entries. Must allow for: one poll skipped as pre-dating the
+            # write, then two consecutive mismatching polls to satisfy the debounce —
+            # three cycles. Scaled to the configured interval so slow pollers still get
+            # their reversions confirmed rather than silently expired; the old flat 120 s
+            # could not confirm a genuine reversion even at the 60 s default.
+            # Uses the *normal* interval, not self.update_interval, so the temporary
+            # offline slow-poll interval doesn't inflate this.
+            if age > max(_WRITE_CHECK_EXPIRY_S,
+                         4 * self._normal_update_interval.total_seconds()):
                 to_remove.append(register)
                 continue
 
+            # Guard 1: this snapshot's registers were read before the write landed.
+            # Leave the entry pending; the next poll will evaluate it fairly.
+            if poll_start is not None and write_time >= poll_start:
+                _LOGGER.debug(
+                    "Write check for '%s' deferred — write landed mid-poll "
+                    "(write_time %.3f >= poll_start %.3f); will verify on next poll",
+                    control_name, write_time, poll_start,
+                )
+                continue
+
             # Get current value from the freshly polled data
             current_value = getattr(data, control_name, None)
             if current_value is None:
@@ -248,14 +291,24 @@ async def _check_for_cloud_overrides(self, data) -> None:
             if int(current_value) == expected_value:
                 # Write stuck — remove from tracking
                 to_remove.append(register)
+            elif mismatch_count == 0:
+                # Guard 2: first mismatch. Could still be a timing artefact — keep the
+                # entry and require the next poll to agree before reporting.
+                _LOGGER.debug(
+                    "Write check for '%s': expected %d but read %d (%.0fs after write) — "
+                    "awaiting confirmation on next poll before reporting",
+                    control_name, expected_value, int(current_value), age,
+                )
+                to_update[register] = (expected_value, write_time, control_name, 1)
             else:
-                # Value reverted — cloud override detected
+                # Mismatched on two consecutive polls — treat as a genuine reversion.
                 overridden_controls.append((control_name, expected_value, int(current_value), age))
                 to_remove.append(register)
 
         # Clean up tracked entries
         for reg in to_remove:
             self._pending_write_checks.pop(reg, None)
+        self._pending_write_checks.update(to_update)
 
         # Report overrides
         if overridden_controls:
@@ -643,6 +696,11 @@ async def _async_update_data(self) -> GrowattData:
             raise UpdateFailed("Growatt client not initialized")
 
         try:
+            # Timestamp taken BEFORE the reads begin. _check_for_cloud_overrides() uses it
+            # to tell "this snapshot pre-dates the write" apart from "the value genuinely
+            # reverted" — see Issue #358.
+            poll_start = time.time()
+
             # Run the blocking operations in executor
             data = await self.hass.async_add_executor_job(self._fetch_data)
 
@@ -850,7 +908,7 @@ async def _async_update_data(self) -> GrowattData:
                 self._just_came_online_time = None
 
             # Check for cloud overrides on recently written registers
-            await self._check_for_cloud_overrides(data)
+            await self._check_for_cloud_overrides(data, poll_start)
 
             # Deliver pending clock-drift notification (populated by _check_inverter_clock
             # on the first successful poll; cleared immediately so it only fires once).

custom_components/growatt_modbus/manifest.json

@@ -12,5 +12,5 @@
     "pymodbus>=3.0.0",
     "pyserial>=3.4"
   ],
-  "version": "1.1.3"
+  "version": "1.1.4"
 }