MAINT-14: maintenance with no SoC reading: charge times out, drain holds at 0 W

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

goodwe_controller/app/maintenance.py

@@ -84,6 +84,10 @@ FAIL_BACKOFF_DAYS = 7
 CHARGE_TICK_MAX_MIN = 5
 # The charge accounting is written to the state file at most this often.
 CHARGE_SAVE_MIN = 5
+# MAINT-14 (DECISIONS/MAINT-14-no-soc-in-maintenance.md): with no SoC reading
+# the timeouts still run, a drain holds at 0 W, and the log says once, after this
+# many minutes, that the level has been unknown for long.
+NOSOC_NOTE_MIN = 15
 
 # ⚠️ CFG-03. THE ONE IN-CODE MIRROR OF config.yaml FOR EVERY `maintenance_*`
 # OPTION, and the only place in the add-on where one of these numbers is typed.
@@ -367,6 +371,10 @@ class Maintenance:
         # written to the state file every CHARGE_SAVE_MIN minutes.
         self._trk = None
         self._trk_saved = None
+        # MAINT-14: when the SoC reading went missing (None while it is there),
+        # and whether the "unknown for long" line was said in this episode.
+        self._nosoc_since = None
+        self._nosoc_said = False
 
     # -- state ---------------------------------------------------------------
     @property
@@ -374,6 +382,7 @@ class Maintenance:
         return self.store.get("phase", IDLE)
 
     def _enter(self, phase: str, now: datetime, events: list, msg: str) -> None:
+        self._nosoc_since = None
         self._trk = None
         self._trk_saved = None
         if self.store.get("charge_track") is not None:
@@ -473,7 +482,8 @@ class Maintenance:
         self._enter(DRAIN, now, events, "maintenance: forced start -> drain")
         return events
 
-    def _charge_account(self, now: datetime, soc: float, gate_open: bool) -> dict:
+    def _charge_account(self, now: datetime, soc: float | None,
+                        gate_open: bool) -> dict:
         """MAINT-13: what this charge has used so far, as minutes of ALLOWED time.
 
         `open_min` counts only ticks with the price gate open; `flat_min` counts
@@ -481,6 +491,9 @@ class Maintenance:
         both. One tick adds at most CHARGE_TICK_MAX_MIN, so a gap (add-on down)
         counts for nothing. A state file from before MAINT-13, or from another
         charge, starts from the wall-clock minutes so far: the old behaviour.
+
+        MAINT-14: `soc` may be None (no reading). Time still counts, the stall
+        wait pauses, and `last` keeps the last SoC seen (saved with the rest).
         """
         since = self.store.get("phase_started")
         trk = self._trk
@@ -490,7 +503,9 @@ class Maintenance:
                 trk = dict(raw)
             else:
                 trk = {"since": since, "open_min": self._elapsed_min(now),
-                       "flat_min": 0.0, "best": float(soc), "at": None}
+                       "flat_min": 0.0,
+                       "best": None if soc is None else float(soc),
+                       "last": None if soc is None else float(soc), "at": None}
             self._trk = trk
         at = trk.get("at")
         try:
@@ -500,10 +515,14 @@ class Maintenance:
         dt = 0.0 if last is None else min(
             CHARGE_TICK_MAX_MIN, max(0.0, (now - last).total_seconds() / 60.0))
         trk["at"] = now.isoformat()
-        if soc > trk["best"]:
+        if soc is None:
+            pass
+        elif trk.get("best") is None or soc > trk["best"]:
             trk["best"], trk["flat_min"] = float(soc), 0.0
         elif gate_open:
             trk["flat_min"] += dt
+        if soc is not None:
+            trk["last"] = float(soc)
         if gate_open:
             trk["open_min"] += dt
         saved = self._trk_saved
@@ -522,6 +541,57 @@ class Maintenance:
         events.append(msg)
         return MaintResult(IDLE, True, 0.0, False, events, failed=kind)
 
