@@ -77,11 +77,14 @@
 # burns its whole retry budget, so a refresh can run for many minutes. It runs as its own task and the
 # cycle waits this long for it before carrying on, so live status and meter data keep being published.
 SETTINGS_REFRESH_WAIT_SECONDS = 20
-# A setting whose read has failed this many periodic refreshes in a row is backed off: skipped for the
-# next refresh, then 2, 4... up to SETTING_READ_BACKOFF_MAX_SKIP refreshes, and tried again after that.
-# Its last known value is kept and published as a failed readback.
+# A setting whose read has failed this many periodic refreshes in a row, while the device answered its
+# other reads, is backed off: not read for SETTING_READ_BACKOFF_MINUTES, doubling with each further
+# failure up to SETTING_READ_BACKOFF_MAX_MINUTES, then tried again. Its last known value is kept and
+# published as a failed readback. Time-based, so no register goes unread for more than the cap whatever
+# the device's refresh cadence.
 SETTING_READ_BACKOFF_FAILURES = 3
-SETTING_READ_BACKOFF_MAX_SKIP = 6
+SETTING_READ_BACKOFF_MINUTES = 15
+SETTING_READ_BACKOFF_MAX_MINUTES = 60
 
 # An inverter under EMS control is expected to leave its own slot 1 windows spanning the whole day so
 # that they never override a command from the EMS (see #3781). Anything else is reported.
