@@ -499,6 +499,7 @@ preclip
 pred
 predai
 predbat
+predbatsolcast
 predbatt
 predheat
 preseed
 
@@ -2530,7 +2530,15 @@
         "has_ge_inverter_mode": False,
         "time_button_press": False,
         "clock_time_format": "%H:%M:%S",
-        "write_and_poll_sleep": 2,
+        # The hub applies register writes one at a time and a single write can take 10-20s (longer
+        # under an EMS), so re-sending every couple of seconds only queues more work ahead of the
+        # read-back. Allow each attempt 10s to verify, give up after 3, and when a control keeps
+        # failing from one cycle to the next send it once, at most every few minutes (see
+        # INVERTER_WRITE_BACKOFF_FAILURES and INVERTER_WRITE_DEGRADED_INTERVAL). Only this row sets
+        # write_max_retry/write_backoff.
+        "write_and_poll_sleep": 10,
+        "write_max_retry": 3,
+        "write_backoff": True,
         "has_time_window": True,
         "support_charge_freeze": True,
         "support_discharge_freeze": True,
 
@@ -635,7 +635,6 @@ pred_bat:
   #  - '{octopus_saving_session}'
   #  - '+[car_charging_planned]'
   #  - '+[car_charging_soc]'
-  #  - '{car_charging_now}'
 
   # Redact additional values from predbat.log and debug dumps that Predbat cannot otherwise
   # recognise as sensitive (an MPAN or similar identifier surfaced by a third-party HA
 
@@ -70,6 +70,13 @@
 INVERTER_WRITE_POLL_INTERVAL = 0.25  # Seconds before the second look, doubling after each miss
 INVERTER_WRITE_POLL_MAX_INTERVAL = 2.0  # Ceiling for that backoff
 INVERTER_MAX_RETRY_REST = 5  # Maximum number of retries for inverter REST commands
+# Per-control write backoff, for inverter types that opt in with write_backoff in INVERTER_DEF (only
+# GWMQTT). A control whose write of the same target has failed to verify this many times in a row
+# (one write per plan cycle) is degraded: it is sent once rather than retried in a burst, and at most
+# once per INVERTER_WRITE_DEGRADED_INTERVAL seconds, until a write verifies, it reads back as wanted,
+# or the target changes. Every call still checks the read-back and reports a mismatch as a failure.
+INVERTER_WRITE_BACKOFF_FAILURES = 2
+INVERTER_WRITE_DEGRADED_INTERVAL = 300
 # Inverter clock skew bands, measured as (inverter time - Predbat computer time) in minutes.
 # At or above the restart threshold Predbat warns loudly and triggers auto_restart. Between the warn
 # and restart thresholds nothing used to be said at all, yet the drift still shifts every charge and
 
@@ -57,8 +57,9 @@
 _TELEMETRY_STALE_THRESHOLD = 120
 
 # How long an identical control command waits for the hub's ack (or, after an ack,
-# for telemetry to catch up) before it may be published again (seconds). Longer than
-# the generic write_and_poll loop (10 x 2 s), so one write sends the command once.
+# for telemetry to catch up) before it may be published again (seconds). Covers the
+# GWMQTT write_and_poll loop (3 attempts of up to 10 s each, see INVERTER_DEF), so one
+# write sends the command once.
 _COMMAND_ACK_WINDOW = 30
 
 # Ids kept per tracked command, so an ack for an earlier send of the same value still
