admin/goodwe-addon
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

SAFETY-129: find readings 30 s late within about 90 s at a 5 s meter

Browse Source 
The meter's delay fit needed 16 new values in 60 s, so at the owner's 5 s P1
only the batteries' fit ran and 30 s late was found after about 3 minutes
(export to -420 W). A meter that slow is now also fitted over 120 s; it calls
a delay late only over 16 s, on two fits in a row, with the same corroboration
as before, and never ends a verdict, so a slow battery (R2-1) runs as before.
Found about 90 s after the start, export above -200 W. 10 s late at a 5 s
meter is not found (nothing swings; it cannot be told from a 10 s battery).

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
glenn schrooyen
2026-11-06 19:38:21 +01:00
co-authored by Claude
parent c66aa7f69a
commit 5b6cb0bf08
4 changed files with 271 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files
goodwe_controller/app/lateness.py
+50 -15
View File
@@ -10,7 +10,8 @@ already fixed. The readings show it: they answer each power request late.
house does not move that reading, so a repeating load cannot fool it. It
needs the request to move FIT_MOVE_W; one reading per 10 s makes it slow.
- `MeterFit`: how long after the site request the meter shows it. Quick at a
1-3 s meter, none at a slower one, and a house load that repeats can fool it.
1-3 s meter, slower and for long lags only at a 5 s one (SAFETY-129), and a
house load that repeats can fool it.
The meter counts only when an ask was slow to start and no battery fit said
"on time"; with hysteresis (ON_S / OFF_S) the result is `late_seen`. Then (`observe()`, each cycle):
- a new command more than ANSWER_W from the battery reading is PENDING until
@@ -163,13 +164,20 @@ class Delay:
# The meter's delay: fitted over this much history, from this many new
# values (a meter of about 3.5 s or faster: a slower one gives too few to
# fit without false delays); late over M_LATE_S (the plant's 6 s settle and one 2 s meter tick),
# but only when the batteries' own readings have not just shown them on time.
# values (a meter of about 3.5 s or faster; a slower one see M_SLOW_FIT_S);
# late over M_LATE_S (the plant's 6 s settle and one 2 s meter tick), but only
# when the batteries' own readings have not just shown them on time.
M_FIT_S = 60.0
M_ROWS = 16
M_LATE_S = freshness.PLANT_SETTLE_S + 2.0 # 8.0
M_SHARE, M_BETTER = 0.4, 0.7
# SAFETY-129: a meter slower than that (a 5 s P1) has fewer than M_ROWS values
# in M_FIT_S, so it is fitted over M_SLOW_FIT_S instead, from the same M_ROWS
# values. It calls a delay late only over M_SLOW_LATE_S and on ON_FITS fits in
# a row: the slow-battery runs (10-12 s dead time, R2-1) read up to 15 s at a
# 5 s meter, and a 10 s lag cannot be told from them, nor does it swing.
M_SLOW_FIT_S = 120.0
M_SLOW_LATE_S = 16.0
# A meter fit counts only after an ask that took this long to start moving a
# reading: on time they start within 1-2 s (the recorded house, at 1-5 s).
SLOW_START_S = 3.0
@@ -183,19 +191,30 @@ class MeterFit:
up with an earlier request, so it only counts while the batteries' own
fit is not on time (`Answer.watch`)."""
def __init__(self):
def __init__(self, fit_s=M_FIT_S, late_s=M_LATE_S):
self.fit_s, self.late_s = fit_s, late_s
self.cmds = deque() # (t, request) when it changed
self.grid = deque() # (t, meter) new values only
def slow(self):
"""The meter is too slow for M_ROWS values in `fit_s`: the usual gap
between its new values (median, so a pause does not count) is over
fit_s / M_ROWS."""
ts = [t for t, _g in self.grid]
if len(ts) < 5:
return False
gaps = sorted(b - a for a, b in zip(ts, ts[1:]))
return gaps[len(gaps) // 2] * M_ROWS > self.fit_s
def add(self, now, cmd, grid):
if cmd is not None and (not self.cmds or self.cmds[-1][1] != cmd):
self.cmds.append((now, float(cmd)))
if grid is not None and (not self.grid or self.grid[-1][1] != grid):
self.grid.append((now, float(grid)))
while self.grid and self.grid[0][0] < now - M_FIT_S:
while self.grid and self.grid[0][0] < now - self.fit_s:
self.grid.popleft()
while (len(self.cmds) > 1
and self.cmds[1][0] <= now - M_FIT_S - MAX_DELAY_S):
and self.cmds[1][0] <= now - self.fit_s - MAX_DELAY_S):
self.cmds.popleft()
def estimate(self):
@@ -214,9 +233,9 @@ class MeterFit:
best = min(range(len(pure)), key=lambda d: (pure[d], d))
if g_var <= 0 or pure[best] > (1 - M_SHARE) * g_var:
return None
if best <= M_LATE_S:
if best <= self.late_s:
return float(best)
if pure[best] > M_BETTER * min(pure[:int(M_LATE_S) + 1]):
if pure[best] > M_BETTER * min(pure[:int(self.late_s) + 1]):
return None
return float(best)
@@ -236,6 +255,8 @@ class Answer:
self._was = None # (command, reading, meter) at the last call
self.delay = Delay()
self.meter = MeterFit()
self.meter_slow = MeterFit(M_SLOW_FIT_S, M_SLOW_LATE_S) # SAFETY-129
self._ms_run = 0 # late slow-meter fits in a row
self._batt_fit = None # (when, d): the batteries' last fit
self._b_run = 0 # late battery fits in a row
self._start_age = None # (when, how long the last ask took to start)
@@ -279,14 +300,18 @@ class Answer:
delays. Late on ON_FITS battery fits from ON_S, or on a meter fit
over M_LATE_S when an ask was slow to start (SLOW_START_S) and no
battery fit within FIT_S said on time: a house load that repeats can
fool the meter fit, not these. On time again on a battery fit under
OFF_S, or a meter fit within M_LATE_S unless a battery fit said late.
fool the meter fit, not these. A meter too slow for M_ROWS values in
M_FIT_S (a 5 s P1) is fitted over M_SLOW_FIT_S and counts only over
M_SLOW_LATE_S, on ON_FITS fits in a row. On time again on a battery fit
under OFF_S, or a meter fit within M_LATE_S unless a battery fit said
late.
"""
if self._start is None:
self._start = now
for name, cmd, reading in units:
self.delay.add(now, name, cmd, reading)
self.meter.add(now, standing_w, grid_w)
self.meter_slow.add(now, standing_w, grid_w)
if self._fit_at is not None and now - self._fit_at < FIT_EVERY_S:
return
self._fit_at = now
@@ -295,6 +320,9 @@ class Answer:
and now - self._exempt_at <= FIT_S:
b = None # a battery that stopped following: no late fit
m = self.meter.estimate()
ms = None
if self.meter.slow():
ms = self.meter_slow.estimate()
if b is not None:
self._batt_fit = (now, b)
self.shown_s = b if b >= ON_S else None
@@ -304,7 +332,13 @@ class Answer:
b_late = recent and self._batt_fit[1] >= ON_S
self._b_run = self._b_run + 1 if (b or 0.0) >= ON_S else 0
d = b if b is not None else m
self._ms_run = self._ms_run + 1 if (ms or 0.0) > M_SLOW_LATE_S else 0
# A slow-meter fit only ever adds a late verdict: it counts as a fit
# when it is late on ON_FITS in a row, and never ends one, so a slow
# battery (R2-1) runs exactly as before.
if self._ms_run < ON_FITS:
ms = None
d = b if b is not None else m if m is not None else ms
if d is None:
if self._fit_ok is None or now - self._fit_ok > FIT_GONE_S:
self.late_seen = False # nothing to tell it by
@@ -312,12 +346,13 @@ class Answer:
self.fits += 1
self.delay_s, self._fit_ok = d, now
warm = now - self._start >= MAX_DELAY_S + FIT_S
m_late = (m or 0.0) > M_LATE_S
m_late = ((m or 0.0) > M_LATE_S and warm) or (
self._ms_run >= ON_FITS
and now - self._start >= MAX_DELAY_S + M_SLOW_FIT_S)
slow = (self._start_age is not None
and now - self._start_age[0] <= M_FIT_S
and self._start_age[1] >= SLOW_START_S)
if self._b_run >= ON_FITS or (
m_late and warm and slow and not b_fresh):
if self._b_run >= ON_FITS or (m_late and slow and not b_fresh):
self.late_seen = True
elif (b is not None and b < OFF_S) or (
m is not None and m <= M_LATE_S and not b_late):