+    def _no_soc(self, now: datetime, phase: str, gate_open: bool,
+                events: list) -> MaintResult:
+        """MAINT-14: one tick of a pack in a moving phase with no SoC reading.
+
+        HOLD is unchanged (0 W). DRAIN holds at 0 W, like HOLD, and its 12 h
+        timeout still runs. CHARGE keeps its timeout and wall backstop: out of
+        time is a failure, except when the last SoC seen was within
+        CHARGE_NEAR_FULL_PCT of the target, which counts as done (MAINT-13).
+        Nothing here may start a phase change that needs the level.
+        """
+        if self._nosoc_since is None:
+            self._nosoc_since = now
+            self._nosoc_said = False
+            self._trk_saved = None          # save the last SoC seen, now
+            if phase == DRAIN:
+                msg = ("maintenance: the battery level is unknown, so the "
+                       "drain holds at 0 W until it is back.")
+                _LOG.warning("%s", msg)
+                events.append(msg)
+        if (not self._nosoc_said and (now - self._nosoc_since).total_seconds()
+                >= NOSOC_NOTE_MIN * 60):
+            self._nosoc_said = True
+            msg = (f"maintenance: no battery level for {NOSOC_NOTE_MIN} min. "
+                   f"The time limit of the {phase} still applies.")
+            _LOG.warning("%s", msg)
+            events.append(msg)
+        if phase == HOLD:
+            return MaintResult(HOLD, True, 0.0, False, events)
+        elapsed = self._elapsed_min(now)
+        if phase == DRAIN:
+            if elapsed > DRAIN_TIMEOUT_MIN:
+                return self._fail(now, "drain",
+                                  f"drain stuck, battery level unknown, after "
+                                  f"{elapsed / 60:.0f} h")
+            return MaintResult(DRAIN, True, 0.0, False, events)
+        trk = self._charge_account(now, None, gate_open)
+        if (trk["open_min"] > CHARGE_TIMEOUT_MIN
+                or elapsed > CHARGE_WALL_TIMEOUT_MIN):
+            last = trk.get("last")
+            if last is not None and last >= self.cfg.soc_target - CHARGE_NEAR_FULL_PCT:
+                self._enter(HOLD, now, events,
+                            f"maintenance: charge time is up and the last level "
+                            f"seen was {last:.0f} %, close enough to full, so the "
+                            f"charge counts as done -> holding "
+                            f"{self.cfg.hold_min} min to balance")
+                return MaintResult(HOLD, True, 0.0, False, events)
+            return self._fail(now, "charge",
+                              f"charge stuck, battery level unknown, after "
+                              f"{trk['open_min'] / 60:.0f} h of charging time")
+        return MaintResult(CHARGE, False, None, True, events)
+
     def abort(self, now: datetime, why: str) -> list:
         events = []
         self._enter(IDLE, now, events, f"maintenance: ABORT ({why})")
@@ -609,13 +679,13 @@ class Maintenance:
         # transitions below mean anything, and a stale "100 %" would end the
         # charge phase having charged nothing. Hold the current phase's command
         # and wait; the phase timeout is the backstop.
+        #
+        # MAINT-14: "hold and wait" is not "wait for ever". The timeouts run
+        # here too, and a drain holds at 0 W (an unknown level never allows
+        # discharge, TEL-08). See `_no_soc`.
         if soc is None:
-            _LOG.warning("maintenance: no SoC reading, holding phase %s", phase)
-            if phase == DRAIN:
-                return MaintResult(DRAIN, True, self.cfg.discharge_w, False, events)
-            if phase == HOLD:
-                return MaintResult(HOLD, True, 0.0, False, events)
-            return MaintResult(CHARGE, False, None, True, events)
+            return self._no_soc(now, phase, gate_open, events)
+        self._nosoc_since = None
 
         elapsed = self._elapsed_min(now)