@@ -1989,8 +1990,8 @@ async def switch_event(self, entity_id, service):
     async def _send_control(self, entity_id, command, **kwargs):
         """Publish a control write once and let the hub's ack confirm it.
 
-        The generic write_and_poll loop calls the event handlers again every couple of
-        seconds until the read-back matches. Publishing on every call queued a fresh
+        The generic write_and_poll loop calls the event handlers again on every retry
+        until the read-back matches. Publishing on every call queued a fresh
         Modbus write on the hub each time, so a slow dongle write turned into a storm.
         Once the hub has shown it acks commands on this connection, an identical command
         (same entity, command and payload) is published only once per _COMMAND_ACK_WINDOW:
 
@@ -31,6 +31,8 @@
     INVERTER_TEST,
     TIME_FORMAT_SECONDS,
     INVERTER_MAX_RETRY,
+    INVERTER_WRITE_BACKOFF_FAILURES,
+    INVERTER_WRITE_DEGRADED_INTERVAL,
     EXPORT_MODE_TARGET,
     EXPORT_MODE_IDLE,
     FULL_EXPORT_POWER,
@@ -62,6 +64,12 @@ class Inverter:
     REST API and Home Assistant entity writes with polling validation.
     """
 
+    # Write retry policy, set per type from INVERTER_DEF by refresh_config(). Declared here too so an
+    # Inverter built without __init__ (the test stubs) gets the default policy: INVERTER_MAX_RETRY
+    # attempts per write and no per-control backoff. Only GWMQTT sets anything else.
+    inv_write_max_retry = INVERTER_MAX_RETRY
+    inv_write_backoff = False
+
     def self_test(self, minutes_now):
         self.base.log("======= INVERTER CONTROL SELF TEST START ========")
         self.adjust_battery_target(99, False)
@@ -348,6 +356,8 @@ def __init__(self, base, id=0, quiet=False):
         # the new value back afterwards. Callers take the difference across their own writes to
         # learn whether something outside Predbat had changed what they manage - see commit_needed().
         self.registers_moved = 0
+        # Per-control write backoff state, keyed by entity_id - see _write_attempts().
+        self.write_backoff = {}
 
         self._init_attribute_defaults()
 
@@ -505,6 +515,9 @@ def refresh_config(self, quiet=False):
         self.inv_has_ge_eco_toggle = INVERTER_DEF[self.inverter_type].get("has_ge_eco_toggle", False)
         self.inv_num_load_entities = INVERTER_DEF[self.inverter_type]["num_load_entities"]
         self.inv_write_and_poll_sleep = INVERTER_DEF[self.inverter_type]["write_and_poll_sleep"]
+        # Only take effect when a row sets them explicitly - currently only GWMQTT does
+        self.inv_write_max_retry = INVERTER_DEF[self.inverter_type].get("write_max_retry", INVERTER_MAX_RETRY)
+        self.inv_write_backoff = INVERTER_DEF[self.inverter_type].get("write_backoff", False)
         self.inv_has_idle_time = INVERTER_DEF[self.inverter_type]["has_idle_time"]
         self.inv_can_span_midnight = INVERTER_DEF[self.inverter_type]["can_span_midnight"]
         self.inv_charge_discharge_with_rate = INVERTER_DEF[self.inverter_type].get("charge_discharge_with_rate", False)
@@ -2256,6 +2269,57 @@ def check_write_entity(self, caller, name, entity_id, new_value):
         self.base.record_status(message, had_errors=True)
         return False
 