@@ -653,7 +656,7 @@ def initialize(self, ge_cloud_direct, api_key, automatic, automatic_evc=False, e
         # a settings read can tell whether a write landed after it was issued
         self.write_seq = 0
         self.recent_writes = {}
-        # serial -> setting id -> {"failures": consecutive failed reads, "skip": refreshes left to skip}
+        # serial -> setting id -> {"failures": consecutive failed reads, "until": not read again before this time}
         self.setting_read_backoff = {}
         self.default_options_stamp = None
         # Devices found by the periodic device check still waiting for their default options, kept across
@@ -2784,8 +2787,7 @@ async def async_get_inverter_settings(self, serial, first=False, previous=None,
                         future["skipped"] = False
                         future["issue_seq"] = refresh_seq
                         state = device_backoff.get(sid, None)
-                        if backoff and not first and state and state["skip"] > 0:
-                            state["skip"] -= 1
+                        if backoff and not first and state and state.get("until") and self.now_utc_exact < state["until"]:
                             future["skipped"] = True
                             future["data"] = None
                             complete.append(future)
@@ -2824,6 +2826,9 @@ async def async_get_inverter_settings(self, serial, first=False, previous=None,
             # A failure only counts towards backing a register off when the device answered other reads in the
             # same refresh: when nothing reads at all the device or GE Cloud is down, not that one register
             device_answered = any(future["data"] and ("value" in future["data"]) for future in complete)
+            if not first and not device_answered and any(not future["skipped"] for future in complete):
+                # Nothing answered: start every register afresh, so all are read as soon as the device is back
+                device_backoff.clear()
 
             # Wait for all the futures to complete and store results
             for future in complete:
@@ -2874,8 +2879,8 @@ def record_setting_read(self, device_backoff, serial, sid, name, success):
         Track consecutive failed reads of a setting and back it off once it keeps failing
 
         An inverter can list a register it cannot serve (for example AC charge slots 8 and 9), and every
-        read of it times out through the whole retry budget. Backed off, it is skipped for 1, 2, 4... up
-        to SETTING_READ_BACKOFF_MAX_SKIP refreshes and then tried again, so it is never hidden for good.
+        read of it times out through the whole retry budget. Backed off, it is not read for 15, 30, then
+        at most 60 minutes before it is tried again, so it is never hidden for good.
         device_backoff is the device's entry in setting_read_backoff taken when the reads started, so a
         device dropped by a device list refresh meanwhile is not added back.
         """
@@ -2884,11 +2889,12 @@ def record_setting_read(self, device_backoff, serial, sid, name, success):
             if state and state["failures"] >= SETTING_READ_BACKOFF_FAILURES:
                 self.log("GECloud: Device {} setting id {} ({}) read again after {} failed refreshes".format(serial, sid, name, state["failures"]))
             return
-        state = device_backoff.setdefault(sid, {"failures": 0, "skip": 0})
+        state = device_backoff.setdefault(sid, {"failures": 0, "until": None})
         state["failures"] += 1
         if state["failures"] >= SETTING_READ_BACKOFF_FAILURES:
-            state["skip"] = min(2 ** (state["failures"] - SETTING_READ_BACKOFF_FAILURES), SETTING_READ_BACKOFF_MAX_SKIP)
-            self.log("GECloud: Warn: Device {} setting id {} ({}) has failed {} refreshes in a row, skipping it for the next {} refreshes and keeping its last known value".format(serial, sid, name, state["failures"], state["skip"]))
+            minutes = min(SETTING_READ_BACKOFF_MINUTES * 2 ** (state["failures"] - SETTING_READ_BACKOFF_FAILURES), SETTING_READ_BACKOFF_MAX_MINUTES)
+            state["until"] = self.now_utc_exact + timedelta(minutes=minutes)
+            self.log("GECloud: Warn: Device {} setting id {} ({}) has failed {} refreshes in a row, not reading it for {} minutes and keeping its last known value".format(serial, sid, name, state["failures"], minutes))
 
     async def async_get_smart_device_data(self, uuid):
         """
 
@@ -11,7 +11,7 @@
 
 from gecloud import GECloudDirect, GECloudData, regname_to_ha
 from gecloud import GE_API_ACCOUNT, GE_API_DEVICES, GE_API_EVC_SEND_COMMAND, GE_API_INVERTER_WRITE_SETTING, GE_API_SITE
-from gecloud import GE_API_INVERTER_READ_SETTING, GE_API_INVERTER_SETTINGS, SETTING_READ_BACKOFF_MAX_SKIP
+from gecloud import GE_API_INVERTER_READ_SETTING, GE_API_INVERTER_SETTINGS, SETTING_READ_BACKOFF_MAX_MINUTES
 from gecloud import EVCCommandFailed, GECloudTerminalError, SITE_MAX_AGE_MINUTES, parse_site_export_limit
 from gecloud import DEVICE_REFRESH_SECONDS, SETTINGS_SLOW_REFRESH_SECONDS, find_ems_slot_overrides, normalise_register_time
 from utils import dp4
@@ -8839,12 +8839,15 @@ async def test():
             ge.settings["inv001"] = await ge.async_get_inverter_settings("inv001", previous={})
             ge.read_values[120] = None
             read_pattern = []
-            for _ in range(9):
+            for _ in range(17):
+                # A refresh every 10 minutes, as in polling mode
+                ge._now_utc_exact += timedelta(minutes=10)
                 before = len(ge.read_calls)
                 ge.settings["inv001"] = await ge.async_get_inverter_settings("inv001", previous=ge.settings["inv001"], backoff=True)
                 read_pattern.append(any(call[1] == 120 for call in ge.read_calls[before:]))
-            # Fails 1, 2, 3 (back off 1), skip, fails 4 (back off 2), skip, skip, fails 5 (back off 4), skip
-            expected = [True, True, True, False, True, False, False, True, False]
+            # Fails 1, 2, 3 (15 min off: skip 1), fails 4 (30 min: skip 2), fails 5 (60 min: skip 5),
+            # fails 6 (capped at 60 min: skip 5), read again
+            expected = [True, True, True, False, True, False, False, True, False, False, False, False, False, True, False, False, False]
             if read_pattern != expected:
                 print("ERROR: Backoff read pattern {} expected {}".format(read_pattern, expected))
                 failed += 1
@@ -8867,7 +8870,8 @@ async def test():
 
             # Good again: read on the next try after the backoff, and the flag and backoff are cleared
             ge.read_values[120] = "03:00"
-            for _ in range(SETTING_READ_BACKOFF_MAX_SKIP + 1):
+            for _ in range(SETTING_READ_BACKOFF_MAX_MINUTES // 10 + 1):
+                ge._now_utc_exact += timedelta(minutes=10)
                 ge.settings["inv001"] = await ge.async_get_inverter_settings("inv001", previous=ge.settings["inv001"], backoff=True)
             register = ge.settings["inv001"][120]
             if register.get("value") != "03:00" or register.get("read_failed") or 120 in ge.setting_read_backoff.get("inv001", {}):
@@ -8878,15 +8882,24 @@ async def test():
                 failed += 1
 
             # The device or GE Cloud being down fails every read: that is not a register it cannot serve, so
-            # nothing is backed off and every register is read again as soon as it is back
+            # nothing is backed off - even a register already backed off is read the moment the device is back
+            ge.read_values = {17: True, 120: None}
+            for _ in range(3):
+                ge._now_utc_exact += timedelta(minutes=10)
+                ge.settings["inv001"] = await ge.async_get_inverter_settings("inv001", previous=ge.settings["inv001"], backoff=True)
+            if not ge.setting_read_backoff.get("inv001", {}).get(120, {}).get("until"):
+                print("ERROR: Expected id 120 backed off before the outage: {}".format(ge.setting_read_backoff))
+                failed += 1
             ge.read_values = {17: None, 120: None}
-            for _ in range(SETTING_READ_BACKOFF_MAX_SKIP + 2):
+            for _ in range(8):
+                ge._now_utc_exact += timedelta(minutes=1)
                 ge.settings["inv001"] = await ge.async_get_inverter_settings("inv001", previous=ge.settings["inv001"], backoff=True)
             if ge.setting_read_backoff.get("inv001"):
                 print("ERROR: An outage backed registers off: {}".format(ge.setting_read_backoff))
                 failed += 1
             ge.read_values = {17: True, 120: "04:00"}
             before = len(ge.read_calls)
+            ge._now_utc_exact += timedelta(minutes=1)
             ge.settings["inv001"] = await ge.async_get_inverter_settings("inv001", previous=ge.settings["inv001"], backoff=True)
             if sorted(call[1] for call in ge.read_calls[before:]) != [17, 120] or ge.settings["inv001"][120]["value"] != "04:00":
                 print("ERROR: Registers not read on the first refresh after an outage: {}".format(ge.read_calls[before:]))