fix: do not write a control that already holds the requested value (#384)

These registers live in EEPROM, which has finite write endurance. Nothing in the
integration writes on its own - a write happens only when async_set_native_value
is called - but there was no guard against a write that could not change
anything. An automation re-applying the same value on a schedule burned a cycle
every run.

Raised by a reporter whose contact repairs inverters and has seen four SPF6000ES
units with failed EEPROMs in a year. That is not attributable to anything here,
and the integration was already innocent of the thing he was worried about, but
there is no argument for spending write cycles on writes that are no-ops.

Gated on having a current reading. When the register has not been read yet the
comparison is meaningless and the write proceeds - a skipped write that should
have happened is a worse failure than a redundant one.

Tests assert the guard exists, that it requires a known current value, and - the
reassuring half of the answer given to the reporter - that neither coordinator.py
nor __init__.py performs any Modbus write at all. If polling ever starts writing,
that promise is void and the test says so.

1008 tests pass.

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

Author: 0xAHA

RELEASENOTES.md

@@ -8,6 +8,10 @@
 
 Merged to `main`, not yet in any release.
 
+- **Setting a control to the value it already has no longer writes to the inverter.** These
+  registers are held in EEPROM, which has a finite number of write cycles. Nothing polls or
+  writes on its own, but an automation re-applying the same value on a schedule used to burn
+  a cycle every run for no effect. Raised by @dinkalin-ux. (#384)
 - **A wrong protocol variant can now be corrected without deleting the integration.** Ten
   inverter families exist as two register maps, chosen by auto-detection at setup. When that
   choice was wrong there was no way back - the profile list shows one name for both, and

custom_components/growatt_modbus/number.py

@@ -319,6 +319,28 @@ async def async_set_native_value(self, value: float) -> None:
 
         # Write to Modbus register with read-back verification
         register = self._control_config['register']
+
+        # Skip a write that would change nothing (#384).
+        #
+        # These registers are held in EEPROM, which has a finite write endurance. Nothing in
+        # the integration writes on its own - a write happens only when this method is
+        # called - but an automation that re-applies the same value on a schedule would
+        # burn a write cycle every time it ran, for no effect. A repairer working on this
+        # inverter family reported four SPF6000ES units with failed EEPROMs in a year, and
+        # while that is not attributable to anything here, there is no reason to spend
+        # cycles on writes that cannot change the value.
+        #
+        # Gated on having a current reading: when the register has not been read yet the
+        # comparison is meaningless and the write goes ahead. A skipped write that should
+        # have happened is worse than a redundant one.
+        current_raw = getattr(self.coordinator.data, self._control_name, None) \
+            if self.coordinator.data is not None else None
+        if current_raw is not None and int(current_raw) == raw_value:
+            _LOGGER.debug(
+                "%s already reads %s (raw %d) — skipping write to register %d",
+                self._control_name, value, raw_value, register,
+            )
+            return
         try:
             write_ok, verified = await self.hass.async_add_executor_job(
                 self.coordinator.modbus_client.write_register_verified,

tests/test_spf_max_charge_current.py

@@ -196,3 +196,45 @@ def test_the_block_read_covers_35_and_36():
               / "growatt_modbus.py").read_text(encoding="utf-8")
     assert "data.bulk_charge_voltage = int(battery_ctrl_regs[1])" in source
     assert "data.float_charge_voltage = int(battery_ctrl_regs[2])" in source
+
+
+# ---------------------------------------------------------------------------
+# EEPROM write avoidance (#384)
+#
+# These registers live in EEPROM, which has finite write endurance. Nothing in the
+# integration writes on its own - a write happens only when a user or an automation sets a
+# value - but an automation re-applying the same value on a schedule would burn a cycle every
+# run for no effect. Raised by a reporter whose contact repairs inverters and saw four
+# SPF6000ES units with failed EEPROMs in a year.
+# ---------------------------------------------------------------------------
+
+def test_nothing_writes_outside_an_explicit_set():
+    """The reassuring half of the answer: polling never writes. If this ever changes, the
+    EEPROM guarantee given to users on #384 is void."""
+    for name in ("coordinator.py", "__init__.py"):
+        source = (Path(__file__).parent.parent / "custom_components" / "growatt_modbus"
+                  / name).read_text(encoding="utf-8")
+        assert "write_register(" not in source, f"{name} performs a Modbus write"
+        assert "write_registers(" not in source, f"{name} performs a Modbus write"
+
+
+def test_setting_the_current_value_does_not_write():
+    """A redundant write costs an EEPROM cycle and cannot change anything."""
+    source = (Path(__file__).parent.parent / "custom_components" / "growatt_modbus"
+              / "number.py").read_text(encoding="utf-8")
+    guard = source[source.index("async def async_set_native_value"):]
+    guard = guard[:guard.index("write_register_verified")]
+    assert "int(current_raw) == raw_value" in guard, (
+        "a write is issued even when the register already holds the requested value"
+    )
+    assert "return" in guard
+
+
+def test_the_guard_needs_a_current_reading():
+    """A skipped write that should have happened is worse than a redundant one, so an
+    unread register must fall through to the write."""
+    source = (Path(__file__).parent.parent / "custom_components" / "growatt_modbus"
+              / "number.py").read_text(encoding="utf-8")
+    assert "current_raw is not None and" in source, (
+        "the no-op guard fires without a known current value"
+    )