+    def _write_attempts(self, name, entity_id, new_value):
+        """
+        How many times to send a write of new_value to this control before giving up on it.
+
+        Normally inv_write_max_retry. For inverter types with write_backoff set, a control whose
+        write of this same target has failed INVERTER_WRITE_BACKOFF_FAILURES times in a row is
+        degraded: re-sending a burst every cycle can swamp a device that applies writes slowly and
+        one at a time, which only makes the read-back lag further behind. A degraded control gets a
+        single attempt, at most once per INVERTER_WRITE_DEGRADED_INTERVAL seconds; in between it
+        gets 0, so the caller only checks the read it already took and, if that still differs,
+        reports the failure as usual. A different target is new work and gets the full ladder at once.
+        """
+        if not self.inv_write_backoff:
+            return self.inv_write_max_retry
+        state = self.write_backoff.get(entity_id)
+        if state is not None and state["value"] != new_value:
+            if state["failures"] >= INVERTER_WRITE_BACKOFF_FAILURES:
+                self.base.log(f"Inverter {self.id} {name} target changed to {new_value}, retrying writes normally again")
+            del self.write_backoff[entity_id]
+            state = None
+        if state is None or state["failures"] < INVERTER_WRITE_BACKOFF_FAILURES:
+            return self.inv_write_max_retry
+        now = time.monotonic()
+        if state.get("published_at") is not None and now - state["published_at"] < INVERTER_WRITE_DEGRADED_INTERVAL:
+            return 0
+        state["published_at"] = now
+        return 1
+
+    def _write_backoff_result(self, name, entity_id, new_value, verified):
+        """
+        Record whether a write to this control verified, for _write_attempts().
+
+        Logged once when a control drops to a single attempt per write and once when it recovers.
+        """
+        if not self.inv_write_backoff:
+            return
+        state = self.write_backoff.get(entity_id)
+        if verified:
+            if state is not None and state["failures"] >= INVERTER_WRITE_BACKOFF_FAILURES:
+                self.base.log(f"Inverter {self.id} {name} write verified, retrying writes normally again")
+            self.write_backoff.pop(entity_id, None)
+            return
+        if state is None or state["value"] != new_value:
+            state = {"value": new_value, "failures": 0}
+            self.write_backoff[entity_id] = state
+        state["failures"] += 1
+        if state["failures"] == INVERTER_WRITE_BACKOFF_FAILURES:
+            # This failing call has just published, so the degraded interval runs from now
+            state["published_at"] = time.monotonic()
+            self.base.log(f"Warn: Inverter {self.id} write of {new_value} to {name} has failed {state['failures']} times in a row, sending it at most once every {INVERTER_WRITE_DEGRADED_INTERVAL} seconds until it verifies")
+
     def write_and_poll_switch(self, name, entity_id, new_value):
         """
         GivTCP Workaround, keep writing until correct
@@ -2300,10 +2364,12 @@ def switch_matched(state):
             # weaker but sufficient evidence.
             if ledger is not None:
                 ledger.record_ownership_from_read(entity_id, name, raw_state, now=time.time(), generation=self._ledger_generation(entity_id))
+            self._write_backoff_result(name, entity_id, new_value, True)
             return True
 
+        attempts = self._write_attempts(name, entity_id, new_value)
         retry = 0
-        while not switch_matched(raw_state) and retry < INVERTER_MAX_RETRY:
+        while not switch_matched(raw_state) and retry < attempts:
             retry += 1
             if domain == "sensor":
                 if new_value:
@@ -2328,6 +2394,7 @@ def switch_matched(state):
             # like a change - PredBat accusing somebody else of its own successful write.
             if ledger is not None:
                 ledger.record_write(entity_id, name, raw_state, now=time.time(), generation=self._ledger_generation(entity_id))
+            self._write_backoff_result(name, entity_id, new_value, True)
             return True
         else:
             self.base.log("Warn: Inverter {} Trying to write {} to {} didn't complete got {}".format(self.id, name, new_value, self.base.get_state_wrapper(entity_id=entity_id)))
@@ -2336,6 +2403,7 @@ def switch_matched(state):
             # confirmation would report the next read of a control we have just failed to set.
             if ledger is not None:
                 ledger.clear(entity_id)
+            self._write_backoff_result(name, entity_id, new_value, False)
             return False
 
     def write_and_poll_value(self, name, entity_id, new_value, fuzzy=0, ignore_fail=False, required_unit=None):
@@ -2382,8 +2450,9 @@ def value_matched(state):
             if not matched:
                 ledger.note_write_attempt(entity_id)
 
+        attempts = self._write_attempts(name, entity_id, new_value) if not matched else 0
         retry = 0
-        while (not matched) and (retry < INVERTER_MAX_RETRY):
+        while (not matched) and (retry < attempts):
             retry += 1
             if domain == "sensor":
                 self.base.set_state_wrapper(entity_id, state=new_value, attributes=self.created_attributes.get(entity_id, {}), required_unit=required_unit)
@@ -2404,12 +2473,13 @@ def value_matched(state):
             current_state = value_state(raw_state)
             matched = value_matched(raw_state)
 
-        if retry == 0:
+        if retry == 0 and matched:
             self.base.log(f"Inverter {self.id} write_and_poll_value: No write needed for {name}: {new_value} == {current_state} fuzzy {fuzzy}")
             # Re-arm - see write_and_poll_switch() for why this early return would otherwise leave
             # the control unwatched for good once ownership had been dropped.
             if ledger is not None:
                 ledger.record_ownership_from_read(entity_id, name, raw_state, fuzzy=fuzzy, now=time.time(), generation=self._ledger_generation(entity_id))
+            self._write_backoff_result(name, entity_id, new_value, True)
             return True
         elif matched:
             self.base.log(f"Inverter {self.id} write_and_poll_value: Wrote {new_value} to {name}, successfully now {current_state}")
@@ -2421,12 +2491,14 @@ def value_matched(state):
             # 0.0 read-back would otherwise be stored as a confirmed owned value.
             if ledger is not None:
                 ledger.record_write(entity_id, name, raw_state, fuzzy=fuzzy, now=time.time(), generation=self._ledger_generation(entity_id))
+            self._write_backoff_result(name, entity_id, new_value, True)
             return True
         else:
             self.base.log(f"Warn: Inverter {self.id} Trying to write {new_value} to {name} didn't complete got {current_state}")
             self.base.record_status(f"Warn: Inverter {self.id} write to {name} failed", had_errors=True)
             if ledger is not None:
                 ledger.clear(entity_id)
+            self._write_backoff_result(name, entity_id, new_value, False)
             return False
 
     def write_and_poll_option(self, name, entity_id, new_value, ignore_fail=False):
@@ -2459,7 +2531,15 @@ def write_and_poll_option(self, name, entity_id, new_value, ignore_fail=False):
             if old_value != new_value:
                 ledger.note_write_attempt(entity_id)
 
-        for _retry in range(INVERTER_MAX_RETRY):
+        attempts = self._write_attempts(name, entity_id, new_value)
+        if attempts == 0 and old_value == new_value:
+            # A degraded control between publishes that already reads back as wanted
+            self.base.log("Inverter {} {} already reads {}".format(self.id, name, new_value))
+            if ledger is not None:
+                ledger.record_ownership_from_read(entity_id, name, old_value, now=time.time(), generation=self._ledger_generation(entity_id))
+            self._write_backoff_result(name, entity_id, new_value, True)
+            return True
+        for _retry in range(attempts):
             if entity_base == "time":
                 service = entity_base + "/set_value"
                 self.base.call_service_wrapper(service, time=new_value, entity_id=entity_id)
@@ -2482,11 +2562,13 @@ def write_and_poll_option(self, name, entity_id, new_value, ignore_fail=False):
                     self.registers_moved += 1
                 if ledger is not None:
                     ledger.record_write(entity_id, name, old_value, now=time.time(), generation=self._ledger_generation(entity_id))
+                self._write_backoff_result(name, entity_id, new_value, True)
                 return True
         self.base.log("Warn: Inverter {} Trying to write {} to {} didn't complete got {}".format(self.id, name, new_value, self.base.get_state_wrapper(entity_id, refresh=True)))
         self.base.record_status("Warn: Inverter {} write to {} failed".format(self.id, name), had_errors=True)
         if ledger is not None:
             ledger.clear(entity_id)
+        self._write_backoff_result(name, entity_id, new_value, False)
         return False
 
     def write_hm_time_part(self, name, new_time):
 
@@ -34,7 +34,7 @@
 import pytz
 import asyncio
 
-THIS_VERSION = "v9.3.2"
+THIS_VERSION = "v9.3.3"
 THIS_VERSION_DISPLAY = THIS_VERSION
 
 from download import predbat_update_move, predbat_update_download, check_install, read_deploy_git_version, DEFAULT_PREDBAT_REPOSITORY