Compare commits

..
2 Commits
58 changed files with 725 additions and 10957 deletions
-403
View File
@@ -1,403 +0,0 @@
#!/usr/bin/env python3
"""CI-18: which test_*.py files does a diff affect? For DEV and REVIEW rounds only.
python3 .gitea/ci/affected_tests.py # merge-base(origin/release/1.0) .. working tree
python3 .gitea/ci/affected_tests.py --base A --head B # a committed range (the graph is read from the working tree: check out B)
python3 .gitea/ci/affected_tests.py --files f1 f2 # explicit changed paths (no git)
... --names # only the file names, one per line
It prints what it chose and why, then the verdict line `SELECT n of N` or
`SELECT ALL`. It never replaces the merge gate: the required context
`checks / unit (pull_request)` runs every test_*.py (checks.yml, run-tests.sh).
WHAT IS SELECTED (the union of):
1. every test file that reaches a changed file through the static graph of
the tree: imports (absolute, relative, `from pkg import mod`), plus any
STRING in the source that names a file (`"predeploy_check.py"`,
`"tools/x.py"`, a dotted `app.mqtt` as in `-m` or import_module). Tests
launch tools by path and read sources as text, so imports alone miss them.
Transitive: a module that imports a changed module carries its tests.
2. every changed test file;
3. the ALWAYS-RUN SAFETY SET below.
A test that walks a directory (`HERE / "app"`, `glob("test_*.py")`) names
that directory or a pattern in a string, so it depends on every file there.
FAILS OPEN. Anything it cannot map selects ALL: a changed file that is not
.py (config.yaml, translations, static, Dockerfile, run-tests.sh, docs, ...),
a deleted or renamed file, a .py nothing references, a file that does not
parse, a base ref that does not exist, a diff it cannot read. Doubt is never "skip". (An EMPTY diff selects the
safety set only: nothing changed.)
OVER-APPROXIMATION IS THE DESIGN. A false edge runs one more file; a missing
edge would skip one. The scan favours false edges (strings, not comments;
suffix matching of module names; any directory name a test spells out).
"""
import argparse
import ast
import fnmatch
import os
import re
import subprocess
import sys
# --- the always-run safety set -------------------------------------------------
# Name and reason, one each. They run on every selection, whatever changed.
# Add a file only with a reason and say it here.
SAFETY_SET = {
"test_bytecode.py": "grades the mutation harness itself; a stale-bytecode "
"survivor makes every other 'it went red' claim void",
"test_ci_gate.py": "grades the gate's checkout/guard shell; cheap, and it "
"is the file that says what a green means",
"test_split_patches.py": "tripwire that tests patch a Controller global "
"where it is read; spans app/main.py and ctl_*.py",
"test_defaults_pin.py": "pins every schema default against config.yaml "
"and scans all modules for literal fallbacks",
"test_docs.py": "operator docs must say what the code does (validator, "
"entity ids)",
}
SKIP_DIRS = {".git", "__pycache__", "node_modules"}
class Fail(Exception):
"""The selector cannot answer; the caller selects ALL."""
def repo_root(start):
p = subprocess.run(["git", "-C", start, "rev-parse", "--show-toplevel"],
capture_output=True, text=True)
if p.returncode != 0:
raise Fail("not inside a git work tree")
return p.stdout.strip()
def all_py(root):
out = []
for d, dirs, files in os.walk(root):
dirs[:] = [x for x in dirs if x not in SKIP_DIRS]
for f in files:
if f.endswith(".py"):
out.append(os.path.relpath(os.path.join(d, f), root))
return sorted(out)
def module_names(rel):
"""Every dotted suffix a file can be imported as: a/b/c.py -> c, b.c, a.b.c."""
parts = rel[:-3].split(os.sep)
if parts[-1] == "__init__":
parts = parts[:-1]
return {".".join(parts[i:]) for i in range(len(parts))} if parts else set()
class Index:
def __init__(self, files):
self.files = files
self.by_mod = {}
self.by_base = {}
self.dirs = {}
# directories that hold test files (the project root): naming one is
# naming the whole tree, which says nothing about a dependency
self.test_dirs = {os.path.basename(os.path.dirname(f))
for f in files
if os.path.basename(f).startswith("test_")}
for f in files:
for m in module_names(f):
self.by_mod.setdefault(m, set()).add(f)
self.by_base.setdefault(os.path.basename(f), set()).add(f)
for comp in os.path.dirname(f).split(os.sep):
if comp:
self.dirs.setdefault(comp, set()).add(f)
def parents(self, rel):
"""Package __init__ files an import of `rel` also runs."""
out = set()
parts = rel.split(os.sep)[:-1]
while parts:
init = os.sep.join(parts + ["__init__.py"])
if init in self.files:
out.add(init)
parts.pop()
return out
def docstring_nodes(tree):
ids = set()
for n in ast.walk(tree):
if isinstance(n, (ast.Module, ast.ClassDef, ast.FunctionDef,
ast.AsyncFunctionDef)) and n.body:
b = n.body[0]
if isinstance(b, ast.Expr) and isinstance(b.value, ast.Constant) \
and isinstance(b.value.value, str):
ids.add(id(b.value))
return ids
# Calls that list a directory: a file making one depends on what the
# directories it names contain (`ast.walk` is not one, and is excluded).
ENUM_CALLS = {"glob", "iglob", "rglob", "listdir", "scandir", "iterdir",
"walk", "copytree"}
# Edge reasons that mean "executes the other file" (they propagate through a
# test file); every other reason means "reads it as data or text".
IMPORT_KINDS = ("import ", "from ", "package of", "dynamic import")
DOTTED = re.compile(r"[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+")
IDENT = re.compile(r"^[A-Za-z_]\w*$")
def edges_of(rel, root, idx):
"""{file `rel` depends on: first reason}."""
path = os.path.join(root, rel)
try:
with open(path, encoding="utf-8") as fh:
src = fh.read()
tree = ast.parse(src, filename=rel)
except (OSError, SyntaxError, UnicodeDecodeError, ValueError) as e:
raise Fail("cannot parse %s: %s" % (rel, e))
deps = {}
def add(target, why):
if target != rel:
deps.setdefault(target, why)
def add_mod(name, why):
hit = idx.by_mod.get(name)
if hit:
for t in hit:
add(t, why)
for p in idx.parents(t):
add(p, "package of " + t)
here = os.path.dirname(rel).split(os.sep) if os.path.dirname(rel) else []
dynamic = False
enumerates = False
consts = []
skip = docstring_nodes(tree)
for n in ast.walk(tree):
if isinstance(n, ast.Import):
for a in n.names:
add_mod(a.name, "import " + a.name)
elif isinstance(n, ast.ImportFrom):
base = n.module or ""
if n.level:
up = here[:len(here) - (n.level - 1)] if n.level > 1 else here
base = ".".join(up + ([base] if base else []))
if base:
add_mod(base, "from %s import" % base)
for a in n.names:
if a.name != "*":
add_mod((base + "." if base else "") + a.name,
"from %s import %s" % (base, a.name))
elif isinstance(n, ast.Call):
fn = n.func
name = fn.attr if isinstance(fn, ast.Attribute) else \
fn.id if isinstance(fn, ast.Name) else ""
obj = fn.value.id if isinstance(fn, ast.Attribute) and \
isinstance(fn.value, ast.Name) else ""
if name in ("import_module", "__import__", "run_module",
"spec_from_file_location", "run_path"):
dynamic = True
if name in ENUM_CALLS and obj != "ast":
enumerates = True
elif isinstance(n, ast.Constant) and isinstance(n.value, str) \
and id(n) not in skip and len(n.value) <= 4000:
consts.append(n.value)
named_dirs = set()
for s in consts:
for m in re.finditer(r"[\w./-]*\.py\b", s):
base = os.path.basename(m.group(0))
for t in idx.by_base.get(base, ()):
add(t, "names file %r" % base)
for tok in DOTTED.findall(s):
add_mod(tok, "names module %r" % tok)
# `app.mqtt.Thing` or `tools.x.main`: shorten from the right
parts = tok.split(".")
for i in range(len(parts) - 1, 0, -1):
add_mod(".".join(parts[:i]), "names module %r" % tok)
if dynamic and IDENT.match(s):
add_mod(s, "dynamic import of %r" % s)
for piece in set(re.split(r"[/\\]", s)) if ("/" in s or "\\" in s) \
else {s}:
if piece in idx.dirs and piece not in idx.test_dirs:
named_dirs.add(piece)
# A file that enumerates directories depends on everything in the ones it
# names, and on what a glob pattern it spells matches in its own directory.
if enumerates:
for d in named_dirs:
for t in idx.dirs[d]:
add(t, "enumerates directory %r" % d)
for s in consts:
if "*" in s and s.endswith(".py"):
pat = os.path.basename(s)
# `test_*.py` globs the tests next to this file; any other
# pattern globs the directories this file names, and only when
# it names none, its own directory.
own = pat.startswith("test_") or not named_dirs
for t in idx.files:
inside = (own and os.path.dirname(t)
== os.path.dirname(rel)) or \
any(c in named_dirs for c in os.path.dirname(t)
.split(os.sep))
if inside and fnmatch.fnmatch(os.path.basename(t), pat):
add(t, "pattern %r" % s)
return deps
def build(root, files):
idx = Index(set(files))
return {f: edges_of(f, root, idx) for f in files}
def is_test(rel):
b = os.path.basename(rel)
return os.path.dirname(rel) == "goodwe_controller" and \
b.startswith("test_") and b.endswith(".py")
def git_changes(root, base, head):
"""[(status, path)] for base..head, or merge-base..working tree."""
def run(*a):
p = subprocess.run(["git", "-C", root] + list(a),
capture_output=True, text=True)
if p.returncode != 0:
raise Fail("git %s failed: %s" % (" ".join(a), p.stderr.strip()))
return p.stdout
if head:
mb = run("merge-base", base, head).strip()
out = run("diff", "--name-status", "--no-renames", "-z", mb, head)
else:
mb = run("merge-base", base, "HEAD").strip()
out = run("diff", "--name-status", "--no-renames", "-z", mb)
toks = out.split("\0")
ch = []
i = 0
while i + 1 < len(toks):
ch.append((toks[i][:1], toks[i + 1]))
i += 2
if not head:
for u in run("ls-files", "-o", "--exclude-standard", "-z").split("\0"):
if u:
ch.append(("A", u))
return ch
def select(root, changes):
"""-> (names, reasons, all_reason). all_reason is not None when ALL."""
files = all_py(root)
tests = sorted(f for f in files if is_test(f))
if not tests:
return None, None, "no test_*.py found under the tree"
reasons = {}
def why(t, r):
reasons.setdefault(t, []).append(r)
if not changes:
for t in SAFETY_SET:
if "goodwe_controller/" + t in tests:
why("goodwe_controller/" + t, "always-run safety set (empty "
"diff): " + SAFETY_SET[t])
return sorted(reasons), reasons, None
changed_py = []
for st, p in changes:
if st not in ("M", "A"):
return None, None, "%s %s (deleted/renamed/type change: the old " \
"importers are not in this tree)" % (st, p)
if not p.endswith(".py"):
return None, None, "changed file %s is not Python (nothing here " \
"can say which tests read it)" % p
if not os.path.exists(os.path.join(root, p)):
return None, None, "changed file %s is not in the work tree" % p
changed_py.append(p)
try:
graph = build(root, files)
except Fail as e:
return None, None, str(e)
rev = {}
for f, deps in graph.items():
for d, r in deps.items():
rev.setdefault(d, {})[f] = r
for p in changed_py:
if is_test(p):
why(p, "changed test file")
continue
# reverse BFS from each changed file
for p in changed_py:
seen = {p: None}
expanded = {p}
queue = [p]
while queue:
cur = queue.pop(0)
for f, r in rev.get(cur, {}).items():
if f not in seen:
seen[f] = (cur, r)
# A test that merely READS another file (names it, globs it)
# is affected by it, but is not a dependency of a third test:
# test_inverter reading every test_*.py as text must not make
# everything that imports a module "affected by test_inverter".
# Only an import carries the change on through a test file.
if f not in expanded and (not is_test(f)
or r.startswith(IMPORT_KINDS)):
expanded.add(f)
queue.append(f)
hit = [f for f in seen if is_test(f) and f != p]
if not hit and not is_test(p):
return None, None, "changed %s is referenced by no test, " \
"directly or through another file" % p
for t in hit:
chain, cur = [], t
while seen[cur]:
nxt, r = seen[cur]
chain.append("%s (%s)" % (os.path.basename(nxt), r))
cur = nxt
why(t, "reaches changed %s via %s" % (p, " <- ".join(
reversed(chain)) if len(chain) > 1 else chain[0]))
for t, r in SAFETY_SET.items():
if "goodwe_controller/" + t in tests:
why("goodwe_controller/" + t, "always-run safety set: " + r)
names = sorted(reasons)
return names, reasons, None
def main(argv=None):
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
ap.add_argument("--base", default="origin/release/1.0")
ap.add_argument("--head", default=None,
help="a ref; default: the working tree")
ap.add_argument("--files", nargs="*", help="changed paths, repo-relative")
ap.add_argument("--root", default=None)
ap.add_argument("--names", action="store_true",
help="print only the chosen file names (one per line), "
"or every test name on SELECT ALL")
a = ap.parse_args(argv)
try:
root = a.root or repo_root(os.getcwd())
changes = [("M", f) for f in a.files] if a.files is not None \
else git_changes(root, a.base, a.head)
names, reasons, all_reason = select(root, changes)
except Fail as e:
names, reasons, all_reason = None, None, str(e)
root = a.root or os.getcwd()
tests = sorted(f for f in all_py(root) if is_test(f)) \
if os.path.isdir(root) else []
if all_reason is not None:
if a.names:
print("\n".join(os.path.basename(t) for t in tests))
else:
print("SELECT ALL - %s" % all_reason)
print("SELECT ALL (%d of %d)" % (len(tests), len(tests)))
return 0
if a.names:
print("\n".join(os.path.basename(t) for t in names))
return 0
print("changed: %s" % (", ".join(p for _, p in changes) or "(nothing)"))
for t in names:
for r in reasons[t][:3]:
print(" %-34s %s" % (os.path.basename(t), r))
print("SELECT %d of %d" % (len(names), len(tests)))
return 0
if __name__ == "__main__":
sys.exit(main())
-35
View File
@@ -1,35 +0,0 @@
#!/bin/sh
# CI-18: run the test files a diff affects, in the CI image, for a dev or review
# round. NOT the merge gate: `checks / unit (pull_request)` runs all of them.
#
# sh .gitea/ci/run-affected.sh # merge-base(origin/release/1.0) .. working tree
# sh .gitea/ci/run-affected.sh --base A --head B # with B checked out: the tests run from the working tree
# INFRA_DIR=/path/to/admin-goodwe@pin sh .gitea/ci/run-affected.sh
#
# Arguments go to affected_tests.py (which prints what it chose and why). It
# selects ALL when it cannot map a change, so a run of this script is never a
# silent skip. Needs python3, git and docker on the host. INFRA_DIR is the
# admin/goodwe checkout at the commit in .gitea/infra-pin (test_freeze.py part 3
# needs sim/hwsim.py); without it test_freeze.py fails, as it does in CI without
# the checkout, and the script says so.
set -eu
repo=$(git rev-parse --show-toplevel)
cd "$repo"
python3 .gitea/ci/affected_tests.py "$@"
only=$(python3 .gitea/ci/affected_tests.py --names "$@" | tr '\n' ' ')
if [ -z "${only# }" ]; then echo "nothing selected"; exit 0; fi
IMG=${CI_IMAGE:-goodwe-addon-checks:1}
docker image inspect "$IMG" >/dev/null 2>&1 || docker build -q -t "$IMG" .gitea/ci >/dev/null
infra=
if [ -n "${INFRA_DIR:-}" ]; then
infra="-v $INFRA_DIR:/w/goodwe:ro"
else
echo "INFRA_DIR is not set: test_freeze.py will fail if it is selected (it needs admin/goodwe at the pin)."
fi
# --network none: the tests need none. --memory: a runaway test must not take the host.
# shellcheck disable=SC2086
exec docker run --rm ${CONTAINER_NAME:+--name "$CONTAINER_NAME"} --network none \
--memory "${CI_MEMORY:-16g}" -e PYTHONDONTWRITEBYTECODE=1 -e GOODWE_REQUIRE_HWSIM=1 \
-e CI_JOBS="${CI_JOBS:-6}" -e CI_ONLY="$only" \
-v "$repo:/w/goodwe-addon:ro" $infra "$IMG" \
sh -eu /w/goodwe-addon/.gitea/ci/run-tests.sh
+10 -33
View File
@@ -41,20 +41,15 @@
# Add a file here only with a measured reason, and say it in this list.
SERIAL="test_loop.py test_freeze.py test_safety87.py"
#
# LONGEST FIRST. With JOBS workers pulling from one queue, starting the longest
# files first keeps the tail short: the batch takes about as long as the longest
# file or the total work divided by JOBS, whichever is more. A sort order, not a
# selection. Seconds, CI-18 local runs at 10 workers on the 12-core host (one
# file's time grows with the load; the order is what matters): opt36 653,
# safety119 704, opt34 515, safety126 402, safety125 388, safety126b 364,
# modes_p3 377, safety94 360, modes_p4c 291, modes_p4b 238, tariff24_weather 235,
# modes_p4d 196, price_run_fixes 197, safety103 189, safety90 185, safety97 163.
# CI-18 split test_modes_p4, test_safety126 and test_safety125 so no one file
# is much over 400 s; test_opt34 and test_opt36 already fan out inside, and
# test_safety119 part 4 is one coupled block, so those three stay whole.
HEAVY="test_opt36.py test_safety119.py test_opt34.py test_safety126.py test_safety125.py test_safety126b.py test_modes_p3.py test_safety94.py test_modes_p4c.py test_modes_p4b.py test_tariff24_weather.py test_modes_p4d.py test_safety125b.py test_price_run_fixes.py test_safety103.py test_safety90.py test_safety97.py test_peakguard.py test_opt20.py test_safety81.py"
# LONGEST FIRST (SAFETY-125's CI run, job 2580; then a local parallel run, seconds:
# modes_p4 758, safety126 634 (SAFETY-126, local, one core), safety125 508 on hotfix-0.19.2 only, modes_p3 364, safety119 328,
# price_run_fixes 184, safety90 160, safety103 134, safety94 114, peakguard 113,
# opt20 102, safety97 101, safety81 100). With JOBS workers pulling from one
# queue, starting the longest files first keeps the tail short: the batch takes
# about as long as the longest file. A sort order, not a selection.
HEAVY="test_modes_p4.py test_safety126.py test_safety125.py test_modes_p3.py test_safety119.py test_price_run_fixes.py test_safety90.py test_safety103.py test_safety94.py test_peakguard.py test_opt20.py test_safety97.py test_safety81.py"
#
JOBS=${CI_JOBS:-10}
JOBS=${CI_JOBS:-6}
cd "${TESTS_DIR:-/w/goodwe-addon/goodwe_controller}"
# one FILE: run it, keep its output in its own file, print its block whole.
@@ -83,21 +78,6 @@ if [ "$1" = "test_*.py" ]; then
echo "NO test_*.py FOUND - the mount is empty or the layout moved. NOTHING has been checked."
exit 1
fi
ALL_COUNT=$#
# CI-18: CI_ONLY="test_a.py test_b.py" runs just those files, for a developer's
# local round (run-affected.sh sets it). checks.yml never sets it and
# test_affected_tests.py fails if it ever does: the merge gate is the glob above.
# Every name must be an existing test_*.py here, and the last line says PARTIAL.
PARTIAL=0
if [ -n "${CI_ONLY:-}" ]; then
PARTIAL=1
for f in $CI_ONLY; do
case "$f" in test_*.py) ;; *) echo "CI_ONLY: '$f' is not a test_*.py name"; exit 1 ;; esac
[ -f "$f" ] || { echo "CI_ONLY: '$f' does not exist in $(pwd)"; exit 1; }
done
set -- $CI_ONLY
echo "PARTIAL RUN (CI_ONLY): $# of $ALL_COUNT test files. NOT the merge gate."
fi
echo "$# test file(s) to run: $JOBS at a time, then the serial group"
RUN_DIR=$(mktemp -d /tmp/ci-tests.XXXXXX)
@@ -106,14 +86,14 @@ export RUN_DIR
: > "$RUN_DIR/ser"
for f in $HEAVY; do
case " $SERIAL " in *" $f "*) continue ;; esac
case " $* " in *" $f "*) if [ -f "$f" ]; then echo "$f" >> "$RUN_DIR/par"; fi ;; esac
if [ -f "$f" ]; then echo "$f" >> "$RUN_DIR/par"; fi
done
for f in "$@"; do
case " $SERIAL $HEAVY " in *" $f "*) continue ;; esac
echo "$f" >> "$RUN_DIR/par"
done
for f in $SERIAL; do
case " $* " in *" $f "*) if [ -f "$f" ]; then echo "$f" >> "$RUN_DIR/ser"; fi ;; esac
if [ -f "$f" ]; then echo "$f" >> "$RUN_DIR/ser"; fi
done
echo "parallel: $(wc -l < "$RUN_DIR/par") file(s); serial: $(wc -l < "$RUN_DIR/ser") file(s)"
@@ -141,8 +121,5 @@ for f in "$@"; do
fi
done
echo "$ran file(s), $bad failed, $(( $(date +%s) - t0 ))s wall"
if [ "$PARTIAL" = 1 ]; then
echo "PARTIAL RUN: $ran of $ALL_COUNT test files ran. This is NOT the merge gate; CI runs all $ALL_COUNT."
fi
if [ "$bad" = 0 ] && [ "$rc" = 0 ]; then exit 0; fi
exit 1
+2 -3
View File
@@ -209,7 +209,7 @@ on:
jobs:
unit:
runs-on: [self-hosted, goodwe-rig]
timeout-minutes: 40 # ~21 to run, measured (CI-18: 10 files at a time; was ~27 at 6, ~60 serial, 22-37 on a busy host); the rest is margin for a busy host
timeout-minutes: 40 # ~15 to run (CI-15: 6 files at a time; the serial suite was ~60 and hit the runner cap); the rest is margin for a busy host
env:
# ⚠️ UNDER /home/homelab, NOT $GITHUB_WORKSPACE (ENV-01, and re-measured
# during CI-01). act's workspace is `/root/.cache/act/<id>/hostexecutor`, a
@@ -534,8 +534,7 @@ jobs:
# shorter timeout - a 60 s limit was tried during CI-01 and reported
# exactly the false hang the docstring predicts.
#
# ⚠️ CI-15: THE FILES RUN SEVERAL AT A TIME (TEN SINCE CI-18, SIX BEFORE),
# NOT ONE AFTER ANOTHER. The serial
# ⚠️ CI-15: THE FILES RUN SIX AT A TIME, NOT ONE AFTER ANOTHER. The serial
# loop summed 3 557 s on SAFETY-125's run (job 2580) and ran past the
# runner's 60-minute cap. The loop now lives in .gitea/ci/run-tests.sh (it
# comes from the merged tree, like the Dockerfile), so the same script runs
+1 -13
View File
@@ -107,22 +107,10 @@ on real hardware, and the comments in `control.py` say which.
### CI and the infra pin
CI (`.gitea/workflows/checks.yml`) runs every `test_*.py` (ten at a time, the wall-clock ones alone afterwards: `.gitea/ci/run-tests.sh`), with `admin/goodwe` checked out next to this repo at the commit in `.gitea/infra-pin`, so `test_freeze.py` grades against the real `sim/hwsim.py`. If that checkout fails, the job fails. The local stub is used only in local runs, and it prints `STUB USED` when it is.
CI (`.gitea/workflows/checks.yml`) runs every `test_*.py` (six at a time, the wall-clock ones alone afterwards: `.gitea/ci/run-tests.sh`), with `admin/goodwe` checked out next to this repo at the commit in `.gitea/infra-pin`, so `test_freeze.py` grades against the real `sim/hwsim.py`. If that checkout fails, the job fails. The local stub is used only in local runs, and it prints `STUB USED` when it is.
The pin tracks `admin/goodwe` **release/1.0**, not master. Two non-required checks go red when release/1.0 has moved past the pin: `infra-pin / fresh` here, on any add-on PR or push to release/1.0, and `addon-pin / fresh` in `admin/goodwe`, on every push to its release/1.0. Nothing re-runs `addon-pin` after a bump, so it stays red on that admin/goodwe commit; `infra-pin / fresh` green on the bump is the all-clear.
**Bump the pin** whenever either is red. Set `.gitea/infra-pin` to the new release/1.0 SHA (`git ls-remote <gitea>/admin/goodwe.git refs/heads/release/1.0`) in a PR, and let `checks / unit` grade the tests against it. CI reads `admin/goodwe` with the Actions secret `INFRA_READ_TOKEN`.
### Running only the affected tests (dev and review rounds)
`checks / unit` runs every `test_*.py` and stays the only merge gate. For a local round, `sh .gitea/ci/run-affected.sh` runs just the files your diff reaches, in the same `goodwe-addon-checks:1` image and through the same `run-tests.sh`:
```bash
INFRA_DIR=~/path/to/admin-goodwe-at-the-pin sh .gitea/ci/run-affected.sh # release/1.0 .. working tree
sh .gitea/ci/run-affected.sh --base origin/release/1.0 --head my-branch # a committed range, with my-branch checked out (the tests run from the working tree)
python3 .gitea/ci/affected_tests.py --files goodwe_controller/app/price.py # only list, with the reasons
```
It prints each chosen file and why, then `SELECT n of N`. A test file is chosen if it imports a changed file, directly or through other modules, or names it in a string (a tool launched by path); a changed test file is chosen; and so is a fixed safety set (`SAFETY_SET` in `affected_tests.py`, one reason each). Anything it cannot map (a non-Python file such as `config.yaml`, a deletion, a `.py` no test reaches) prints `SELECT ALL`. Most modules are imported by `app/main.py`, so a change to `app/` usually selects nearly everything; the saving is for test-only, tool and helper changes. A partial run ends with `PARTIAL RUN ... NOT the merge gate`. `INFRA_DIR` is the `admin/goodwe` checkout at `.gitea/infra-pin`, which `test_freeze.py` needs.
## Compatibility
**Check the serial number, not the model name.** Characters 6-8 of the serial are
-124
View File
@@ -1,129 +1,5 @@
# Changelog
### Not in a release yet
- The *Car* card can now charge: choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. The car is never slowed for the peak limit, the add-on says so instead of raising false peak alarms, and the batteries help cover it unless you switch that off. Off still writes nothing ([[EV-04]]).
- Car charger fixes: when the car alone takes the batteries to the peak reserve, the add-on no longer raises "Battery stopped limiting the peak" (the grey "Car over the peak limit" note says it instead); that note and the Car card's reason stay steady instead of flickering; and switching to Off right after the add-on's own change no longer shows "Something else changes the charger".
## 0.23.0
**A minor bump: the add-on can now read a car charger (Alfen, through Home Assistant), and with two inverters a maintenance charge stays paused during a real peak. Four new options were added, all with defaults, and none needs setting.**
Four options were added (`ev_charger`, `ev_current_entity`, `ev_max_a` and `ev_phases`), none was removed or renamed, and no default changed (90 options, 86 before). **Existing installs need no option change:** the new options have defaults, and `ev_charger` is off, so an install that sets none of them runs as 0.22.0 did. It is a minor bump because it adds a feature and new options; every saved setting still starts.
**A car charger can be read.** The add-on can now read an Alfen charger through its Home Assistant integration. Home gets a *Car* card that shows whether a car is connected, its power and today's energy. The car's power is left out of the House tile and out of what the batteries plan for the night, so they no longer buy energy for the car. The page shows a note when something else changes the charger, and three sensors go to Home Assistant. It is off until you choose a charger in Settings. **The add-on never changes the charger in this version.** The peak limit works as before: the car still counts in what the grid meter sees. See "Car charger" in DOCS ([[EV-03]]).
**A maintenance charge stays paused in a real peak.** With two inverters, during a real peak, a battery in its maintenance charge now stays paused instead of switching between charging and giving, and the batteries give only what the peak guard needs. In one rig test, with a 6.5 kW load for 90 minutes, that battery switched 0 times, against 325 to 385 times on 0.22.0. The night charge was the same as before ([[MAINT-28]]).
**No change in behaviour:** a peak-guard test no longer fails when the build machine is busy, and the test runs are quicker.
Contents of this release, in merge order since 0.22.0 (`b700c0b`):
| | |
|---|---|
| `6c0546b` | Two inverters: during a real peak, a battery in its maintenance charge stays paused instead of switching between charging and giving, and the batteries give only what the peak guard needs. This was taken out of 0.22.0 and is back, fixed ([[MAINT-28]], #248) |
| `6bf3759` | A peak-guard test no longer fails when the build machine is busy. It is a test only, so there is no change in behaviour ([[CI-17]], #252) |
| `7513fd9` | The add-on can read an Alfen car charger through Home Assistant: a *Car* card on Home, the car's power left out of House and out of the batteries' night plan, a note when something else changes the charger, and three Home Assistant sensors. It is off by default, and the add-on never changes the charger in this version ([[EV-03]], #253) |
| `5fc92cf` | The test runs are quicker: a developer can run only the tests a change reaches, the longest test files are split, and ten run at a time. It touches the build and tests only, so there is no change in behaviour ([[CI-18]], #254) |
### Known issues
- A false "Battery is not keeping up" can still show when the peak guard pauses a maintenance charge ([[SAFETY-92]]).
- A battery capped at a low limit with a perfectly flat reading can still trip the stale check ([[SAFETY-74]]).
- A battery whose reading at rest is beyond about ±175 W is still not caught when it refuses ([[SAFETY-97]]).
- The peak guard can still back off near the end of a 15-minute period when a meter reading is late, by less than 30 s. This is about the guard's discharge only; a grid charge is cut back since 0.19.2 ([[SAFETY-99]]).
- Two inverters: the maintenance charge can switch on and off while the house is above the peak aim ([[SAFETY-88]]).
- Two inverters: the "circulating" figure counts a battery's reading at rest ([[SAFETY-98]]).
- Two inverters: a drain that starts during a big step in house use can send the other battery to full power, and about 1 kW goes to the grid for about 10 s ([[SAFETY-104]]).
- Two inverters: when a battery comes back during a maintenance charge, the grid can step by several kW at once ([[SAFETY-101]]).
- Two inverters: when a battery drops out during a solar surplus, the others can swing by up to 1.5 kW in a simulation ([[SAFETY-105]]).
- Two inverters: after a drain ends, a change in house use can go unanswered for about 9 s, because some readings are old ([[SAFETY-106]]).
- Two inverters: when one battery's level is missing, both batteries are held at 0 W, and for about 15 s the last command stays on ([[SAFETY-108]]).
- Two inverters: if one battery's level stays missing for 12 h, the other battery's cycle can be marked failed, with a 7-day wait and a notice, though it is healthy. This comes from reading the code; it has not been seen on a site ([[MAINT-17]]).
- When the 15-minute demand forecast sensor counts the battery's own charge, the maintenance charge runs at about half the power the peak limit leaves, so it takes about twice as long (seen on a site: about 1.2 kW instead of 2.5 kW; the peak limit was kept). At the start of a month, before a peak above the limit, that is about 2 kWh a night in a rig test: the cycle can reach its 36 h limit after about 4 nights and fail, and since 0.22.0 the other battery gets no grid charge on those nights ([[SAFETY-111]]).
- One inverter: after a link drop, the battery's own safety stop to 0 W can be taken as a refusal, and the site stays at 0 W for up to 15 min ([[SAFETY-102]]).
- After a Home Assistant restart, control still waits until Home Assistant has finished starting, which can take several minutes, though the readings are already there ([[SAFETY-115]]).
- While Home Assistant is not answering, the page can list inverters as refusing commands and sensors as missing, and send you to Developer Tools, though they are fine ([[UX-37]]).
- If Home Assistant hangs or stops, the page keeps saying "Waiting for Home Assistant" and never turns into an alarm ([[SAFETY-113]]).
- Right after Home Assistant has started, the page can say for about 4 s that an inverter cannot be controlled, and the first command can come late ([[SAFETY-114]]).
- After a Home Assistant restart, the controller status sensor can still say "running" while the add-on cannot control. It was seen once, and the cause is not known ([[SAFETY-116]]).
- Battery modes on: after a planned top-up from the grid, the Batteries screen can say "Enough sun is forecast" ([[UX-32]]).
- Battery modes on: the forecast line "we count on" can show more sun than the plan counts, because the plan takes house use off first ([[UX-33]]).
- Battery modes on: before a planned top-up, the Today list shows a smaller "gives" amount than the plan will use; it grows as the charge happens ([[UX-34]]).
- Two inverters, battery modes on: while the other battery is in its maintenance charge, a battery's card can say it charges from the grid while it stays at 0 W ([[OPT-18]]).
- Two inverters, battery modes on: while a battery refuses to charge in a cheap run, the action log on the page gets about 8 lines an hour for its retries, and the page hint says "waiting for a better price" ([[UX-38]]).
- A battery in a safety stop, or one the add-on cannot reach, can still be started for a cycle, and its drain then waits about 12 h and ends in a failed-cycle notice. This comes from reading the code; it has not been seen on a site ([[MAINT-19]]).
- On the Settings page, the rows of the solar forecast lists are labelled "Phase 1", "Phase 2" instead of "Sensor 1", "Sensor 2" ([[UX-27]]).
- In the solar forecast list, a blank or repeated row makes "source 2 of 2" count differently from the rows on the Settings page ([[UX-28]]).
- The solar forecast message says "has no reading" also when the sensor shows a number that is too old or in the wrong unit ([[UX-29]]).
- If you use only the forecast lists, two Settings notes sit on the single-sensor field, and one of them tells you to set that field ([[UX-30]]).
- After a restart during a price outage, the "No prices" message can say "yet" when prices did come in earlier ([[UX-39]]).
- On the new settings page, you cannot see whether a price service token is set. Check the Configuration tab ([[UX-41]]).
- On the classic settings page, the first click on Save after editing a field can do nothing. Click again ([[UX-42]]).
- A steady overload on a 1 s meter can warn, and send the Home Assistant notification, 2 or 3 times at the start of each 15-minute period instead of once. The peak limit is still kept ([[SAFETY-122]]).
- A fixed tariff is priced once per hour, so a price window that starts or ends at :15, :30 or :45 gets the wrong price for part of that hour. Windows that start and end on the hour are right ([[TARIFF-23]]).
- Step 6 of the setup wizard stays empty because of an error in the page, in English and in Dutch ([[UX-51]]).
- On Dutch pages, refusal texts, the last-event line under the Home buttons, the installer details and the trading status sentences are still English, and a few Dutch texts read badly, such as "1 metingen geweigerd" ([[UX-52]]).
- Some price texts say "hour" where the add-on acts on a 15-minute period, such as "cheapest hour" ([[UX-47]]).
- After the add-on restarts, the Home price chart shows no price for the earlier part of today, and the setup check can say "12 of 24 hours", though the prices are known ([[UX-48]]).
- With battery modes on and only batteries on "Leftover solar", the Home price chart can mark a cheap period where no battery charges ([[UX-49]]).
- On a phone, the bars of the Home price chart are too thin to tap one 15-minute period. The arrow keys work ([[UX-50]]).
- In the last second of a 15-minute period, being a few watts over the aim can make the peak guard ask a battery for full power for one second. When a charge ends on a period edge, the last-second give can fade out over about 10 s, and a rig test exported up to 7.4 kW for about 8 s ([[SAFETY-124]]).
- During the night grid charge, a 15-minute period can end 6 to 14 W over the peak aim, because the battery charges harder than asked. This was seen in simulation; a rig test saw 2 to 8 W ([[OPT-35]]).
- The test rig could not bring back the false peak alarm that [[SAFETY-126]] fixes, so that fix is shown in simulation only. Watch the notifications for a few nights ([[TEST-35]]).
- The night cheap run is sized for the batteries' full charging power, not for what the peak limit leaves. Under a tight limit the run can end before the batteries reach their level, and Home can show a level they do not reach (79.9 % against a shown 95 % in a rig test) ([[OPT-25]]).
- By day, a Leftover solar plan that has only a daily forecast figure counts the sun from now, not from when the figure was read. It counts about 22 % too much for a figure one hour old; the night plan is not affected ([[OPT-30]]).
- The night charge can buy too much in a house that uses more at night than by day, such as one with a car charger or heat pump, and on a sunny day, because spare sun in one expensive hour does not count for the later ones ([[OPT-31]]).
- A cheap run that has already started can overlap a new give run after a re-plan, so a battery can charge from the grid at the dearest price for part of an hour. This was seen in a test case, not on a site. Also in 0.19.2 ([[OPT-32]]).
- If the solar forecast sensors stop updating before 17:00, as in winter or further north, there is no forecast from three hours after their last update until 20:00 ([[OPT-33]]).
- With a forecast that gives only a daily total, the sun is spread an hour off on the two clock-change days after the change. The day's total is right ([[OPT-24]]).
- The add-on learns the house's use only once a solar forecast is set, so a site that adds a forecast later waits one more day for its first plan ([[OPT-26]]).
- Home says "No trading on price yet: no prices have arrived" when every battery is on Solar first, though the prices are shown ([[UX-55]]).
- The Home plan header can say "Charges in the cheapest hour, gives power in the dearest" when Home draws no charge, and it says "hour" for 15-minute prices ([[UX-56]]).
- While the peak guard holds back charging, Home hides the rest of the cheap run and gives no reason. The charge starts again when the guard lets go ([[UX-57]]).
- With battery modes on and selling on, Home can draw a "Sells up to" block when the add-on judges the trade not worth it, and then it will not sell ([[UX-58]]).
- Home, the plan and the Forecast tab stop drawing a battery's give at the trading floor, though control goes on giving down to the battery's cut-out ([[UX-59]]).
- During a price outage, the Batteries screen says "Prices differ too little" and Home says "The price gap is too small" ([[UX-60]]).
- With battery modes on and no meter, or a meter that is a Home Assistant entity, a grid charge is not possible and nothing says so ([[UX-61]]).
- On the Batteries screen, a charge the add-on refused in a cheap run reads as "Saves its power for ...", for up to 15 minutes ([[UX-62]]).
- A Leftover solar battery with no capacity set never charges from the grid when a solar forecast is set, and nothing warns about it ([[UX-63]]).
- The "How the modes work" box on the Batteries screen does not describe Cheap hours only ([[UX-64]]).
- With battery modes on, Settings still shows "Trade on the price spread", which the modes ignore. A site with modes on and no price source starts, and the Batteries screen says "No prices, so it follows the house" without pointing to Settings ([[UX-65]]).
- With battery modes off and several equal prices in a row, Home and the Forecast tab draw one price quarter, while the add-on trades every quarter of the run ([[UX-67]]).
- Late in the day, the Forecast tab's "now" line and last bars sit over the axis labels at the right edge ([[UX-68]]).
- The Forecast tab's level curve charges at each battery's full rating. Under a peak limit the levels it draws are too high and a charge block can end early (54.6 % shown against 39.7 % in a rig test) ([[UX-70]]).
- The peak forecast check says maintenance charging is not kept under the peak limit when no peak forecast is set, but since 0.19.2 it is ([[UX-73]]).
- The peak guard row can show the same figure twice, such as "at this rate 3 500 W, over 3 500 W". Also in 0.19.2 ([[UX-74]]).
- If the inverter's setpoint entity appears in Home Assistant after the add-on has started, the page keeps saying "Inverter control: not found in Home Assistant" and the batteries say "An alarm stopped control" until a restart, though control runs ([[UX-75]]).
- In the last minute of a 15-minute period, with Home Assistant readings 30 s late, the period can end about 80 W over the peak aim and over the limit: 3 530 W against a 3 450 W aim and a 3 500 W limit in a rig test with a 2 kW load added 45 s before the end. The peak guard sees the load too late to hold it back ([[SAFETY-133]]).
- With Home Assistant readings 10 s late, the grid charge in a cheap run can swing by several kW. In a test the add-on asked for an 8.7 kW charge (9.6 kW on 0.20.0) ([[SAFETY-132]]).
- A plan rebuilt while the battery levels are missing for a moment can drop a cheap run that has not started yet, so the battery does not charge that day. Seen in a replay of real prices, where it cost about EUR 0.40 of extra grid use; the Leftover solar change in 0.20.1 no longer triggers it in those replays, but the cause stays ([[OPT-37]]).
- On a 5 s meter, Home Assistant readings 10 s late are still not caught, and readings 15 s late only after about 4 minutes. Control now follows the meter more gently, so less goes to the grid: in a simulation with a changing load, 340 Wh became 189 Wh at 10 s late and 363 Wh became 296 Wh at 15 s late. In a rig test, 15 s late exported 13 to 19 % more than before ([[SAFETY-136]], [[SAFETY-134]]).
- With readings 10 to 15 s late, the hold can end in the middle of the delay and the swing can come back. Seen in rig tests with a 2 s and a 5 s meter ([[SAFETY-134]]).
- With readings 10 s late on a 1 s meter, the grid can still move between -422 and +340 W while the batteries are held. With a very long delay (30 to 90 s) the request can swing by about 900 W every few seconds. Seen in review tests ([[SAFETY-130]]).
- A battery that answers very slowly (10 s or more) can be taken for late Home Assistant readings and held, and the page then blames Home Assistant. A GoodWe battery settles in about 6 s and this has not been seen on one ([[SAFETY-131]]).
- The page row for late readings reads awkwardly in English ("Home Assistant readings show requests about N seconds late, so control holds the batteries"), and the Dutch text misses a word ([[UX-78]]).
- When the add-on stops, a write that takes more than 2 s can still land after the 0 W, and the 30 s safety timer on the ESPHome board then sets 0 W. After the Stop button, a cycle that had already decided can send its share (560 to 670 W) just after the 0 W; the next cycle sends 0 W again ([[SAFETY-138]]).
- In the last hour of a cheap run, Home can draw a battery's grid charge up to an hour past the time control stops charging it. It only draws too much, never too little ([[UX-79]]).
- A tomorrow solar forecast sensor that reports just after midnight with yesterday's value can be used as the new day's forecast for up to 12 hours. This has not been seen on a site ([[OPT-39]]).
- During a cheap-hours charge, at some 15-minute boundaries the add-on sends 0 W for one tick ("no trade (headroom)") and then goes on. Seen in a rig test, in 5 of 8 cases; once, with a frozen battery reading, it left a battery at 0 W until 23:45 ([[OPT-40]]).
- While one battery's monthly cycle charges, the other battery's card on Home says "Saves its power for higher prices", and the plan still shows its grid charge in the cheap hours, though it will not charge ([[UX-80]]).
- After a failed monthly cycle, the plan line shows the day the wait ends, such as 18 November, not when the cycle tries again, such as 19 November at 19:00 ([[MAINT-26]]).
- At the start of a cheap window the peak guard can step once although the period is under the aim, and the step can land on a battery in its monthly charge. In a rig test it gave 1.7 to 2.3 kW for 6 s ([[SAFETY-140]]).
- A grid charge at full power in the last seconds of a 15-minute period can run into the next period, where the peak guard cuts it back ([[SAFETY-139]]).
- In a long real peak, the peak guard can end a 15-minute period up to 10 W over its aim, as 0.22.0 does (up to 31 W there). In a rig test the month's highest peak did not rise ([[SAFETY-141]]).
- The peak reserve notification can be created again and again, 24 to 47 times in 2 hours in a rig test, while the guard holds a battery at its reserve. 0.22.0 does the same ([[MAINT-29]]).
- When you switch the car charger off, its three sensors stay in Home Assistant with their last values. From reading the code, the PV power sensor does the same when it is switched off ([[TEL-19]]).
- In Settings, the choice for no car charger says "None", while its help says "Off" ([[UX-81]]).
- DOCS names the car's energy sensor `goodwe_car_today_kwh`, but Home Assistant creates it as `sensor.goodwe_car_energy_today` ([[TEL-20]]).
### If you are crossing from a version older than 0.10.0
`## 0.10.0` below can refuse an old config: `slew_w` above its limit, and the
withdrawn `price_provider` ids `engie_dynamic`, `totalenergies_dynamic` and
`eneco_eddy`. Read it before you update. Run `tools/predeploy_check.py` with the
bare options (`jq '.data.options'`) first.
## 0.22.0
**A minor bump: a battery's monthly charge now gets the cheap night, the plan knows about the 7-day wait, a slow meter is followed more gently, and one peak-guard stop no longer costs a night charge its whole period. No option changes.**
@@ -1,149 +0,0 @@
# EV-04 — Manual mode: the first write to a car charger
The design is `reports/EV-01-design-report.md` (sections 2 to 5), accepted on
2026-11-15 with all eight decisions as recommended. This record keeps what the
code had to decide that the design left open.
## What writes, and who may
`app/carmode.py` `ManualWriter` is the only caller of `write_current` and
`write_phases` (test_ev03.py greps for any other). It runs in a background task
(`ctl_car.CarMixin.car_kick`), never in the control cycle: a write waits up to
10 s for the charger's read-back, and the cycle must never wait for a charger.
- **Off writes nothing.** The mode is runtime state in the store (`car_mode`,
`car_current`, `car_phases`), changed on Home or from Home Assistant with no
restart. Solar and Night are not accepted (EV-05, EV-02).
- **Once per user change.** A user change sets a flag the writer clears when the
charger has what was asked. A difference nobody asked for is the other-writer
detector's business, not a reason to write.
- **No car or a full car: nothing is written**, and the setting waits for a car.
- **Shadow mode and a stopped control write nothing**; the card says what the add-on
would set.
- **The clamp is the driver's too.** The writer asks for at most the clamp, and
`AlfenHaDriver.write_current` refuses anything above
`min(ev_max_a, station limit read now, entity range max)`: it sends nothing,
logs `CHARGER_CLAMP` at ERROR (the OUTPUT_CLAMP shape) and answers False.
- **"Taken"** means the read-back followed within 10 s. A write that was not
taken is tried again after a minute, three times, then it waits for the user
(an amber row). A late read-back is adopted, never called another writer.
## The phase sequence
0 A, wait until the charger reports under 100 W or mode3 leaves C (20 s at most),
select the phases, wait 10 s, write the current. One switch per 10 minutes. A
charger that does not take the 0 A never gets the phases select. A sequence that
has begun is finished whatever the mode, because it leaves the car at 0 A
otherwise; a stop of the add-on in the middle gives the car its current back
(`car_shutdown`).
## Another writer
A read-back that differs from what the add-on last wrote (or tried to write, or
saw before a refused write) for 30 s is another writer: a grey row, and no write
until the user changes the mode or a value. EV-03's detector still serves Off;
the tracker mutes its own detector for 15 s after each of our writes, so Manual
back to Off does not show the add-on as a second writer.
## The peak guard's alarm path
`Controller` passes the car's power to the guard's alarm path (`car_cycle`).
**The car explains the excess when the house alone would land the period under
the aim**: the car's average over the whole period (what it drew so far, and its
power now for the rest, `car_avg_w`) is at least how far the projected period is
over the aim. With decision 1 on it also needs the guard to be unable to hold
it (saturated or at the peak reserve). Then "Load too high" and "Battery stopped
limiting the peak" are not raised, the rows are not red, and one grey notice per
charging session says so. The claim, the floor and the commands are unchanged.
The brief's wording is `car_w >= projected excess over the aim`. The
instantaneous form (`car_w >= excess_w`, the watts to come off the meter now)
stops holding late in a period that the car already pushed over, because
`excess_w` grows as the seconds run out; the average form does not, and it is the
same test for a steady car.
**A stale, stuck or frozen car figure must never hide a real overload.** Only
`CarTracker.car_w_trusted` is used: fresh (the EV-03 rules, which also make an
unavailable reading None at once), not stuck after a write (SAFETY-37's shape),
never above what the read-back allows, and CORROBORATED by the charger's energy
meter (round 2). The rule (`CarTracker.corroborated`, constants `CORR_*` in
`chargers.py`): the charger reports charging (mode3 C) and has an energy entity,
and, looking back over unbroken charging readings to the shortest stretch that
is at least 55 s long and over which the reported power adds up to at least
40 Wh, the meter has gained at least 50 % of that, less 15 Wh (the meter shows
10 Wh steps, so at 40 Wh it must show one step; an honest car can fall one step
short and still passes). Readings are kept 180 s. A gap, a state other than C or
a meter that goes back starts the history again. With no such stretch yet (a
session just began, or the add-on just started) the figure is believed, so a
charge does not raise false alarms for its first minute; a frozen figure is
believed for that long only. No energy entity: never corroborated, so the normal
alarms stand. **Bound:** a frozen figure of P watts on a car that has really
stopped is caught within max(60 s, 40 Wh / P): 60 s from 2.4 kW up, 104 s at
1.38 kW (6 A, 1 phase, the lowest charge), plus the alarms' own 10 s hold. Below
about 0.8 kW (40 Wh over the 180 s kept) the figure is believed; it cannot hide
an overload that matters. (Round 2 had a 15 Wh slack that cancelled the 50 % rule
up to 1.8 kW; the 40 Wh floor fixes that.)
## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3)
- **The car is the cause when the alarm's own test says so, on the same
landing** (EV-10). `car_cycle` (`_car_explains_alarm`) runs the alarm's test on
the period as it is and on the period without the car's fresh, corroborated
average (`car_exclude`): the car explains the alarm only if it is true with the
car and false without it. A saturated guard, and a floor with other batteries
left, use `load_too_high` on the landing (the batteries give only what they
still can). A floor that leaves nothing uses SAFETY-126's `misses_aim` (the
batteries at 0 W from now on), which is latched for the quarter; the add-on keeps
that latch twice, with and without the car, from the same readings. Both reset
at a new quarter and when the guard stops wanting power, and they run every
cycle, so the cover option does not touch them. This holds with the projection
still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the
same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`,
sets the latch without the car, and the normal alarms stand. There is no minimum
car power: the comparison itself is what separates car from house.
- **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter
became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so
the test crossed the aim every few seconds. `car_over` (row, card, notice) now
stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (longer than
the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a
quarter) and a gap does not restart the 10 s
on-count. `car_explains`, which the alarms read, has no hold.
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
own detector opens before the write and runs 15 s from when it returns, because
the read-back reaches the cycle while the write still waits for it.
## The one write shadow mode allows
When the add-on has paused the car (0 A) for a phase change and has not yet
selected the phases, Off, a stop of control, a safety latch or shadow mode ends
the change. The old current is given back (clamped, `_restore_a`) in every one of
those cases, shadow mode included. With the shipped `shadow_mode: auto`, stopping
control turns shadow on, so without this the car would stay at 0 A for as long
as control is stopped, while the design's Manual column says the current
stands. Undoing our own half-done change is not a new command; it is the same
write the shutdown restore makes. Nothing else is written in shadow mode: no
phase switch, and no write afterwards.
## Decision 1 (`ev_batt_cover`)
On (the default): the guard works as it does and the batteries cover the car down
to the peak reserve. Off: the projection the guard sees leaves the car out
(`house - car_w`, with the car's average so far), so it does not force the
batteries to discharge for it, and the period goes over by the car alone. The
car is never throttled either way. The projection the guard sees is also the
one `charge_room_w` reads, so with the switch off a grid charge of the batteries
sees the room the car leaves; that is the owner's trade and DOCS says so.
## Deviations from the design text
- **Titles and setting names** follow STYLE.md (at most 5 and 6 words):
"Car over the peak limit" (the design: "Car charge over the peak limit"),
setting "Batteries help with the peak" (the design: "... while the car
charges", which is in its description).
- **No "or choose Solar"** in the Why or the notice: Solar is not in this card.
- **The Why lines** are two sentences of at most 12 words, as test_messages.py
asks; `peak.car` says "The car takes {car} and the batteries cover {cov}."
without "of it".
- **`peak.set_by_car`** keeps its first sentence only ("The batteries were at the
peak reserve" is not true with decision 1 off). A quarter counts as set by the
car when the car drew half the peak or more over it.
@@ -1,55 +0,0 @@
# MAINT-28 - during a real peak the maintenance charge stays paused
**Status: fix-forward after the rig FAIL (TEST-23, f3f9483).** Tests: `test_maint28.py`, `test_maint28b.py`. No option added; the peak aim, the month peak and the MAINT-13 numbers are unchanged. MAINT-24 follow-up (rig test finding F-1, `reports/MAINT-24-test-report.md`).
## What happened (rig x10, house 6.5 kW, month aim 5.95 kW, A in maintenance CHARGE)
`peakguard.shaping_suspended()` pauses the charge while the forecast is over the aim or the guard is engaged. MAINT-24 moved the aim from 3450 W to the month aim (SAFETY-80), so the pause no longer lasts the whole peak: the guard gives, its projection drops under 5950 W and it idles ("heading for 5 6xx W, under this month's peak"), the pause ends, the floor charges A 150-460 W, the grid goes to 6.3-6.9 kW, the guard trips again. A flipped charge/give 468 times in 45 min (base 02eac3b 11). The quarters stayed at the aim; the cost was a battery working against itself and a grid that swung 5.4-6.9 kW.
## The change
`peakguard.shaping_held(suspended, held, forecast, aim, house)`: `suspended` is the old `shaping_suspended()`, and once it was true the pause stays until the house (`grid + battery power`, the load without our own charge) is `MAINT_RESUME_UNDER_W` = 300 W under the aim. A guard that is engaged or a forecast over the aim still pauses at once. House unread: the forecast stands in; neither read: no pause (SAFETY-63). `ctl_cycle.py` keeps the flag in `_maint_peak_hold`. The hold is for N=2 and up, and only where MAINT-24 moved the aim (a banked month peak above `peak_cap_w`, so the aim is above cap minus margin). Elsewhere the old rule stays, byte for byte: SAFETY-87's N=1 digests (`n1_charge_low`) and SAFETY-119's N=2 charge at 5050 W over a 5000 W cap with no banked peak are pinned, and 1b5f7c9 behaves as 02eac3b there (a chase that was not a MAINT-24 regression).
Why the house and not the forecast: while A gives, the forecast sits just under the aim by design, so no forecast margin is both safe and reachable. The house is the meter reading plus the batteries' power (`grid + site_batt_w`): the net demand the meter would see with no battery at work. Solar is already in it, and that is right: the aim is a limit on what the meter takes, so a sunny hour that lowers the net demand is real room, and a cloud that raises it brings the hold back at once. It is not the gross load, and it would be wrong to add PV back (that would hold the pause on room the meter really has). It does not stay put when a battery steps: see "Fix-forward" below.
Why 300 W: the house wanders +-50 W; once the charge resumes it settles at (aim - house) / 2, so 300 W gives at least 150 W, three times the noise, and charging less than that is not worth a restart.
The flag lives only while the charge-only branch is taken: every cycle that reaches the maintenance loop starts it at False, so a maintenance that ended, a mode change or a missing aim cannot carry a stale True into the next charge (test_maint28.py part 1b). `cycle()` has two returns before that loop, and the flag is kept through them on purpose: "inputs missing" and "readings late" (SAFETY-128) are holds of under `stale_after` seconds that write nothing and decide nothing, so the next full cycle sees the same charge and the same peak. A missed poll must not end a peak pause; a reset there would restart the charge on it (`_maint_shape_suspended` is kept through them the same way).
It only ever keeps the maintenance charge off. No cut-back is delayed or weakened: the guard's claim is filed as before. While the pause is held, the pack in CHARGE gives only its share of the guard's floor (0 W if the guard holds it at its reserve), and the batteries together give only what the guard needs (see Fix-forward, F-2 and H-1). The first version let A give for the house; it was dropped.
## Numbers (sim, real `cycle()`, A rated 2500 W)
House 3000 -> 6500 W for 45 min -> 3000 W, +-50 W every 5 s, banked month peak 6000 W (aim 5950 W), forecast = quarter average so far plus the rest at the present grid (`scratch/MAINT-28/dev/m28_repro.py`; `test_maint28.py` runs the same shape for 15 min to keep the suite short).
| 45 min load | base 02eac3b | 1b5f7c9 | MAINT-28 (f3f9483, without the lag) |
|---|---|---|---|
| A charge/give reversals | 0 | 52 | 1 (the first trip) |
| A charging seconds in the load (of 2700) | 0 | 367 | 301 (before the first trip) |
| quarter averages (W) | 5959 5950 5950 5438 5502 | 5356 5923 5924 5041 4479 | 5356 4012 4000 4226 4476 |
| A out / in (kWh) | 0.65 / 0 | 0.45 / 0.51 | 1.67 / 0.56 |
| charge back after the load | - | 3 s | 3 s |
Rig (MAINT-24 test report, F-1): 468 reversals in 45 min on 1b5f7c9, 11 on 02eac3b. Live shape (house 3000 W): no pause, A 1475 W, as MAINT-24.
## Tests and mutants
`test_maint28.py`: part 1 the real peak, 1b the stale hold, 2 `shaping_held()` edges, 3 the unchanged cases (digests equal 1b5f7c9). On 1b5f7c9 itself (hold stubbed out) part 1 and 1b fail. Mutants, each red: M1 hold state not kept (`held` always False: the 1b5f7c9 behaviour); M2 resume line `-` to `+`; M3 house not passed; M4 the per-cycle reset removed; M5 the N=1 gate removed (digest `n1_peak`: N=1, banked peak, house 6500 W); M6 the aim gate removed (digest `n2_nobank`).
## Not changed
MAINT-24's rate and its tests, N=1, the drain, modes off (digests of 1b5f7c9). The pause for a late or missing forecast.
## Fix-forward (rig FAIL F-1, F-2; `reports/MAINT-28-test-report.md`)
The sim had no battery-reading lag, and the first version said the 300 W line is far larger than the lag moves the estimate. That was wrong. The rig publishes a battery's power every 10 s; the meter is newer. After each guard step charge -> give (+500-1000 W) the next meter reading shows the give and the battery reading still shows the charge, so `grid + site_batt_w` drops by the step, under the 5650 W line: 69/69, 132/133, 215/215, 51/51 releases at a median 5430 W with the house at 6450 W or more. Test: `test_maint28b.py`, sim `Lag.batt_period_s`.
**F-1: the pause ends only on a settled estimate.** `Controller._batts_settled()` is False from a step UP of a unit's command (`MAINT_STEP_W` = 100 W more give or less charge, the SAFETY-128 pending size) until its reading changed `PLANT_SETTLE_S` (6 s) after the step, or `BATT_OBLIGED_S` (17 s) have passed. `peakguard.shaping_held(..., settled)` then keeps the pause. A step down makes the estimate err high, which only holds the pause, so it waits for nothing. Measured in the 45 min sim, pause on: settled, the estimate was at most 146 W under the real house (0 cycles over 300 W); not settled, up to 1933 W under (725 of 1611 cycles over 300 W). Sim, 45 min, house 6500 W: 83 of 83 releases on a stale estimate (f3f9483) -> 0; flips 148 -> 1 (1b5f7c9 210). Charge is back 4 s after the load (12 s in test_maint28b), not 0: the first settled estimate. No cut-back is touched.
**F-2 and the cap.** Owner 2026-11-13 ("1" = cap): while the pause holds, the pack in maintenance CHARGE gives only what the guard claims for the peak, at any SoC; other packs unchanged (replaced by H-1 below). Owner 2026-11-13 ("ok max", relayed by the manager): accepted "while the hold is on, the pack in maintenance CHARGE gives at most the largest floor the peak guard claimed in the current quarter" (about 0.37 kWh per 45-min peak in the sim; quarters at or under the aim).
**H-1 (review 2026-11-14, owner decision 2026-11-14): the batteries together give only what the guard needs.** With the cap on A alone, the loop gave for the whole house with B (Cheap hours): in the live-try shape (A 11 % in CHARGE, B 25 %, house 6.5 kW for 90 min) B gave 4.6 kW, went from 25 to 10 % in 43 min, and two quarters were 6502 and 6499 W against the month peak 6000 W. So while the pause holds, `_m28_share()` also files one site limit (source `charge`, `P_MAINT_SHAPE`, per-site `_m28_site`): `hi` = the largest floor of the period, never under this cycle's floor. The guard's claim is not cut: `hi` is at least the floor, `P_PEAK` outranks `P_MAINT_SHAPE`, and `_peak_on_able` still places the whole floor. Outside the hold nothing is filed. Live try, same shape (test_maint28b): quarters 5357 to 5911 W (aim 5950), B 0.86 kWh and ends at 20.6 % (1b5f7c9: 1.0 kWh, 19.8 %), B switches give/idle once, A never. The re-pinned `n2_charge_banked` quarters are 3349 and 3950 W (aim 3950).
The rule as built (`Controller._m28_share()`): while the pause holds (N>=2, month aim above the cap) the pack gets a unit limit `hi` = the largest part of the guard's floor placed on it in this 15-minute period. Its part in a cycle is the floor less what the other units are placed at in this cycle's split without that limit, so a part the guard's split puts on the other pack is not this pack's. A pack the guard holds at its reserve (`peak_guard.held`) gets 0 W and its part starts again from 0 W. The largest part is kept per unit (`_m28_hi`, keyed by the unit) and dropped in a new period or when the pause ends; only one pack can be in maintenance CHARGE anyway (`maintenance.arbitrate()`, one slot per site).
Why the largest of the period and not the present part: the guard alone lands the quarter 9.5-10 W over its aim in the sim (SAFETY-126: its own projection ends on 5950.0 W but the meter reading it counts lags the true grid), and with the present part only, test_maint28 part 1 ends at 5960.1 W; the largest of the period lets the loop keep A up and it ends at 5925 W. Why not `hi` = 0 W: with the other pack under its reserve the guard needs this one (test_maint28b, house 12 kW, B at 18 %: A gives 1.07 kWh for the guard).
Tests (test_maint28b, 13-min load, A 5 kW): A at 49 %: SoC drop 0.64 point (the owner's 0.37 kWh per 45 min is 0.70 point here; the check is <= 0.70). Both packs able, B on Cheap hours: B is placed nothing, A's limit is the period's largest floor (3087 W) and A gives 3081 W. B on Solar first (it gives for the house): A's limit stays under the period's largest floor by 500 W or more in 740 of 744 paused cycles, and the quarters stay under the aim.
Sim, rig shape, 45 min, house 6500 W (load from minute 10), A in CHARGE at 49 %, B 30 % on Cheap hours: A gives 0.17 kWh (f3f9483 0.44), SoC 50.5 -> 49.0 %, charge/give flips 1, give/idle switches 1, quarters 5358 5897 5911 5176 4477 W, charge back 4 s after the load; B gives 0.23 kWh (before H-1 3.04, f3f9483 0.32). test_safety84 n2_charge_banked: banked quarters 3349 and 3950 W against the aim 3950 W.
Mutants, each red: the freshness check dropped (always settled); the cap dropped; the other units' placement dropped (part = the whole floor); one cap for the site instead of per unit; the 0 W for a held pack dropped (all in `test_maint28b.py`); the period's largest dropped (present part only: `test_maint28.py` part 1 quarter 5960 W); `_batts_settled()` replaced by True at the hold in ctl_cycle.py (the 45-min rig shape in `test_maint28b.py`, one stale release); the site limit dropped (the live try in `test_maint28b.py`: quarters 6502 and 6499 W, B 2.91 kWh to 10.0 %).
-130
View File
@@ -251,12 +251,6 @@ The label and description each setting shows on the Configuration tab, in tab or
| Safety | Opposing inverters time (s) | `circulation_hold_s` | For two or more inverters: how long they may push against each other before a safety stop. Derived value, leave it unchanged. |
| Safety | Not delivering alarm after (s) | `delivery_hold_s` | For two or more inverters: how long one may fall short of its share before an alarm, which changes nothing. Derived value, leave it unchanged. |
| Safety | Shadow mode | `shadow_mode` | The add-on makes every decision but keeps every inverter at 0 W. 'auto' does this while control is stopped, 'on' always, 'off' never. |
| Car charger | Charger | `ev_charger` | Which car charger the add-on drives. Off leaves everything as it is. In Off mode the add-on only reads the charger and never changes it. |
| Car charger | Current setting entity | `ev_current_entity` | The entity that sets the charger's current. The add-on finds the charger's other entities from its name. |
| Car charger | Charger limit (A) | `ev_max_a` | The most current the charger may ever be asked for. Never above what the charger reports. Lower it for a weaker fuse or cable. |
| Car charger | Phases | `ev_phases` | How many phases the charger may use: 1, 3, or 1 and 3 (auto). |
| Car charger | Batteries help with the peak | `ev_batt_cover` | While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak. |
| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. A restart never changes the charger's current. |
| Advanced | Start control on boot | `auto_start` | Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart. |
| Advanced | Control gain | `gain` | How much of the remaining error control corrects each cycle. Measured on real hardware, do not raise it. |
| Advanced | Largest change per cycle (W) | `slew_w` | How far the command may move in one cycle. 0 follows “Inverter rating” and is recommended. |
@@ -3275,112 +3269,6 @@ row is printed **always**, including when it is zero: a row that reports
staleness only once it is stale cannot be told from one that never reports
it.
### Car charger
The add-on can drive your car charger and shows it on **Home**, on a *Car* card.
The card has two modes in this version: **Off** (the add-on only reads the
charger and writes nothing) and **Manual** (the add-on sets the current and the
phases you choose). Solar and Night modes come in later versions.
| option | meaning |
|---|---|
| `ev_charger` | `off` (the default: nothing changes at all) or `alfen_ha`, an Alfen charger through its Home Assistant integration. |
| `ev_current_entity` | The charger's current setting, for example `number.wallbox_power_connector_max_current_socket_1`. The add-on finds the charger's other entities from this name. |
| `ev_max_a` | The most current the charger may ever be asked for. It cannot be higher than the station limit the charger reports. |
| `ev_phases` | `1`, `3` or `auto` (1 and 3). |
| `ev_batt_cover` | On (the default): the batteries help cover the car down to the peak reserve. Off: the car is left out of what the peak guard protects. |
| `ev_mode_start` | `keep` (the default) or `off`: the mode after a restart. |
**What the Car card shows.** The state (Charging, Connected waiting, No car
connected, Car is full, Charger not reachable), the power and current, and the
energy charged today. The car's power is taken out of the **House** tile and out
of the house profile that plans the batteries' night charge, so the batteries
no longer buy energy for a car that charged last night.
**Manual mode.** Choose *Manual* on Home, then set the current (6 A up to the
charger limit) and 1 or 3 phases. The same three are Home Assistant entities
when MQTT is on: `select.goodwe_car_mode` (Off, Manual), `number.goodwe_car_current`
and `select.goodwe_car_phases`. The mode, the current and the phases apply at
once, with no restart. The add-on writes each one once, when you change it, and
checks within 10 seconds that the charger took it.
- The current is never higher than the smallest of the charger limit, the station
limit the charger reports and the charger's own range. A value above that is a
software fault: it is logged and never sent.
- With no car connected, or a full car, nothing is written. The setting waits
until a car is connected.
- A phase change always goes through the same steps: 0 A, wait until the
charger draws under 100 W (at most 20 seconds), select the phases, wait 10
seconds, set the current again. At most one phase change per 10 minutes.
- Shadow mode keeps the charger alone, as it keeps the inverters alone: the card
says what the add-on *would* set. Nothing is written either while control is
stopped.
- A restart, stopping control and a safety stop leave the charger at its
current. When the charger answers again after being away, the add-on sets your
current again only if the charger shows a different one.
- Off writes nothing, ever.
**The car is never slowed for the peak limit.** A Manual charge goes on whatever
the 15-minute peak does. With the default `ev_batt_cover` on, the batteries help
cover it down to the peak reserve; a 3-phase 16 A charge (11 kW) can empty two
batteries to the reserve in about 1.5 hours, and the month's peak then rises by
what the car drew. When the car alone is why the batteries cannot hold the
period, the add-on does **not** raise *Battery stopped limiting the peak* or
*Load too high for battery*. It shows a grey note *Car over the peak
limit* once per charging session, a grey row, and says so in the car's *Why*.
This holds only while the car's reading is fresh and the charger's energy
meter confirms it (the meter must have gained at least half of what the power
adds up to over the last minute). A stale, stuck or frozen reading, or a
charger with no energy entity, never hides a real overload of the house: the
normal alarms stand. With `ev_batt_cover` off, the peak
guard protects the house without the car, so it does not spend the batteries on
it. Normal zero-grid control can still discharge them for the car, and a grid
charge of the batteries can bring the period to the peak limit plus the car.
The period can go over by the car alone. When the month's peak was set by a car
charge, Home's peak line says so.
**When the charger does not answer.** After 30 seconds the card says *Charger
not reachable* and one amber row appears. After 5 minutes one notification
follows. While the car reading is older than 15 seconds the House tile shows no
reading, and that moment is left out of the house profile, rather than guessing
how much the car took. A reading that does not move for a minute after the
add-on changed the current shows the amber row *Charger reading may be stuck*;
the add-on goes on writing. If the charger does not take a phase change three
times, an amber row says so and the add-on stops trying until you change
something; the car gets its current back each time.
**Another writer.** In Manual, if the charger shows a different current than the
add-on set, for 30 seconds, something else is setting it, usually your own
automation. The page shows a grey row, and the add-on writes nothing over it until
you change the mode or a value. In Off the grey row *Something else changes the
charger* shows for an hour after a change. That is expected while you migrate.
**Moving your own automation to the add-on.** Each step can be undone.
1. Install this version and set `ev_charger` to `alfen_ha`. The mode starts in
**Off**: the add-on reads the charger and writes nothing. Compare the card
with your automation for a few days.
2. Cut-over, in the evening with the car unplugged: in Home Assistant switch your
automation **off** (do not delete it). On the card choose **Manual** with the
current your helper held (`input_number.ev_manual_current`). Plug in and check
the current on the card and on the charger's display.
3. On the next sunny day, choose Solar, with *spare sun goes first to* set as
your priority switch was. (Solar comes in a later version; until then keep
Manual or Off.)
4. Keep your Home Assistant helpers for a week. To go back, set the add-on mode
to Off and switch the automation on. After that you can delete the helpers and
the automation.
**Never let the automation and the add-on both write the charger.** Two writers
fight over the one setting and neither can tell which won. Turn the automation
off before you choose Manual, and the add-on off (mode Off) before you turn the
automation on.
**Home Assistant entities.** With MQTT the add-on adds the sensors
`goodwe_car_power`, `goodwe_car_state` and `goodwe_car_today_kwh`, and the three
controls named above. A saved ("retained") command is never applied, so a
restart of Home Assistant cannot change the charger.
### Site
| option | meaning |
@@ -3500,22 +3388,6 @@ battery goes on as before. Check that the add-on can reach the internet and that
the price service token is right. The notification goes by itself when a price
is back. It is shown only while the monthly battery cycle is switched on.
### Charger not reachable
The add-on has not been able to read the car charger for 5 minutes, because its
entities are unavailable or the charger's login is off. The charger keeps its
last setting. The add-on changes nothing on the charger in any case. Check the
charger's integration in Home Assistant. The notification goes by itself when
the charger answers again.
### Car over the peak limit
The car charge you set (Manual) takes the 15-minute period over the peak limit,
and the batteries cannot hold it because they are at the peak reserve or at
their full power. The add-on never slows the car, so this is information, not an
alarm. It is raised once per charging session. To stay under the limit, lower the
current.
### For installers: notifications
A fixed tariff beside the price service raises no notification: it is the
@@ -3542,8 +3414,6 @@ default `info` hides it.
| Meter reading may be stuck | alarm | `goodwe_meter_frozen` | SAFETY-18 |
| Battery cycle did not finish | warning | `goodwe_maint_failed_<name>` | MAINT-13 |
| No prices | warning | `goodwe_no_prices` | PRICE-01 |
| Charger not reachable | warning | `goodwe_charger_unreachable` | EV-03 |
| Car over the peak limit | info | `goodwe_car_over` | EV-04 |
**The Details link.** Home Assistant 2026.2 and newer show add-on pages at
`/config/app/<slug>/documentation`; 2026.5 removed the old
-367
View File
@@ -1,367 +0,0 @@
"""EV-04: the car charger's Manual mode, the one place the add-on WRITES to it.
Pure but for the driver it is handed: no clock of its own (`now` is monotonic
seconds from the caller), no Home Assistant, no store. DECISIONS/EV-04-manual-
mode.md has the record; the design is reports/EV-01-design-report.md sections
2, 3 and 4.
THE RULES, each tested in test_ev04.py:
* Off writes NOTHING. Manual writes the current (6 A to the clamp) and the
phases (1 or 3), each ONCE PER USER CHANGE, and only with a car connected
and not full: with no car, or a full one, the current stands and the write
waits for the car.
* Every current is clamped to `min(ev_max_a, the station limit the charger
reports, the entity's own range)`. The driver refuses anything above it; this
module never asks for more.
* Phases change only through the SAFE SEQUENCE: 0 A, wait until the charger
reports under `QUIET_W` or mode3 leaves C (at most `ZERO_WAIT_S`), select the
phases, wait `SETTLE_S`, write the current again. At most one switch per
`PHASE_GAP_S`. A sequence that has begun is always finished, because it
leaves the car at 0 A otherwise.
* A read-back that differs from the add-on's own last write for `WRITER_S` is
ANOTHER WRITER: an info row, and no write over it until the user changes the
mode or a value again.
* A charger that comes back after being unavailable gets the setting again only
if its read-back differs.
"""
from __future__ import annotations
import logging
from . import chargers as CH
_LOG = logging.getLogger("goodwe")
OFF, MANUAL = "off", "manual"
#: the modes this card offers. Solar and Night are later cards (EV-05, EV-02).
MODES = (OFF, MANUAL)
#: Home Assistant's select labels, English and pinned.
MODE_LABELS = {OFF: "Off", MANUAL: "Manual"}
START_KEEP, START_OFF = "keep", "off"
KEY_MODE, KEY_A, KEY_PHASES = "car_mode", "car_current", "car_phases"
DEFAULT_A = 6.0
DEFAULT_PHASES = 1
QUIET_W = 100.0 # "paused": under this, or mode3 has left C
ZERO_WAIT_S = 20.0 # at most this long for the car to stop drawing
SETTLE_S = 10.0 # after the phases select, before the current
PHASE_GAP_S = 600.0 # at most one phase switch per this
WRITER_S = 30.0 # a differing read-back this long is another writer
RETRY_S = 60.0 # a write the charger did not take, tried again after
MAX_TRIES = 3 # ... this many times, then it waits for the user
TOL_A = CH.TOOK_TOL_A
def allowed_phases(opts: dict) -> tuple:
"""The phase counts the user may pick: the `ev_phases` setting says what
the installation allows (`auto` is 1 and 3)."""
v = str((opts or {}).get("ev_phases", CH.EV_OPTION_DEFAULTS["ev_phases"]))
return (1,) if v == "1" else (3,) if v == "3" else (1, 3)
def start_mode(opts: dict, stored) -> str:
"""The mode after a restart: the stored one (`keep`), or Off."""
if str((opts or {}).get("ev_mode_start")
or CH.EV_OPTION_DEFAULTS["ev_mode_start"]) == START_OFF:
return OFF
return stored if stored in MODES else OFF
def clamp_for(opts: dict, reading) -> float | None:
"""The most a write may ask for, from the options and the last reading:
`min(ev_max_a, the station limit, 40 A)`. None when the limit setting is
not a number. (The driver reads the entity's own range as well.)"""
amps = CH.max_a(opts)
if amps is None:
return None
lim = [amps, CH.ENTITY_MAX_A]
st = getattr(reading, "station_a", None)
if st is not None:
lim.append(float(st))
return min(lim)
def value_a(raw, clamp: float | None):
"""A current the user asked for, as a whole number of amps inside
`[6, clamp]`, or None when it is not a number. Above the clamp is the
clamp: the user's value never reaches the driver bigger than it."""
try:
v = float(raw)
except (TypeError, ValueError):
return None
if v != v:
return None
v = round(v)
hi = CH.ENTITY_MAX_A if clamp is None else max(CH.MIN_A, float(clamp))
return float(min(max(v, CH.MIN_A), hi))
class ManualWriter:
"""What Manual does to the charger, one `step()` per cycle."""
def __init__(self):
self.rev_applied = None # the user's last change we have acted on
self.last_a = None # the last current the charger took from us
self.attempted_a = None # a write it did not take ...
self.prior_a = None # ... and what the charger showed before it
self.mismatch_since = None
self.hold = False # another writer: no write until the user
self.other = False # ... and the info row says so
self.reapply = True # first reading, or the charger came back
self.was_available = False
self.fails = 0
self.fail_at = None
self.gave_up = False
self.seq = None # a phase change under way
self.last_switch = None
self.blocked = False # a phase change waits for PHASE_GAP_S
self.would = None # (amps, phases): what it would set
self.log = [] # (kind, value, now, ok), for the checks
self.last_done = None # when our latest write was confirmed
self._clock = None
self.phase_fails = 0 # phase selects the charger did not take
self.phases_gave_up = False
self.undone = 0 # sequences undone before the select
# ------------------------------------------------------------------ user
def user_changed(self) -> None:
"""The user changed the mode or a value: one more write is allowed,
and another writer's hold is lifted."""
self.rev_applied = None
self.hold = self.other = False
self.mismatch_since = None
self.fails, self.fail_at, self.gave_up = 0, None, False
self.phase_fails, self.phases_gave_up = 0, False
self.attempted_a = self.prior_a = None
# ------------------------------------------------------------------ step
async def step(self, drv, r, *, mode, want_a, want_phases, rev, clamp,
now, tracker, writing, status, shadow=False, clock=None):
"""One cycle. `r` is the latest `ChargerReading`; `writing` is False in
shadow mode and while control is stopped (the step then only works out
what it WOULD set, in `self.would`)."""
self._clock = clock or (lambda: now)
if r is None or not r.available:
self.was_available = False
return
# A reading taken before our latest write was confirmed says nothing
# about it (the writer runs beside the cycle and can finish between a
# read and the step that follows): wait for one taken after.
if self.last_done is not None and tracker is not None \
and tracker.obs_at is not None \
and tracker.obs_at <= self.last_done:
return
if not self.was_available:
self.was_available = True
self.reapply = True # on return: only if it differs
cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
if self.seq is not None:
if self.seq["stage"] in ("zero", "select") \
and (mode != MANUAL or not writing):
await self._undo(drv, now, tracker, clamp, shadow)
return
await self._advance(drv, r, cur, now, tracker, want_a, clamp, rev)
return
self.would = None
if mode != MANUAL:
return
if clamp is None or clamp < CH.MIN_A:
return
n_eff = want_phases if want_phases in (1, 3) else DEFAULT_PHASES
target = min(max(float(want_a), CH.MIN_A), float(clamp))
self.would = (target, n_eff)
# No car, or a full one: the current stands, nothing is written. The
# setting waits (rev stays unapplied) until a car is there.
if r.state == "A" or status in (CH.NONE_, CH.FULL):
self.mismatch_since = None
return
if not writing:
return
self._watch(cur, now)
if self.hold:
return
phases_need = (r.phases_allowed is not None
and r.phases_allowed != n_eff
and not self.phases_gave_up)
cur_need = cur is None or abs(cur - target) > TOL_A
need_user = rev != self.rev_applied
if not (phases_need or cur_need):
self.rev_applied, self.reapply = rev, False
self.fails, self.blocked = 0, False
if cur is not None:
self.last_a = cur # adopt what is already set
return
if not (need_user or self.reapply):
return # a difference nobody asked for: `_watch()` judges
if self.gave_up or (self.fail_at is not None
and now - self.fail_at < RETRY_S):
return
if phases_need:
if self.last_switch is not None \
and now - self.last_switch < PHASE_GAP_S:
self.blocked = True
else:
self.blocked = False
await self._begin(drv, r, cur, n_eff, now, tracker)
return
if cur_need:
ok = await self._write(drv, target, cur, now, tracker)
if not ok:
self._failed(now)
return
self.fails, self.fail_at = 0, None
if not phases_need:
self.rev_applied, self.reapply = rev, False
# ------------------------------------------------------------- internals
def _failed(self, now) -> None:
self.fails += 1
self.fail_at = now
if self.fails >= MAX_TRIES:
self.gave_up = True
_LOG.warning("The charger did not take the current, so the add-on "
"stops asking until you change it: CHARGER_REFUSED.")
_LOG.debug("The charger refused the current %d times.", self.fails)
def _watch(self, cur, now) -> None:
"""Is the read-back what we wrote? A difference that stands for
`WRITER_S` is another writer."""
known = [x for x in (self.last_a, self.attempted_a, self.prior_a)
if x is not None]
if not known or cur is None:
self.mismatch_since = None
return
if any(abs(cur - k) <= TOL_A for k in known):
self.mismatch_since = None
if self.hold:
self.hold = self.other = False
return
if self.mismatch_since is None:
self.mismatch_since = now
elif now - self.mismatch_since >= WRITER_S and not self.hold:
self.hold = self.other = True
_LOG.info("Something else changes the charger (read-back %.0f A, "
"the add-on set %.0f A), so the add-on stops writing "
"to it until you change it.", cur, known[0])
async def _write(self, drv, a, was, now, tracker) -> bool:
tracker.begin_write() # EV-12: the read-back is ours
try:
ok = await drv.write_current(a)
finally:
self._stamp(now)
tracker.end_write(self.last_done)
tracker.note_write(now, was, a)
tracker.end_write(self.last_done)
self.log.append(("current", a, now, ok))
if ok:
self.last_a = a
self.attempted_a = self.prior_a = None
else:
self.attempted_a, self.prior_a = a, was
return ok
def _stamp(self, now) -> None:
self.last_done = (self._clock or (lambda: now))()
@staticmethod
def _restore_a(prev, clamp):
"""The current to give back: what it was, never above the clamp."""
if prev is None:
return None
hi = CH.ENTITY_MAX_A if clamp is None else float(clamp)
a = min(float(prev), hi)
return a if a >= CH.MIN_A else None
async def _undo(self, drv, now, tracker, clamp, shadow) -> None:
"""Off, shadow mode or a stopped control while the car is paused and the
phases have NOT been selected: no switch. The old current comes back
(clamped), in shadow mode too: it undoes the add-on's own half-done
change (as the shutdown restore does) and is the one write shadow mode
allows. Nothing else is written afterwards."""
q, self.seq = self.seq, None
self.undone += 1
self.rev_applied, self.reapply = None, True
a = self._restore_a(q.get("prev"), clamp)
if a is not None:
await self._write(drv, a, 0.0, now, tracker)
async def _begin(self, drv, r, cur, n, now, tracker) -> None:
"""Step 1 of the safe sequence: 0 A. A charger that does not take it
stops the sequence before the phases are touched."""
ok = await self._write(drv, 0.0, cur, now, tracker)
if not ok:
self._failed(now)
return
self.seq = {"stage": "zero", "t0": now, "n": n, "tries": 0,
"prev": cur}
async def abandon(self, drv, now, tracker, clamp=None) -> None:
"""The add-on is stopping in the middle of a phase change: give the car
its current back (a stopped add-on must not leave it at 0 A), clamped
like every write. The phases stay as the select left them."""
q, self.seq = self.seq, None
a = None if q is None else self._restore_a(q.get("prev"), clamp)
if a is not None:
self._clock = self._clock or (lambda: now)
await self._write(drv, a, 0.0, now, tracker)
async def _advance(self, drv, r, cur, now, tracker, want_a, clamp, rev):
q = self.seq
if q["stage"] in ("zero", "select") and cur is not None \
and cur >= CH.MIN_A:
# Something else raised the current while the car was being
# paused. The phases are never selected under that: give up the
# change, and leave the charger to whoever set it until the user
# changes something.
self.seq = None
self.hold = self.other = True
self.last_a = self.attempted_a = self.prior_a = None
_LOG.info("Something else raised the charger's current during a "
"phase change, so the phases were not touched.")
return
if q["stage"] == "zero":
quiet = ((r.power_w is not None and r.power_w < QUIET_W)
or (r.state is not None and r.state != "C"))
if not quiet and now - q["t0"] < ZERO_WAIT_S:
return
q["stage"] = "select"
if q["stage"] == "select":
ok = await drv.write_phases(q["n"])
self._stamp(now)
self.last_switch = now
self.log.append(("phases", q["n"], now, ok))
q["stage"], q["t1"] = "settle", self.last_done # from its return
if not ok:
# The charger did not take it: the car gets its current back
# on the old phases after the same SETTLE_S as a taken select
# (HA may have taken it and only the read-back be late), and
# the change is tried again after PHASE_GAP_S, MAX_TRIES times.
self.phase_fails += 1
if self.phase_fails >= MAX_TRIES:
self.phases_gave_up = True
_LOG.warning("The charger did not take the phases, so the "
"add-on stops trying until you change "
"something: CHARGER_PHASES.")
return
if now - q["t1"] < SETTLE_S:
return
hi = CH.ENTITY_MAX_A if clamp is None else float(clamp)
a = min(max(float(want_a), CH.MIN_A), hi)
if await self._write(drv, a, 0.0, now, tracker):
# Judged afresh next cycle: a value the user changed meanwhile is
# still wanted, and one that is in place is adopted.
self.seq, self.rev_applied, self.reapply = None, None, False
self.fails, self.blocked = 0, False
return
q["tries"] += 1
if q["tries"] >= MAX_TRIES:
# Left at 0 A is the safe side; the next reading re-applies.
self.seq, self.last_a, self.reapply = None, None, True
self._failed(now)
self.rev_applied = None
return
q["t1"] = now - SETTLE_S + 5.0 # again in 5 s
-908
View File
@@ -1,908 +0,0 @@
"""EV-03: the car charger seam, and the Alfen driver behind Home Assistant.
SHAPED LIKE `app/drivers.py`'s `Driver` (DECISIONS/EV-03-charger-seam.md): one
actuator per site, a census key, a read, a clamped write that says whether the
charger took it, and a hand-back. A charger is a modulated actuator with a fail
state, not one of DEV-01's on/off loads.
EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, and only in Manual
(`app/carmode.py` is the one caller). `write_current` is clamped to
`min(ev_max_a, the station limit the charger reports, the entity's own range)`
and a value above that is NEVER SENT: it is a software fault, logged in the
OUTPUT_CLAMP shape. It says True only when the charger's read-back followed
within `TOOK_S`. Off writes nothing (EV-03's no-write test still holds for it).
VALUES ARE BELIEVED ONLY IN THEIR OWN UNIT (as TEL-11 does for power): power in
a power unit, energy in a kWh unit, current in A. A reading in another unit is
absent, never converted by a guess. ABSENCE IS NEVER ZERO.
The pure half (`CarTracker`, the state words, the entity table) takes its clock
as an argument, so the checks need no sleep.
"""
from __future__ import annotations
import asyncio
import logging
import re
import time
from dataclasses import dataclass, field
from .hass import BAD_STATES
from .solarfc import KWH_PER
_LOG = logging.getLogger("goodwe")
OFF = "off"
ALFEN_HA = "alfen_ha"
#: the `ev_charger` values the options accept
SELECTABLE = (OFF, ALFEN_HA)
PHASES_CHOICES = ("1", "3", "auto")
# config.yaml's shipped defaults, mirrored (test_defaults_pin.py checks it).
EV_OPTION_DEFAULTS = {"ev_charger": "off", "ev_current_entity": "",
"ev_max_a": 16, "ev_phases": "auto",
"ev_batt_cover": True, "ev_mode_start": "keep"}
def max_a(opts: dict):
"""`ev_max_a` as a float, or None when it is not a number."""
raw = opts.get("ev_max_a", EV_OPTION_DEFAULTS["ev_max_a"])
if raw is None or raw == "":
raw = EV_OPTION_DEFAULTS["ev_max_a"]
try:
return float(raw)
except (TypeError, ValueError):
return None
MIN_A = 6.0 # IEC 61851: no car charges below 6 A
ENTITY_MAX_A = 40.0 # the Alfen current entity's own range
# Reachability and the car card's timers, in seconds.
UNREACHABLE_S = 30.0 # entities unavailable / login off this long
NOTIFY_S = 300.0 # then one warning notification
FULL_B_S = 60.0 # mode3 B with current allowed this long: car full
FULL_C_S = 600.0 # mode3 C under FULL_C_W this long: car full
FULL_C_W = 200.0
WRITER_HOLD_S = 3600.0 # "another controller" stays shown this long
IDLE_A = 1.0 # a phase under this draws nothing
TOOK_S = 10.0 # a write is "taken" when the read-back follows by then
TOOK_TOL_A = 0.5 # ... to within this
STUCK_S = 60.0 # EV-04: power and read-back unchanged after a write
STUCK_MIN_A = 1.0 # ... that moved the setpoint by at least this
OWN_WRITE_MUTE_S = 15.0 # the tracker's two-writer detector ignores our own
# Volts used to bound a car figure by what the read-back allows (a physical
# ceiling for the alarm path, never a setpoint).
CEILING_V = 253.0
# EV-04 round 2: the car's power may be used by the peak guard's alarm path only
# while the charger's energy meter CORROBORATES it. Looking back over readings
# (all in mode3 C, no gap) to the shortest stretch that is at least CORR_WINDOW_S
# long AND over which the reported power adds up to at least CORR_MIN_WH, the
# meter must have advanced by at least CORR_RATIO of that, less CORR_SLACK_WH (the
# meter shows 10 Wh steps, so at 40 Wh expected it must show one step). Readings
# are kept for CORR_KEEP_S. Until such a stretch exists (a session just began, or
# the add-on just started) the figure is believed, as it was before. A frozen
# figure of P watts on a car that has really stopped is caught within
# max(CORR_WINDOW_S, CORR_MIN_WH / P) seconds: 60 s at 2.4 kW and up, 104 s at
# 1.38 kW (6 A, 1 phase). Below CORR_MIN_WH over CORR_KEEP_S (about 0.8 kW) the
# figure is believed; it cannot hide an overload that matters.
CORR_WINDOW_S = 60.0
CORR_RATIO = 0.5
CORR_SLACK_WH = 15.0
CORR_MIN_WH = 40.0
CORR_KEEP_S = 180.0
# role -> (entity domain, suffix after `<x>_`). `current` is the setpoint, the
# one the installer names; the rest are derived by swapping its suffix.
SETPOINT_SUFFIX = "power_connector_max_current_socket_1"
ROLES = {
"current": ("number", SETPOINT_SUFFIX),
"readback": ("sensor", "main_active_max_current_socket_1"),
"state": ("sensor", "mode3_state_socket_1"),
"display": ("sensor", "display_state_socket_1"),
"power": ("sensor", "active_power_total_socket_1"),
"energy": ("sensor", "meter_reading_socket_1"),
"l1": ("sensor", "current_l1_socket_1"),
"l2": ("sensor", "current_l2_socket_1"),
"l3": ("sensor", "current_l3_socket_1"),
"station": ("number", "max_station_current"),
"station_active": ("sensor", "main_station_active_max_current_socket_1"),
"phases_set": ("select", "installation_max_allowed_phases"),
"phases_read": ("sensor", "connector_1_max_allowed_of_phases"),
"error": ("sensor", "display_error_number_socket_1"),
"login": ("binary_sensor", "https_api_login_status"),
}
#: a missing one of these refuses the charger (not the add-on). `power` is one
#: of them: without it the car's power is unknown for good, House would show no
#: reading for ever and the house profile would drop every sample.
#: The power entity must also read in a Home Assistant power unit (`POWER_UNITS`).
REQUIRED = ("current", "readback", "state", "power")
_SETPOINT_RE = re.compile(r"^number\.(?P<x>.+)_" + SETPOINT_SUFFIX + "$")
_ROLE_ORDER = tuple(ROLES)
#: power unit -> W. The probe and the reading both use this one table.
_W_PER = {"mW": 0.001, "W": 1.0, "kW": 1000.0, "MW": 1000000.0}
POWER_UNITS = tuple(_W_PER)
def census_key(entity) -> str:
"""The SAFETY-28 form: stripped, lowercase."""
return str(entity or "").strip().lower()
def entities_for(setpoint) -> dict:
"""role -> entity id, derived from the setpoint entity by its suffix.
Empty when the setpoint does not end the way the Alfen integration names it."""
m = _SETPOINT_RE.match(str(setpoint or "").strip())
if not m:
return {}
x = m.group("x")
return {role: f"{dom}.{x}_{suffix}" for role, (dom, suffix) in ROLES.items()}
# --------------------------------------------------------------------------- #
# What a read gives
# --------------------------------------------------------------------------- #
@dataclass(frozen=True)
class ChargerReading:
"""One read of the charger. None means "did not answer", never zero."""
available: bool = False # the integration answers
state: str | None = None # mode3: "A", "B", "C", ... or None
connected: bool | None = None
charging: bool | None = None
power_w: float | None = None
energy_kwh: float | None = None # the meter, total increasing
current_a: tuple = () # per phase, as many as read
setpoint_a: float | None = None # the entity the installer named
allowed_a: float | None = None # read-back of the limit the charger applies
phases_allowed: int | None = None
station_a: float | None = None # the charger's own station limit
error: str | None = None # None: no error (or not read)
display: str | None = None
why: str = "" # for the log only, "" when available
def _state_obj(obj):
"""(text, unit, attributes) of a state object, or (None, "", {})."""
if not isinstance(obj, dict):
return None, "", {}
raw = str(obj.get("state", "")).strip()
attrs = obj.get("attributes") if isinstance(obj.get("attributes"), dict) else {}
unit = str(attrs.get("unit_of_measurement") or "").strip()
return (None if raw.lower() in BAD_STATES else raw), unit, attrs
def _amps(obj):
raw, unit, _ = _state_obj(obj)
if raw is None:
return None
try:
v = float(raw)
except ValueError:
return None
if v != v:
return None
if unit == "A":
return v
if unit == "mA":
return v / 1000.0
return None
def _watts(obj):
"""Power in W, believed only in a power unit (its own copy of the rule: the
PV channel's reader stays out of the charger's, test_pv.py part 6)."""
raw, unit, _ = _state_obj(obj)
if raw is None or unit not in _W_PER:
return None
try:
v = float(raw) * _W_PER[unit]
except ValueError:
return None
return v if v == v else None
def _kwh(obj):
raw, unit, _ = _state_obj(obj)
if raw is None or unit not in KWH_PER:
return None
try:
v = float(raw) * KWH_PER[unit]
except ValueError:
return None
return v if v == v and v >= 0 else None
def _phases(obj):
raw, _u, _ = _state_obj(obj)
m = re.match(r"\s*([13])\s*phase", raw or "", re.I)
return int(m.group(1)) if m else None
_MODE3 = re.compile(r"^(?:STATE[_ ]?)?([A-F])$", re.I)
def mode3_letter(text) -> str | None:
m = _MODE3.match(str(text or "").strip())
return m.group(1).upper() if m else None
def display_class(text) -> str | None:
"""The fallback when mode3 is missing: firmware wording, so only the words
the owner's automation keys on. `connected`, `charging`, `none` or None."""
t = str(text or "").lower()
if not t:
return None
if "wait vehicle" in t or "ev connected" in t or "cable connected" in t:
return "connected"
if "charging" in t:
return "charging"
if t in ("available", "ready", "idle"):
return "none"
return None
def reading_from_states(states: dict) -> ChargerReading:
"""A `ChargerReading` from `{role: state object or None}`. Pure."""
def txt(role):
return _state_obj(states.get(role))[0]
login, state_o = txt("login"), states.get("state")
# Reachable: the three entities the card cannot do without answer, and the
# login sensor is not off.
gone = [r for r in REQUIRED if txt(r) is None]
if gone or (login or "").lower() == "off":
why = ("login off" if not gone else
"no answer from " + ", ".join(gone))
return ChargerReading(available=False, why=why)
# A power entity that answers but cannot be believed (a unit the add-on
# cannot convert, no unit, not a number) makes the reading UNAVAILABLE, so
# it goes down the visible "Charger not reachable" path instead of leaving
# the car's power unknown for good with nothing said.
if _watts(states.get("power")) is None:
return ChargerReading(available=False, why="power unit")
letter = mode3_letter(txt("state"))
disp = txt("display")
cls = display_class(disp)
power = _watts(states.get("power"))
currents = tuple(a for a in (_amps(states.get(k)) for k in ("l1", "l2", "l3"))
if a is not None)
if letter is not None:
connected, charging = letter in "BCD", letter in "CD"
elif cls is not None:
connected, charging = cls in ("connected", "charging"), cls == "charging"
else:
connected = charging = None
err = txt("error")
err_none = err is None or err.strip().startswith("0")
return ChargerReading(
available=True, state=letter, connected=connected, charging=charging,
power_w=power, energy_kwh=_kwh(states.get("energy")),
current_a=currents, setpoint_a=_amps(states.get("current")),
allowed_a=_amps(states.get("readback")),
phases_allowed=_phases(states.get("phases_read")),
station_a=_first(_amps(states.get("station_active")),
_amps(states.get("station"))),
error=None if err_none else err, display=disp)
def _first(*vals):
return next((v for v in vals if v is not None), None)
@dataclass(frozen=True)
class ChargerProbe:
"""A read-only look: which derived entities exist."""
setpoint: str = ""
found: tuple = () # ((role, entity), ...)
missing: tuple = ()
station_a: float | None = None
derived: bool = True # False: the setpoint's name does not fit
power_unit: str | None = None # the power entity's unit, when it is
# reading a number and that unit is not W or kW (an unavailable entity
# has no unit to judge: that is the unreachable path, not a refusal)
@property
def required_missing(self) -> tuple:
return tuple(r for r, _e in self.missing if r in REQUIRED)
@property
def ok(self) -> bool:
return (self.derived and not self.required_missing
and self.power_unit is None)
def probe_from(setpoint, exists) -> ChargerProbe:
"""`exists(entity) -> state object or None`. Pure; the caller reads."""
ents = entities_for(setpoint)
if not ents:
return ChargerProbe(setpoint=str(setpoint or ""), derived=False)
found, missing = [], []
for role in _ROLE_ORDER:
(found if exists(ents[role]) is not None else missing).append(
(role, ents[role]))
st = {r: exists(e) for r, e in ents.items()}
raw, unit, _ = _state_obj(st.get("power"))
bad_unit = None
if raw is not None and unit not in POWER_UNITS:
try:
float(raw)
bad_unit = unit or "none"
except ValueError:
pass
return ChargerProbe(str(setpoint), tuple(found), tuple(missing),
station_a=_first(_amps(st.get("station_active")),
_amps(st.get("station"))),
power_unit=bad_unit)
# --------------------------------------------------------------------------- #
# The seam
# --------------------------------------------------------------------------- #
class ChargerNotBound(RuntimeError):
pass
class ChargerDriver:
"""One charger's I/O. Constructed from the options with no Home Assistant;
`bind()` gives it one. Everything that talks to the world is a coroutine."""
name = ""
writer_key = "ev_current_entity"
brand = ""
words: dict = {}
@classmethod
def from_options(cls, opts: dict) -> "ChargerDriver":
raise NotImplementedError
def bind(self, hass) -> "ChargerDriver":
return self
def bind_getter(self, getter) -> "ChargerDriver":
return self
def bound(self) -> bool:
return True
def configured(self) -> bool:
raise NotImplementedError
def actuator_id(self) -> str:
raise NotImplementedError
def entities(self) -> dict:
return {}
async def limits(self) -> tuple:
"""`(min_a, max_a, phases)`; None where unread."""
raise NotImplementedError
async def read(self) -> ChargerReading:
raise NotImplementedError
# --- the write side (EV-04). `app/carmode.py` is the one caller. ---------
async def clamp_a(self) -> float:
"""The most a write may ask for: `min(ev_max_a, the station limit read
from the charger, the entity's own range max)`."""
raise NotImplementedError
async def write_current(self, a: float) -> bool:
raise NotImplementedError
async def write_phases(self, n: int) -> bool:
raise NotImplementedError
async def release(self, mode: str) -> bool:
raise NotImplementedError
async def probe(self) -> ChargerProbe:
raise NotImplementedError
class AlfenHaDriver(ChargerDriver):
"""The Alfen behind its Home Assistant integration (`alfen_wallbox`)."""
name = ALFEN_HA
brand = "Alfen"
def __init__(self, current_entity="", limit_a=16.0):
self.current_entity = str(current_entity or "").strip()
self.max_a = float(limit_a)
self._ents = entities_for(self.current_entity)
self._hass = None
self._getter = None
# Seams for the checks: how a write waits for the read-back, and the
# clock it counts on.
self._sleep = asyncio.sleep
self._clock = time.monotonic
self.clamp_faults = [] # (asked, clamp), newest last, for the log
self.sent = [] # every number value actually sent
@classmethod
def from_options(cls, opts: dict) -> "AlfenHaDriver":
amps = max_a(opts)
return cls(opts.get("ev_current_entity", ""),
EV_OPTION_DEFAULTS["ev_max_a"] if amps is None else amps)
@classmethod
def actuator_id_of(cls, opts: dict) -> str:
return str(opts.get("ev_current_entity") or "").strip()
def bind(self, hass):
self._hass, self._getter = hass, None
return self
def bind_getter(self, getter):
self._hass, self._getter = None, getter
return self
def bound(self) -> bool:
return self._hass is not None or self._getter is not None
def _h(self):
hass = self._getter() if self._getter is not None else self._hass
if hass is None:
raise ChargerNotBound("the charger has no Home Assistant")
return hass
def configured(self) -> bool:
return bool(self._ents)
def actuator_id(self) -> str:
return self.current_entity
def entities(self) -> dict:
return dict(self._ents)
async def _states(self, roles=_ROLE_ORDER) -> dict:
hass = self._h()
got = await asyncio.gather(*(hass.state(self._ents[r]) for r in roles))
return dict(zip(roles, got))
async def limits(self) -> tuple:
st = await self._states(("station", "station_active", "phases_read"))
return (MIN_A, _first(_amps(st["station_active"]), _amps(st["station"])),
_phases(st["phases_read"]))
async def read(self) -> ChargerReading:
if not self.configured():
return ChargerReading(why="not set up")
return reading_from_states(await self._states())
async def probe(self) -> ChargerProbe:
st = await self._states()
by_ent = {self._ents[r]: o for r, o in st.items()}
return probe_from(self.current_entity, by_ent.get)
# --- the write side -------------------------------------------------------
async def clamp_a(self) -> float:
"""`min(ev_max_a, station limit, entity range max)`. A limit the charger
did not answer is not a limit (the other two still bound the write)."""
st = await self._states(("current", "station", "station_active"))
station = _first(_amps(st["station_active"]), _amps(st["station"]))
rng = ENTITY_MAX_A
attrs = (st["current"] or {}).get("attributes") \
if isinstance(st.get("current"), dict) else None
if isinstance(attrs, dict):
try:
rng = min(rng, float(attrs["max"]))
except (KeyError, TypeError, ValueError):
pass
return min(x for x in (self.max_a, station, rng) if x is not None)
async def write_current(self, a: float) -> bool:
"""Set the current, once. True only when the charger took it: the
read-back followed within `TOOK_S`. A value above `clamp_a()` is a
SOFTWARE FAULT: nothing is sent, it is logged (the clamp watchdog's
shape) and the answer is False."""
try:
a = float(a)
except (TypeError, ValueError):
a = float("nan")
clamp = await self.clamp_a()
if a != a or a < 0.0 or a > clamp + 1e-9:
self.clamp_faults.append((a, clamp))
del self.clamp_faults[:-20]
_LOG.error("Software fault: the add-on was about to ask the charger "
"for more than its limit, so nothing was sent: "
"CHARGER_CLAMP.")
_LOG.debug("Asked for %.1f A against a limit of %.1f A.", a, clamp)
return False
hass = self._h()
self.sent.append(a)
del self.sent[:-50]
if not await hass.set_number(self.current_entity, a):
return False
return await self._took(a)
async def _took(self, a: float) -> bool:
"""Did the read-back follow the write, within `TOOK_S`?"""
t0 = self._clock()
while True:
st = await self._states(("readback", "current"))
seen = _first(_amps(st["readback"]), _amps(st["current"]))
if seen is not None and abs(seen - a) <= TOOK_TOL_A:
return True
if self._clock() - t0 >= TOOK_S:
return False
await self._sleep(1.0)
async def write_phases(self, n: int) -> bool:
"""Select 1 or 3 phases. ONLY THROUGH `carmode`'s safe sequence: the
setting moves the contactors, so it is touched with the car paused."""
if n not in (1, 3):
return False
want = "1 Phase" if n == 1 else "3 Phases"
if not await self._h().call("select", "select_option", {
"entity_id": self._ents["phases_set"], "option": want}):
return False
t0 = self._clock()
while True:
st = await self._states(("phases_read", "phases_set"))
seen = _phases(st["phases_read"])
if seen is None:
seen = _phases(st["phases_set"])
if seen == n:
return True
if self._clock() - t0 >= TOOK_S:
return False
await self._sleep(1.0)
async def release(self, mode: str) -> bool:
"""The mode's fail state. Manual and Off keep the current (the charger
is a stand-alone device and the current is the user's setting)."""
return True
class UnavailableCharger(ChargerDriver):
"""No charger: `ev_charger` is off, or the charger is refused. `why` says
which, for the Car card; nothing is read and nothing is written."""
name = OFF
def __init__(self, why="off", wanted=""):
self.why = why
self.wanted = wanted
@classmethod
def from_options(cls, opts: dict):
return cls()
def configured(self) -> bool:
return False
def actuator_id(self) -> str:
return ""
async def limits(self) -> tuple:
return None, None, None
async def clamp_a(self) -> float:
return 0.0
async def read(self) -> ChargerReading:
return ChargerReading(why=self.why)
async def write_current(self, a):
return False
async def write_phases(self, n):
return False
async def release(self, mode):
return False
async def probe(self) -> ChargerProbe:
return ChargerProbe()
def mode_of(opts: dict) -> str:
v = str((opts or {}).get("ev_charger") or OFF).strip()
return v if v in SELECTABLE else OFF
def build(opts: dict) -> ChargerDriver:
"""The driver the options name. Off, or a name this build lacks, is
`UnavailableCharger`; nothing here touches Home Assistant."""
which = mode_of(opts)
if which == ALFEN_HA:
drv = AlfenHaDriver.from_options(opts)
if drv.configured():
return drv
return UnavailableCharger("not set up", which)
return UnavailableCharger("off")
def census_entity(opts: dict) -> str:
"""The charger setpoint the SAFETY-28 census counts: only while a charger
is switched on (an off charger writes nothing)."""
if mode_of(opts) == OFF:
return ""
return str(opts.get("ev_current_entity") or "").strip()
# --------------------------------------------------------------------------- #
# The car's state, kept over time
# --------------------------------------------------------------------------- #
CHARGING, WAITING, NONE_, FULL, UNREACH, SETUP, FAULT = (
"charging", "waiting", "none", "full", "unreach", "setup", "fault")
@dataclass
class CarTracker:
"""What the cycle learns about the car from the readings. Pure, clocked by
the caller (monotonic seconds for timers, UTC datetimes for the words).
FRESHNESS (the rule applied, and the one decision EV-03 makes about a stale
car reading): the car's power counts only while the last GOOD reading is not
older than `stale_s`, the same `stale_input_s` bound the meter reading has.
Older than that, `fresh()` is False and the House tile and the house profile
say they do not know, instead of keeping the last car figure."""
stale_s: float = 15.0
reading: ChargerReading | None = None
last_ok: float | None = None
bad_since: float | None = None
bad_since_utc: object = None
notified: bool = False
state_since_utc: object = None
last_status: str | None = None
last_good: ChargerReading | None = None
last_good_utc: object = None
b_since: float | None = None
c_low_since: float | None = None
writer_at_utc: object = None
_prev: tuple | None = None
# EV-04: our own writes, and the stuck-reading rule (SAFETY-37's shape)
mute_until: float = 0.0
armed_at: float | None = None
armed_sig: tuple | None = None
sig: tuple | None = None
stuck_now: bool = False
obs_at: float | None = None # monotonic second of the latest reading
_hist: list = field(default_factory=list) # (t, power W, energy Wh)
# today's energy
day: str | None = None
today_kwh: float | None = None
last_kwh: float | None = None
persist: bool = False # set when `today` changed, for the store
def observe(self, r: ChargerReading, now: float, now_utc, day: str):
self.reading = r
self.obs_at = now
self._corr_note(r, now)
usable = r.available and r.power_w is not None
if r.available:
self.bad_since = None
self.bad_since_utc = None
elif self.bad_since is None:
self.bad_since, self.bad_since_utc = now, now_utc
if usable:
self.last_ok = now
self.last_good, self.last_good_utc = r, now_utc
if r.available:
self._sig(r, now)
self._writer(r, now_utc, now)
self._energy(r, day)
self._timers(r, now)
self._status_edge(now, now_utc)
# -- reachability ----------------------------------------------------------
def unreachable(self, now: float) -> bool:
return self.bad_since is not None and now - self.bad_since >= UNREACHABLE_S
def notify_due(self, now: float) -> bool:
return (self.bad_since is not None and not self.notified
and now - self.bad_since >= NOTIFY_S)
def fresh(self, now: float) -> bool:
return self.last_ok is not None and now - self.last_ok <= self.stale_s
def car_w(self, now: float):
"""The car's power now, or None (unknown) when the reading is not fresh
OR the current reading carries no power. Never the last good figure: a
read that says "no power" contradicts it, and absence is never zero. It
never raises (telemetry has no foot in the control path)."""
r = self.reading
if not self.fresh(now) or r is None or not r.available \
or r.power_w is None:
return None
try:
return max(0.0, float(r.power_w))
except (TypeError, ValueError):
return None
# -- EV-04: the stuck-reading rule -------------------------------------------
def begin_write(self) -> None:
"""EV-12: a write of ours is in flight. Its read-back can reach the
tracker before `note_write` runs (the write waits for it), so the mute
is open until `end_write`."""
self.mute_until = float("inf")
def end_write(self, now: float) -> None:
"""EV-12: the write returned (or failed). The mute runs
`OWN_WRITE_MUTE_S` from now, not from before the write."""
self.mute_until = now + OWN_WRITE_MUTE_S
def note_write(self, now: float, was_a, to_a) -> None:
"""The add-on wrote the current. Its own change is not "another
writer" for `OWN_WRITE_MUTE_S`, and a write that moved the setpoint by
`STUCK_MIN_A` or more arms the stuck check: power and read-back that
have not changed `STUCK_S` later are a stuck reading, not a car."""
self.mute_until = now + OWN_WRITE_MUTE_S
try:
moved = was_a is None or abs(float(to_a) - float(was_a)) \
>= STUCK_MIN_A
except (TypeError, ValueError):
moved = False
if moved and self.armed_at is None:
self.armed_at, self.armed_sig = now, self.sig
def _sig(self, r, now: float) -> None:
sig = (r.power_w, r.allowed_a)
if self.armed_at is not None and self.armed_sig is not None \
and sig != self.armed_sig:
self.armed_at = self.armed_sig = None # it moved: alive
self.stuck_now = False
elif self.armed_at is not None and self.armed_sig is None:
self.armed_sig = sig
self.sig = sig
if self.armed_at is not None and now - self.armed_at >= STUCK_S:
self.stuck_now = True
def _corr_note(self, r, now: float) -> None:
"""Keep the last `CORR_WINDOW_S` of (power, energy) while the charger is
charging. Any gap, a car that is not in mode3 C, a reading without
power or energy, or a meter that goes back starts the window again."""
h = self._hist
ok = (r.available and r.charging is True and r.power_w is not None
and r.energy_kwh is not None)
if not ok or (h and r.energy_kwh * 1000.0 < h[-1][2] - 0.5):
h.clear()
if not ok:
return
h.append((now, float(r.power_w), r.energy_kwh * 1000.0))
while len(h) > 2 and now - h[1][0] >= CORR_KEEP_S:
h.pop(0)
def corroborated(self, now: float) -> bool:
"""Does the charger's energy meter agree with the power it reports? No
energy entity, or not charging: no. Less than a window of readings: yes
(the first minute of a session is believed). Otherwise the energy the
meter gained over the window must be at least `CORR_RATIO` of what the
power adds up to, less `CORR_SLACK_WH`. A frozen power figure on a car
that has stopped fails this within a window, and so does everything
frozen together."""
r = self.reading
h = self._hist
if r is None or not r.available or r.charging is not True \
or r.energy_kwh is None or not h:
return False
exp_wh = 0.0
for k in range(len(h) - 1, 0, -1):
(t0, p0, e0), (t1, _p1, _e1) = h[k - 1], h[k]
exp_wh += p0 * (t1 - t0) / 3600.0
if h[-1][0] - t0 >= CORR_WINDOW_S - 5.0 and exp_wh >= CORR_MIN_WH:
got_wh = h[-1][2] - e0
return got_wh >= CORR_RATIO * exp_wh - CORR_SLACK_WH
return True
def stuck(self, now: float) -> bool:
"""Power and read-back unchanged `STUCK_S` after a write that moved the
setpoint. Cleared the moment either moves."""
return self.stuck_now
def car_w_trusted(self, now: float):
"""The car's power for the peak guard's ALARM PATH, or None. Fresh (the
EV-03 rules), not stuck after a write, corroborated by the energy meter
(`corroborated`), and never above what the read-back allows the car to
draw: an old or frozen figure must not hide a house overload."""
w = self.car_w(now)
if w is None or self.stuck(now) or not self.corroborated(now):
return None
r = self.reading
a = r.allowed_a if r.allowed_a is not None else r.setpoint_a
if a is not None:
n = r.phases_allowed if r.phases_allowed in (1, 3) else 3
w = min(w, max(0.0, float(a)) * CEILING_V * n)
return w
# -- the two-writer detector ----------------------------------------------
def _writer(self, r, now_utc, now=None):
cur = (r.setpoint_a, r.allowed_a)
prev = self._prev
muted = now is not None and now < self.mute_until
if prev is not None and not muted:
for a, b in zip(prev, cur):
if a is not None and b is not None and a != b:
self.writer_at_utc = now_utc
# keep the last known value where one read came back empty
self._prev = tuple(b if b is not None else (prev[i] if prev else None)
for i, b in enumerate(cur))
def other_writer(self, now_utc) -> bool:
t = self.writer_at_utc
return t is not None and (now_utc - t).total_seconds() <= WRITER_HOLD_S
# -- today's kWh -----------------------------------------------------------
def load(self, saved):
if isinstance(saved, dict):
try:
self.day = str(saved["day"])
self.today_kwh = float(saved["kwh"])
self.last_kwh = (None if saved.get("last") is None
else float(saved["last"]))
except (KeyError, TypeError, ValueError):
self.day = self.today_kwh = self.last_kwh = None
def dump(self) -> dict:
return {"day": self.day, "kwh": round(self.today_kwh or 0.0, 3),
"last": self.last_kwh}
def _energy(self, r, day):
e = r.energy_kwh
if self.day != day:
self.day, self.today_kwh = day, 0.0
self.last_kwh = e
self.persist = True
return
if e is None:
return
if self.last_kwh is not None:
# a meter that goes back has been reset: count from its new zero
d = e - self.last_kwh if e >= self.last_kwh else e
if d:
self.today_kwh = (self.today_kwh or 0.0) + d
self.persist = True
self.last_kwh = e
if self.today_kwh is None:
self.today_kwh = 0.0
# -- the car's state -------------------------------------------------------
def _timers(self, r, now):
allowed = r.allowed_a is not None and r.allowed_a >= MIN_A
self.b_since = (self.b_since if self.b_since is not None else now) \
if (r.state == "B" and allowed) else None
low = (r.state == "C" and allowed and r.power_w is not None
and r.power_w < FULL_C_W)
self.c_low_since = (self.c_low_since if self.c_low_since is not None
else now) if low else None
def status(self, now: float, configured: bool = True):
"""One of the state words, or None before the first reading."""
if not configured:
return SETUP
if self.unreachable(now):
return UNREACH
r = self.reading
if r is None or not r.available:
return None if self.last_good is None else self.last_status
if r.state in ("E", "F"): # the charger's own error states
return FAULT
if r.state == "A" or (r.state is None and r.connected is False):
return NONE_
if r.state in ("B", "C", "D") or r.connected:
if self.b_since is not None and now - self.b_since >= FULL_B_S:
return FULL
if self.c_low_since is not None and \
now - self.c_low_since >= FULL_C_S:
return FULL
return CHARGING if r.charging else WAITING
return None
def _status_edge(self, now, now_utc):
s = self.status(now)
if s != self.last_status and s is not None:
self.last_status, self.state_since_utc = s, now_utc
elif s is None and self.last_status is None:
pass
def phases_in_use(self) -> int | None:
r = self.reading
if r is None or not r.current_a:
return None
n = sum(1 for a in r.current_a if a >= IDLE_A)
return n or None
+1 -28
View File
@@ -233,9 +233,6 @@ class AlarmsMixin:
# persistent overload is still notified once per quarter.
high = bool(
g is not None and g.saturated and p is not None
# EV-04: not when the car you set explains the excess (a fresh,
# trusted car reading only; `ctl_car.car_cycle`).
and not getattr(self, "car_explains", False)
and p.block_start is not None and not self._peak_rolled
and peakguard.load_too_high(
p, batt_w=batt, ceiling_w=g.ceiling_w,
@@ -279,8 +276,7 @@ class AlarmsMixin:
the floor binds this guard only; the loop has no SoC floor and goes on
discharging. Edge-triggered. (DECISIONS/MAIN-orchestration-archive.md)"""
g = self.peak_guard
limited = bool(g is not None and g.floor_limited
and not getattr(self, "car_explains", False))
limited = bool(g is not None and g.floor_limited)
if limited and (g.floor_w or 0.0) > 0.0:
limited = self._reserve_short(g)
else:
@@ -405,29 +401,6 @@ class AlarmsMixin:
await self.hass.call("persistent_notification", "dismiss",
messages.prices_back().data())
async def check_charger(self) -> None:
"""EV-03. One warning notification when the car charger has not
answered for 5 minutes, taken down when it does; the WARNING log line
is edge-logged. READ ONLY: this raises a notification and calls no
service on the charger."""
if not self.charger.configured():
return
now = self.car_now()
self.car_log_edges(now)
if self.car.notify_due(now) and not self._car_announced:
self._car_announced = True
self.car.notified = True
since = brussels(self.car.bad_since_utc)
await self.hass.call("persistent_notification", "create",
messages.charger_unreachable(
f"{since:%H:%M}",
self.charger.brand or "Alfen").data())
elif self.car.bad_since is None and self._car_announced:
self._car_announced = False
self.car.notified = False
await self.hass.call("persistent_notification", "dismiss",
messages.charger_back().data())
async def check_fixed_note(self) -> None:
"""PRICE-01 G1. First cycle only: one INFO line when `static_profile`
sits beside `price_service` (the plan's last fallback, not a fault, so
-380
View File
@@ -1,380 +0,0 @@
"""EV-04: the Controller's side of the car's Manual mode.
The writes themselves are `carmode.ManualWriter`'s; this mixin owns the state
(mode, current, phases: runtime state in the store, like OPT-11's modes), the
actions, the background step that never holds up a control cycle, and what the
car means for the peak guard's ALARM PATH. DECISIONS/EV-04-manual-mode.md.
"""
import asyncio
import dataclasses
import logging
from datetime import timezone
from . import carmode, chargers, messages, peakguard
from .tariff import QUARTER_S
_LOG = logging.getLogger("goodwe")
CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W}
CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept
CAR_PEAK_KEEP = 3200 # about a month of quarters
OVER_HOLD_S = peakguard.ALARM_HOLD_S
# EV-11: the card, the row and Why stay on this long after the car stops being
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
# sampling) and shorter than a quarter, or until the session really ends.
OVER_OFF_HOLD_S = 180.0
class CarMixin:
# ------------------------------------------------------------------ state
def car_init(self, opts, store) -> None:
"""Mode, current and phases from the store; `ev_mode_start` says what a
restart does with the mode. A site with no charger keeps defaults and
writes nothing."""
data = getattr(store, "data", None) or {}
self.car_mode = carmode.start_mode(opts, data.get(carmode.KEY_MODE))
if carmode.start_mode(opts, carmode.MANUAL) == carmode.OFF \
and data.get(carmode.KEY_MODE) not in (None, carmode.OFF):
store.set(carmode.KEY_MODE, carmode.OFF)
clamp = carmode.clamp_for(opts, None)
a = carmode.value_a(data.get(carmode.KEY_A, carmode.DEFAULT_A), clamp)
self.car_a = carmode.DEFAULT_A if a is None else a
n = data.get(carmode.KEY_PHASES, carmode.DEFAULT_PHASES)
ok = carmode.allowed_phases(opts)
self.car_n = n if n in ok else ok[0]
self.car_rev = 0
self.car_writer = carmode.ManualWriter()
self._car_task = None
self._car_step_failed = False
self.car_explains = False # the car alone explains the excess
self.car_over = False # ... held: the card and row say so
self._car_over_since = None
self._car_over_gone = None
self._car_batt_prev = None
self._car_need_real = self._car_need_excl = False # EV-10 latches
self._car_latch_block = None
self._car_over_notified = None # the session a notice was raised for
self._car_session = 0
self._car_prev_state = None
self._carq = {"key": None, "ws": 0.0, "mono": None}
self._peak_proj_real = None
saved = data.get(CAR_PEAK_KEY)
self.car_peak_q = dict(saved) if isinstance(saved, dict) else {}
@property
def car_cover(self) -> bool:
"""Decision 1: do the batteries help cover the car down to the peak
reserve? Default yes."""
v = self.o.get("ev_batt_cover")
return bool(chargers.EV_OPTION_DEFAULTS["ev_batt_cover"]
if v is None else v)
def car_manual(self) -> bool:
return (self.charger.configured()
and self.car_mode == carmode.MANUAL)
def car_clamp(self):
return carmode.clamp_for(self.o, self.car.reading)
def car_writing(self) -> bool:
"""May the add-on write to the charger now? Control runs, shadow mode is
off, no safety stop is latched and the add-on is not shutting down. Shadow mode gates charger
writes exactly as it gates inverter writes."""
latched = (any(i.sign_wd.tripped for i in self.inverters)
or self.site_sign_wd.tripped or self.circ_wd.tripped)
return bool(self.auto and not self.shadow and not latched
and not getattr(self, "stopping", False))
# ---------------------------------------------------------------- actions
def _car_action(self, what, value, now) -> dict:
"""The mode, the current or the phases, from the page or from Home
Assistant. Store state, applied by the next step with no restart."""
if not self.charger.configured():
return {"error": messages.car_refused("off")}
if what == "car_mode":
if value not in carmode.MODES:
return {"error": messages.car_refused("value")}
self.car_mode = value
self.store.set(carmode.KEY_MODE, value)
elif what == "car_current":
clamp = self.car_clamp()
if isinstance(value, bool):
return {"error": messages.car_refused("value")}
a = carmode.value_a(value, clamp)
try:
inside = a is not None and abs(float(value) - a) < 0.5
except (TypeError, ValueError):
inside = False
if not inside:
return {"error": messages.car_refused("value")}
self.car_a = a
self.store.set(carmode.KEY_A, a)
else:
if value not in (1, 3) or isinstance(value, bool):
return {"error": messages.car_refused("value")}
if value not in carmode.allowed_phases(self.o):
return {"error": messages.car_refused("phases")}
self.car_n = value
self.store.set(carmode.KEY_PHASES, value)
self.car_rev += 1
self.car_writer.user_changed()
self.log_event(f"car {what[4:]} set to {value} by operator",
hint=messages.hint(what))
return {"mode": self.car_mode, "current": self.car_a,
"phases": self.car_n}
def car_command_values(self) -> dict:
"""The MQTT state of the three car entities."""
return {"car_mode": carmode.MODE_LABELS[self.car_mode],
"car_current": round(self.car_a),
"car_phases": str(self.car_n)}
# ------------------------------------------------------------- the writer
def car_kick(self) -> None:
"""Start one writer step in the background, unless one is running. A
write waits up to 10 s for the charger's read-back, and a control cycle
never waits for the charger."""
if not self.charger.configured():
return
t = self._car_task
if t is not None and not t.done():
return
self._car_task = asyncio.ensure_future(self._car_run())
async def car_settle(self) -> None:
"""Wait for the writer step in flight (the checks use it)."""
t = self._car_task
if t is not None:
await asyncio.gather(t, return_exceptions=True)
async def _car_run(self) -> None:
try:
await self.car_step()
except asyncio.CancelledError:
raise
except Exception: # noqa: BLE001
# Once at WARNING-and-above, then quietly: a step that fails
# fails every second.
if not self._car_step_failed:
self._car_step_failed = True
_LOG.exception("The car charger step failed")
else:
_LOG.debug("The car charger step failed again", exc_info=True)
else:
self._car_step_failed = False
async def car_shutdown(self) -> None:
"""The add-on stops: no new write, and a phase change in the middle is
undone by giving the car its current back. The current stands
otherwise (Manual's fail state)."""
t, self._car_task = getattr(self, "_car_task", None), None
if t is not None and not t.done():
t.cancel()
await asyncio.gather(t, return_exceptions=True)
if not self.charger.configured() \
or getattr(self, "car_writer", None) is None \
or self.car_writer.seq is None:
return
try:
await asyncio.wait_for(self.car_writer.abandon(
self.charger, self.car_now(), self.car, self.car_clamp()),
15.0)
except Exception: # noqa: BLE001
_LOG.warning("The car could not be given its current back "
"before the add-on stopped: CHARGER_RESTORE.")
async def car_step(self) -> None:
"""One step of Manual. Reads nothing from the world (the cycle's read
did) and writes only through `carmode.ManualWriter`."""
if not self.charger.configured():
return
now = self.car_now()
await self.car_writer.step(
self.charger, self.car.reading, mode=self.car_mode,
want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
clamp=self.car_clamp(), now=now, tracker=self.car,
writing=self.car_writing(), shadow=bool(self.shadow),
status=self.car.status(now, True), clock=self.car_now)
# ------------------------------------------- the car and the peak guard
def car_alarm_w(self):
"""The car's power for the guard's alarm path: Manual only, fresh, not
stuck (`CarTracker.car_w_trusted`), and never above what the read-back
allows. None otherwise, and then the normal alarms stand."""
if not self.car_manual():
return None
return self.car.car_w_trusted(self.car_now())
def _car_quarter(self, proj, w, mono) -> None:
"""The car's energy in the open quarter, for the average the guard's
house leaves out and for the peak line."""
q = self._carq
key = None if proj is None else proj.block_start
last = q["mono"]
if key != q["key"]:
self._car_bank(q)
q["key"], q["ws"] = key, 0.0
if key is not None and w is not None and last is not None:
q["ws"] += float(w) * min(max(mono - last, 0.0), 5.0)
q["mono"] = mono
def _car_bank(self, q) -> None:
"""A closed quarter in which the car drew its share goes on the list."""
key = q["key"]
if key is None:
return
avg = q["ws"] / QUARTER_S
if avg < CAR_PEAK_MIN_W:
return
self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg)
if len(self.car_peak_q) > CAR_PEAK_KEEP:
for k in sorted(self.car_peak_q)[:-CAR_PEAK_KEEP]:
del self.car_peak_q[k]
self.store.set(CAR_PEAK_KEY, dict(self.car_peak_q))
def car_avg_w(self, proj, w) -> float:
"""The car's average over the whole open quarter: what it drew so far
and `w` for the rest."""
if proj is None or w is None:
return 0.0
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
so_far = self._carq["ws"] if self._carq["key"] == proj.block_start \
else 0.0
return (so_far + float(w) * left) / QUARTER_S
def car_exclude(self, proj, w):
"""Decision 1 off: the projection the guard sees without the car
(`house - car_w`). Unchanged without a fresh car reading."""
if proj is None or w is None or proj.block_start is None:
return proj
avg = self.car_avg_w(proj, w)
return dataclasses.replace(
proj, projected_w=max(0.0, float(proj.projected_w) - avg),
held_w=max(0.0, float(proj.held_w) - float(w)))
def car_cycle(self, real_proj, guard, target_w, now_utc) -> None:
"""After the guard has decided: does the car alone explain the excess?
`real_proj` is the projection WITH the car, whatever the guard saw."""
mono = self.car_now()
w = self.car_alarm_w()
self._car_quarter(real_proj, w, mono)
self._car_session_tick(mono)
explains = over = False
if real_proj is not None and target_w is not None \
and real_proj.block_start is not None:
# EV-10: every cycle, so the latches do not depend on the option.
graded = self._car_explains_alarm(real_proj, guard, target_w, w)
if self.car_cover:
explains = over = graded
elif w is not None:
ex = float(real_proj.projected_w) - float(target_w)
over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
self.car_explains = explains
# EV-11: on once the condition has stood for OVER_HOLD_S, a short gap
# in it not starting that count again; off only after it has been gone
# for OVER_OFF_HOLD_S. `car_explains` (the alarm decision) has no hold.
if over:
self._car_over_gone = None
if self._car_over_since is None:
self._car_over_since = mono
if mono - self._car_over_since >= OVER_HOLD_S:
self.car_over = True
else:
if self._car_over_gone is None:
self._car_over_gone = mono
if mono - self._car_over_gone >= OVER_OFF_HOLD_S:
self.car_over, self._car_over_since = False, None
self._car_over_gone = None
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
"""EV-10: is the alarm's own test true with the car and false without
its fresh, corroborated share (`car_exclude`), on the same landing? The
tests are the alarms': a saturated guard and a floor with other
batteries left are graded by `load_too_high` on where the period lands
(SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's
`misses_aim` (the batteries at 0 W from now on), latched for the
quarter. That latch is kept here twice, on the period as it is
(`_car_need_real`) and without the car (`_car_need_excl`), from the
same `misses_aim` and the same batteries reading. Both reset at a new
quarter and when the guard no longer wants power, whatever the cover
option says (this runs every cycle). A car that is 0 W, or untrusted
(`w` None sets the second latch), makes the two equal and explains
nothing."""
batt, prev = self.site_batt_w, self._car_batt_prev
self._car_batt_prev = batt
wants = bool(guard is not None and guard.engaged
and guard.blind is None
and (guard.wanted_w or 0.0) > 0.0)
if real_proj.block_start != self._car_latch_block:
self._car_latch_block = real_proj.block_start
self._car_need_real = self._car_need_excl = False
if not wants:
self._car_need_real = self._car_need_excl = False
if batt is not None and prev is not None:
batt = min(float(batt), float(prev))
excl = self.car_exclude(real_proj, w)
if wants:
if batt is None:
self._car_need_real = self._car_need_excl = True
else:
self._car_need_real = self._car_need_real or \
peakguard.misses_aim(real_proj, batt_w=batt,
target_w=target_w)
self._car_need_excl = self._car_need_excl or w is None or \
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
if w is None or batt is None or not wants \
or not (guard.saturated or guard.floor_limited):
return False
if guard.saturated:
rating = self.site_rating_w
elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None:
rating = guard.able_w
else:
return bool(not guard.within_aim and self._car_need_real
and not self._car_need_excl)
def high(p):
return peakguard.load_too_high(
p, batt_w=batt, ceiling_w=guard.ceiling_w,
achievable_w=rating)
return bool(high(real_proj) and not high(excl))
def _car_session_tick(self, mono) -> None:
"""A charging session is a plug-in: the state goes from no car to a
car. The notice is raised once per session."""
s = self.car.status(mono, True)
if s in (chargers.NONE_,) and self._car_prev_state not in (
None, chargers.NONE_):
self._car_over_notified = None
# The session is over: that is a real end, with no hold.
self.car_over = False
self._car_over_since = self._car_over_gone = None
if s not in (chargers.NONE_, None) and self._car_prev_state in (
chargers.NONE_, None):
self._car_session += 1
self._car_prev_state = s
async def check_car_over(self) -> None:
"""One grey notice per charging session: the charge you set takes the
15-minute period over the peak limit. Raised nowhere else."""
if not self.car_over or self._car_over_notified == self._car_session:
return
self._car_over_notified = self._car_session
_LOG.info("The car charge you set takes this 15-minute period over "
"the peak limit: CAR_OVER_PEAK.")
await self.hass.call("persistent_notification", "create",
messages.car_over(f"{self.car_a:.0f}").data())
def car_peak_by_car(self, reading, now):
"""`(True, local time)` when the month's peak quarter was one the car
mostly made (it drew half the peak or more), else `(False, None)`."""
if reading is None or not getattr(reading, "is_observed", False) \
or reading.quarter_start is None or not self.car_peak_q:
return False, None
avg = self.car_peak_q.get(
reading.quarter_start.astimezone(timezone.utc).isoformat())
if avg is None or reading.peak_w is None \
or 2.0 * float(avg) < float(reading.peak_w):
return False, None
return True, reading.quarter_start
+5 -55
View File
@@ -29,7 +29,7 @@ from . import shadow
from .price import Uncertainty
from .tariff import next_quarter
from .watchdog import loop_is_following
from .ctl_trade import M28_REASON, pack_energy_of
from .ctl_trade import pack_energy_of
from .rows import why_key, why_raised
_LOG = logging.getLogger("goodwe")
@@ -391,15 +391,6 @@ class CycleMixin:
if self._peak_proj is not None and len(self.inverters) > 1:
self._peak_proj = next_quarter(self._peak_proj,
self.p1.averager.max_hold_s)
# EV-04, decision 1: with "Batteries help with the peak while the car
# charges" OFF, the guard's house leaves the car out (`house - car_w`).
# `_peak_proj_real` keeps the quarter as the meter will bill it, for
# the car's own words. Only a fresh, trusted car reading is left out.
self._peak_proj_real = self._peak_proj
if (self._peak_proj is not None and not self.car_cover
and self.car_manual()):
self._peak_proj = self.car_exclude(self._peak_proj,
self.car_alarm_w())
self.peak_guard = None if not self.p1_enabled else peakguard.decide(
self._peak_proj,
# ⚠️ THE SITE SUM. The guard sizes a floor from what the battery is
@@ -449,13 +440,6 @@ class CycleMixin:
self.peak_guard = self._peak_landing(self.peak_guard)
self.peak_guard = peakguard.cap_floor( # SAFETY-128
self.peak_guard, self.answer.peak_cap(site_standing))
# EV-04: does the car alone explain what the guard cannot hold? Fresh
# car readings only; the claim, the floor and the commands above are
# not touched by it.
self.car_cycle(self._peak_proj_real, self.peak_guard,
peakguard.quarter_target_w(
float(self.o.get("peak_cap_w", 3500)),
self.peak_margin_w, _reading), now)
# SITE, and peakguard.claim() says so on the object it builds: the
# quantity is the 15-minute average OFFTAKE AT THE GRID CONNECTION,
# which the capacity tariff bills (one quarter-hour peak per site, not
@@ -553,10 +537,6 @@ class CycleMixin:
# maintenance ⚠️ ONE PASS PER PACK, AND `arbitrate()` IS WHY THE LIST
# STAYS SHORT. (DECISIONS/MAIN-orchestration-archive.md)
# MAINT-28: the hold lives only while the charge-only branch is taken;
# kept through the two short holds above on purpose
# (DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md).
_peak_held, self._maint_peak_hold = self._maint_peak_hold, False
for inv, result in zip(self.inverters, maint_results):
if result.owns_setpoint:
# PER-INVERTER: §12's recalibration is a PACK procedure, filed
@@ -584,18 +564,8 @@ class CycleMixin:
maint_aim = peakguard.quarter_target_w(
float(self.o.get("peak_cap_w", 3500)),
self.peak_margin_w, _reading)
# MAINT-28: hold the pause in a real peak.
# DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md
house = (None if self.grid is None or self.site_batt_w is None
else float(self.grid) + float(self.site_batt_w))
_susp = peakguard.shaping_suspended(
self.peak_guard, self.peak_fc, maint_aim)
_m28 = (len(self.inverters) > 1
and maint_aim > self.peak_aim_w())
self._maint_peak_hold = peakguard.shaping_held(
_susp, _peak_held and _m28, self.peak_fc, maint_aim,
house, self._batts_settled())
if self._maint_peak_hold:
if peakguard.shaping_suspended(
self.peak_guard, self.peak_fc, maint_aim):
# Edge-logged: level-logging here would write one line per
# cycle for as long as the event lasts and flush the 40-line
# action log of the very context that explains it.
@@ -605,18 +575,6 @@ class CycleMixin:
"suspended so the peak claim is not "
"contradicted",
hint=messages.hint("maint_paused"))
# MAINT-28: while held this pack gives at most the most of
# the guard's floor placed on it this period
# (`_m28_share()`).
# DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md
shape = ((0.0 if self.peak_guard is not None
and inv.name in self.peak_guard.held
else max([c.lo for c in claims
if c.source == peakguard.SOURCE]
+ [self._m28_was(self.actuator_of(
"maintenance", inv), now)],
default=0.0), M28_REASON)
if _m28 else None)
else:
self._maint_shape_suspended = False
hi = 0.0
@@ -633,12 +591,10 @@ class CycleMixin:
floor = self._charge_headroom(floor, claims)
if floor > 0:
hi, reason = -floor, "cheap-window charge"
shape = (hi, reason)
if shape is not None:
# PER-INVERTER, like the SET above and for the same reason -
# the shaping is about the pack being charged, which is `inv`.
claims.append(Claim.limit("maintenance", P_MAINT_SHAPE,
hi=shape[0], reason=shape[1],
claims.append(Claim.limit("maintenance", P_MAINT_SHAPE, hi=hi,
reason=reason,
actuator=self.actuator_of("maintenance",
inv)))
@@ -886,9 +842,6 @@ class CycleMixin:
self.loop_clamp_facts = ()
self._loop_decision = None
# MAINT-28: a paused pack gives at most its largest part of the floor
# in this period.
self._m28_share(claims, now)
# SAFETY-28. A new resolution is a new tick, and the previous record is
# stale from this line onwards. Incremented BEFORE resolve() so that the
# record resolve() builds is stamped with the tick it is for.
@@ -1063,9 +1016,6 @@ class CycleMixin:
# Not a safety check, so it is one of the cheap ones: an attribute test
# and, on a change only, one Home Assistant call.
await self.check_price_gap()
await self.check_charger()
await self.check_car_over()
self.car_kick() # EV-04: Manual, in the background
await self.check_fixed_note()
# SAFETY-31's alarm, and its boundary is the LATCH, not a number: it
-99
View File
@@ -13,9 +13,7 @@ from . import freshness
from . import lateness
from . import messages
from . import pv as pv_read
from . import chargers
from .price import brussels, price_option, provider_configured
from .hass import OUTAGE
from .price_chain import uses_chain
from .static_tariff import static_status
from .rows import tariff_plan_row
@@ -50,10 +48,6 @@ FC_HOLD_KEY = "solar_fc_hold"
FORECAST_READ_S = 60.0
# EV-03: the car's energy today, kept so a restart does not lose it.
CAR_TODAY_KEY = "car_today"
class InputsMixin:
def _readings_late(self, standing_w):
"""SAFETY-128: update the answer gate; seconds the late verdict has
@@ -108,95 +102,6 @@ class InputsMixin:
return "input"
# -- io ------------------------------------------------------------------
# -- EV-03: the car charger, READ ONLY ----------------------------------------
@property
def car_enabled(self) -> bool:
"""`ev_charger` is on, whether or not the charger could be set up."""
return chargers.mode_of(self.o) != chargers.OFF
def car_now(self) -> float:
return freshness.monotonic()
def car_term(self) -> tuple:
"""`(car_w, unknown)`: what the House tile and the house profile take
out for the car. `(0.0, False)` with no charger, so a site without one
is exactly as before. With one, a reading older than `stale_input_s`
(the meter's own bound) is UNKNOWN, never the last figure: the tile
shows no reading and the profile leaves that moment out."""
if not self.charger.configured():
return 0.0, False
w = self.car.car_w(self.car_now())
return (0.0, True) if w is None else (w, False)
async def _read_charger(self, now_mono: float) -> None:
"""One read of the charger, and what the tracker learns from it. It
never raises (telemetry has no foot in the control path) and it only
reads: nothing here, or anywhere in this card, writes to the charger."""
now_utc = datetime.now(timezone.utc)
day = brussels(now_utc).date().isoformat()
try:
if not self._charger_probed:
pr = await asyncio.wait_for(self.charger.probe(), 5.0)
if OUTAGE.waiting():
raise RuntimeError("Home Assistant is not answering")
self._charger_probed = True
self._judge_probe(pr)
if not self.charger.configured():
return
reading = await asyncio.wait_for(self.charger.read(), 5.0)
except Exception as err: # noqa: BLE001
_LOG.debug("The charger could not be read: %s", err)
reading = chargers.ChargerReading(why="no answer")
self.car.observe(reading, now_mono, now_utc, day)
if self.car.persist:
self.car.persist = False
self.store.set(CAR_TODAY_KEY, self.car.dump())
def _judge_probe(self, pr) -> None:
"""A charger whose setpoint, read-back or state entity is missing, or
whose limit is above the station limit, is REFUSED: the add-on starts
and the Car card says so. Said once."""
why = None
if not pr.ok and pr.power_unit is not None \
and not pr.required_missing:
why = "unit"
_LOG.warning("The car charger is not set up, because its power "
"has no power unit: CHARGER_POWER_UNIT.")
_LOG.debug("The charger power entity reads in %r.", pr.power_unit)
elif not pr.ok:
why = "not_found"
_LOG.warning("The car charger is not set up, because Home "
"Assistant has no entity it needs: CHARGER_NOT_FOUND.")
_LOG.debug("Charger entities missing: %s.",
", ".join(e for _r, e in pr.missing) or "the name")
else:
amps = chargers.max_a(self.o)
if pr.station_a is not None and amps is not None \
and amps > pr.station_a:
why = "limit"
_LOG.warning("The charger limit is above what the charger "
"allows, so the charger is not used: "
"CHARGER_LIMIT.")
_LOG.debug("ev_max_a %.0f A, station limit %.0f A.", amps,
pr.station_a)
if why is not None:
self.charger_refused = why
self.charger = chargers.UnavailableCharger(why, chargers.ALFEN_HA)
def car_log_edges(self, now_mono: float) -> None:
"""One WARNING when the charger goes unreachable, one INFO when it is
back. Edge-logged, never every cycle."""
down = self.car.unreachable(now_mono)
if down and not self._car_down_logged:
self._car_down_logged = True
_LOG.warning("The car charger does not answer, so the Car card has "
"no reading: CHARGER_UNREACHABLE.")
_LOG.debug("The charger entities read unavailable, or its login "
"is off, for %.0f s.", chargers.UNREACHABLE_S)
elif not down and self._car_down_logged and self.car.bad_since is None:
self._car_down_logged = False
_LOG.info("The car charger answers again.")
@property
def pv_roster(self) -> tuple:
"""Every configured PV production entity, or `()` (TEL-11/TEL-12). ONE
@@ -304,10 +209,6 @@ class InputsMixin:
_reads = [self._read_unit(inv, now_mono) for inv in self.inverters]
if self.pv_roster:
_reads.append(self._read_pv())
# EV-03: the charger, read only, in the same gather. Nothing is added
# without a charger, so a site with none runs exactly as before.
if self.charger.configured():
_reads.append(self._read_charger(now_mono))
# OPT-11 P4: the solar forecast, in the same gather (a slow sensor must
# not delay control), at most once per FORECAST_READ_S.
if self.fc_entity is not None and (
+1 -104
View File
@@ -15,8 +15,7 @@ from .freeze import rail_unreachable, rail_w
from .hass import OUTAGE
from .maintenance import IDLE
from .mqtt import (
BASE, PAYLOAD_NONE, announced_units, optional_keys, parse_car_command,
parse_command, unit_slugs, unit_state_key,
announced_units, optional_keys, parse_command, unit_slugs, unit_state_key,
)
from . import peakguard
from . import pv as pv_read
@@ -35,9 +34,6 @@ class StatusMixin:
already holds the last choice). Never raises: MQTT must not reach
control. (DECISIONS/MAIN-orchestration-archive.md)"""
try:
if isinstance(topic, str) and topic.startswith(f"{BASE}/car/"):
await self._car_mqtt_command(topic, payload, retained)
return
slug, action, value, why = parse_command(
topic, payload, retained, packmode.MODES)
if why is None:
@@ -71,29 +67,6 @@ class StatusMixin:
except Exception: # noqa: BLE001
_LOG.exception("Home Assistant command could not be handled")
async def _car_mqtt_command(self, topic, payload, retained) -> None:
"""EV-04: one command from the car's HA entities, through
handle_action(). A retained command is never applied. Never raises."""
action, value, why = parse_car_command(topic, payload, retained)
result = None
if why is None:
result = await self.handle_action(action, value=value)
if isinstance(result, dict) and "error" not in result:
self.mqtt.publish(self.car_command_values())
return
why = result["error"] if isinstance(result, dict) else "refused"
else:
why = messages.car_refused("topic") if why == "topic" else \
messages.pack_refused(why)
topic_s = "".join(c if c.isprintable() else "?" for c in str(topic)[:128])
_LOG.debug("Home Assistant command %s %s refused: %s", topic_s,
repr(payload)[:48], why)
if (topic_s, why) not in self._mqtt_refused \
and len(self._mqtt_refused) < 32:
self._mqtt_refused.add((topic_s, why))
_LOG.warning("Home Assistant command on %s ignored: %s", topic_s,
why)
@property
def why_words(self) -> str:
"""The page's "Why" line. While control waits for a missing reading
@@ -162,10 +135,6 @@ class StatusMixin:
if "pv" in optional_keys(self.o):
values["pv"] = (None if self.pv_w is None
else round(self.pv_w, 1))
# EV-03: the car, only with a charger switched on (the same predicate
# that announces the three sensors). Absence is `None`, never 0.
if "car_state" in optional_keys(self.o):
values.update(self.car_values())
# ⚠️ ONLY when P1 ingestion is running: the ESP32's stale-input
# watchdog subscribes to sensor.goodwe_p1_sample_age and forces layer-1
# failsafe at max_age_s, so with meter_source off a published age would
@@ -192,66 +161,6 @@ class StatusMixin:
values.update(self.mode_values())
self.mqtt.publish(values)
# -- EV-03: the car charger ------------------------------------------------
def car_rows(self) -> list:
"""The charger's status rows: amber when it is not set up or does not
answer, grey while something else changes it."""
if not self.charger.configured():
return [{"ok": False, "warn": True, "id": "charger_setup",
"text": messages.row_charger_setup()}]
out = []
if self.car.unreachable(self.car_now()):
out.append({"ok": False, "warn": True, "id": "charger",
"text": messages.row_charger_unreach(
f"{brussels(self.car.bad_since_utc):%H:%M}")})
w = self.car_writer
if self.car_mode == "manual":
# EV-04: in Manual the add-on's own writes are not "another
# writer"; its own detector (a read-back that differs from the
# last write for 30 s) says so, in grey.
if w.other:
out.append({"ok": True, "warn": True, "id": "charger_other",
"text": messages.row_charger_other()})
if w.gave_up:
out.append({"ok": False, "warn": True, "id": "charger_refused",
"text": messages.row_charger_refused()})
if w.phases_gave_up:
out.append({"ok": False, "warn": True, "id": "charger_phases",
"text": messages.row_charger_phases()})
elif self.car.other_writer(datetime.now(timezone.utc)):
out.append({"ok": True, "warn": True, "id": "charger_writer",
"text": messages.row_charger_writer()})
if self.car.stuck(self.car_now()):
out.append({"ok": False, "warn": True, "id": "charger_stuck",
"text": messages.row_charger_stuck()})
r = self.car.reading
if r is not None and r.available and r.error:
out.append({"ok": True, "warn": True, "id": "charger_error",
"text": messages.row_charger_error(r.error)})
if self.car_over:
out.append({"ok": True, "warn": True, "id": "car_over",
"text": messages.row_car_over()})
return out
def car_values(self) -> dict:
"""The MQTT values for the three car sensors."""
now = self.car_now()
state = self.car.status(now, self.charger.configured())
r = self.car.reading
down = state in (None, "unreach", "setup")
with homeview.in_lang("en"):
word = homeview.car_state_word(state)
return {
**self.car_command_values(),
"car_state": word,
# `ABSENT_AS_UNKNOWN` stays the one PV key (test_pv.py): an absent
# car figure is HA's own "no value" payload, sent by name.
"car_power": (PAYLOAD_NONE if down or r is None
or r.power_w is None else round(r.power_w, 1)),
"car_today_kwh": (PAYLOAD_NONE if self.car.today_kwh is None
else round(self.car.today_kwh, 3)),
}
# -- UI ------------------------------------------------------------------
def checks(self, when: datetime | None = None) -> list:
"""The status rows. `when` is the reference time for anything billed by
@@ -386,13 +295,6 @@ class StatusMixin:
if _pg is None:
out.append({"ok": True, "warn": True, "id": "peak_guard",
"text": messages.row_peak_guard_waiting()})
elif self.car_explains and (_pg.saturated or _pg.floor_limited):
# EV-04: the car you set is what the batteries cannot hold, so
# no red row. The grey row `car_over` says what is going on.
out.append({"ok": True, "warn": False, "id": "peak_guard",
"text": messages.row_peak_guard_on(
_pg.floor_w or 0.0, _pg.ceiling_w,
shadow=self.shadow)})
elif _pg.saturated and not _pg.within_aim:
out.append({"ok": False, "warn": False, "id": "peak_guard",
"runs": True,
@@ -711,9 +613,6 @@ class StatusMixin:
out.append({"ok": False, "warn": True, "id": "pv",
"text": messages.row_pv_stray(
_inv_list.index(ent) + 1)})
# EV-03: the car charger's rows, only with a charger switched on.
if self.car_enabled:
out.extend(self.car_rows())
return out
def status_payload(self, lang: str = "en") -> dict:
@@ -922,8 +821,6 @@ class StatusMixin:
now = datetime.now(timezone.utc)
if what in ("pack_use", "pack_mode", "pack_sell"):
return self._pack_action(what, unit, value, now)
if what in ("car_mode", "car_current", "car_phases"):
return self._car_action(what, value, now)
if what == "auto_toggle":
self.auto = not self.auto
self.store.set("auto", self.auto)
+2 -94
View File
@@ -10,7 +10,7 @@ from datetime import datetime, timedelta, timezone
from . import arbitrage
from .arbiter import (
ACTUATOR_SITE, Claim, P_MAINTENANCE, P_MAINT_SHAPE, P_PEAK, SET,
pre_resolve, resolve,
pre_resolve,
)
from . import allocator
from . import dayplan
@@ -19,7 +19,6 @@ from . import packmode
from . import priceruns
from . import solarfc
from . import control as _ctl
from . import freshness
from . import messages
from .maintenance import CHARGE, DRAIN, HOLD, IDLE, MaintConfig, POWER_MOVING
from .mqtt import MODE_LABELS, USE_OFF, USE_ON, unit_slugs, unit_state_key
@@ -50,13 +49,6 @@ EDGE_HOLD_S = _ctl.PLANT_SETTLE_S
HOUSE_PROFILE_KEY = "house_profile"
# MAINT-28: a step of a battery's command, in W, after which its reading is not
# current until a changed one arrives (`Controller._batts_settled()`).
MAINT_STEP_W = 100.0
# MAINT-28: the reason on a paused pack's cap (`Controller._m28_share()`).
M28_REASON = "peak hold"
# OPT-34: the level of a night grid charge that has started, so it does not
# drop when the forecast goes (`Controller._latch_charge()`).
CHARGE_LATCH_KEY = "night_charge_latch"
@@ -388,18 +380,8 @@ class TradeMixin:
price_now = None
house = (None if self.grid is None or self.site_batt_w is None
else float(self.grid) + float(self.site_batt_w))
# EV-03: the car is not the house. Out of the profile that plans the
# batteries' night charge; with a charger whose reading is not fresh
# the moment is left out (None), not guessed.
# ONLY the profile's sample: `house` below stays what it was, since
# the battery decision's input is not part of this card.
house_sample = house
if house is not None:
_car_w, _car_unknown = self.car_term()
house_sample = (None if _car_unknown else max(0.0, house - _car_w)
if _car_w else house)
if self.house_profile is not None and \
self.house_profile.add(now, house_sample):
self.house_profile.add(now, house):
self.store.set(HOUSE_PROFILE_KEY, self.house_profile.dump())
targets = self.plan_targets()
if targets is None:
@@ -729,80 +711,6 @@ class TradeMixin:
lo = hi = float(inv.batt)
self._read_span[inv.name] = (min(lo, cmd), max(hi, cmd), since)
def _batts_settled(self) -> bool:
"""MAINT-28: False while a battery reading may pre-date a step UP of
its command, so `grid + site_batt_w` is a new grid and an old battery.
DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md"""
now, ok = self._now_mono, True
if now is None:
return True
for inv in self.inverters:
cmd = float(inv.standing_w())
seen = self._m28_step.get(inv.name)
if seen is None:
seen = self._m28_step[inv.name] = (cmd, None)
elif abs(cmd - seen[0]) >= MAINT_STEP_W:
seen = self._m28_step[inv.name] = (
cmd, now if cmd > seen[0] else seen[1])
at = seen[1]
if at is None or now - at >= freshness.BATT_OBLIGED_S:
continue
got = inv.batt_fresh.changed_mono
if got is None or got < at + freshness.PLANT_SETTLE_S:
ok = False
return ok
def _m28_share(self, claims, now) -> None:
"""MAINT-28: each paused pack's cap (0 W if the guard holds it at its
reserve) set to the largest part of the guard's floor left to it in
this 15-minute period: the floor less what the other units are placed
at in this cycle's split without the cap. Kept per unit in `_m28_hi`,
dropped while the unit is not paused or is held. Also one site limit,
the period's largest floor, so the other pack does not give for the
house (`_m28_site`).
DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md"""
floor = max((c.lo for c in claims if c.source == peakguard.SOURCE),
default=0.0)
g = self.peak_guard
held = {self.actuator_of("maintenance", inv) for inv in self.inverters
if g is not None and inv.name in g.held}
q, seen = int(now.timestamp() // 900), set()
site = any(c.source == "maintenance" and c.reason == M28_REASON
and c.actuator != ACTUATOR_SITE for c in claims)
for i, c in enumerate(claims):
if c.source != "maintenance" or c.reason != M28_REASON \
or c.actuator == ACTUATOR_SITE or c.actuator in held:
continue
seen.add(c.actuator)
shares = resolve(claims[:i] + claims[i + 1:], units=self.units,
live=self.live_units(), weights=self.pack_weights,
reserve=self._held_back()).shares
part = max(0.0, floor - sum(float(w) for u, w in shares.items()
if u != c.actuator))
hi = max(part, self._m28_was(c.actuator, now))
self._m28_hi[c.actuator] = (q, hi)
claims[i] = dataclasses.replace(c, hi=hi)
# A unit not paused (or held at its reserve) starts again from 0 W.
for u in set(self._m28_hi) - seen:
del self._m28_hi[u]
# Site: while the pause holds, the packs together give at most the
# period's largest floor, never under this cycle's (the guard's claim
# and P_PEAK outrank this one anyway).
if not site:
self._m28_site = (None, 0.0)
return
hi = max(floor, self._m28_site[1] if self._m28_site[0] == q else 0.0)
self._m28_site = (q, hi)
claims.append(Claim.limit("charge", P_MAINT_SHAPE, hi=hi,
reason=M28_REASON,
actuator=ACTUATOR_SITE))
def _m28_was(self, u, now) -> float:
"""MAINT-28: unit `u`'s cap so far in this 15-minute period, 0 W in
a new one (`_m28_share()`)."""
q, hi = self._m28_hi.get(u, (None, 0.0))
return hi if q == int(now.timestamp() // 900) else 0.0
def _reseed_drop(self, live) -> None:
"""SAFETY-96, N>=2: a battery that drops out of the split (stale link)
leaves the loop's start point, so the others take over at one slew step
+7 -182
View File
@@ -19,8 +19,7 @@ section at the bottom and is held to STYLE.md by test_messages.py.
import contextlib
from datetime import datetime, timedelta, timezone
from . import (arbitrage, carmode, cheaproll, handback, messages, peakguard,
priceruns, uitext)
from . import arbitrage, cheaproll, handback, messages, peakguard, priceruns, uitext
from .dayplan import EFF
from .maintenance import CHARGE as M_CHARGE, DRAIN as M_DRAIN, HOLD as M_HOLD
from .maintenance import IDLE as M_IDLE, next_slot_start
@@ -73,26 +72,16 @@ def flow(w, *, shadow=False):
return "resting"
def now_block(*, grid_w, pv_w, batt_w, has_solar, shadow, settled=True,
car_w=0.0, car_unknown=False):
def now_block(*, grid_w, pv_w, batt_w, has_solar, shadow, settled=True):
"""The four tiles. `house_w` needs all three readings, so without a solar
reading it is None rather than a number that leaves the sun out.
EV-03: `car_w` is what a car charger takes, and it is not the house, so it
is taken out of House (the Car card shows it). `car_unknown` is a charger
whose reading is not fresh: House then has no figure rather than one that
may hold the car. Both default to "no charger", the figure as before."""
reading it is None rather than a number that leaves the sun out."""
house, disagree = None, False
if has_solar and None not in (grid_w, pv_w, batt_w):
house = float(grid_w) + float(pv_w) + float(batt_w) - float(car_w or 0.0)
if car_unknown:
house = None
house = float(grid_w) + float(pv_w) + float(batt_w)
# The three are read at slightly different moments, so the sum can dip
# under zero. Inside the idle band that is 0 W; beyond it the readings
# disagree and no house figure is shown.
if house is None:
pass
elif house < -IDLE_W:
if house < -IDLE_W:
house, disagree = None, True
elif house < 0.0:
house = 0.0
@@ -872,10 +861,8 @@ def peak_engaged(c) -> bool:
only), so no battery gives power for it. Nor when the quarter ends on
the aim anyway (SAFETY-126, `within_aim`)."""
pg = getattr(c, "peak_guard", None)
# EV-04: not for a cause the car's own Why explains.
return bool(pg is not None and pg.engaged and (pg.floor_w or 0.0) > 0.0
and not pg.within_aim
and not getattr(c, "car_explains", False))
and not pg.within_aim)
def battery_rows(c, shadow, running, held=False):
@@ -1083,7 +1070,6 @@ ATTN_DOCS = {
"not_keeping_up": messages.T_LOOP_BOUND,
"circulating": messages.T_CIRCULATING,
"delivery": messages.S_NOT_DELIVERING,
"charger": messages.T_CHARGER_UNREACH,
}
@@ -1132,30 +1118,10 @@ def month_peak(c, now):
if pg is not None:
out["period_w"] = pg.projected_w
ceiling = pg.ceiling_w or limit_w
real = getattr(c, "_peak_proj_real", None)
if getattr(c, "car_enabled", False) and c.charger.configured() \
and not c.car_cover and c.car_manual() and real is not None \
and getattr(real, "block_start", None) is not None:
# EV-04, decision 1 off: the guard's own projection leaves the car
# out; the period as the meter will bill it does not.
out["period_w"] = real.projected_w
out["line"] = line_period(out["period_w"], ceiling, c.shadow,
unmeasured=getattr(c, "peak_unmeasured_s", 0.0)
> 0.0,
cut=getattr(c, "room_charge", False))
# EV-04: when a car charge you asked for is in this period, and when one
# set the month's peak. Both empty without a charger in Manual.
out["car_line"] = out["set_by"] = ""
if getattr(c, "car_enabled", False) and c.charger.configured():
w = c.car_alarm_w()
if pg is not None and w is not None and w >= 500.0 \
and out["period_w"] is not None and (pg.engaged or c.car_over):
out["car_line"] = _t("peak.car", kw=_kw(out["period_w"]),
car=_kw(w),
cov=_kw(max(0.0, float(c.site_batt_w or 0))))
by_car, at = c.car_peak_by_car(reading, now)
if by_car:
out["set_by"] = _t("peak.set_by_car", t=f"{brussels(at):%H:%M}")
return out
@@ -1221,10 +1187,7 @@ def _build(c, *, level, checks, now, held=None, waiting=False):
"sub": banner_sub(kind)},
"now": now_block(grid_w=c.grid, pv_w=c.pv_w, batt_w=c.site_batt_w,
has_solar=bool(c.pv_roster), shadow=shadow,
settled=settled,
**dict(zip(("car_w", "car_unknown"),
c.car_term()))),
"car": car_block(c, now),
settled=settled),
"batteries": rows,
"plan": plan,
"modes_on": bool(getattr(c, "modes_on", False)),
@@ -1245,133 +1208,6 @@ def _docs_url():
messages._site["ha"])
# --------------------------------------------------------------------------- #
# EV-03: the Car card. READ ONLY: Off is the only mode in this version.
# --------------------------------------------------------------------------- #
_CAR_KIND = {"charging": "ok", "full": "ok", "unreach": "warn",
"setup": "warn", "fault": "warn"}
def car_state_word(key) -> str:
return _t("car.state." + (key if key else "wait"))
def car_phases_word(n) -> str:
return _t("car.phase_one") if n == 1 else _t("car.phase_many", n=n)
def _car_big(key, c, r, good):
if key == "charging" and r is not None and r.power_w is not None:
parts = [_dec(f"{r.power_w / 1000:.1f}")
+ " kW"]
amps = (r.allowed_a if r.allowed_a is not None
else max(r.current_a) if r.current_a else None)
if amps is not None:
parts.append(f"{amps:.0f} A")
n = c.car.phases_in_use()
if n:
parts.append(car_phases_word(n))
return " · ".join(parts)
if key == "unreach":
t = c.car.last_good_utc
return (_t("car.big.seen", t=hhmm(t)) if t is not None
else _t("car.big.no_reading"))
if key == "charging": # the reading is too old
return _t("car.big.no_reading")
return _t("car.big." + (key or "wait"))
def _car_why(key, c, good):
brand = (getattr(c.charger, "brand", "") or "Alfen")
if key == "unreach":
r = c.car.reading
if r is not None and r.why == "power unit":
return _t("car.why.unreach_unit")
a = None if good is None else good.setpoint_a
if a is None and good is not None:
a = good.allowed_a
if a is not None:
return _t("car.why.unreach_a", a=f"{a:.0f}", brand=brand)
return _t("car.why.unreach", brand=brand)
if key == "setup":
why = {"not_found": "not_found", "limit": "limit",
"unit": "unit"}.get(
c.charger_refused or "", "name")
return _t("car.why." + why)
return _t("car.why." + (key if key else "wait"))
def _car_manual_why(c, key):
"""The Why of Manual: what you set, and what the peak limit does about it.
Plan lines: two sentences of at most 12 words."""
a = f"{float(c.car_a):.0f}"
w = c.car_writer
pct = _pct(c.o.get("peak_soc_floor", peakguard.PEAK_OPTION_DEFAULTS[
"peak_soc_floor"]))
if c.car_over:
pg = getattr(c, "peak_guard", None)
if not c.car_cover:
return _t("car.why.manual_nocover", a=a)
return _t("car.why.manual_over" if pg is not None and pg.floor_limited
else "car.why.manual_full", a=a, pct=pct)
if c.shadow:
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
return _t("car.why.manual_would", a=f"{float(t):.0f}",
phases=car_phases_word(n))
if not c.auto:
return _t("car.why.manual_stopped")
if key in ("none", "full"):
return _t("car.why.manual_wait", a=a)
if w.blocked:
return _t("car.why.manual_blocked")
if c.car_cover and peak_engaged(c):
giving = max(0.0, float(c.site_batt_w or 0.0))
return _t("car.why.manual_cover", a=a, kw=_kw(giving), pct=pct)
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
def car_block(c, now):
"""The Car card for `/status`, or None when no charger is switched on (the
page then draws nothing, as before)."""
if not getattr(c, "car_enabled", False):
return None
mono = c.car_now()
configured = c.charger.configured()
key = c.car.status(mono, configured)
r = c.car.reading if configured else None
good = c.car.last_good
fresh = configured and c.car.fresh(mono)
today = None
if configured and c.car.today_kwh is not None:
today = _t("car.today", kwh=_kwh(c.car.today_kwh))
mode = getattr(c, "car_mode", "off") if configured else "off"
why = _car_why(key, c, good)
if mode == "manual" and key in ("charging", "waiting", "none", "full"):
why = _car_manual_why(c, key)
out = {
"state": key or "wait",
"chip": car_state_word(key),
"kind": _CAR_KIND.get(key, "muted"),
"big": _car_big(key, c, r if fresh else None, good),
"today": today,
"why": why,
"mode": mode,
"power_w": (None if not fresh or r is None or r.power_w is None
else round(float(r.power_w), 1)),
}
if configured:
# EV-04: what the page can set. Off and Manual only (Solar and Night
# are later cards, so they are not offered).
clamp = c.car_clamp()
hi = int(clamp) if clamp is not None and clamp >= 6 else 6
out["modes"] = ["off", "manual"]
out["current"] = {"value": round(float(c.car_a)), "min": 6,
"max": hi}
out["phases"] = {"value": c.car_n,
"choices": list(carmode.allowed_phases(c.o))}
return out
# =========================================================================== #
# The words. STYLE.md: plain, short, present tense. A plan line is at most
# two sentences of at most 12 words each (UX-13 design, section 4); a title at
@@ -1879,17 +1715,6 @@ def _samples() -> list:
out += [("plan", day_note(k, pct=70, name="Battery A", at="08:15",
kwh="9.2 kWh", count="6.4 kWh"))
for k in words["day"]]
out += [("title", _t("car.state." + k)) for k in words["car"]["state"]]
out += [("plan", _t("car.big." + k, t="09:12")) for k in
words["car"]["big"]]
out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW",
pct="20 %", phases=car_phases_word(3)))
for k in words["car"]["why"]]
out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW",
cov="8.6 kW")),
("plan", _t("peak.set_by_car", t="19:45"))]
out += [("plan", _t("car.today", kwh="14.2 kWh")),
("plan", "11.0 kW · 16 A · " + _t("car.phase_many", n=3))]
out += [("plan", line_no_trade(k)) for k in
("not_covered", "no_prices", "peak", "not_firm", "not_worth",
"no_level")]
+3 -45
View File
@@ -42,8 +42,6 @@ from .arbiter import (
P_SAFETY, SET, Claim, Resolution, actuator_for, pre_resolve, resolve,
)
from . import allocator
from . import carmode
from . import chargers
from . import dayplan
from . import modetrade
from . import packmode
@@ -84,9 +82,8 @@ from .maintenance import (
CHARGE, DRAIN, HOLD, IDLE, POWER_MOVING, MaintConfig, Maintenance,
FAIL_BACKOFF_DAYS, MaintResult, arbitrate as maint_arbitrate, site_zone,
)
from .mqtt import (CAR_CONFIGS_KEY, MODE_CONFIGS_KEY, MODE_LABELS, USE_OFF,
USE_ON, MqttPublisher, announced_units, car_configs,
mode_configs,
from .mqtt import (MODE_CONFIGS_KEY, MODE_LABELS, USE_OFF, USE_ON,
MqttPublisher, announced_units, mode_configs,
optional_keys, parse_command, unit_slugs, unit_state_key)
from . import peakguard
from . import packshare
@@ -115,7 +112,6 @@ from . import web
# stays importable from `app.main`. DECISIONS/MAIN-orchestration.md.
from .ctl_tasks import TasksMixin
from .ctl_status import StatusMixin
from .ctl_car import CarMixin
from .ctl_alarms import (
AlarmsMixin, HANDBACK_CYCLES, REANNOUNCE_S, ROLLING_BOUND_CYCLES,
ROLLING_S, SHORT_CYCLES, SHORT_SPAN_S,
@@ -186,7 +182,7 @@ def _load_latch(data, now=None):
class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
StatusMixin, TasksMixin, CarMixin):
StatusMixin, TasksMixin):
def __init__(self, opts: dict, hass: HomeAssistant, store, mqtt_pub, *, stop,
peak_db_path: str = "/data/tariff.db",
price_history_path: str = "/data/price_history.json",
@@ -509,10 +505,6 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
self._land_batt_prev = None
self._peak_needed = False
self._maint_shape_suspended = False
self._maint_peak_hold = False # MAINT-28
self._m28_step = {} # MAINT-28: unit -> (command, step at)
self._m28_hi = {} # MAINT-28: unit -> (period, cap)
self._m28_site = (None, 0.0) # MAINT-28: (period, site cap)
# OPT-11: battery modes, off by default (SAFETY-10 section 1). Each
# battery's mode and on/off switch live in the store, not in options,
# so a change applies at once (`pack_use`, `pack_mode`).
@@ -568,19 +560,6 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
self._charge_latch = _load_latch(
(getattr(store, "data", None) or {}).get(CHARGE_LATCH_KEY),
datetime.now(timezone.utc))
# EV-03: the car charger, READ ONLY. Off builds `UnavailableCharger`,
# which reads nothing, so a site without a charger is unchanged.
self.charger = chargers.build(opts)
self.charger.bind_getter(lambda: self.hass)
self.car = chargers.CarTracker(
stale_s=float(opts.get("stale_input_s", 15) or 15))
self.car.load((getattr(store, "data", None) or {}).get("car_today"))
self.charger_refused = None
self._charger_probed = False
self._car_down_logged = False
self._car_announced = False
# EV-04: Manual mode's state (runtime, in the store) and its writer.
self.car_init(opts, store)
self.house_profile = None
if self.fc_entity is not None:
self.house_profile = dayplan.HouseProfile(
@@ -1041,7 +1020,6 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
_LOG.info(handback.log_shutdown(handback.current())
or "shutting down - commanding 0 W on every inverter")
await self.command_site_release()
await self.car_shutdown() # EV-04: undo a phase change half way
self.mqtt.close()
@@ -1068,23 +1046,6 @@ def mode_announcement(opts, store) -> tuple:
return modes, retract
def car_announcement(opts, store) -> tuple:
"""EV-04: `(car, retract)` for the MQTT publisher at start-up: the three car
entities while a charger is switched on, and the config topics to remove
when it is not (`mqtt.car_configs()`). A site that never had a charger gets
nothing and its store is not written."""
car = None
if chargers.census_entity(opts):
amps = chargers.max_a(opts)
car = (chargers.EV_OPTION_DEFAULTS["ev_max_a"] if amps is None
else amps, carmode.allowed_phases(opts))
stored = store.data.get(CAR_CONFIGS_KEY)
keep, retract = car_configs(car, stored)
if keep and keep != stored:
store.set(CAR_CONFIGS_KEY, keep)
return car, retract
def control_task_done(task: asyncio.Task, *, controller, stop: asyncio.Event,
died: list) -> None:
"""Done-callback on the control task: log its death now and wake amain()
@@ -1254,7 +1215,6 @@ async def amain() -> None:
# OPT-11 P2: each battery's switch and mode list, only while
# battery modes are on (`mode_announcement()`).
_modes, _retract = mode_announcement(opts, store)
_car, _car_retract = car_announcement(opts, store)
broker = await hass.mqtt_service()
pub = MqttPublisher(
broker.get("host") if broker else None,
@@ -1274,8 +1234,6 @@ async def amain() -> None:
units=roster_names(opts),
modes=_modes,
retract=_retract,
car=_car,
car_retract=_car_retract,
)
except Exception as err: # noqa: BLE001
_LOG.warning("MQTT unavailable (%s) - continuing without status entities", err)
-139
View File
@@ -186,10 +186,6 @@ T_OUTPUT_CLAMP_NL = "Vermogensvraag te hoog"
T_PEAK_SATURATED_NL = "Belasting te hoog voor de batterij"
T_METER_FROZEN_NL = "Meter staat mogelijk vast"
TITLE_NL = {T_LOOP_BOUND: T_LOOP_BOUND_NL, T_OUTPUT_CLAMP: T_OUTPUT_CLAMP_NL}
T_CHARGER_UNREACH = "Charger not reachable"
T_CHARGER_UNREACH_NL = "Laadpaal onbereikbaar"
T_CAR_OVER = "Car over the peak limit"
T_CAR_OVER_NL = "Auto boven de piekgrens"
T_NO_PRICES = "No prices"
T_NO_PRICES_NL = "Prijzen ontbreken"
@@ -202,8 +198,6 @@ ID_NOT_DELIVERING = "goodwe_not_delivering_{slug}"
ID_METER_FROZEN = "goodwe_meter_frozen"
ID_MAINT_FAILED = "goodwe_maint_failed_{slug}"
ID_NO_PRICES = "goodwe_no_prices"
ID_CHARGER_UNREACH = "goodwe_charger_unreachable"
ID_CAR_OVER = "goodwe_car_over"
# PRICE-01: an earlier build raised a card with this id. Nothing raises it now;
# the add-on only dismisses it at start.
OLD_FIXED_CARD_ID = "goodwe_fixed_tariff_unused"
@@ -471,98 +465,6 @@ def row_no_prices(since=None, now=None) -> str:
"Nog geen prijzen, onderhoud wacht.")
def charger_unreachable(since_text_, brand="Alfen") -> Notice:
"""EV-03: the car charger has not answered for 5 minutes. Said once."""
en = (f"The add-on cannot reach the car charger since {since_text_}, so "
f"check the {brand} integration in Home Assistant.")
nl = (f"De add-on kan de laadpaal niet bereiken sinds {since_text_}, dus "
f"controleer de {brand}-integratie in Home Assistant.")
return Notice(ID_CHARGER_UNREACH, WARNING, T_CHARGER_UNREACH, en,
body_nl=f"{T_CHARGER_UNREACH_NL}. {nl}")
def charger_back() -> Dismiss:
"""EV-03: takes the 'Charger not reachable' notification down."""
return Dismiss(ID_CHARGER_UNREACH)
def row_charger_unreach(since_text_) -> str:
"""EV-03: the amber row while the charger does not answer."""
return Bi(f"The add-on cannot reach the charger since {since_text_}.",
f"De add-on kan de laadpaal niet bereiken sinds {since_text_}.")
def row_charger_writer() -> str:
"""EV-03: the grey row while something else sets the charger's current."""
return Bi("Something else changes the charger, and this add-on only reads "
"it.",
"Iets anders wijzigt de laadpaal en deze add-on leest alleen.")
def car_over(a_text) -> Notice:
"""EV-04: a charge the user set takes the 15-minute period over the peak
limit, and the batteries cannot hold it. Grey, once per charging session.
Not an alarm: the car is never throttled, the user asked for it."""
en = (f"You set {a_text} A, which takes this 15-minute period over the "
"peak limit.")
nl = f"U stelde {a_text} A in, wat dit kwartier boven de piekgrens brengt."
return Notice(ID_CAR_OVER, INFO, T_CAR_OVER, en,
body_nl=f"{T_CAR_OVER_NL}. {nl}")
def row_car_over() -> str:
"""EV-04: the grey row while the car charge you set is over the peak limit."""
return Bi("The car charge you set takes this 15-minute period over the "
"peak limit.",
"De autolading die u instelde brengt dit kwartier boven de "
"piekgrens.")
def row_charger_other() -> str:
"""EV-04: the grey row, in Manual, while something else sets the current."""
return Bi("Something else changes the charger, so the add-on writes "
"nothing until you change it.",
"Iets anders wijzigt de laadpaal, dus de add-on schrijft niets "
"tot u iets wijzigt.")
def row_charger_stuck() -> str:
"""EV-04: the amber row when the charger's reading does not move."""
return Bi("The charger reading may be stuck, so check the charger.",
"De meting van de laadpaal staat mogelijk vast, dus controleer "
"de laadpaal.")
def row_charger_refused() -> str:
"""EV-04: the amber row when the charger does not take the setting."""
return Bi("The charger did not take the setting, so check the charger.",
"De laadpaal nam de instelling niet over, dus controleer de "
"laadpaal.")
def row_charger_phases() -> str:
"""EV-04: the amber row when the charger does not take the phases."""
return Bi("The charger did not take the phases, so check the charger.",
"De laadpaal nam de fasen niet over, dus controleer de "
"laadpaal.")
def row_charger_error(text) -> str:
"""EV-04: the grey row while the charger reports an error. Writes go on."""
t = " ".join(str(text or "").split())[:60]
return Bi(f"The charger reports an error: {t}.",
f"De laadpaal meldt een fout: {t}.")
def row_charger_setup() -> str:
"""EV-03: the amber row when the charger's entities are not found."""
return Bi("The add-on cannot find the charger, so check its entity in "
"Settings.",
"De add-on vindt de laadpaal niet, dus controleer de entiteit "
"bij Instellingen.")
def row_maint_waits(until_text: str) -> str:
"""MAINT-13: the status row while a failed cycle waits."""
return Bi(f"Waits until {until_text} after a cycle that did not finish.",
@@ -1481,9 +1383,6 @@ def why_waiting(missing_s) -> str:
HINTS = {
"control_started": "Control started",
"control_stopped": "Control stopped",
"car_mode": "Car mode set",
"car_current": "Car current set",
"car_phases": "Car phases set",
"settings_saved": "Settings saved, they apply after a restart",
"restart_requested": "Restart requested from the settings page",
"setup_only": "In setup, nothing is sent to any inverter",
@@ -1572,20 +1471,6 @@ def pack_refused(why: str) -> str:
return PACK_REFUSED[why]
# EV-04: why a car mode, current or phases change was refused (the page and
# Home Assistant show it).
CAR_REFUSED = {
"off": "The car charger is not set up.",
"value": "That choice is not possible for the car charger.",
"phases": "The charger limit allows only one number of phases.",
"topic": "That is not a car command.",
}
def car_refused(why: str) -> str:
return CAR_REFUSED[why]
# MAINT-11: why a start or stop of ONE battery's cycle was refused. `{unit}` is
# the battery the sentence is about (for "busy", the one that is cycling). The
# page shows the same sentences in Dutch from app/ui_text, keyed by the code.
@@ -1776,15 +1661,6 @@ def status_samples() -> list:
("row_no_prices", AMBER, row_no_prices(*_SINCE_SAMPLE)),
("row_no_prices", AMBER, row_no_prices(*_SINCE_OLDER)),
("row_no_prices", AMBER, row_no_prices()),
("row_charger_unreach", AMBER, row_charger_unreach("09:12")),
("row_charger_writer", GREEN, row_charger_writer()),
("row_car_over", GREEN, row_car_over()),
("row_charger_other", GREEN, row_charger_other()),
("row_charger_error", GREEN, row_charger_error("Socket error")),
("row_charger_stuck", AMBER, row_charger_stuck()),
("row_charger_refused", AMBER, row_charger_refused()),
("row_charger_phases", AMBER, row_charger_phases()),
("row_charger_setup", AMBER, row_charger_setup()),
]
@@ -1820,8 +1696,6 @@ def samples() -> list:
no_prices(*_SINCE_SAMPLE),
no_prices(*_SINCE_OLDER),
no_prices(),
charger_unreachable("09:12"),
car_over("16"),
]
@@ -1884,13 +1758,6 @@ LABELS = {
"solar_trust_pct": "Trust in the forecast",
"p1_phase_import_entities": "Import entities per phase",
"p1_phase_export_entities": "Export entities per phase",
# EV-03
"ev_charger": "Charger",
"ev_current_entity": "Current setting entity",
"ev_max_a": "Charger limit",
"ev_batt_cover": "Batteries help with the peak",
"ev_mode_start": "Mode after a restart",
"ev_phases": "Phases",
}
@@ -1971,12 +1838,6 @@ LABELS_NL = {
"solar_trust_pct": "Vertrouwen in de prognose",
"p1_phase_import_entities": "Afname-entiteiten per fase",
"p1_phase_export_entities": "Injectie-entiteiten per fase",
"ev_charger": "Laadpaal",
"ev_current_entity": "Entiteit van de laadstroom",
"ev_max_a": "Laadpaalgrens",
"ev_batt_cover": "Batterijen helpen met de piek",
"ev_mode_start": "Modus na een herstart",
"ev_phases": "Fasen",
}
# The inverter list shows two of them under a shorter name.
UNIT_LABELS_NL = {"setpoint_entity": "Setpoint-entiteit",
+5 -118
View File
@@ -139,11 +139,6 @@ SENSORS = [
# a charge-power limit, or the optimiser declining to charge.
OPTIONAL_SENSORS = [
("pv", "goodwe_pv_power", "PV power", "W", "power", "measurement", None),
# EV-03: only with a car charger switched on. Read only: there are no
# command entities in this version.
("car_power", "goodwe_car_power", "Car power", "W", "power", "measurement", "mdi:car-electric"),
("car_state", "goodwe_car_state", "Car state", None, None, None, "mdi:ev-station"),
("car_today_kwh", "goodwe_car_today_kwh", "Car energy today", "kWh", "energy", "total_increasing", "mdi:ev-station"),
]
# ⚠️ HA's OWN "this sensor has no value" PAYLOAD, and the one place this add-on
@@ -197,11 +192,7 @@ def optional_keys(opts: dict) -> tuple:
# `_load()` is the same decision for the same kind of reason. Measured, not
# assumed: move this line to module scope and test_mqtt.py part 8 dies.
from . import pv as _pv
from . import chargers as _ch # EV-03: same reason
out = ("pv",) if _pv.entities(opts) else ()
if _ch.census_entity(opts):
out += ("car_power", "car_state", "car_today_kwh")
return out
return ("pv",) if _pv.entities(opts) else ()
BASE = "goodwe_ctl"
@@ -405,7 +396,7 @@ def _unit_places(names):
yield slug, device, prefix
def discovery_payloads(units=(), omit=(), include=(), modes=(), car=None) -> list:
def discovery_payloads(units=(), omit=(), include=(), modes=()) -> list:
"""Every `(topic, payload)` this add-on announces, in announcement order.
Split out of `_announce()` so that the acceptance criterion can be graded as
@@ -421,8 +412,6 @@ def discovery_payloads(units=(), omit=(), include=(), modes=(), car=None) -> lis
re-announces every entity on a live install).
`modes` (OPT-11 P2) is the battery modes offered, empty when they are off.
`car` (EV-04) is None, or `(max_a, phases)`: the car's three command
entities, announced after everything else so no existing row moves.
"""
omit = set(omit)
include = [k for k in include if k not in omit]
@@ -454,7 +443,6 @@ def discovery_payloads(units=(), omit=(), include=(), modes=(), car=None) -> lis
DEVICE, unit, dev_class, state_class, icon)))
# OPT-11 P2: last, and only when battery modes are on.
out.extend(mode_payloads(units, modes))
out.extend(car_payloads(car))
return out
@@ -521,101 +509,6 @@ def mode_payloads(units, modes) -> list:
return out
# --- EV-04: the car's mode, current and phases, as HA entities ----------------
# Announced only with a charger switched on, after every other row. A command
# goes through Controller.handle_action(); a retained one is dropped.
CAR_MODE_LABELS = {"off": "Off", "manual": "Manual"} # English, pinned
CAR_MODES = tuple(CAR_MODE_LABELS)
CAR_CONFIGS_KEY = "mqtt_car_configs"
CAR_MIN_A = 6
_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases)/set")
_CAR_CONFIG_RE = re.compile(
rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases)/config")
# (key, component, name, icon)
CAR_ENTITIES = [
("mode", "select", "Car mode", "mdi:car-electric"),
("current", "number", "Car current", "mdi:current-ac"),
("phases", "select", "Car phases", "mdi:sine-wave"),
]
def car_payloads(car) -> list:
"""The `(topic, payload)` for `select.goodwe_car_mode`,
`number.goodwe_car_current` and `select.goodwe_car_phases`. `car` is
`(max_a, phases)`; empty when it is None."""
if not car:
return []
max_a, phases = car
out = []
for key, component, name, icon in CAR_ENTITIES:
unique_id = f"{BASE}_car_{key}"
cfg = {
"name": name,
"object_id": f"goodwe_car_{key}",
"unique_id": unique_id,
"state_topic": f"{BASE}/car_{key}",
"command_topic": f"{BASE}/car/{key}/set",
}
if key == "mode":
cfg["options"] = list(CAR_MODE_LABELS.values())
elif key == "phases":
cfg["options"] = [str(n) for n in phases]
else:
cfg.update({"min": CAR_MIN_A, "max": int(max_a), "step": 1,
"unit_of_measurement": "A", "device_class": "current",
"mode": "box"})
cfg.update({"retain": False, "availability_topic": AVAILABILITY,
"device": DEVICE, "icon": icon})
out.append((f"homeassistant/{component}/{unique_id}/config", cfg))
return out
def car_configs(car, stored) -> tuple:
"""`(keep, retract)` at start-up, as `mode_configs()` does for the battery
modes: turning the charger off removes exactly the entities announced
before, and a site that never had one publishes nothing."""
current = [t for t, _ in car_payloads(car)]
old = [t for t in (stored if isinstance(stored, list) else [])
if isinstance(t, str) and _CAR_CONFIG_RE.fullmatch(t)
and t not in current]
old = list(dict.fromkeys(old))
return current + old, old
def parse_car_command(topic, payload, retained):
"""`(action, value, reject)` for one message on a car command topic.
`action` is `car_mode`, `car_current` or `car_phases`. A value that is
none of the entity's own is None (the action then refuses it)."""
m = _CAR_CMD_RE.fullmatch(topic) if isinstance(topic, str) else None
if m is None:
return None, None, "topic"
key = m.group(1)
action = f"car_{key}"
if bool(retained):
return action, None, "retained"
if not isinstance(payload, (bytes, bytearray)):
return action, None, "size"
if MAX_COMMAND_BYTES < len(payload):
return action, None, "size"
try:
text = bytes(payload).decode(encoding="utf-8").strip()
except ValueError: # UnicodeDecodeError is one
return action, None, "encoding"
value = None
if key == "mode":
value = next((k for k, v in CAR_MODE_LABELS.items() if v == text),
None)
elif key == "phases":
value = {"1": 1, "3": 3}.get(text)
else:
try:
f = float(text)
value = f if f == f and abs(f) < 1000 else None
except ValueError:
value = None
return action, value, None
def mode_retractions(stored, current) -> list:
"""Config topics announced before and not now: each gets an empty
retained config, which removes the entity from HA. Anything in the store
@@ -672,13 +565,11 @@ class MqttPublisher:
# test fixture that builds one with __new__) behaves as before.
modes = ()
retract = ()
car = None # EV-04: `(max_a, phases)` when the charger is on
_loop = None
_handler = None
def __init__(self, host, port, username=None, password=None, omit=(),
units=(), include=(), modes=(), retract=(), car=None,
car_retract=()):
units=(), include=(), modes=(), retract=()):
# `omit` drops sensor keys from discovery entirely. ⚠️ Announcing a
# sensor that nothing will ever publish to is not harmless here:
# p1_sample_age_s is a watchdog input, and an entity that exists but is
@@ -697,8 +588,7 @@ class MqttPublisher:
# OPT-11 P2: the modes offered (empty when battery modes are off), and
# the mode config topics to remove (`mode_retractions()`).
self.modes = tuple(modes)
self.retract = [str(t) for t in retract] + [str(t) for t in car_retract]
self.car = tuple(car) if car else None
self.retract = [str(t) for t in retract]
self.enabled = mqtt is not None and bool(host)
self.client = None
if not self.enabled:
@@ -737,8 +627,7 @@ class MqttPublisher:
# diffing what actually goes on the wire - and a payload built here
# instead would be one this add-on publishes and no check has ever seen.
for topic, cfg in discovery_payloads(self.units, self.omit,
self.include, self.modes,
self.car):
self.include, self.modes):
self.client.publish(topic, json.dumps(cfg), retain=True)
for topic in self.retract:
self.client.publish(topic, "", retain=True)
@@ -749,8 +638,6 @@ class MqttPublisher:
if self.modes:
for key in ("mode", "use"):
self.client.subscribe(f"{BASE}/unit/+/{key}/set")
if self.car:
self.client.subscribe(f"{BASE}/car/+/set")
def bind(self, loop, handler) -> None:
"""OPT-11 P2: hand each command to `handler(topic, payload, retained)`,
-23
View File
@@ -28,10 +28,6 @@ FLOOR_AT_SOC_FLOOR = "the battery level is at or below the peak reserve"
SOURCE = "peak"
# MAINT-28. Watts the house must sit under the aim before a paused maintenance
# charge resumes. DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md.
MAINT_RESUME_UNDER_W = 300.0
# Mirror of config.yaml's peak options, pinned to the file by
# test_peakguard.py. Not a read: `decide()` takes them as arguments.
PEAK_OPTION_DEFAULTS = {
@@ -450,25 +446,6 @@ def shaping_suspended(decision, peak_forecast_w, cap_w) -> bool:
return decision is not None and decision.engaged
def shaping_held(suspended, held, peak_forecast_w, aim_w, house_w,
settled=True) -> bool:
"""MAINT-28. `suspended` (`shaping_suspended()`'s answer), kept on while
`held` until the house is `MAINT_RESUME_UNDER_W` under `aim_w`
(`peak_forecast_w` stands in for an unread house; neither read: not held,
as SAFETY-63) and `settled` (no battery reading older than its last
command step, so `house_w` is not a new grid plus an old battery). Only
ever pauses the maintenance charge, never a cut-back.
DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md."""
if suspended:
return True
if not held:
return False
level = house_w if house_w is not None else peak_forecast_w
if level is None:
return False
return level > float(aim_w) - MAINT_RESUME_UNDER_W or not settled
def cap_floor(decision, cap_w):
"""SAFETY-128: the floor no higher than `cap_w` (the command standing while
the readings have not answered it), or `decision` unchanged when None.
+1 -13
View File
@@ -82,7 +82,7 @@ import os
import aiohttp
from . import chargers, messages
from . import messages
from .configui import changed_keys
from .inverter import build_roster
from .validate import validate_startup_config, validate_unit_ranges
@@ -362,18 +362,6 @@ async def problems_and_ranges(opts: dict, hass=None, notes=None):
unread = [unit.driver.actuator_id() for unit in units
if unit.driver.configured() and unit.dev_min is None
and unit.dev_max is None]
# EV-03: the charger limit may not exceed the station limit the charger
# reports. A read only; a charger that does not answer skips the check.
if hass is not None and chargers.mode_of(opts) != chargers.OFF:
drv = chargers.build(opts)
if drv.configured():
_lo, station, _ph = await drv.bind(hass).limits()
amps = chargers.max_a(opts)
if station is not None and amps is not None and amps > station:
problems.append(
f"{messages.setting('ev_max_a')} is {amps:.0f} A, but the "
f"charger allows at most {station:.0f} A. Lower it to "
f"{station:.0f} A or less.")
return problems, unread
-5
View File
@@ -272,8 +272,3 @@ table.fct th,table.fct td{padding:4px 3px;text-align:right;border-bottom:1px sol
table.fct th:first-child,table.fct td:first-child{text-align:left}
table.fct th{color:var(--muted);font-weight:600}
.ymax{position:absolute;top:-2px;left:2px;font-size:10px;color:var(--faint);pointer-events:none}
/* EV-03: the Car card */
.car-big{font-size:20px;font-weight:700;line-height:1.3;margin:8px 0 2px;font-variant-numeric:tabular-nums}
.car-lab{margin:12px 0 4px;color:var(--muted)}
.car-why{display:grid;grid-template-columns:auto 1fr;gap:10px;margin-top:12px}
+1 -58
View File
@@ -113,8 +113,7 @@
const setup = S.setup_only === true;
banner($("#home-banner"), S.level, setup ? t("setup_only.name") : S.banner, structured ? S.state.sub : setup ? t("setup_only.description") : "", S.level === "bad" ? "alert" : null);
["#c-now", "#c-plan", "#c-peak", "#c-attn"].forEach((id) => { $(id).hidden = !structured; });
if (structured) { renderNow(); renderCar(); renderPlan(); renderPeak(); renderAttention(); }
else $("#c-car").hidden = true;
if (structured) { renderNow(); renderPlan(); renderPeak(); renderAttention(); }
renderControl(structured, setup);
renderDetails(!structured && !setup);
renderBatteries(force);
@@ -146,60 +145,6 @@
h("div", { class: "small muted", style: "grid-column:1/-1" }, b.now))));
}
/* ---------------- Home: the car (read only) ---------------- */
function renderCar() {
const c = S.car;
$("#c-car").hidden = !c;
if (!c) return;
const chip = $("#car-chip");
chip.textContent = c.chip;
chip.className = "chip" + (c.kind === "warn" ? " rs" : c.kind === "ok" ? " now" : "");
$("#car-big").textContent = c.big;
$("#car-today").textContent = c.today || "";
$("#car-today").hidden = !c.today;
$("#car-why").textContent = c.why;
renderCarControls(c);
}
// EV-04: Off and Manual. The mode and the phases send at once; the current
// sends after two seconds of rest. A slider being dragged is left alone.
let carTouch = 0, carTimer = null, carBusy = false;
async function carAct(what, value) {
if (carBusy) return;
carBusy = true;
try {
const r = await fetch("action", { method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ action: what, value: value }) });
const j = await r.json().catch(() => ({}));
if (!r.ok) toast(j.error || t("toast.failed"));
} catch (e) { toast(t("toast.failed")); }
finally { carBusy = false; }
await refresh(true);
}
function renderCarControls(c) {
const modes = c.modes || [];
$("#car-mode").hidden = !modes.length;
$("#car-mode").replaceChildren(...modes.map((m) => h("button", {
type: "button", role: "radio", "aria-checked": String(c.mode === m),
onclick: () => carAct("car_mode", m) }, t("car.mode_" + m))));
$("#car-help").textContent = t("car.help_" + c.mode + ".description") || "";
const on = c.mode === "manual" && !!c.current;
$("#car-manual").hidden = !on;
if (!on) return;
const a = $("#car-a");
if (Date.now() - carTouch > 3000) {
a.min = c.current.min; a.max = c.current.max; a.value = c.current.value;
}
$("#car-a-out").textContent = a.value + " A";
a.oninput = () => {
carTouch = Date.now(); $("#car-a-out").textContent = a.value + " A";
clearTimeout(carTimer);
carTimer = setTimeout(() => carAct("car_current", Number(a.value)), 2000);
};
$("#car-phases").replaceChildren(...c.phases.choices.map((n) => h("button", {
type: "button", role: "radio", "aria-checked": String(c.phases.value === n),
onclick: () => carAct("car_phases", n) }, t("car.phases_" + n))));
}
/* ---------------- Home: today's plan ---------------- */
const LEGEND = [["cheap", "background:var(--cheap)"], ["dear", "background:repeating-linear-gradient(135deg,var(--dear) 0 3px,transparent 3px 5px)"],
["grid", "background:var(--accent)"], ["give", "background:repeating-linear-gradient(135deg,var(--house) 0 3px,transparent 3px 5px)"],
@@ -328,8 +273,6 @@
bar.className = pct >= 100 ? "bad" : pct >= 80 ? "warn" : "";
$("#peak-meter").setAttribute("aria-label", t("peak.this_month") + " " + (m.pct == null ? "–" : Math.round(m.pct) + " %"));
$("#peak-line").textContent = m.line;
$("#peak-car").textContent = m.car_line || ""; $("#peak-car").hidden = !m.car_line;
$("#peak-setby").textContent = m.set_by || ""; $("#peak-setby").hidden = !m.set_by;
}
function renderAttention() {
const list = S.attention;
-18
View File
@@ -39,22 +39,6 @@
<div id="home-batts" style="margin-top:6px"></div>
</div>
<div class="card" id="c-car" hidden>
<div class="row spread"><h2 data-t="car.name"></h2><span class="chip" id="car-chip"></span></div>
<div class="car-big" id="car-big"></div>
<div class="small muted" id="car-today"></div>
<div class="small car-lab" data-t="car.mode"></div>
<div class="seg" role="radiogroup" id="car-mode" data-t-label="car.mode"></div>
<p class="tiny muted" style="margin:6px 0 0" id="car-help"></p>
<div id="car-manual" hidden>
<div class="small car-lab" data-t="car.current"></div>
<div class="slider"><input type="range" id="car-a" min="6" max="16" step="1" data-t-label="car.current"><output class="small" id="car-a-out"></output></div>
<div class="small car-lab" data-t="car.phases"></div>
<div class="seg" role="radiogroup" id="car-phases" data-t-label="car.phases"></div>
</div>
<div class="car-why small"><span class="muted" data-t="car.why"></span><span id="car-why"></span></div>
</div>
<div class="card" id="c-plan">
<div class="row spread"><h2 data-t="plan.name"></h2><span class="chip tiny muted" id="verdict"></span></div>
<div class="small" id="plan-head"></div>
@@ -77,8 +61,6 @@
<div class="row spread small" id="peak-figures"><span><span data-t="peak.this_month"></span>: <strong id="peak-now"></strong></span><span class="muted"><span data-t="peak.limit"></span> <span id="peak-limit"></span></span></div>
<div class="meter" id="peak-meter" role="img"><i style="width:0%"></i></div>
<div class="tiny muted" id="peak-line"></div>
<div class="tiny muted" id="peak-car" hidden></div>
<div class="tiny muted" id="peak-setby" hidden></div>
</div>
<div class="card" id="c-attn">
-49
View File
@@ -4,7 +4,6 @@
"inverters": {"name": "Inverters and batteries", "description": "The inverters the add-on controls, and your solar."},
"tariff": {"name": "Tariff and prices", "description": "What you pay and are paid per kWh."},
"safety": {"name": "Safety limits", "description": "The peak limit, starting and stopping, and the safety stops."},
"car": {"name": "Car charger", "description": "Which charger the add-on drives, its limits and the mode defaults."},
"maintenance": {"name": "Maintenance", "description": "The monthly battery cycle and the log."},
"tuning": {"name": "Control tuning", "description": "For support only, because these were measured on real hardware."}
},
@@ -34,9 +33,6 @@
"fallback": {"none": "None", "fixed": "One price", "daynight": "Day and night", "custom": "Other time windows"},
"region": {"flanders": "Flanders, Fluvius Antwerpen", "own": "I enter my own figure"},
"meter_source": {"off": "One grid power entity", "ha_dsmr": "Import and export entities", "mqtt_p1": "Meter over MQTT", "ha_signed": "One net power entity", "homewizard_local": "HomeWizard meter on the network"},
"ev_charger": {"off": "None", "alfen_ha": "Alfen (Home Assistant integration)"},
"ev_phases": {"1": "1 phase", "3": "3 phases", "auto": "1 and 3"},
"ev_mode_start": {"keep": "Keep the last mode", "off": "Off"},
"meter_phases": {"1": "1 phase", "3": "3 phases"},
"shadow_mode": {"auto": "Automatic", "on": "Always on", "off": "Off"},
"price_provider": {"generic_dayahead": "Day-ahead market price", "custom_formula": "Your own price formula", "manual_csv": "A price file", "price_service": "Your own price service"},
@@ -91,7 +87,6 @@
"loading": "Loading the forecast."
},
"peak": {"name": "Peak limit", "this_month": "This month's peak", "limit": "Limit", "none": "None recorded yet", "unreadable": "Cannot be read now"},
"car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "mode_manual": "Manual", "help_off": {"description": "The add-on leaves the charger alone."}, "help_manual": {"description": "Charges at the current you set, whatever the sun or the peak limit do."}, "current": "Current", "phases": "Phases", "phases_1": "1 phase", "phases_3": "3 phases", "why": "Why"},
"attention": {"name": "Needs attention", "nothing": "Nothing to look at", "to_look": "to look at", "details": "Details", "alarm": "Alarm", "warning": "Warning", "info": "Info"},
"control": {"name": "Control", "stop": "Stop control", "start": "Start control", "maint_start": "Start a battery cycle now", "maint_abort": "Stop the battery cycle", "docs": "Add-on documentation", "more": "More actions"},
"details": {"name": "Details for installers", "rows": "Status rows", "checks": "Checks", "event": "Last event"},
@@ -301,41 +296,6 @@
"waiting": "Control resumes by itself when Home Assistant answers.",
"warning": "See Needs attention below."
},
"car": {
"state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "fault": "Charger fault", "wait": "No reading yet"},
"big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "fault": "The charger reports a fault.", "wait": "No reading yet."},
"phase_one": "1 phase",
"phase_many": "{n} phases",
"today": "{kwh} charged today.",
"why": {
"charging": "The charger is charging the car. The add-on leaves it alone.",
"waiting": "The car is connected and not charging. The add-on leaves the charger alone.",
"none": "No car is connected.",
"full": "The car stopped charging by itself.",
"unreach_a": "The charger keeps its last setting, {a} A. Check the {brand} integration in Home Assistant.",
"unreach_unit": "The charger's power is in a unit the add-on cannot use. Check it in Home Assistant.",
"unreach": "The add-on cannot read the charger. Check the {brand} integration in Home Assistant.",
"not_found": "The add-on cannot find the charger. Check the current setting entity in Settings.",
"unit": "The charger power has no power unit. Check the charger in Settings.",
"limit": "The charger limit is above what the charger allows. Lower it in Settings.",
"name": "The current setting entity does not fit the charger. Check it in Settings.",
"fault": "The charger reports a fault. Check it at the charger itself.",
"wait": "Waiting for the first reading.",
"manual_set": "You set {a} A, {phases}. The charger keeps it, whatever the peak limit does.",
"manual_cover": "You set {a} A. The batteries give {kw} and help down to {pct}.",
"manual_over": "You set {a} A. The batteries are at {pct}, so this charge sets the peak.",
"manual_full": "You set {a} A. The batteries give all they can, so this charge sets the peak.",
"manual_nocover": "You set {a} A. The guard ignores the car, so this charge can set the peak.",
"manual_wait": "You set {a} A. It is set when a car is connected.",
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
"manual_blocked": "The phases change once per 10 minutes at most. This waits."
}
},
"peak": {
"car": "This 15-minute period is heading for {kw}. The car takes {car} and the batteries cover {cov}.",
"set_by_car": "Set by the car charge you asked for, at {t}."
},
"tile": {
"not_set_up": "Not set up",
"no_reading": "No reading",
@@ -539,15 +499,6 @@
"estop": "Emergency stop",
"pv": "Solar reading",
"solar_forecast": "Solar forecast",
"charger": "Charger not reachable",
"charger_writer": "Something else changes the charger",
"charger_other": "Something else changes the charger",
"charger_phases": "Charger did not take phases",
"charger_stuck": "Charger reading may be stuck",
"charger_refused": "Charger did not take it",
"charger_error": "The charger reports an error",
"car_over": "Car over the peak limit",
"charger_setup": "Charger not set up",
"none": "Inverter connection"
},
"months": ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
-49
View File
@@ -4,7 +4,6 @@
"inverters": {"name": "Omvormers en batterijen", "description": "De omvormers die de add-on regelt, en uw zonnepanelen."},
"tariff": {"name": "Tarief en prijzen", "description": "Wat u per kWh betaalt en terugkrijgt."},
"safety": {"name": "Veiligheidsgrenzen", "description": "De piekgrens, starten en stoppen, en de veiligheidsstops."},
"car": {"name": "Laadpaal", "description": "Welke laadpaal de add-on stuurt, haar grenzen en de standaardmodus."},
"maintenance": {"name": "Onderhoud", "description": "De maandelijkse batterijcyclus en het logboek."},
"tuning": {"name": "Afstelling van de regeling", "description": "Alleen voor support, want deze zijn gemeten op echte hardware."}
},
@@ -34,9 +33,6 @@
"fallback": {"none": "Geen", "fixed": "Eén prijs", "daynight": "Dag en nacht", "custom": "Andere tijdvakken"},
"region": {"flanders": "Vlaanderen, Fluvius Antwerpen", "own": "Ik vul zelf een bedrag in"},
"meter_source": {"off": "Eén entiteit voor netvermogen", "ha_dsmr": "Entiteiten voor afname en injectie", "mqtt_p1": "Meter via MQTT", "ha_signed": "Eén entiteit voor nettovermogen", "homewizard_local": "HomeWizard-meter op het netwerk"},
"ev_charger": {"off": "Geen", "alfen_ha": "Alfen (Home Assistant-integratie)"},
"ev_phases": {"1": "1 fase", "3": "3 fasen", "auto": "1 en 3"},
"ev_mode_start": {"keep": "Laatste modus houden", "off": "Uit"},
"meter_phases": {"1": "1 fase", "3": "3 fasen"},
"shadow_mode": {"auto": "Automatisch", "on": "Altijd aan", "off": "Uit"},
"price_provider": {"generic_dayahead": "Day-aheadprijs van de markt", "custom_formula": "Uw eigen prijsformule", "manual_csv": "Een prijsbestand", "price_service": "Uw eigen prijsdienst"},
@@ -88,7 +84,6 @@
"loading": "De prognose wordt geladen."
},
"peak": {"name": "Piekgrens", "this_month": "Piek van deze maand", "limit": "Grens", "none": "Nog niets gemeten", "unreadable": "Nu niet leesbaar"},
"car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "mode_manual": "Handmatig", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "help_manual": {"description": "Laadt met de stroom die u instelt, wat de zon of de piekgrens ook doen."}, "current": "Stroom", "phases": "Fasen", "phases_1": "1 fase", "phases_3": "3 fasen", "why": "Waarom"},
"attention": {"name": "Vraagt aandacht", "nothing": "Niets om na te kijken", "to_look": "na te kijken", "details": "Details", "alarm": "Alarm", "warning": "Waarschuwing", "info": "Info"},
"control": {"name": "Regeling", "stop": "Regeling stoppen", "start": "Regeling starten", "maint_start": "Nu een batterijcyclus starten", "maint_abort": "Batterijcyclus stoppen", "docs": "Documentatie van de add-on", "more": "Meer acties"},
"details": {"name": "Details voor installateurs", "rows": "Statusregels", "checks": "Controles", "event": "Laatste gebeurtenis"},
@@ -255,41 +250,6 @@
"verdict": {"held": "Op 0 W gehouden", "stopped": "Gestopt", "cycle": "Vandaag maandelijkse cyclus", "trade": "Handelt op prijs", "house": "Volgt het huis"},
"pill": {"running": "Actief", "shadow": "Schaduwmodus", "stopped": "Gestopt", "alarm": "Heeft u nu nodig", "waiting": "Wacht op Home Assistant", "warning": "Actief, met een waarschuwing"},
"banner_sub": {"running": "De batterijen volgen het plan hieronder.", "shadow": "De plannen hieronder tonen wat de add-on zou doen.", "stopped": "Start de regeling hieronder als u klaar bent.", "alarm": "Zie Vraagt aandacht hieronder voor wat u moet doen.", "waiting": "De regeling gaat vanzelf verder zodra Home Assistant antwoordt.", "warning": "Zie Vraagt aandacht hieronder."},
"car": {
"state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "fault": "Laadpaalstoring", "wait": "Nog geen meting"},
"big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "fault": "De laadpaal meldt een storing.", "wait": "Nog geen meting."},
"phase_one": "1 fase",
"phase_many": "{n} fasen",
"today": "Vandaag {kwh} geladen.",
"why": {
"charging": "De laadpaal laadt de auto. De add-on laat haar met rust.",
"waiting": "De auto is aangesloten en laadt niet. De add-on laat de laadpaal met rust.",
"none": "Er is geen auto aangesloten.",
"full": "De auto is zelf gestopt met laden.",
"unreach_a": "De laadpaal houdt haar laatste instelling, {a} A. Controleer de {brand}-integratie in Home Assistant.",
"unreach_unit": "De laadpaal meldt vermogen in een onbruikbare eenheid. Controleer de eenheid in Home Assistant.",
"unreach": "De add-on kan de laadpaal niet lezen. Controleer de {brand}-integratie in Home Assistant.",
"not_found": "De add-on vindt de laadpaal niet. Controleer de entiteit van de laadstroom bij Instellingen.",
"unit": "Het vermogen van de laadpaal heeft geen vermogenseenheid. Controleer de laadpaal bij Instellingen.",
"limit": "De laadpaalgrens is hoger dan de laadpaal toestaat. Verlaag ze bij Instellingen.",
"name": "De entiteit van de laadstroom past niet bij de laadpaal. Controleer ze bij Instellingen.",
"fault": "De laadpaal meldt een storing. Controleer ze aan de laadpaal zelf.",
"wait": "Wacht op de eerste meting.",
"manual_set": "U stelde {a} A in, {phases}. De laadpaal houdt dit aan, wat de piekgrens ook doet.",
"manual_cover": "U stelde {a} A in. De batterijen leveren {kw} en helpen tot {pct}.",
"manual_over": "U stelde {a} A in. De batterijen staan op {pct}, dus deze lading bepaalt de piek.",
"manual_full": "U stelde {a} A in. De batterijen geven alles, dus deze lading bepaalt de piek.",
"manual_nocover": "U stelde {a} A in. De bewaking negeert de auto, dus deze lading kan de piek bepalen.",
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht."
}
},
"peak": {
"car": "Dit kwartier gaat richting {kw}. De auto neemt {car} en de batterijen dekken {cov}.",
"set_by_car": "Bepaald door de autolading die u vroeg, om {t}."
},
"tile": {"not_set_up": "Niet ingesteld", "no_reading": "Geen meting", "producing": "Produceert", "not_producing": "Produceert niet", "needs_solar": "Zonnemeting nodig", "not_adding_up": "Metingen kloppen niet", "using": "Verbruikt", "taking": "Neemt af van het net", "feeding": "Injecteert", "balanced": "In evenwicht", "giving": "Levert stroom", "charging": "Laadt", "resting": "Rust"},
"now": {
"no_reading": "Geen meting van deze batterij.",
@@ -460,15 +420,6 @@
"estop": "Noodstop",
"pv": "Meting van de zonnepanelen",
"solar_forecast": "Zonneprognose",
"charger": "Laadpaal onbereikbaar",
"charger_writer": "Iets anders wijzigt de laadpaal",
"charger_other": "Iets anders wijzigt de laadpaal",
"charger_phases": "Laadpaal nam fasen niet over",
"charger_stuck": "Laadpaalmeting staat mogelijk vast",
"charger_refused": "Laadpaal nam het niet over",
"charger_error": "De laadpaal meldt een fout",
"car_over": "Auto boven de piekgrens",
"charger_setup": "Laadpaal niet ingesteld",
"none": "Verbinding met de omvormer"
},
"months": ["januari", "februari", "maart", "april", "mei", "juni", "juli", "augustus", "september", "oktober", "november", "december"]
-14
View File
@@ -77,7 +77,6 @@ _MAINT = (("maintenance_enabled", "==", True),)
_ONE = (("inverter_count", "==", 1),)
_SEVERAL = (("inverter_count", ">", 1),)
_PHASES = (("meter_phases", ">", 1),)
_CAR = (("ev_charger", "!=", "off"),)
# One inverter stored flat has no name or capacity (uimodel._roster_encode).
_LISTED = (("inverter_shape", "!=", "flat"),)
@@ -223,19 +222,6 @@ GROUPS = (
Field("delivery_hold_s", LOCKED, "s", step=5, show=_SEVERAL),
), collapsed=True),
)),
# EV-03: the car charger. Everything after the choice shows only while a
# charger is switched on. EV-04 adds the battery switch and the restart mode.
Group("car", (
Part("", (
Field("ev_charger", CHOICE, simple=True),
Field("ev_current_entity", ENTITY, kind="number", simple=True,
show=_CAR),
Field("ev_max_a", SLIDER, "A", simple=True, show=_CAR),
Field("ev_phases", SEGMENTED, simple=True, show=_CAR),
Field("ev_batt_cover", TOGGLE, simple=True, show=_CAR),
Field("ev_mode_start", SEGMENTED, simple=True, show=_CAR),
)),
)),
Group("maintenance", (
Part("", (
Field("maintenance_enabled", TOGGLE),
+1 -140
View File
@@ -332,7 +332,7 @@ import math
import re
from typing import NamedTuple
from . import chargers, dayplan, messages, pv, solarfc
from . import dayplan, messages, pv, solarfc
from .arbitrage import enabled as arbitrage_on
from .control import SLEW_RAIL_FRAC, LOOP_TICK_S, PLANT_SETTLE_S
from . import drivers
@@ -667,34 +667,6 @@ def _labels(keys, joiner: str = "and") -> str:
return f" {joiner} ".join(S(k) for k in keys)
def _charger_problems(opts: dict, writers: dict) -> list[str]:
"""EV-03: the car charger options. A charger whose entities are missing is
refused at run time (the Car card says so), not here: it never stops the
add-on. What stops it is a setpoint that an inverter also writes."""
out: list[str] = []
raw = opts.get("ev_charger", chargers.OFF)
if raw not in (None, "") and str(raw).strip() not in chargers.SELECTABLE:
out.append(f"{S('ev_charger')} is {messages.shown(raw)}. Choose "
f"{', '.join(chargers.SELECTABLE)}.")
return out
if chargers.mode_of(opts) == chargers.OFF:
return out
ph = opts.get("ev_phases", chargers.EV_OPTION_DEFAULTS["ev_phases"])
if str(ph).strip() not in chargers.PHASES_CHOICES:
out.append(f"{S('ev_phases')} is {messages.shown(ph)}. Choose 1, 3 or "
"auto.")
amps = chargers.max_a(opts)
if amps is None or not chargers.MIN_A <= amps <= chargers.ENTITY_MAX_A:
out.append(f"{S('ev_max_a')} is {messages.shown(opts.get('ev_max_a'))}"
f". Set it from {chargers.MIN_A:.0f} to "
f"{chargers.ENTITY_MAX_A:.0f} A.")
entity = chargers.census_entity(opts)
if entity and drivers.census_key(entity) in writers:
out.append(f"{S('ev_current_entity')} is {entity}, which an inverter "
"also uses. Give the charger its own entity.")
return out
def _roster_problems(opts: dict) -> list[str]:
"""Rule 9 (CFG-04): the `inverters:` roster, refused where it cannot mean
what it says.
@@ -984,12 +956,6 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None,
f"{actuator}: {', '.join(who)}. Give each inverter its own "
"setpoint entity.")
# --- EV-03: the car charger's setpoint is a writer too ---------------------
# Counted in the census beside the inverters', and kept apart from
# `actuator_writers()` so setup-only mode still reads "no inverter". An
# inverter's entity named as the charger is two writers on one actuator.
problems.extend(_charger_problems(opts, writers))
# --- 9. CFG-04's roster, graded BEFORE anything reads a per-unit number --
# ⚠️ FIRST, THOUGH IT IS THE NEWEST RULE. Rules 5 and 6 below now ask the
# roster what one unit may be commanded, so a roster that is nonsense has to
@@ -1955,7 +1921,6 @@ def config_notes(opts: dict, *, entities: dict | None = None,
notes: list[Note] = []
if entities is not None:
_entity_notes(notes, opts, entities)
_charger_notes(notes, opts, entities)
cap = _number(opts, "peak_cap_w", None)
if month_peak_w is not None and cap is not None and cap < month_peak_w:
_advise(notes, "warn", ("peak_cap_w",),
@@ -1967,110 +1932,6 @@ def config_notes(opts: dict, *, entities: dict | None = None,
return notes
def charger_probe_rows(opts: dict, entities: dict | None) -> dict:
"""EV-03: the settings panel's read-only look at the charger. `entities` is
Home Assistant's list by id (None: it did not answer). Nothing is written.
`{"ok", "found": [[role, entity]], "missing": [[role, entity]], "limit_a",
"state"}`; `state` is `off`, `no_name` (the setpoint is not named the way
the charger's integration names it), `unread`, `ok` or `missing`."""
if chargers.mode_of(opts) == chargers.OFF:
return {"ok": False, "found": [], "missing": [], "limit_a": None,
"state": "off"}
setpoint = str(opts.get("ev_current_entity") or "").strip()
if not chargers.entities_for(setpoint):
return {"ok": False, "found": [], "missing": [], "limit_a": None,
"state": "no_name" if setpoint else "empty"}
if entities is None:
return {"ok": False, "found": [], "missing": [], "limit_a": None,
"state": "unread"}
def state_obj(e):
row = entities.get(e)
return None if row is None else {
"state": row.get("state"),
"attributes": {"unit_of_measurement": row.get("unit")}}
pr = chargers.probe_from(setpoint, state_obj)
return {"ok": pr.ok, "found": [list(x) for x in pr.found],
"missing": [list(x) for x in pr.missing], "limit_a": pr.station_a,
"power_unit": pr.power_unit,
"state": "ok" if pr.ok else "missing"}
# The roles the "Found:" note names, in words (EV-03).
_CHARGER_WORDS = (
("state", "car state", "autostatus"), ("power", "power", "vermogen"),
("energy", "energy", "energie"), ("readback", "read-back", "terugmelding"),
("phases_read", "phases", "fasen"),
("station", "the charger limit", "de laadpaalgrens"))
def charger_probe_for(setpoint: str, entities: dict | None) -> dict:
"""`charger_probe_rows()` for a setpoint entity typed on the page."""
return charger_probe_rows({"ev_charger": chargers.ALFEN_HA,
"ev_current_entity": setpoint}, entities)
def _charger_notes(notes, opts: dict, entities: dict) -> None:
"""EV-03: a note for each charger entity Home Assistant does not have, and
one when the limit is above the charger's own. Never a refusal."""
look = charger_probe_rows(opts, entities)
key = ("ev_current_entity",)
if look["state"] == "no_name":
_advise(notes, "warn", key,
f"{S('ev_current_entity')} must be named like the Alfen "
"integration's current setting, so the charger is not read.",
nl=f"{SN('ev_current_entity')} moet heten zoals de "
"stroominstelling van de Alfen-integratie, dus de laadpaal "
"wordt niet gelezen.")
return
if look["state"] == "empty":
_advise(notes, "warn", key,
f"{S('ev_current_entity')} is empty, so the charger is not "
"read.",
nl=f"{SN('ev_current_entity')} is leeg, dus de laadpaal wordt "
"niet gelezen.")
return
if look["state"] not in ("ok", "missing"):
return
for role, entity in look["missing"]:
required = role in chargers.REQUIRED
# A missing required entity (current, read-back, car state or power)
# means the charger is not used: the Car card says "not set up".
if required:
_advise(notes, "warn", key,
f"Home Assistant has no entity {entity}, which the "
"charger needs, so it is not used.",
nl=f"Home Assistant kent {entity} niet, die de laadpaal "
"nodig heeft, dus ze wordt niet gebruikt.")
else:
_advise(notes, "info", key,
f"Home Assistant has no entity {entity}, which the "
"charger can also use.",
nl=f"Home Assistant kent {entity} niet, die de laadpaal "
"ook kan gebruiken.")
if look.get("power_unit") is not None:
_advise(notes, "warn", key,
"The charger's power does not read in a power unit, so the "
"charger is not used.",
nl="Het vermogen van de laadpaal heeft geen vermogenseenheid, dus "
"ze wordt niet gebruikt.")
lim = look["limit_a"]
if look["ok"]:
have = {r for r, _e in look["found"]}
words = [(w_en, w_nl) for r, w_en, w_nl in _CHARGER_WORDS if r in have]
tail_en = f", {lim:.0f} A" if lim is not None else ""
_advise(notes, "ok", key,
"Found: " + ", ".join(w[0] for w in words) + tail_en + ".",
nl="Gevonden: " + ", ".join(w[1] for w in words) + tail_en
+ ".")
amps = chargers.max_a(opts)
if lim is not None and amps is not None and amps > lim:
_advise(notes, "warn", ("ev_max_a",),
f"{S('ev_max_a')} is above the {lim:.0f} A the charger "
"reports, so lower it.",
nl=f"{SN('ev_max_a')} is hoger dan de {lim:.0f} A die de "
"laadpaal meldt, dus verlaag ze.")
def _entity_notes(notes, opts: dict, entities: dict, bad=()) -> None:
"""A note for each entity these options read that Home Assistant does not
have, or that reads in kW where watts are taken. A missing entity whose
+1 -21
View File
@@ -51,8 +51,7 @@ from aiohttp import web
from . import messages, price, selfconfig, uipage, uitext
from .haentities import EntityCache
from .homeview import priced_hours, region_of
from .validate import (charger_probe_for, config_notes, note_text,
setup_checks)
from .validate import config_notes, note_text, setup_checks
from .config_page import CONFIG_PAGE
from .configui import (changed_keys, field_model, hide_secrets, keep_secrets,
problems_by_field, secret_keys)
@@ -62,7 +61,6 @@ _LOG = logging.getLogger("goodwe.web")
# OPT-11: the per-battery actions, which name a battery and a value.
PACK_ACTIONS = ("pack_use", "pack_mode", "pack_sell")
CAR_ACTIONS = ("car_mode", "car_current", "car_phases")
# MAINT-11: start or stop one battery's maintenance cycle (the unit is optional).
MAINT_ACTIONS = ("maint_start", "maint_abort")
@@ -177,15 +175,6 @@ def build_app(controller, selfcfg=None) -> web.Application:
return web.json_response({"ok": False,
"error": result["error"]},
status=400)
elif what in CAR_ACTIONS:
# EV-04: the car's mode, current or phases. Store state, applied by
# the writer's next step; nothing is written to the charger here.
result = await controller.handle_action(
what, value=body.get("value"))
if isinstance(result, dict) and "error" in result:
return web.json_response({"ok": False,
"error": result["error"]},
status=400)
elif what in MAINT_ACTIONS and body.get("unit") is not None:
# MAINT-11: one battery's cycle. No unit = the old bare call below.
result = await controller.handle_action(what, unit=body["unit"])
@@ -485,14 +474,6 @@ def build_app(controller, selfcfg=None) -> web.Application:
return web.json_response(await entities.reading(one))
return web.json_response(await entities.payload(kind))
async def config_charger(request):
"""EV-03: the settings page's read-only look at the car charger: which
entities Home Assistant has and which it lacks. Reads the cached entity
list and writes nothing, anywhere."""
rows, _age = await entities.get(max_age=5.0)
return web.json_response(charger_probe_for(
str(request.query.get("entity") or "")[:255], rows))
app = web.Application()
app.add_routes([
web.get("/", index),
@@ -505,7 +486,6 @@ def build_app(controller, selfcfg=None) -> web.Application:
web.post("/config/save", config_save),
web.post("/config/restart", config_restart),
web.get("/ha/entities", ha_entities),
web.get("/config/charger", config_charger),
])
return app
+1 -30
View File
@@ -1,5 +1,5 @@
name: GoodWe RS485 Controller
version: "0.23.0"
version: "0.22.0"
slug: goodwe_controller
description: >-
Drives a GoodWe ES/BP battery inverter over its RS485 EMS port by sending it a
@@ -872,22 +872,6 @@ options:
# be reached by accident.
shadow_mode: "auto"
# ==========================================================================
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
# ==========================================================================
# `off` is the shipped value and means NO CHANGE AT ALL: nothing is read,
# shown or announced, and the House tile and the house profile are as before.
# `alfen_ha` drives the charger through its Home Assistant integration. The
# mode (Off or Manual), the current and the phases are runtime state in the
# store, not options. `ev_batt_cover`: the batteries help with the peak while
# the car charges. `ev_mode_start`: the mode after a restart.
ev_charger: "off"
ev_current_entity: ""
ev_max_a: 16
ev_phases: "auto"
ev_batt_cover: true
ev_mode_start: "keep"
# ==========================================================================
# ADVANCED - the control law and diagnostics
# ==========================================================================
@@ -1265,19 +1249,6 @@ schema:
# long as nobody notices.
shadow_mode: list(auto|on|off)
# ==========================================================================
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
# ==========================================================================
# `ev_current_entity` is the charger's current setpoint; the other entities
# are found from its name. `ev_max_a` may not exceed the charger's own station
# limit (the settings page and the start check read it).
ev_charger: list(off|alfen_ha)
ev_current_entity: str?
ev_max_a: int(6,40)
ev_phases: list(1|3|auto)
ev_batt_cover: bool
ev_mode_start: list(keep|off)
# ==========================================================================
# ADVANCED - the control law and diagnostics
# ==========================================================================
-273
View File
@@ -1,273 +0,0 @@
"""Runnable check for CI-18's selector. `python3 test_affected_tests.py`
`.gitea/ci/affected_tests.py` says which test_*.py files a diff affects, so a
developer's round can skip the rest. It is used ONLY for local rounds; the merge
gate (`checks / unit (pull_request)`) runs every file. So the properties graded
here are the ones whose failure would be a missed test:
1. A synthetic tree: transitive imports, a tool launched by path, a module
named in a string, and what must NOT be chosen.
2. FAIL OPEN: a non-Python file, a deletion, a .py nothing references, a
file that does not parse, a base that does not exist, all select ALL.
3. The real tree: the safety set names files that exist, config.yaml and
run-tests.sh select ALL, a changed test file is chosen.
4. THE MUTANT: break a real module in a private copy of the tree; the
selector must choose a test that goes red, and the unbroken copy is green.
5. The merge gate cannot be partial: checks.yml and the CI image never
mention CI_ONLY, and checks.yml still runs the unfiltered run-tests.sh line.
Read MUTATION.md before you report a survivor.
"""
import os
import shutil
import subprocess
import sys
import tempfile
HERE = os.path.dirname(os.path.abspath(__file__))
REPO = os.path.dirname(HERE)
SEL = os.path.join(REPO, ".gitea", "ci", "affected_tests.py")
sys.path.insert(0, os.path.dirname(SEL))
import affected_tests as sel # noqa: E402
fails = []
tmps = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
def mk(root, files):
for rel, text in files.items():
p = os.path.join(root, rel)
os.makedirs(os.path.dirname(p), exist_ok=True)
with open(p, "w", encoding="utf-8") as fh:
fh.write(text)
def tmp():
d = tempfile.mkdtemp(prefix="test_affected.")
tmps.append(d)
return d
def choose(root, paths, status="M"):
names, _r, why = sel.select(root, [(status, p) for p in paths])
return ([os.path.basename(n) for n in names] if names is not None else None,
why)
# ---------------------------------------------------------------- 1. synthetic
print("1. a synthetic tree")
R = tmp()
P = "goodwe_controller/"
mk(R, {
P + "app/__init__.py": "",
P + "app/low.py": "def f():\n return 1\n",
P + "app/mid.py": "from app import low\n\ndef g():\n return low.f()\n",
P + "app/top.py": "from app.mid import g\n",
P + "app/lonely.py": "X = 1\n",
P + "app/viastr.py": "Y = 2\n",
P + "tools/launched.py": "print('hi')\n",
P + "tools/reader.py": "print('r')\n",
P + "test_a.py": "from app import top\n",
P + "test_b.py": "from app import lonely\n",
P + "test_c.py": "import subprocess\nsubprocess.run(['python3', 'tools/launched.py'])\n",
P + "test_d.py": "import importlib\nm = importlib.import_module('app.viastr')\n",
# reads every test_*.py as text: affected by a changed test, but it is a
# reader, not a dependency of anything that imports a module
P + "test_reader.py": "import glob\nfor f in glob.glob('test_*.py'):\n open(f).read()\n",
P + "test_unrelated.py": "print('x')\n",
# a test imported by another test carries the change on (an import runs it)
P + "test_base.py": "from app import lonely\n",
P + "test_chain.py": "import test_base\n",
})
n, why = choose(R, [P + "app/low.py"])
check("a change two imports down chooses the test that imports the top (transitive)",
n is not None and "test_a.py" in n)
check("...and not tests that do not reach it",
n is not None and not {"test_b.py", "test_c.py", "test_unrelated.py"} & set(n))
n, why = choose(R, [P + "app/lonely.py"])
check("a direct importer is chosen", n is not None and "test_b.py" in n)
check("a test that imports another test is chosen with it, even though "
"test_reader (a pattern reader) also reaches test_base as text",
n is not None and "test_chain.py" in n and "test_base.py" in n)
n, why = choose(R, [P + "tools/launched.py"])
check("a tool launched by path in a string chooses the launching test",
n is not None and "test_c.py" in n)
n, why = choose(R, [P + "app/viastr.py"])
check("a module imported dynamically by name chooses its test",
n is not None and "test_d.py" in n)
n, why = choose(R, [P + "test_unrelated.py"])
check("a changed test file is chosen", n is not None and "test_unrelated.py" in n)
check("a test that only READS test files by pattern is chosen with it",
n is not None and "test_reader.py" in n)
check("...but a reader does not drag in the importers of an unrelated module",
n is not None and "test_a.py" not in n and "test_b.py" not in n)
n, why = choose(R, [P + "app/low.py", P + "tools/launched.py"])
check("two changes choose the union",
n is not None and {"test_a.py", "test_c.py"} <= set(n))
# the safety set is always in, whatever changed
R2 = tmp()
files = {P + "app/__init__.py": "", P + "app/m.py": "A = 1\n",
P + "test_m.py": "from app import m\n", P + "test_zzz.py": "print(1)\n"}
for name in sel.SAFETY_SET:
files[P + name] = "print('safety')\n"
mk(R2, files)
n, why = choose(R2, [P + "app/m.py"])
check("every safety-set file is chosen on a one-module change",
n is not None and set(sel.SAFETY_SET) <= set(n))
check("...with a reason printed for each", all(sel.SAFETY_SET.values()))
check("...and a test outside the set that does not reach it stays out",
n is not None and "test_zzz.py" not in n)
# ------------------------------------------------------------ 2. fails open
print("\n2. it fails open")
for label, paths, status in (
("config.yaml (not Python)", [P + "config.yaml"], "M"),
("a translation file", [P + "translations/en.yaml"], "M"),
("run-tests.sh itself", [".gitea/ci/run-tests.sh"], "M"),
("a Dockerfile", [P + "Dockerfile"], "M"),
("a markdown file", ["README.md"], "M"),
("a deleted module", [P + "app/low.py"], "D"),
("a renamed module", [P + "app/low.py"], "R"),
("a .py nothing references", [P + "app/never_imported.py"], "M")):
if label.startswith("a .py"):
mk(R, {P + "app/never_imported.py": "Z = 1\n"})
n, why = choose(R, paths, status)
check(f"{label}: SELECT ALL", n is None and why)
mk(R, {P + "app/broken.py": "def (:\n"})
n, why = choose(R, [P + "app/low.py"])
check("a file in the tree that does not parse: SELECT ALL", n is None and why)
os.remove(os.path.join(R, P + "app/broken.py"))
n, why = choose(tmp(), [P + "app/low.py"])
check("a tree with no test files: SELECT ALL", n is None and why)
# the CLI: --names prints every test on SELECT ALL, and a bad base is ALL
g = tmp()
mk(g, {P + "app/__init__.py": "", P + "app/m.py": "A = 1\n",
P + "test_m.py": "from app import m\n"})
env = {**os.environ, "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t",
"GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t"}
def git(*a):
return subprocess.run(["git", "-C", g] + list(a), env=env,
capture_output=True, text=True)
git("init", "-q", "-b", "base")
git("add", "-A")
git("commit", "-q", "-m", "base")
git("checkout", "-q", "-b", "work")
mk(g, {P + "app/m.py": "A = 2\n"})
git("commit", "-q", "-am", "work")
r = subprocess.run([sys.executable, SEL, "--root", g, "--base", "base",
"--head", "work", "--names"], capture_output=True, text=True)
check("a committed range via git: the importer is chosen",
r.returncode == 0 and r.stdout.split() == ["test_m.py"])
r = subprocess.run([sys.executable, SEL, "--root", g, "--base", "nosuchref",
"--head", "work"], capture_output=True, text=True)
check("a base that does not exist: SELECT ALL, not an error and not nothing",
r.returncode == 0 and "SELECT ALL" in r.stdout)
mk(g, {P + "app/m.py": "A = 3\n"})
r = subprocess.run([sys.executable, SEL, "--root", g, "--base", "base",
"--names"], capture_output=True, text=True)
check("uncommitted work is part of the diff (no --head)",
r.returncode == 0 and r.stdout.split() == ["test_m.py"])
mk(g, {P + "app/newmod.py": "B = 1\n", P + "test_new.py": "from app import newmod\n"})
r = subprocess.run([sys.executable, SEL, "--root", g, "--base", "base",
"--names"], capture_output=True, text=True)
check("an untracked new module and its new test are in the diff",
r.returncode == 0 and set(r.stdout.split()) == {"test_m.py", "test_new.py"})
# ---------------------------------------------------------------- 3. real tree
print("\n3. the real tree")
tests = sorted(f for f in os.listdir(HERE)
if f.startswith("test_") and f.endswith(".py"))
check("every safety-set name is a test file that exists",
all(f in tests for f in sel.SAFETY_SET))
for p in ("goodwe_controller/config.yaml", ".gitea/ci/run-tests.sh",
".gitea/workflows/checks.yml", "goodwe_controller/DOCS.md",
"goodwe_controller/translations/en.yaml"):
n, why = choose(REPO, [p])
check(f"{p}: SELECT ALL", n is None and why)
n, why = choose(REPO, ["goodwe_controller/app/maintenance.py"])
check("app/maintenance.py chooses test_maint25.py (it imports it through main)",
n is not None and "test_maint25.py" in n)
n, why = choose(REPO, ["goodwe_controller/test_maint25.py"])
check("a changed test chooses itself and the safety set",
n is not None and "test_maint25.py" in n and set(sel.SAFETY_SET) <= set(n))
check("...and far fewer than all",
n is not None and len(n) < len(tests) // 2)
n, why = choose(REPO, [".gitea/ci/affected_tests.py"])
check("the selector's own file chooses this file",
n is not None and "test_affected_tests.py" in n)
# ------------------------------------------------------------------ 4. mutant
print("\n4. the mutant: break a module, the selector must choose a red test")
M = tmp()
ign = shutil.ignore_patterns(".git", "scenarios", "__pycache__", "*.pyc")
shutil.copytree(REPO, os.path.join(M, "repo"), ignore=ign, symlinks=True)
mroot = os.path.join(M, "repo")
cwd = os.path.join(mroot, "goodwe_controller")
env2 = {**os.environ, "PYTHONDONTWRITEBYTECODE": "1"}
def run_test(name):
r = subprocess.run([sys.executable, "-B", name], cwd=cwd, env=env2,
capture_output=True, text=True, timeout=600)
return r.returncode
check("control: test_maint25.py is green on the unbroken copy",
run_test("test_maint25.py") == 0)
path = os.path.join(cwd, "app", "maintenance.py")
with open(path, encoding="utf-8") as fh:
src = fh.read()
old = " return until if now < until else None\n"
check("the line to break is where this test expects it", src.count(old) == 1)
with open(path, "w", encoding="utf-8") as fh:
fh.write(src.replace(old, " return None\n"))
n, why = choose(mroot, ["goodwe_controller/app/maintenance.py"])
check("the selector chooses test_maint25.py for the broken module",
n is not None and "test_maint25.py" in n)
check("...and running the chosen file is RED", run_test("test_maint25.py") != 0)
with open(path, "w", encoding="utf-8") as fh:
fh.write(src)
check("put back: GREEN again", run_test("test_maint25.py") == 0)
# --------------------------------------------- 5. the gate cannot be partial
print("\n5. the merge gate runs everything")
with open(os.path.join(REPO, ".gitea", "workflows", "checks.yml"),
encoding="utf-8") as fh:
wf = fh.read()
check("checks.yml never mentions CI_ONLY", "CI_ONLY" not in wf)
check("checks.yml runs run-tests.sh with no file list",
"sh -eu /w/goodwe-addon/.gitea/ci/run-tests.sh\n" in wf)
check("checks.yml never calls the selector or the local wrapper",
"affected_tests" not in wf and "run-affected" not in wf)
with open(os.path.join(REPO, ".gitea", "ci", "run-tests.sh"),
encoding="utf-8") as fh:
rt = fh.read()
check("run-tests.sh takes CI_ONLY from the environment only and says PARTIAL",
"PARTIAL RUN" in rt and 'set -- test_*.py' in rt)
with open(os.path.join(REPO, ".gitea", "ci", "Dockerfile"),
encoding="utf-8") as fh:
df = fh.read()
check("the CI image (built from the merged tree) never sets CI_ONLY",
"CI_ONLY" not in df)
for d in tmps:
shutil.rmtree(d, ignore_errors=True)
print()
if fails:
print(f"{len(fails)} FAILED:")
for f in fails:
print(f" - {f}")
sys.exit(1)
print("all checks passed")
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
-562
View File
@@ -1,562 +0,0 @@
"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3).
`python3 -B test_ev10.py`
1. EV-10: the car alone takes the batteries to the peak reserve while the period
is still projected UNDER the aim: no alarm, one grey notice. A stuck car
figure with a house overload, and a house-only drain, still alarm. Mutant:
an uncorroborated car figure in the "period without the car" test.
2. EV-11: the grey row and the Car Why do not flicker while the car keeps the
period over the limit; a real end clears them after OVER_OFF_HOLD_S. The
alarm decision (`car_explains`) has no hold.
3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another
writer"; a real outside change afterwards still shows the row.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import asyncio
import dataclasses
import logging
import os
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import ctl_car, homeview, chargers as CH # noqa: E402
from app.main import Controller # noqa: E402
from app import freshness # noqa: E402
from chargersim import FakeHa, SimCharger # noqa: E402
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
import opt11_identity as rig # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
class _Log(logging.Handler):
def __init__(self):
super().__init__(logging.DEBUG)
self.rec = []
def emit(self, r):
self.rec.append((r.levelname, r.getMessage()))
LOG = _Log()
_lg = logging.getLogger("goodwe")
_lg.addHandler(LOG)
_lg.setLevel(logging.DEBUG)
_lg.propagate = False
# =========================================================================== #
print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)")
# =========================================================================== #
CAP = 4500.0 # the aim is 4450 W (50 W margin)
HOUSE = 1100.0
def at_reserve(plant, c):
"""The batteries reach the peak reserve late in the period, and the house
eases a little: the period is still projected UNDER the aim."""
plant.soc = 19.0
plant.load = lambda at: 780.0 + plant.ch.power_w
def alarms(r):
return P.ids(r, *P.ALARMS)
UNDER = [] # (second, projected W, aim W) while floor-limited
def watch(first, fn):
"""Events for seconds 840 to 894: `fn` at `first`, and a note of every
cycle in which the guard is floor-limited."""
def note(plant, c):
g = c.peak_guard
if g is not None and g.floor_limited:
UNDER.append((plant.t, g.projected_w, g.target_w))
ev = {t: note for t in range(first - 10, 895)}
ev[first] = lambda plant, c: (fn(plant, c), note(plant, c))
return ev
LOG.rec.clear()
r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, at_reserve))
ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")]
check("PRECONDITION: the guard was floor-limited with the projection UNDER "
"the aim (the rig's 5888 W against 6000 W)",
any(p < a for _t, p, a in UNDER))
check("the car alone: no 'Load too high', no 'Battery stopped limiting the "
"peak'", alarms(r10) == [])
rows10 = {x["id"]: x for x in r10["c"].checks()}
check("...no red row; the grey 'Car over the peak limit' row says it",
rows10["peak_guard"]["ok"] is True
and not [x for x in r10["c"].checks()
if x["ok"] is False and not x["warn"]]
and rows10.get("car_over", {}).get("ok") is True)
check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1)
check("...no ERROR (or WARNING) line was logged for it", ERR10 == [])
def house_stuck(plant, c):
at_reserve(plant, c)
plant.ch.freeze() # the reading stops moving
plant.ch.unplug() # the car really goes
plant.load = lambda at: 9000.0 + plant.ch.power_w
asyncio.get_event_loop().create_task(c.handle_action("car_current",
value=10))
r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, house_stuck))
check("a stuck car figure and a house overload at the reserve: the normal "
"alarm still fires",
[n for _t, n in alarms(r10s)]
and all(n in P.ALARMS for _t, n in alarms(r10s)))
def house_drain(plant, c):
plant.soc = 19.0
plant.load = lambda at: 12000.0 + plant.ch.power_w
r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, user_a=6, setpoint=6,
events=watch(600, house_drain))
check("a house-only drain to the reserve with the car charging little: the "
"normal alarm still fires",
alarms(r10h) != [] and not r10h["c"].car_explains)
def plug_late(plant, c):
plant.ch.plug_in()
def house_reserve(plant, c):
plant.soc = 19.0
plant.load = lambda at: 3075.0 + plant.ch.power_w
def swapped_events():
ev = watch(850, house_reserve)
ev[800] = plug_late
return ev
def swapped(mode):
return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode,
plug=False, events=swapped_events())
r10x = swapped("manual")
r10xo = swapped("off")
check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car "
"plugs in late (a small share); the projection is under the aim at the "
"reserve, and Off raises the alarm", alarms(r10xo) != []
and any(p < a for _t, p, a in UNDER))
check("the house drains the batteries and a small car is plugged in: the "
"normal alarm still fires in Manual", alarms(r10x) != [])
r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, mode="off", events=watch(850, at_reserve))
check("PRECONDITION: Off, the same case raises the normal alarm (the false "
"alarm Manual must not make)", alarms(r10off) != [])
# a direct unit of the rule: the car's average, the period without it
class _Car(ctl_car.CarMixin):
def __init__(self, cover=True, w=3700.0):
self.o = {"ev_batt_cover": cover}
self.w = w
self._now = 0.0
self.site_batt_w, self.site_rating_w = 300.0, 5000.0
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
def car_now(self):
return self._now
def car_alarm_w(self):
return self.w
class car: # noqa: N801
@staticmethod
def status(*_a):
return "charging"
@dataclasses.dataclass
class _Proj:
projected_w: float
elapsed_s: float = 850.0
held_w: float = 0.0
block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
def __post_init__(self):
self.held_w = self.projected_w
class _G:
def __init__(self, floor=True, sat=False, within_aim=False):
self.floor_limited, self.saturated = floor, sat
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0
self.engaged, self.blind, self.wanted_w = True, None, 300.0
self.within_aim = within_aim
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None,
within_aim=False, earlier=(), block=0, c=None, at=0.0):
"""One cycle of `car_cycle` on a stub; `earlier` are projections of
cycles before it in the same quarter (they latch SAFETY-126's test)."""
c = c or _Car(cover, car_w)
c.w = car_w
for k, e in enumerate(tuple(earlier) + (proj_w,)):
p = _Proj(e)
p.block_start = p.block_start + timedelta(minutes=15 * block)
c._now = at - len(earlier) + k
c._carq = {"key": p.block_start,
"ws": ((car_w or 0.0) if car_so_far_w is None else car_so_far_w)
* p.elapsed_s, "mono": c._now}
c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None)
return c.car_explains
check("rule: the alarm's test is true with the car (4468 W, the batteries "
"at 0 W land 4485 W) and false without it (768 W): the car explains it, "
"with the projection under the aim", explains(4468.0, 3700.0))
check("rule: under the aim, the quarter's test latched by the car's share "
"(4600 W earlier), the car explains the alarm (the positive under-aim "
"case; a single 4300 W cycle has no landing miss to explain, so it "
"needs the earlier cycle)", explains(4300.0, 3700.0, earlier=(4600.0,)))
check("rule: where the alarm would not fire anyway nothing is explained",
not explains(4300.0, 3700.0, within_aim=True))
check("rule: without the car it is still over the aim: the car does not "
"explain it", not explains(9000.0, 3700.0))
check("rule: no car power, no explanation", not explains(4300.0, 0.0))
check("rule: ...also when the test was latched earlier in the quarter",
not explains(4300.0, 0.0, earlier=(4600.0,))
and not explains(9000.0, 0.0))
check("rule: an untrusted car figure (None) explains nothing",
not explains(4300.0, None, earlier=(4600.0,)))
# the latches: per quarter, and independent of the cover option
c4 = _Car(True, 3700.0)
explains(9000.0, 3700.0, c=c4, block=0) # the house needs it: latched
check("latch: in the same quarter the house need stays latched, so the car "
"does not explain", not explains(4300.0, 3700.0, c=c4, block=0, at=10.0))
check("latch: a new quarter starts clean: the car alone explains it again",
explains(4300.0, 3700.0, c=c4, block=1, at=1000.0,
earlier=(4600.0,)))
c5 = _Car(False, 3700.0) # cover OFF
explains(9000.0, 3700.0, c=c5, block=0) # the house needs it
c5.o["ev_batt_cover"] = True # ... and the option flips
check("latch: the option flipping to ON does not lose a house need seen "
"while it was off", not explains(4300.0, 3700.0, c=c5, block=0, at=10.0))
c6 = _Car(True, 3700.0)
explains(9000.0, 3700.0, c=c6, block=0)
c6.o["ev_batt_cover"] = False
explains(4300.0, 3700.0, c=c6, block=0, at=10.0)
c6.o["ev_batt_cover"] = True
check("latch: ... nor does flipping it off and on again",
not explains(4300.0, 3700.0, c=c6, block=0, at=20.0))
check("rule: the guard is not floor-limited or saturated: nothing to explain",
not explains(4300.0, 3700.0, floor=False))
# =========================================================================== #
print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)")
# =========================================================================== #
# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own
# quarter (14.0 kW) was the month peak, so the aim was that quarter's average
# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The
# projection crossed the aim every few seconds, `ex > 0` came and went, and
# `car_over` followed it with no hold on the way off.
def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0,
cover=False):
"""Run `car_cycle` once a second; returns (car_over, car_explains) per second."""
out = []
for k in range(secs):
t = t0 + k
c._now = t
c.w = w_of(t)
p = _Proj(proj_of(t), elapsed_s=300.0 + (t % 400))
c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s,
"mono": t}
c.car_cycle(p, _G(True), target, None)
out.append((c.car_over, c.car_explains))
return out
def noisy(t):
"""The projection straddles the aim: +-40 W, a new value every 7 s."""
return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3))
c11 = _Car(cover=False)
o11 = over_run(c11, 1200, noisy)
flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0])
check("while the car keeps the period at the limit the row stays on: one "
"switch on in 20 minutes, none off", flips == 1 and len(o11) == 1200 and o11[-1][0] is True)
check("it turns on after the existing 10 s hold, not later than the first "
"10 s the condition has stood (a gap does not restart the count)",
next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25)
# the condition on its own, for the PRECONDITION: the same input flips
c11o = _Car(cover=False)
raw = []
for k in range(1200):
c11o._now = float(k)
p = _Proj(noisy(k), elapsed_s=300.0 + (k % 400))
c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k}
ex = p.projected_w - 14000.0
raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex)
raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b)
check("PRECONDITION: the condition itself flips many times in those 20 "
"minutes", raw_flips > 20)
# a real end: the car stops (no trusted power) after 600 s
c11e = _Car(cover=False)
o11e = over_run(c11e, 1000, lambda t: 14500.0,
w_of=lambda t: 11000.0 if t < 600 else None)
off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1)
check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes",
off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S)
and not any(x[0] for x in o11e[off_at:]))
o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0)
check("it comes back after the usual 10 s if the condition returns after "
"it went", len(o11r) == 100 and o11r[9][0] is False and o11r[10][0] is True)
# the alarm decision has no hold: a real house overload is never delayed
c11a = _Car(cover=True)
o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0)
check("decision 1 on: the car explains it at once (no hold)",
len(o11a) == 60 and o11a[0][1] is True)
c11a.w = None # the figure is not trusted
c11a._now = 61.0
c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None)
check("...and the moment the car figure is not trusted it explains nothing, "
"so the normal alarms stand at once (the grey row may stay)",
c11a.car_explains is False)
# the whole thing on the real controller: the Why does not flicker either
def p7_like(plant, c):
plant.load = lambda at: 3000.0 + plant.ch.power_w
r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP,
phases=3, opts={"ev_batt_cover": False})
ov = [s[2] for s in r11["snaps"]]
check("real controller, cover off, an 11 kW car: the flag is steady once on",
sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True)
# =========================================================================== #
print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)")
# =========================================================================== #
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[0]
SET = "number.wallbox_power_connector_max_current_socket_1"
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
"pv_entities": ["sensor.pv"], "ev_charger": "alfen_ha", "ev_max_a": 16,
"ev_phases": "auto", "ev_current_entity": SET}
class _Store:
def __init__(self):
self.data = {}
def set(self, k, v):
self.data[k] = v
def get(self, k, d=None):
return self.data.get(k, d)
def set_time(self, k, v):
self.data[k] = v.isoformat()
def get_time(self, k):
v = self.data.get(k)
return None if v is None else datetime.fromisoformat(v)
class _Pub:
enabled = False
def publish(self, v):
pass
def close(self):
pass
class Site(FakeHa):
def __init__(self, charger):
super().__init__(charger, None)
async def limits(self, _e):
return (-5000.0, 5000.0, 1.0)
def _all(self):
out = super()._all()
for eid, val, unit in (("sensor.grid", 800.0, "W"),
("sensor.soc", 50.0, "%"),
("sensor.batt", 0.0, "W"),
("sensor.pv", 2000.0, "W")):
out[eid] = {"entity_id": eid, "state": str(val),
"attributes": {"unit_of_measurement": unit}}
return out
async def number(self, entity_id, invert=False):
s = self._all().get(entity_id)
try:
v = float(s["state"])
except (TypeError, ValueError, KeyError):
return None
return -v if invert else v
async def set_number(self, entity_id, value):
return await super().set_number(entity_id, float(value))
class World:
"""A real Controller on the charger model. While a write waits for its
read-back, the controller's own reading goes on (as in production, where
the cycle runs while the writer task waits): that is how the read-back of
our own write reaches the tracker BEFORE the write returns."""
def __init__(self, setpoint=10):
self.sim = SimCharger(setpoint_a=setpoint)
self.sim.plug_in()
self.sim.lag_s = 2.0 # the rig's read-back lag
self.sim.phases_allowed = 1
self.t = 1000.0
CLOCK[0] = self.t
self.c = Controller(dict(BASE), Site(self.sim), _Store(), _Pub(),
stop=asyncio.Event())
self.c.auto = True
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
self.drv = self.c.charger
self.drv._sleep = self.sleep
self.drv._clock = lambda: CLOCK[0]
async def sleep(self, s):
self.sim.tick(s)
self.t += s
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t) # the cycle reads on
async def step(self, n=1):
for _ in range(n):
self.sim.tick(1.0)
self.t += 1.0
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t)
await self.c.cycle()
await self.c.car_settle()
def rows(self):
return {r["id"]: r for r in self.c.checks()}
async def own_then_off(wait):
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(wait)
await w.c.handle_action("car_mode", value="off")
await w.step(40)
return w
w12 = asyncio.run(own_then_off(2))
check("PRECONDITION: the add-on wrote 12 A and the charger took it",
w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1)
check("our own write, then Off 2 s later: no 'Something else changes the "
"charger'", "charger_writer" not in w12.rows()
and w12.c.car.writer_at_utc is None)
w12b = asyncio.run(own_then_off(14))
check("...and 14 s later (inside the 15 s)", "charger_writer" not in
w12b.rows() and w12b.c.car.writer_at_utc is None)
async def own_then_outside():
w = await own_then_off(2)
w.sim.set_current(7) # somebody else, afterwards
await w.step(3)
early = "charger_writer" in w.rows()
await w.step(30)
return early, "charger_writer" in w.rows()
early12, late12 = asyncio.run(own_then_outside())
check("an outside change after that still shows the row (within 30 s)",
late12 is True)
async def manual_own():
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(60)
await w.c.handle_action("car_current", value=8)
await w.step(20)
return w
wm = asyncio.run(manual_own())
check("Manual: two writes of ours, never 'another writer' in the tracker",
wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows())
async def failed_write_then_outside(how):
"""A write that RAISES or returns FAILURE must still close the self-mute:
it ends 15 s after the write returned, and a later outside change shows
the row."""
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
ret = []
async def bad(a):
await w.sleep(1.0)
ret.append(w.t) # when the write came back
if how == "raise":
raise RuntimeError("the charger link broke")
return False
w.drv.write_current = bad
await w.c.handle_action("car_current", value=12)
await w.step(3) # the write is tried
closed = (bool(ret) and w.c.car.mute_until <= ret[-1] + 15.0 + 1e-6)
await w.c.handle_action("car_mode", value="off")
await w.step(20) # past the 15 s mute
w.sim.set_current(7) # somebody else
await w.step(3)
return w, closed
for how in ("raise", "fail"):
wf, closed = asyncio.run(failed_write_then_outside(how))
check(f"a write that {'raises' if how == 'raise' else 'returns failure'}"
": the mute ends within 15 s of the write's return, and a later "
"outside change shows the row",
closed and "charger_writer" in wf.rows())
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)
-288
View File
@@ -1,288 +0,0 @@
"""Runnable check for MAINT-28. `python3 test_maint28.py`
MAINT-24 follow-up. With A in maintenance CHARGE and a real peak (house over
the month aim), MAINT-24's pause ended every time the guard idled: the
forecast dipped under the aim, the floor charged A, the guard tripped again,
and A flipped charge/give every few seconds (rig x10: 468 flips in 45 min,
base 02eac3b 11). Now the pause is held (`peakguard.shaping_held()`) until the
house is MAINT_RESUME_UNDER_W under the aim.
All on the real Controller through `cycle()` (tools/opt20_scen.py): cheap
window, cap 3500 / margin 50, a month peak of 6000 W banked (aim 5950 W), a
peak forecast like the live sensor (quarter average so far, the rest at the
present grid), house +-50 W every 5 s.
1. A real peak (house 3000 W, then 6500 W for 15 min, then 3000 W): once the
guard has stepped in, A does not charge and does not flip; every quarter is
at or under the aim; A's charge is back within 10 cycles after the load.
2. peakguard.shaping_held(): the pure rule, with its edges.
3. Unchanged: the MAINT-24 live shape (A 1475 W, no pause), N=1, the SAFETY-78
drain and battery modes off (digests of release/1.0 1b5f7c9, as
test_maint24.py).
Mutations: DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md.
Read MUTATION.md before you report a survivor.
"""
import logging
import os
import random
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
logging.disable(logging.WARNING)
import opt11p3_replay as rp # noqa: E402
import opt20_scen as sc # noqa: E402
from app import ctl_cycle, peakguard, tariff # noqa: E402
from app.maintenance import DRAIN, IDLE, MaintResult # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
CH = sc.MAINT_CHARGE
MONTH_PEAK = 6000.0
AIM = MONTH_PEAK - 50.0
DRAIN_R = MaintResult(DRAIN, True, 2000.0, False, [])
T0 = sc.at(2.0) # a quarter boundary
PRE, LOAD, POST = 120.0, 900.0, 120.0 # s (CI time: short runs)
def stepped_house(base_w, hi_w):
"""[(t_utc, W)]: base_w, then hi_w from PRE for LOAD s, +-50 W per 5 s."""
rnd = random.Random(28)
out = [(sc.UTC0.timestamp() - 10, base_w)]
for t in range(0, int(PRE + LOAD + POST), 5):
w = hi_w if PRE <= t < PRE + LOAD else base_w
out.append((T0.timestamp() + t, w + rnd.uniform(-50.0, 50.0)))
return out
def scen(*, a=None, tick=None, soc=(49.0, 30.0), house=None, house_w=3000.0,
peak=MONTH_PEAK, fc="grid", n=2, variant="p3_ch_sell", dur=600.0):
"""`a`: A's forced maintenance result. `fc`: "grid" (follows the grid),
"quarter" (quarter average so far, the rest at the present grid, like the
live sensor) or None (no forecast entity). Returns (rows, stats, c)."""
rows = []
q = dict(q=None, s=0.0, last=None, start=None)
def patch(c):
if tick is not None:
c.maints[0].tick = (
lambda now, soc_, blocked_by=None, gate_open=True: tick(now))
elif a is not None:
c.maints[0].tick = (
lambda now, soc_, blocked_by=None, gate_open=True: a)
if peak is not None:
orig_peak = c.peak.peak
def peak_(now):
r = orig_peak(now)
return tariff.PeakReading(tariff.OBSERVED,
getattr(r, "month", ""), peak)
c.peak.peak = peak_
orig = c.cycle
susp = []
c._m28_susp = susp
async def cyc():
c.cheap = True
if fc and c.grid is not None:
g = float(c.grid)
if fc == "grid":
c.peak_fc = g
else:
# the replay's clock; not main_files.live (it parses
# every app file per access: ~0.1 s a cycle).
now = ctl_cycle.datetime.now()
qi = int(now.timestamp() // 900)
if q["q"] != qi:
q.update(q=qi, s=0.0, last=now, start=now)
el = (now - q["start"]).total_seconds()
q["s"] += g * (now - q["last"]).total_seconds()
q["last"] = now
c.peak_fc = (q["s"] + g * (900.0 - el)) / 900.0
await orig()
susp.append(bool(c._maint_shape_suspended))
c.cycle = cyc
def cb(c, h, now, pr):
sh = dict(c.allocation.shares) if c.allocation is not None \
and c.allocation.shares else {}
rows.append(dict(
now=now, grid=h.grid(), shares=sh,
action=getattr(c.arb, "action", None),
reason=getattr(c.arb, "reason", None) or "",
roles=dict(c.mode_tick.roles) if c.mode_tick else {},
why=c.mode_tick.why if c.mode_tick else None,
p={u: p.p for u, p in h.plants.items()},
t=(now - T0).total_seconds(), a=h.plants["a"].p,
susp=c._m28_susp[-1], hold=bool(getattr(c, "_maint_peak_hold", False))))
src = house if house is not None else [(sc.UTC0.timestamp() - 10, house_w)]
stats, c = rp.run(variant, src, sc.WPTS, T0, dur, check=cb, lag=sc.LAG,
n=n, soc0={"a": soc[0], "b": soc[1]},
choice=sc.CH_CH, refuse=(), patch=patch,
extra={"cycle_cost_threshold_eur": 0.10})
return rows, stats, c
def flips(rs):
"""Reversals of A between charging and giving (beyond 50 W)."""
n, s = 0, 0
for r in rs:
v = 1 if r["a"] > 50 else -1 if r["a"] < -50 else 0
if v and s and v != s:
n += 1
if v:
s = v
return n
# ============================================================================ #
print("1. a real peak: house 3000 W, 6500 W for 15 min, 3000 W")
rows, st, c = scen(a=CH, house=stepped_house(3000.0, 6500.0), fc="quarter",
dur=PRE + LOAD + POST)
end = PRE + LOAD
trip = next((r["t"] for r in rows if r["t"] >= PRE and r["a"] > 50), None)
load = [r for r in rows if trip is not None and trip <= r["t"] < end]
after = [r for r in rows if r["t"] >= end]
back = next((i for i, r in enumerate(after) if r["a"] < -50), None) # cycles
print(f" first give at {trip}, flips in the load {flips(load)}, charge s in"
f" the load {sum(1 for r in load if r['a'] < -50)}, charge back "
f"{back} cycles after it, quarters "
f"{[round(a[0] / a[1]) for a in st['quarters'].values()]}")
check("the guard stepped in once the projection went over the aim",
trip is not None)
check("from the first give to the load's end A does not flip",
flips(load) == 0)
check("...and does not charge at all", not any(r["a"] < -50 for r in load))
check("...the pause is on in every one of those cycles",
all(r["susp"] for r in load))
check("every quarter at or under the month aim",
max(a[0] / a[1] for a in st["quarters"].values()) <= AIM + 1.0)
check("after the load A's charge is back within 10 cycles (1 s each)",
back is not None and back <= 10)
tail = [r["a"] for r in after[10:]]
check("...and stays on: at least 150 W (half the resume margin), no give",
tail and sum(tail) / len(tail) <= -150.0 and max(tail) <= 50.0)
# ============================================================================ #
print("\n1b. the hold does not outlive the charge: a stale True must not "
"pause the next charge")
# The idle window opens on a quarter boundary, so the new charge meets a
# fresh quarter whose projection (house 5700 W) is under the aim.
HI_START, HI_END, IDLE_END, B_END = 300.0, 900.0, 1000.0, 1300.0
def _house_b():
rnd = random.Random(29)
out = [(sc.UTC0.timestamp() - 10, 3000.0)]
for t in range(0, int(B_END) + 100, 5):
w = 3000.0 if t < HI_START else 6500.0 if t < HI_END else 5700.0
out.append((T0.timestamp() + t, w + rnd.uniform(-50.0, 50.0)))
return out
def _tick_b(now):
t = (now - T0).total_seconds()
return MaintResult(IDLE, False, None, False, []) \
if HI_END <= t < IDLE_END else CH
rb, sb, cb_ = scen(tick=_tick_b, house=_house_b(), fc="quarter", dur=B_END)
held_before = [r for r in rb if HI_START <= r["t"] < HI_END and r["hold"]]
idle_rows = [r for r in rb if HI_END <= r["t"] < IDLE_END]
later = [r["a"] for r in rb if IDLE_END + 10.0 <= r["t"] < B_END]
print(f" hold on {len(held_before)} cycles before; in the idle window "
f"{sum(r['hold'] for r in idle_rows)} of {len(idle_rows)}; A after "
f"{sum(later) / len(later):+.0f} W (house 5700 W: 125 W)")
check("the hold was on in the peak", len(held_before) > 100)
check("it is off in every cycle the charge-only branch is not taken",
not any(r["hold"] for r in idle_rows))
check("a new maintenance charge at house 5700 W (over the resume line) "
"starts at once: (5950 - 5700) / 2 = 125 W, not paused",
sum(later) / len(later) <= -60.0)
# ============================================================================ #
print("\n2. peakguard.shaping_held()")
def held(was, decision, fc, aim, house):
return peakguard.shaping_held(
peakguard.shaping_suspended(decision, fc, aim), was, fc, aim, house)
U = peakguard.MAINT_RESUME_UNDER_W
eng = peakguard.PeakDecision(engaged=True, floor_w=100.0, ceiling_w=6000.0,
ceiling_from="x", target_w=AIM)
idle = peakguard.PeakDecision(engaged=False, floor_w=None, ceiling_w=6000.0,
ceiling_from="x", target_w=AIM)
check("the old conjunction still pauses: forecast over the aim; guard engaged",
held(False, idle, AIM + 1, AIM, 3000.0)
and held(False, eng, None, AIM, 3000.0))
check("not held and not suspended: not paused", not held(False, idle, AIM - 1,
AIM, 6500.0))
check("held: stays paused while the house is over the aim minus the margin",
held(True, idle, AIM - 1, AIM, 6500.0)
and held(True, idle, AIM - 1, AIM, AIM - U + 1))
check("held: resumes when the house is the margin under the aim",
not held(True, idle, AIM - 1, AIM, AIM - U)
and not held(True, idle, AIM - 1, AIM, 3000.0))
check("held, house unread: the forecast stands in; neither read: resumes "
"(SAFETY-63)",
held(True, idle, AIM - 1, AIM, None)
and not held(True, idle, AIM - U, AIM, None)
and not held(True, idle, None, AIM, None))
check("a guard that is engaged pauses whatever the house reads",
held(True, eng, AIM - 1, AIM, 3000.0))
# ============================================================================ #
print("\n3. unchanged: the live shape, N=1, the drain, modes off")
rl, sl, cl = scen(a=CH)
body = rl[len(rl) // 6:]
mean_a = sum(r["a"] for r in body) / len(body)
print(f" A {mean_a:+.0f} W, paused {sum(cl._m28_susp)} cycles")
check("MAINT-24 live shape: A charges 1475 W and the pause never comes",
-1500.0 <= mean_a <= -1440.0 and not any(cl._m28_susp))
d1 = sc.digest(scen(a=CH, n=1, fc=None, peak=None)[0])
dd = sc.digest(scen(a=DRAIN_R, soc=(60.0, 30.0), peak=None, fc=None)[0])
dm = sc.digest(scen(a=CH, variant="modes_off", peak=None, fc=None)[0])
d2n = sc.digest(scen(a=CH, house_w=5000.0, peak=None, fc="grid")[0])
d1p = sc.digest(scen(a=CH, n=1, fc=None, house_w=6500.0)[0])
AT_BASE = {
"n2_nobank": "f9053833891794ead8b3f44db4030ded8c4b43681e25e8a19882105d3593f20d",
"n1_peak": "3e451c536bea8270469fffe578c5a7199431e0e7ba4902413406b0afe2bb0fd1",
"n1": "02ecc3011c559df050ae5321ceb6b24cf79342ae35f1a289fbd1a749c86f1d10",
"drain": "bfcf9a643dfffff21d0a8417426d2088377a8f64afbc544732b1635a77775d8a",
"off": "6f4ec14578d8ed59fc7721485d037f3c1fb086abae7c52f28c9e9155cf2107b0",
}
got = {"n2_nobank": d2n, "n1_peak": d1p, "n1": d1, "drain": dd, "off": dm}
for k in AT_BASE:
print(f" {k} {'same' if got[k] == AT_BASE[k] else 'DIFFERS'} "
f"{got[k]}")
check("N=1 with A in maintenance charge and no forecast entity: equal to "
"release/1.0 1b5f7c9", got["n1"] == AT_BASE["n1"])
check("N=1 in a real peak above a banked month peak (house 6500 W, the guard steps in): equal "
"to 1b5f7c9, the hold is for N=2 and up", got["n1_peak"] == AT_BASE["n1_peak"])
check("N=2 in a real peak with no banked peak (house 5000 W over the aim "
"3450 W): equal to 1b5f7c9, the hold is for a month aim above the cap",
got["n2_nobank"] == AT_BASE["n2_nobank"])
check("the SAFETY-78 drain beside a charger: equal to 1b5f7c9",
got["drain"] == AT_BASE["drain"])
check("battery modes off: equal to 1b5f7c9", got["off"] == AT_BASE["off"])
print()
if fails:
print(f"{len(fails)} FAILED:")
for f in fails:
print(f" - {f}")
sys.exit(1)
print("all checks passed")
-485
View File
@@ -1,485 +0,0 @@
"""Runnable check for MAINT-28 fix-forward. `python3 test_maint28b.py`
The rig failed MAINT-28 (TEST-23, f3f9483): the hold of the maintenance pause
ended at almost every guard step (F-1), and while it stuck, the pack in
maintenance CHARGE gave its full rating for the house below its peak reserve
(F-2). test_maint28.py missed both because its battery reading has no lag. Here
the battery register is published every 10 s and held (`Lag.batt_period_s`),
the meter reading is 2 s old, as on the rig; the rating is the rig's A (5 kW).
All on the real Controller through `cycle()` (tools/opt20_scen.py): cheap
window, cap 3500 / margin 50, a month peak of 6000 W banked (aim 5950 W), a
peak forecast like the live sensor, house +-50 W every 5 s, 3000 W then
6500 W for 13 min (over a quarter boundary), then 3000 W.
1. A real peak, A in CHARGE above its peak reserve: A flips charge/give a few
times (base 1b5f7c9: dozens), no release of the pause on an estimate that
mixes a new grid with an old battery reading, quarters at or under the aim,
A's charge back after the load.
2. F-2 and the cap (owner 2026-11-13): while the pause holds, A gives at most
the largest part of the guard's floor placed on it in the 15-min period,
at any SoC (never under its reserve; SoC drop within the owner-accepted
give); with both packs able, never over the period's largest floor, and
when B is placed part of it A's limit is its own part, not the whole floor;
one unit's limit is its own (two packs in CHARGE never share it); with the
other pack under its reserve, A still gives for the guard.
3. The mirror: B in CHARGE, under its reserve at the load: it gives nothing
for the house.
4. Unchanged: the MAINT-24 live shape (A 1475 W, B no grid trade), with the
same lag on.
5. `peakguard.shaping_held()` with `settled`, and `Controller._batts_settled()`.
6. H-1 (owner 2026-11-14): while the pause holds the batteries together give
only what the guard needs. The live try (A 11 %, B 25 %, 90 min at 6.5 kW)
and, for the F-1 wiring, the 45-min rig shape.
Mutations: DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md.
Read MUTATION.md before you report a survivor.
"""
import logging
import os
import random
import sys
from datetime import timedelta
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
logging.disable(logging.WARNING)
import opt11p3_replay as rp # noqa: E402
import opt20_scen as sc # noqa: E402
from app import (ctl_cycle, ctl_trade, freshness, maintenance, # noqa: E402
packmode, peakguard, tariff)
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
rp.RATING, rp.CAP_KWH = 5000.0, 15.36 # the rig's A
LAG = rp.Lag(dead_s=1.0, meter_s=2.0, batt_s=1.0, p1_s=0.35, tick=1.0,
tau_s=2.0, ramp_w_s=1e9, batt_period_s=10.0)
CH = sc.MAINT_CHARGE
MONTH_PEAK = 6000.0
AIM = MONTH_PEAK - 50.0
LINE = AIM - getattr(peakguard, "MAINT_RESUME_UNDER_W", 300.0)
T0 = sc.at(2.0) # a quarter boundary
PRE, LOAD, POST = 120.0, 780.0, 120.0 # s (CI time: short runs)
RESERVE = 20.0 # peak_soc_floor default
def stepped_house(base_w, hi_w, load=LOAD, pre=PRE):
rnd = random.Random(28)
out = [(sc.UTC0.timestamp() - 10, base_w)]
for t in range(0, int(pre + load + POST), 5):
w = hi_w if pre <= t < pre + load else base_w
out.append((T0.timestamp() + t, w + rnd.uniform(-50.0, 50.0)))
return out
def scen(*, unit="a", soc=49.0, other=30.0, house=None, house_w=3000.0,
peak=MONTH_PEAK, dur=PRE + LOAD + POST, fc="quarter", n=2,
choice=None):
"""`unit` is in maintenance CHARGE (forced result), at `soc`, the other at
`other`. Rows: the plants' power and SoC, the pause flag, the add-on's house
estimate and the real house."""
rows = []
q = dict(q=None, s=0.0, last=None, start=None)
idx = 0 if unit == "a" else 1
o = "b" if unit == "a" else "a"
def patch(c):
c.maints[idx].tick = (
lambda now, soc_, blocked_by=None, gate_open=True: CH)
if peak is not None:
orig_peak = c.peak.peak
def peak_(now):
r = orig_peak(now)
return tariff.PeakReading(tariff.OBSERVED,
getattr(r, "month", ""), peak)
c.peak.peak = peak_
orig = c.cycle
async def cyc():
c.cheap = True
if fc and c.grid is not None:
g = float(c.grid)
now = ctl_cycle.datetime.now() # the replay's clock
qi = int(now.timestamp() // 900)
if q["q"] != qi:
q.update(q=qi, s=0.0, last=now, start=now)
el = (now - q["start"]).total_seconds()
q["s"] += g * (now - q["last"]).total_seconds()
q["last"] = now
c.peak_fc = (q["s"] + g * (900.0 - el)) / 900.0
await orig()
c.cycle = cyc
def cb(c, h, now, pr):
est = (None if c.grid is None or c.site_batt_w is None
else float(c.grid) + float(c.site_batt_w))
g = c.peak_guard
floor = (float(g.floor_w) if g is not None and g.engaged
and g.floor_w is not None else 0.0)
sh = (dict(c.allocation.shares) if c.allocation is not None
and c.allocation.shares else {})
au = c.actuator_of("maintenance", c.inverters[idx])
ao = c.actuator_of("maintenance", c.inverters[1 - idx])
rows.append(dict(
t=(now - T0).total_seconds(), grid=h.grid(), u=h.plants[unit].p,
o=h.plants[o].p, soc=h.plants[unit].soc, soc_o=h.plants[o].soc,
hold=bool(getattr(c, "_maint_peak_hold", False)), est=est,
floor=floor, share_u=float(sh.get(au, 0.0)),
hi_u=next((float(pl.hi) for pl in (c.allocation.plans
if c.allocation else ())
if pl.unit == au), None),
share_o=float(sh.get(ao, 0.0)),
house=h.grid() + sum(p.p for p in h.plants.values())))
src = house if house is not None else [(sc.UTC0.timestamp() - 10, house_w)]
ch = dict(sc.CH_CH if choice is None else choice)
stats, c = rp.run("p3_ch_sell", src, sc.WPTS, T0, dur, check=cb, lag=LAG,
n=n, soc0={unit: soc, o: other}, choice=ch,
refuse=(), patch=patch,
extra={"cycle_cost_threshold_eur": 0.10})
return rows, stats, c
def flips(rs, k="u"):
n, s = 0, 0
for r in rs:
v = 1 if r[k] > 50 else -1 if r[k] < -50 else 0
if v and s and v != s:
n += 1
if v:
s = v
return n
def releases(rows):
"""Cycles in the load where the pause ended: (row, estimate under the
release line while the real house was over it)."""
out = []
for p, r in zip(rows, rows[1:]):
if PRE <= r["t"] < PRE + LOAD and p["hold"] and not r["hold"]:
out.append((r, r["est"] is not None and r["est"] < LINE
and r["house"] >= LINE))
return out
def quarters_ok(st):
# SAFETY-126: a landing 0-7 W over the aim is not an overrun.
return (max(a[0] / a[1] for a in st["quarters"].values())
<= AIM + peakguard.ALARM_MISS_W)
def show(tag, rows, st):
load = [r for r in rows if PRE <= r["t"] < PRE + LOAD]
rel = releases(rows)
print(f" {tag}: flips {flips(load)}, charge s "
f"{sum(1 for r in load if r['u'] < -50)}, releases {len(rel)} "
f"(stale {sum(1 for _r, s in rel if s)}), lowest SoC "
f"{min(r['soc'] for r in rows):.1f} %, give kWh "
f"{sum(r['u'] for r in load if r['u'] > 0) / 3.6e6:.2f}, quarters "
f"{[round(a[0] / a[1], 1) for a in st['quarters'].values()]}")
# ============================================================================ #
print("1. a real peak, A in CHARGE at 49 % (above its reserve), the battery "
"reading lagging")
rows, st, c = scen(house=stepped_house(3000.0, 6500.0))
show("A 49 %", rows, st)
load = [r for r in rows if PRE <= r["t"] < PRE + LOAD]
rel = releases(rows)
after = [r for r in rows if r["t"] >= PRE + LOAD]
back = next((i for i, r in enumerate(after) if r["u"] < -50), None)
print(f" A's charge back {back} s after the load")
check("A flips charge/give 3 times or fewer in the 13 min (1b5f7c9: 60, "
"f3f9483: 11)", flips(load) <= 3)
check("the pause never ends on an estimate under the release line while the "
"real house is over it", not any(s for _r, s in rel))
check("every quarter at or under the month aim",
quarters_ok(st))
check("after the load A's charge is back within 20 cycles (1 s each: a 10 s "
"register period plus its settle time, 16 s)",
back is not None and back <= 20)
# M-1 (review 2026-11-14): the F-1 wiring, `_batts_settled()` read at the hold
# in ctl_cycle.py. With `settled=True` there the 13-min load above still passes;
# the rig shape (the load starts 10 min into the quarter, 45 min long) does not.
RIG_PRE, RIG_LOAD = 600.0, 2700.0
rows, st, c = scen(house=stepped_house(3000.0, 6500.0, RIG_LOAD, RIG_PRE),
dur=RIG_PRE + RIG_LOAD + POST)
load45 = [r for r in rows if RIG_PRE <= r["t"] < RIG_PRE + RIG_LOAD]
rel45 = [(r, s_) for p, r in zip(rows, rows[1:])
if RIG_PRE <= r["t"] < RIG_PRE + RIG_LOAD and p["hold"]
and not r["hold"]
for s_ in [r["est"] is not None and r["est"] < LINE
and r["house"] >= LINE]]
print(f" A 49 %, 45 min: flips {flips(load45)}, releases {len(rel45)} "
f"(stale {sum(1 for _r, s_ in rel45 if s_)}), quarters "
f"{[round(a[0] / a[1]) for a in st['quarters'].values()]}")
check("45 min: A flips charge/give 3 times or fewer (f3f9483: 148)",
flips(load45) <= 3)
check("45 min: no release of the pause on a stale estimate (f3f9483: 83 of 83)",
not any(s_ for _r, s_ in rel45))
check("45 min: every quarter at or under the month aim", quarters_ok(st))
# ============================================================================ #
print("\n2. the cap: while the pause holds, A gives at most the largest part "
"of the guard's floor placed on it this period")
rows, st, c = scen(soc=RESERVE + 1.0, house=stepped_house(3000.0, 6500.0))
show("A 21 %", rows, st)
check("A gives only the guard's claim, under 0.15 kWh (f3f9483 0.94)",
sum(r["u"] for r in rows if r["u"] > 0) / 3.6e6 < 0.15)
check("A never goes under its peak reserve in the peak (rig: to 10 %)",
min(r["soc"] for r in rows) >= RESERVE - 0.5)
check("every quarter at or under the month aim", quarters_ok(st))
rows, st, c = scen(house=stepped_house(3000.0, 6500.0))
soc_start = max(r["soc"] for r in rows if r["t"] <= PRE + 5.0)
drop = soc_start - min(r["soc"] for r in rows if r["t"] >= PRE)
print(f" A at 49 %: SoC drop {drop:.2f} point")
# Owner 2026-11-13 accepted about 0.37 kWh per 45-min peak with the cap
# (DECISIONS): 0.37 * 13 / 45 = 0.107 kWh in this load, 0.70 point of
# 15.36 kWh. Measured 0.64.
check("A at 49 %: its SoC drops no more than the owner-accepted give allows "
"(0.70 point in the 13 min; f3f9483 6.1)", drop <= 0.70)
rows, st, c = scen(soc=49.0, other=18.2, house=stepped_house(3000.0, 12000.0))
show("A 49 %, B 18 % under its reserve, house 12000 W", rows, st)
load = [r for r in rows if PRE <= r["t"] < PRE + LOAD]
check("the guard's own claim stands: with B under its reserve A gives for "
"the peak (over 0.2 kWh; the cap yields to the guard)",
sum(r["u"] for r in load if r["u"] > 0) / 3.6e6 > 0.2)
g = [("give" if r["u"] > 50 else "idle") for r in load]
sw = sum(1 for x, y in zip(g, g[1:]) if x != y)
print(f" give/idle switches of A in the load: {sw}")
check("...give/idle switches of A at most 10 in the 13 min", sw <= 10)
def period_max(rows, f):
"""Per row: the largest f(row) over the paused rows of its 15-minute
period so far (0 W outside the pause), as the owner rule reads."""
out, q, m = [], None, 0.0
for r in rows:
qi = int((T0.timestamp() + r["t"]) // 900)
if qi != q or not r["hold"]:
q, m = qi, 0.0
if r["hold"]:
m = max(m, f(r))
out.append(m)
return out
for tag, ch, hi_w in (("B on Cheap hours", None, 9000.0),
("B on Solar first (it gives for the house too)",
{"a": sc.CH_CH["a"],
"b": (True, packmode.SOLAR_FIRST, False)},
12000.0)):
rows, st, c = scen(soc=49.0, other=40.0, choice=ch,
house=stepped_house(3000.0, hi_w))
show(f"A 49 %, B 40 %, both able, {tag}, house {hi_w:.0f} W", rows, st)
mf = period_max(rows, lambda r: r["floor"])
held_rows = [(r, m) for r, m in zip(rows, mf)
if r["hold"] and r["floor"] > 0.0 and r["hi_u"] is not None]
n = max(1, len(held_rows))
over = sum(1 for r, m in held_rows if r["share_u"] > m + 2.0)
# the whole floor, as far as A's rating lets it be A's limit
under = sum(1 for r, m in held_rows
if r["hi_u"] < min(m, rp.RATING) - 500.0)
print(f" {len(held_rows)} paused cycles with a guard floor (mean "
f"{sum(r['floor'] for r, _m in held_rows) / n:.0f} W, period's "
f"largest {sum(m for _r, m in held_rows) / n:.0f} W): A's limit "
f"{sum(r['hi_u'] for r, _m in held_rows) / n:.0f} W, A "
f"{sum(r['share_u'] for r, _m in held_rows) / n:.0f} W, B "
f"{sum(r['share_o'] for r, _m in held_rows) / n:.0f} W; A over the "
f"period's largest floor in {over}; A's limit 500 W or more under it"
f" (or A's rating) in {under}")
check(f"{tag}: the pause holds with a guard floor for over 5 min",
len(held_rows) >= 300)
check("...A never gives more than the largest guard floor of the period "
"(owner 2026-11-13)", over == 0)
if ch is not None:
check("...B is placed part of the floor, so A's limit is its own part,"
" 500 W or more under the period's largest floor (or A's "
"rating) in 9 of 10 cycles (not the whole floor)",
under >= 0.9 * len(held_rows))
check("...every quarter at or under the month aim", quarters_ok(st))
rows, st, c = scen(soc=18.2, other=30.0, house=stepped_house(3000.0, 12000.0))
show("A 18 % under its reserve, B 30 % able, house 12000 W", rows, st)
check("the guard places its claim on the other pack: A under its reserve "
"gives under 0.05 kWh and its SoC stays at 18 %",
sum(r["u"] for r in rows if r["u"] > 0) / 3.6e6 < 0.05
and min(r["soc"] for r in rows) >= 18.0)
# H-1 (review 2026-11-14, owner decision): while the pause holds, the packs
# together give only what the guard needs. The live try: A 11 % in CHARGE (under
# its reserve), B 25 % on Cheap hours, 90 min at 6.5 kW.
LIVE = 5400.0
rp.CAP_KWH = 20.48 # the rig's B; A gives nothing here
rows, st, c = scen(soc=11.0, other=25.0,
house=stepped_house(3000.0, 6500.0, LIVE, RIG_PRE),
dur=RIG_PRE + LIVE + POST)
rp.CAP_KWH = 15.36
qs = [a[0] / a[1] for a in st["quarters"].values()]
load = [r for r in rows if RIG_PRE <= r["t"] < RIG_PRE + LIVE]
gb = sum(r["o"] for r in load if r["o"] > 0) / 3.6e6
def switches(k):
g = [("give" if r[k] > 50 else "idle") for r in load]
return sum(1 for x, y in zip(g, g[1:]) if x != y)
b_low = min((r["soc_o"] for r in rows), default=0.0)
print(f" live try: quarters {[round(q) for q in qs]}, B gives {gb:.2f} kWh, "
f"B lowest {b_low:.1f} %, give/idle switches A "
f"{switches('u')}, B {switches('o')}")
check("live try: every quarter at or under the aim + 10 W (07d23d2: 6502 and "
"6499 W against the month peak 6000 W)", max(qs) <= AIM + 10.0)
check("live try: B gives about its guard part, under 1.5 kWh (1b5f7c9 1.0; "
"07d23d2 4.6 kW, 25 -> 10 % in 43 min)", gb < 1.5)
check("live try: B's SoC never goes under 19.8 % (1b5f7c9 19.8)",
b_low >= 19.8)
check("live try: give/idle switches of B at most 40 in the 90 min",
switches("o") <= 40)
# ============================================================================ #
print("\n3. mirror: B in CHARGE at 18 % (under its reserve), A on Cheap hours")
rows, st, c = scen(unit="b", soc=18.2, other=30.0,
house=stepped_house(3000.0, 6500.0))
show("B 18 %", rows, st)
check("B gives nothing for the house: its SoC never goes under 18 %",
min(r["soc"] for r in rows) >= 18.0)
check("every quarter at or under the month aim", quarters_ok(st))
# ============================================================================ #
print("\n4. unchanged: the MAINT-24 live shape with the lagging reading")
rl, sl, cl = scen(house_w=3000.0, dur=600.0)
body = rl[len(rl) // 6:]
mean_a = sum(r["u"] for r in body) / len(body)
mean_b = sum(r["o"] for r in body) / len(body)
print(f" A {mean_a:+.0f} W, B {mean_b:+.0f} W, pause "
f"{sum(r['hold'] for r in rl)} cycles")
check("A charges about 1475 W (-1500..-1440) and the pause never comes",
-1500.0 <= mean_a <= -1440.0 and not any(r["hold"] for r in rl))
check("B does not trade with the grid (Cheap hours, nothing to charge it)",
abs(mean_b) < 100.0)
# ============================================================================ #
print("\n5. peakguard.shaping_held() with `settled`; Controller._batts_settled()")
check("the rule exists (MAINT_STEP_W, _batts_settled)",
hasattr(ctl_trade, "MAINT_STEP_W") and hasattr(ctl_trade.TradeMixin,
"_batts_settled"))
if not hasattr(ctl_trade, "MAINT_STEP_W"):
print(f"\n{len(fails)} FAILED:")
for f in fails:
print(f" - {f}")
sys.exit(1)
U = peakguard.MAINT_RESUME_UNDER_W
idle = peakguard.PeakDecision(engaged=False, floor_w=None, ceiling_w=6000.0,
ceiling_from="x", target_w=AIM)
def held(was, fc, house, settled):
return peakguard.shaping_held(
peakguard.shaping_suspended(idle, fc, AIM), was, fc, AIM, house,
settled)
check("held, house under the line but not settled: stays paused",
held(True, AIM - 1, AIM - U - 100.0, False))
check("held, house under the line and settled: resumes",
not held(True, AIM - 1, AIM - U - 100.0, True))
check("not held: settled makes no difference",
not held(False, AIM - 1, 6500.0, False))
check("neither the house nor the forecast read: no pause, settled or not "
"(SAFETY-63)",
not held(True, None, None, False))
class _Fresh:
def __init__(self, changed):
self.changed_mono = changed
class _Inv:
def __init__(self, name, cmd, changed):
self.name, self.cmd = name, cmd
self.batt_fresh = _Fresh(changed)
def standing_w(self):
return self.cmd
class _Ctl:
_batts_settled = getattr(ctl_trade.TradeMixin, "_batts_settled", None)
def __init__(self, invs):
self.inverters, self._m28_step, self._now_mono = invs, {}, 0.0
S = freshness.PLANT_SETTLE_S
a = _Inv("a", -1500.0, 0.0)
k = _Ctl([a, _Inv("b", 0.0, 0.0)])
check("no step seen yet: settled", k._batts_settled())
a.cmd = 500.0
k._now_mono = 100.0
check("a step up of the command: not settled", not k._batts_settled())
k._now_mono = 100.0 + S - 0.5
a.batt_fresh.changed_mono = 100.0 + S - 1.0
check("...a reading that arrived before step + settle does not count",
not k._batts_settled())
a.batt_fresh.changed_mono = 100.0 + S
k._now_mono = 100.0 + S
check("...one that arrived at step + settle does", k._batts_settled())
a.cmd = 3000.0
k._now_mono = 200.0
check("a second step up; the old reading is not current",
not k._batts_settled())
k._now_mono = 200.0 + freshness.BATT_OBLIGED_S
check("...and a reading that never changes is waited for no longer than "
"BATT_OBLIGED_S", k._batts_settled())
a.cmd = -1500.0
k._now_mono = 400.0
check("a step down (less give: the estimate errs high) is no step",
k._batts_settled())
a2 = _Inv("a", -1500.0, 0.0)
k2 = _Ctl([a2])
k2._batts_settled()
a2.cmd, k2._now_mono = -1500.0 + ctl_trade.MAINT_STEP_W - 1.0, 1.0
check("a move under ctl_trade.MAINT_STEP_W is no step", k2._batts_settled())
a2.cmd = -1500.0 + ctl_trade.MAINT_STEP_W
check("...one of ctl_trade.MAINT_STEP_W is", not k2._batts_settled())
# Per unit: the cap so far lives under each unit's own key, and only one pack
# can be in maintenance CHARGE at all (maintenance.arbitrate(): one slot).
au, ab = (cl.actuator_of("maintenance", i) for i in cl.inverters)
t = T0 + timedelta(seconds=60)
cl._m28_hi = {au: (int(t.timestamp() // 900), 3000.0)}
check("the period's cap is kept per unit: A's 3000 W is not B's",
cl._m28_was(au, t) == 3000.0 and cl._m28_was(ab, t) == 0.0)
check("...and it starts again from 0 W in the next 15-minute period",
cl._m28_was(au, t + timedelta(seconds=900)) == 0.0)
class _M:
def __init__(self, name):
self.name, self.phase = name, maintenance.CHARGE
check("maintenance.arbitrate(): with two packs in CHARGE only the first keeps "
"the slot", maintenance.arbitrate([_M("a"), _M("b")], t)[1] != ""
and maintenance.arbitrate([_M("a"), _M("b")], t)[0] == "")
print()
if fails:
print(f"{len(fails)} FAILED:")
for f in fails:
print(f" - {f}")
sys.exit(1)
print("all checks passed")
+335 -5
View File
@@ -22,11 +22,7 @@ record.
8. Options: validation of the trust and the entities.
Mutations (MUTATION.md, purged copies) are listed in the pull request.
This file is parts 1-5 and 8. Part 6 (the real controller over a night and a day,
the slow one) and part 7 are in test_modes_p4b.py, test_modes_p4c.py and
test_modes_p4d.py, one group of scenarios each, so CI can run them side by side
(CI-18). Every check is in exactly one of the four files."""
"""
import asyncio
import logging
@@ -553,6 +549,340 @@ e = modetrade.energy([pk(B, packmode.LEFTOVER_SOLAR, 30.0)], 20.0, 95.0,
check("the cheap run is sized by the shortfall (1.5 kWh), not the room to "
"95 % (6.5 kWh)", abs(e[0] - 1.5) < 1e-9)
# ============================================================================ #
print("6. the real controller over a night and a day")
AIM = rp.PEAK_CAP - 50
FC_KWH = [None] # today's forecast in the fake sensor (None: down)
async def _sensor(self, e):
now = rp_start[0] + timedelta(seconds=self.t)
kwh = FC_KWH[0](now) if callable(FC_KWH[0]) else FC_KWH[0]
if kwh is None:
return {"state": "unavailable", "attributes": {},
"last_updated": now.isoformat()}
if e.endswith("tomorrow"):
return None
loc = now.astimezone(L)
d0 = loc.replace(hour=0, minute=0, second=0, microsecond=0)
wh = {(d0 + timedelta(hours=h)).astimezone(timezone.utc).isoformat():
(kwh * 100.0 if 8 <= h < 18 else 0.0) for h in range(24)}
left = sum(v for k, v in wh.items()
if datetime.fromisoformat(k) >= now) / 1000.0
return {"state": f"{left:.3f}",
"attributes": {"unit_of_measurement": "kWh", "wh_period": wh},
"last_updated": now.isoformat(), "last_reported": now.isoformat()}
rp.Hass.state = _sensor
rp_start = [UTC0]
FC_OPTS = {"pv_forecast_entity": "sensor.energy_production_today_remaining",
"cycle_cost_threshold_eur": 0.20}
# TARIFF-24 round 2: with a forecast read, a price mode needs the cycle cost
# itself (0.20 here), no longer 1.5 times it (0.30). These scenarios were
# written for a 0.30 gap, and a midday 0.21 gap now plans a grid top-up they
# are not about, so they ask for 0.30 with the forecast; the no-forecast leg
# (`rows_nf`) keeps 0.20, which is 0.30 widened: the same gate on both sides.
GATE_030 = {"cycle_cost_threshold_eur": 0.30}
def seed_profile(c):
if c.house_profile is not None:
c.house_profile = profile(day_w=600.0, evening=3000.0)
def house_flat(w):
return [(UTC0.timestamp() - 10, float(w))]
def run_day(choice, *, fc, soc0, hours=21.0, start_h=0.75, house_w=800.0,
refuse=(), extra=None, patch=seed_profile):
FC_KWH[0] = fc
start = UTC0 + timedelta(hours=start_h)
rp_start[0] = start
rows = []
def cb(c, h, now, pr):
sh = dict(c.allocation.shares) if c.allocation is not None and \
c.allocation.shares else {}
rows.append(dict(
now=now, grid=h.grid(), shares=sh,
action=getattr(c.arb, "action", None),
roles=dict(c.mode_tick.roles) if c.mode_tick else {},
soc={u: p.soc for u, p in h.plants.items()},
targets=c.plan_targets(), plan=c.day_plan, runs=c.mode_runs))
st_, c = rp.run("p3_ls", house_flat(house_w), WPTS, start, 3600 * hours,
check=cb, soc0=soc0, choice=choice, refuse=refuse,
extra=dict(FC_OPTS, **(extra or {})), patch=patch)
return rows, st_, c
SF_LS = {"a": (True, "solar_first", False), "b": (True, "leftover_solar",
False)}
SF_CH = {"a": (True, "solar_first", False), "b": (True, "cheap_hours",
False)}
def invariants(tag, rows, c):
charge = [r for r in rows if r["action"] == arbitrage.CHARGE]
mixed = [r for r in rows if any(v > 0 for v in r["shares"].values())
and any(v < 0 for v in r["shares"].values())]
check(f"{tag}: no opposite-direction split on any cycle", not mixed)
check(f"{tag}: Solar first never charges from the grid (A's share >= 0 "
"while the site charges)",
all(r["shares"].get(A, 0) >= 0 for r in charge))
q = {int(r["now"].timestamp() // 900) for r in charge}
banked = [b.offtake_avg_w for b in c.p1.blocks
if int(b.start.timestamp() // 900) in q]
check(f"{tag}: every banked quarter with a grid charge <= cap - margin "
f"(max {max(banked, default=0):.1f} W, aim {AIM})",
not banked or max(banked) <= AIM + 0.5)
return charge
# Sunny: 40 kWh forecast. B (Leftover solar) at 30 % needs nothing.
rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0},
extra=GATE_030)
charge = invariants("sunny", rows, c)
_last = nth(rows, -1, "a cycle")
print(f" sunny: verdict {present(_last) and _last['plan'] and _last['plan'].verdict}, "
f"{len(charge)} charge cycles")
check("sunny: a day plan is made, and says sunny",
any(r["plan"] is not None and r["plan"].verdict == dayplan.SUNNY
for r in rows))
check("sunny: no grid charge at all", not charge)
# TARIFF-24 round 2: the same day at the cycle cost 0.20 itself. With the
# forecast read the gap needed is 0.20 (not 1.5 x = 0.30), so the midday
# quarter 0.339 against the evening 0.551 (gap 0.21, between 1x and 1.5x) is
# a planned top-up for B (Leftover solar) up to its planned level.
rows_g, st_, c_g = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0})
charge_g = invariants("gap between 1x and 1.5x", rows_g, c_g)
_first_g = nth(charge_g, 0, "a charge cycle")
_gaps = [min(g.mean_eur_kwh for g in r["runs"].give)
- r["runs"].cheap.mean_eur_kwh for r in charge_g
if r["runs"] is not None and r["runs"].give]
print(f" gap 0.20 <= gap < 0.30: {len(charge_g)} charge cycles, run gap "
f"{min(_gaps, default=0):.3f}, B to "
f"{max((r['soc']['b'] for r in rows_g), default=0):.1f} %")
check("a forecast day whose price gap lies between 1x and 1.5x the cycle "
"cost (0.20 < 0.21 < 0.30) plans a cheap run: B charges from the grid "
"inside it, only B, and only up to its planned level",
present(_first_g) and len(_gaps) == len(charge_g)
and all(0.20 <= g < 0.30 for g in _gaps)
and all(r["runs"].cheap.holds(r["now"]) for r in charge_g)
and all(r["roles"][B] == modetrade.CHARGE for r in charge_g)
and all(r["roles"][A] != modetrade.CHARGE for r in charge_g)
and max(r["soc"]["b"] for r in rows_g) <= 45.64 + 2.0)
check("...and the same day with no forecast read does not (it needs 0.30): "
"the old gate, kept for a day without a forecast",
not [r for r in run_day(SF_LS, fc=None,
soc0={"a": 60.0, "b": 30.0})[0]
if r["action"] == arbitrage.CHARGE
and r["now"].astimezone(L).hour == 12])
# Dark: 1 kWh. B buys the evening's shortfall only, in the cheap run.
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0})
charge = invariants("dark", rows, c)
tgt = nth([r["targets"][B] for r in rows if r["targets"]], 0, "a level")
top = max(r["soc"]["b"] for r in rows)
print(f" dark: B level {tgt:.1f} %, B reached {top:.1f} %, "
f"{len(charge)} charge cycles")
check("dark: Leftover solar charges from the grid in the cheap run",
charge and all(r["runs"].cheap.holds(r["now"]) for r in charge)
and all(r["roles"][B] == modetrade.CHARGE for r in charge))
check("dark: ...only up to its level (the shortfall), not 95 %",
present(tgt) and tgt < 60.0 and top <= tgt + 2.0)
check("dark: A rests while B charges", all(r["roles"][A] == modetrade.REST
for r in charge))
# Cheap hours on a partly sunny day: ignores the plan, fills as in P3.
rows, st_, c = run_day(SF_CH, fc=14.0, soc0={"a": 60.0, "b": 30.0},
extra=GATE_030)
charge = invariants("cheap hours, partly", rows, c)
top = max(r["soc"]["b"] for r in rows)
print(f" cheap hours partly: B reached {top:.1f} %")
check("Cheap hours gets no planned level",
not any(r["targets"] and B in r["targets"] for r in rows))
rows_nf, _s, c_nf = run_day(SF_CH, fc=None, soc0={"a": 60.0, "b": 30.0})
check("Cheap hours with a sun forecast charges as with none (P3)",
charge and abs(max(r["soc"]["b"] for r in rows_nf) - top) < 1.0
and top > 80.0)
# The forecast goes away mid-run: a charge under way goes on to its level
# (OPT-34; it stopped at once, P3 option A, before). With no charge under way
# the levels go with the forecast (below, and test_opt27.py).
# OPT-27: a sensor that is unavailable is covered by its last fresh reading
# for up to 3 h (`solarfc.Hold`), so "lost" here is a hold that never covers;
# the next scenario is the same loss with the hold (test_opt27.py).
DROP = UTC0 + timedelta(hours=1, minutes=30)
class _NoHold(solarfc.Hold):
def stand_in(self, *a, **k):
return None
def seed_profile_no_hold(c):
seed_profile(c)
c.fc_hold = _NoHold()
rows, st_, c = run_day(SF_LS, fc=lambda now: 1.0 if now < DROP else None,
soc0={"a": 60.0, "b": 10.0}, patch=seed_profile_no_hold)
invariants("forecast lost mid-run", rows, c)
before = [r for r in rows if r["now"] < DROP and r["action"]
== arbitrage.CHARGE]
late = [r for r in rows if r["now"] > DROP + timedelta(
seconds=2 * 60 + 10) and r["action"] == arbitrage.CHARGE]
check("forecast lost mid-run (OPT-34): Leftover solar was charging, and goes "
"on charging past a forecast read (60 s) and a cycle, to its level",
before and late)
rows, st_, c = run_day(SF_LS, fc=lambda now: 1.0 if now < DROP else None,
soc0={"a": 60.0, "b": 10.0})
invariants("forecast unavailable mid-run, covered", rows, c)
check("forecast unavailable mid-run (OPT-27): the last reading covers it, so "
"Leftover solar goes on charging past the point where it was lost",
[r for r in rows if r["now"] < DROP and r["action"]
== arbitrage.CHARGE]
and [r for r in rows if r["now"] > DROP + timedelta(
seconds=2 * 60 + 10) and r["action"] == arbitrage.CHARGE])
# The forecast is far too high (40 kWh, and there is no sun at all): no grid
# charge, so B covers less of the evening - a money risk, never a safety one.
rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 30.0, "b": 30.0},
extra=GATE_030)
invariants("forecast too high", rows, c)
check("forecast too high: no grid charge, and B still keeps its power for "
"the dear run", not [r for r in rows if r["action"]
== arbitrage.CHARGE]
and all(r["roles"].get(B) != modetrade.GIVE for r in rows
if r["now"].astimezone(L).hour not in (19,)))
# A refusal wins over the plan.
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
refuse=("b",), extra=GATE_030)
invariants("refusal", rows, c)
check("refusal: B refuses to charge, so the plan's charge ends and B is "
"never a charger after it", rows and not [
r for r in rows[len(rows) // 3:]
if r["roles"].get(B) == modetrade.CHARGE])
# Off wins over the plan.
rows, st_, c = run_day({"a": (True, "solar_first", False),
"b": (False, "leftover_solar", False)},
fc=1.0, soc0={"a": 60.0, "b": 30.0})
check("Off: an Off battery never charges from the grid, whatever the plan",
not [r for r in rows if r["action"] == arbitrage.CHARGE]
and all(abs(r["shares"].get(B, 0)) < 1e-6 for r in rows))
# No house profile yet (first day): no plan, P3 option A.
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
patch=None)
check("no house profile yet: no plan, and Leftover solar takes solar only",
all(r["plan"] is None for r in rows)
and not [r for r in rows if r["action"] == arbitrage.CHARGE])
check("...while the profile learns and the store keeps each closed hour",
c.house_profile is not None and len(
c.store.data.get("house_profile") or {}) >= 1)
check("selling stays off (option A)", packmode.SELLING_ENABLED is False)
# A forecast arriving mid-period makes the plan at once, not at the next
# 15-minute period.
COME = datetime(2026, 9, 21, 1, 3, tzinfo=L).astimezone(timezone.utc)
rows, st_, c = run_day(SF_LS, fc=lambda now: None if now < COME else 1.0,
soc0={"a": 60.0, "b": 30.0}, hours=0.5)
first = next((r["now"] for r in rows if r["targets"]), None)
check("a forecast that arrives at 01:03 makes the plan before 01:15",
first is not None and first < COME + timedelta(minutes=3))
# Battery modes off: the forecast is never read.
READS = [0]
_real_sensor = rp.Hass.state
async def _counted(self, e):
READS[0] += 1
return await _real_sensor(self, e)
rp.Hass.state = _counted
FC_KWH[0] = 1.0
rp.run("modes_off", house_flat(800.0), WPTS, UTC0 + timedelta(hours=1),
600.0, extra=dict(FC_OPTS))
rp.Hass.state = _real_sensor
check("battery modes off: the forecast sensor is never read", READS[0] == 0)
# ============================================================================ #
print("7. the Batteries screen and the Simple view")
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
hours=0.6)
main_files.live.datetime = datetime
sb = homeview.solar_block(c, c.solar_fc.at)
check("the forecast line names the forecast, what is counted and when",
sb["line"].startswith("Solar still to come today:")
and "we count on" in sb["line"] and sb["state"] == "plan")
why = homeview.day_key(c, B)
check("B's Why key (plan, dark) is tops_up", why == "tops_up")
check("...and says so in plain words, with the level and what it covers "
"(OPT-28)", homeview.why_words(why, pct="82 %", kwh="9.4 kWh")
== "It charges from the grid to 82 %. That covers 9.4 kWh of "
"expensive hours the sun will not.")
_d0, _d1 = homeview.local_day(c.solar_fc.at)
_blocks, _ = homeview.mode_runs(c, _d0, _d1, c.solar_fc.at, False)
_grid = [b for b in _blocks if b["kind"] == "grid" and b["battery"] == 1]
_need = homeview.plan_need(c, B)
check(f"Today: B's grid block is the planned shortfall ({_need:.2f} kWh), "
"not its room to 95 %", _grid and abs(_grid[0]["kwh"] - _need) < 0.01
and _need < 3.0)
_run = c.mode_runs.cheap
_packs = c._mode_packs()
_m1 = c._run_mark("charge", _run, _packs, lambda p: True, ((B, 40.0),))
_m2 = c._run_mark("charge", _run, _packs, lambda p: False, ((B, 50.0),))
check("a level the hysteresis moved opens the run to that battery again",
_m1 and not _m2)
latch, c._charge_latch = c._charge_latch, None
c.solar_fc = None
check("with no charge under way, the levels are dropped as soon as the "
"forecast goes, even before the plan is rebuilt",
c._plan_targets and c.plan_targets() is None)
check("a lost forecast says so: no forecast, Leftover solar solar only",
homeview.solar_block(c, datetime.now(timezone.utc))["state"]
== "no_forecast" and homeview.day_key(c, B) == "no_forecast")
c._charge_latch = latch
# the latch ends at its end time; this replay ran in September, so ask at a
# moment inside it
_real_dt = main_files.live.datetime
main_files.live.datetime = type("_DT", (datetime,), {"now": classmethod(
lambda cls, tz=None: latch[0] - timedelta(hours=1))})
check("OPT-34: with a charge under way (B charged in this run), the level "
"stays: plan_targets() gives it (the line: test_opt34.py)",
latch is not None and c.plan_targets() is not None
and B in c.plan_targets() and c.plan_targets()[B] == c._plan_targets[B])
main_files.live.datetime = _real_dt
check("the Why line wins over 'saves its power' only while holding",
homeview.battery_why(modes_on=True, mode="leftover_solar", off=False,
reading=True, phase="idle", shadow=False,
running=True, held=False, refused=0, peak=False,
sf_ahead=True, role="hold", has_at=True,
day="sun_fills") == "sun_fills"
and homeview.battery_why(modes_on=True, mode="leftover_solar",
off=False, reading=True, phase="idle",
shadow=False, running=True, held=False,
refused=0, peak=False, sf_ahead=True,
role="charge", has_at=True, day="tops_up")
== "grid_charge")
for lang in ("en", "nl"):
homeview._LANG[0] = lang
t = [homeview.why_words(k, pct="82 %", kwh="9.4 kWh")
for k in ("sun_fills", "tops_up", "no_forecast")]
t += [homeview._t("solar.no_forecast"), homeview._t("solar.learning"),
homeview.line_solar(9.2, 6.4, "10:15")]
check(f"{lang}: every P4 sentence is there and short (<= 2 x 12 words)",
all(t) and all(len(s.split()) <= 24 for s in t))
homeview._LANG[0] = "en"
from app import uilayout # noqa: E402
simple = [f.key for _g, _p, f in uilayout.fields() if f.simple]
check("the Simple view has the solar forecast card",
"pv_forecast_entity" in simple)
# ============================================================================ #
print("8. options")
-225
View File
@@ -1,225 +0,0 @@
"""Runnable check for OPT-11 P4, part 6a: the sunny day, the 0.20 gap between 1x and 1.5x, the dark day.
`python3 test_modes_p4b.py`
Split out of test_modes_p4.py by CI-18 so the slow part 6 runs in pieces (CI
runs files side by side; the one file took ~13 min). The docstring there describes
the whole. Same fake Home Assistant, same engine (tools/opt11p3_replay.py), same
checks, none dropped: the four files print exactly the check lines the one file did.
Read MUTATION.md before you report a survivor."""
import asyncio
import logging
import os
import random
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
logging.disable(logging.WARNING)
from named_absence import nth, present # noqa: E402
import main_files # noqa: E402
import opt11p3_replay as rp # noqa: E402
from app import arbitrage, dayplan, homeview, modetrade, packmode # noqa
from app import priceruns, solarfc, validate # noqa: E402
from app.tariff import BILLING_TZ # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
L = timezone(timedelta(hours=2))
A, B = "inverter-a", "inverter-b"
D0 = datetime(2026, 9, 21, tzinfo=L)
UTC0 = D0.astimezone(timezone.utc)
# ============================================================================ #
def profile(day_w=None, days=1, evening=None, start=UTC0 - timedelta(days=1)):
hp = dayplan.HouseProfile()
t = start
end = start + timedelta(days=days)
while t < end:
h = t.astimezone(L).hour
w = (evening if evening is not None and 17 <= h < 22 else
day_w if day_w is not None else 600.0)
hp.add(t, w)
t += timedelta(seconds=5)
hp.add(t, None)
return hp
P = modetrade.Pack
def pk(name, mode, soc, cap=10.0, **kw):
return P(name, True, mode, False, 2500.0, soc, cap, **kw)
# Prices: cheap 01:00-03:00, dear 19:00-20:00 local (as in test_modes_p3).
DAYW = [0.20] * 96 * 2
for i in list(range(4, 12)) + list(range(100, 108)):
DAYW[i] = 0.02
for i in list(range(76, 80)) + list(range(172, 176)):
DAYW[i] = 0.40
WPTS = [(UTC0 + timedelta(minutes=15 * i), 900, p) for i, p in enumerate(DAYW)]
from app.price import PricePoint # noqa: E402
# ============================================================================ #
print("6. the real controller over a night and a day")
AIM = rp.PEAK_CAP - 50
FC_KWH = [None] # today's forecast in the fake sensor (None: down)
async def _sensor(self, e):
now = rp_start[0] + timedelta(seconds=self.t)
kwh = FC_KWH[0](now) if callable(FC_KWH[0]) else FC_KWH[0]
if kwh is None:
return {"state": "unavailable", "attributes": {},
"last_updated": now.isoformat()}
if e.endswith("tomorrow"):
return None
loc = now.astimezone(L)
d0 = loc.replace(hour=0, minute=0, second=0, microsecond=0)
wh = {(d0 + timedelta(hours=h)).astimezone(timezone.utc).isoformat():
(kwh * 100.0 if 8 <= h < 18 else 0.0) for h in range(24)}
left = sum(v for k, v in wh.items()
if datetime.fromisoformat(k) >= now) / 1000.0
return {"state": f"{left:.3f}",
"attributes": {"unit_of_measurement": "kWh", "wh_period": wh},
"last_updated": now.isoformat(), "last_reported": now.isoformat()}
rp.Hass.state = _sensor
rp_start = [UTC0]
FC_OPTS = {"pv_forecast_entity": "sensor.energy_production_today_remaining",
"cycle_cost_threshold_eur": 0.20}
# TARIFF-24 round 2: with a forecast read, a price mode needs the cycle cost
# itself (0.20 here), no longer 1.5 times it (0.30). These scenarios were
# written for a 0.30 gap, and a midday 0.21 gap now plans a grid top-up they
# are not about, so they ask for 0.30 with the forecast; the no-forecast leg
# (`rows_nf`) keeps 0.20, which is 0.30 widened: the same gate on both sides.
GATE_030 = {"cycle_cost_threshold_eur": 0.30}
def seed_profile(c):
if c.house_profile is not None:
c.house_profile = profile(day_w=600.0, evening=3000.0)
def house_flat(w):
return [(UTC0.timestamp() - 10, float(w))]
def run_day(choice, *, fc, soc0, hours=21.0, start_h=0.75, house_w=800.0,
refuse=(), extra=None, patch=seed_profile):
FC_KWH[0] = fc
start = UTC0 + timedelta(hours=start_h)
rp_start[0] = start
rows = []
def cb(c, h, now, pr):
sh = dict(c.allocation.shares) if c.allocation is not None and \
c.allocation.shares else {}
rows.append(dict(
now=now, grid=h.grid(), shares=sh,
action=getattr(c.arb, "action", None),
roles=dict(c.mode_tick.roles) if c.mode_tick else {},
soc={u: p.soc for u, p in h.plants.items()},
targets=c.plan_targets(), plan=c.day_plan, runs=c.mode_runs))
st_, c = rp.run("p3_ls", house_flat(house_w), WPTS, start, 3600 * hours,
check=cb, soc0=soc0, choice=choice, refuse=refuse,
extra=dict(FC_OPTS, **(extra or {})), patch=patch)
return rows, st_, c
SF_LS = {"a": (True, "solar_first", False), "b": (True, "leftover_solar",
False)}
SF_CH = {"a": (True, "solar_first", False), "b": (True, "cheap_hours",
False)}
def invariants(tag, rows, c):
charge = [r for r in rows if r["action"] == arbitrage.CHARGE]
mixed = [r for r in rows if any(v > 0 for v in r["shares"].values())
and any(v < 0 for v in r["shares"].values())]
check(f"{tag}: no opposite-direction split on any cycle", not mixed)
check(f"{tag}: Solar first never charges from the grid (A's share >= 0 "
"while the site charges)",
all(r["shares"].get(A, 0) >= 0 for r in charge))
q = {int(r["now"].timestamp() // 900) for r in charge}
banked = [b.offtake_avg_w for b in c.p1.blocks
if int(b.start.timestamp() // 900) in q]
check(f"{tag}: every banked quarter with a grid charge <= cap - margin "
f"(max {max(banked, default=0):.1f} W, aim {AIM})",
not banked or max(banked) <= AIM + 0.5)
return charge
# Sunny: 40 kWh forecast. B (Leftover solar) at 30 % needs nothing.
rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0},
extra=GATE_030)
charge = invariants("sunny", rows, c)
_last = nth(rows, -1, "a cycle")
print(f" sunny: verdict {present(_last) and _last['plan'] and _last['plan'].verdict}, "
f"{len(charge)} charge cycles")
check("sunny: a day plan is made, and says sunny",
any(r["plan"] is not None and r["plan"].verdict == dayplan.SUNNY
for r in rows))
check("sunny: no grid charge at all", not charge)
# TARIFF-24 round 2: the same day at the cycle cost 0.20 itself. With the
# forecast read the gap needed is 0.20 (not 1.5 x = 0.30), so the midday
# quarter 0.339 against the evening 0.551 (gap 0.21, between 1x and 1.5x) is
# a planned top-up for B (Leftover solar) up to its planned level.
rows_g, st_, c_g = run_day(SF_LS, fc=40.0, soc0={"a": 60.0, "b": 30.0})
charge_g = invariants("gap between 1x and 1.5x", rows_g, c_g)
_first_g = nth(charge_g, 0, "a charge cycle")
_gaps = [min(g.mean_eur_kwh for g in r["runs"].give)
- r["runs"].cheap.mean_eur_kwh for r in charge_g
if r["runs"] is not None and r["runs"].give]
print(f" gap 0.20 <= gap < 0.30: {len(charge_g)} charge cycles, run gap "
f"{min(_gaps, default=0):.3f}, B to "
f"{max((r['soc']['b'] for r in rows_g), default=0):.1f} %")
check("a forecast day whose price gap lies between 1x and 1.5x the cycle "
"cost (0.20 < 0.21 < 0.30) plans a cheap run: B charges from the grid "
"inside it, only B, and only up to its planned level",
present(_first_g) and len(_gaps) == len(charge_g)
and all(0.20 <= g < 0.30 for g in _gaps)
and all(r["runs"].cheap.holds(r["now"]) for r in charge_g)
and all(r["roles"][B] == modetrade.CHARGE for r in charge_g)
and all(r["roles"][A] != modetrade.CHARGE for r in charge_g)
and max(r["soc"]["b"] for r in rows_g) <= 45.64 + 2.0)
check("...and the same day with no forecast read does not (it needs 0.30): "
"the old gate, kept for a day without a forecast",
not [r for r in run_day(SF_LS, fc=None,
soc0={"a": 60.0, "b": 30.0})[0]
if r["action"] == arbitrage.CHARGE
and r["now"].astimezone(L).hour == 12])
# Dark: 1 kWh. B buys the evening's shortfall only, in the cheap run.
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0})
charge = invariants("dark", rows, c)
tgt = nth([r["targets"][B] for r in rows if r["targets"]], 0, "a level")
top = max(r["soc"]["b"] for r in rows)
print(f" dark: B level {tgt:.1f} %, B reached {top:.1f} %, "
f"{len(charge)} charge cycles")
check("dark: Leftover solar charges from the grid in the cheap run",
charge and all(r["runs"].cheap.holds(r["now"]) for r in charge)
and all(r["roles"][B] == modetrade.CHARGE for r in charge))
check("dark: ...only up to its level (the shortfall), not 95 %",
present(tgt) and tgt < 60.0 and top <= tgt + 2.0)
check("dark: A rests while B charges", all(r["roles"][A] == modetrade.REST
for r in charge))
print()
if fails:
print(f"FAILED: {len(fails)}")
for f in fails:
print(" -", f)
sys.exit(1)
print("all checks passed")
-232
View File
@@ -1,232 +0,0 @@
"""Runnable check for OPT-11 P4, part 6b: cheap hours on a partly sunny day, the forecast lost mid-run, a forecast far too high.
`python3 test_modes_p4c.py`
Split out of test_modes_p4.py by CI-18 so the slow part 6 runs in pieces (CI
runs files side by side; the one file took ~13 min). The docstring there describes
the whole. Same fake Home Assistant, same engine (tools/opt11p3_replay.py), same
checks, none dropped: the four files print exactly the check lines the one file did.
Read MUTATION.md before you report a survivor."""
import asyncio
import logging
import os
import random
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
logging.disable(logging.WARNING)
from named_absence import nth, present # noqa: E402
import main_files # noqa: E402
import opt11p3_replay as rp # noqa: E402
from app import arbitrage, dayplan, homeview, modetrade, packmode # noqa
from app import priceruns, solarfc, validate # noqa: E402
from app.tariff import BILLING_TZ # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
L = timezone(timedelta(hours=2))
A, B = "inverter-a", "inverter-b"
D0 = datetime(2026, 9, 21, tzinfo=L)
UTC0 = D0.astimezone(timezone.utc)
# ============================================================================ #
def profile(day_w=None, days=1, evening=None, start=UTC0 - timedelta(days=1)):
hp = dayplan.HouseProfile()
t = start
end = start + timedelta(days=days)
while t < end:
h = t.astimezone(L).hour
w = (evening if evening is not None and 17 <= h < 22 else
day_w if day_w is not None else 600.0)
hp.add(t, w)
t += timedelta(seconds=5)
hp.add(t, None)
return hp
P = modetrade.Pack
def pk(name, mode, soc, cap=10.0, **kw):
return P(name, True, mode, False, 2500.0, soc, cap, **kw)
# Prices: cheap 01:00-03:00, dear 19:00-20:00 local (as in test_modes_p3).
DAYW = [0.20] * 96 * 2
for i in list(range(4, 12)) + list(range(100, 108)):
DAYW[i] = 0.02
for i in list(range(76, 80)) + list(range(172, 176)):
DAYW[i] = 0.40
WPTS = [(UTC0 + timedelta(minutes=15 * i), 900, p) for i, p in enumerate(DAYW)]
from app.price import PricePoint # noqa: E402
# ============================================================================ #
print("6. the real controller over a night and a day")
AIM = rp.PEAK_CAP - 50
FC_KWH = [None] # today's forecast in the fake sensor (None: down)
async def _sensor(self, e):
now = rp_start[0] + timedelta(seconds=self.t)
kwh = FC_KWH[0](now) if callable(FC_KWH[0]) else FC_KWH[0]
if kwh is None:
return {"state": "unavailable", "attributes": {},
"last_updated": now.isoformat()}
if e.endswith("tomorrow"):
return None
loc = now.astimezone(L)
d0 = loc.replace(hour=0, minute=0, second=0, microsecond=0)
wh = {(d0 + timedelta(hours=h)).astimezone(timezone.utc).isoformat():
(kwh * 100.0 if 8 <= h < 18 else 0.0) for h in range(24)}
left = sum(v for k, v in wh.items()
if datetime.fromisoformat(k) >= now) / 1000.0
return {"state": f"{left:.3f}",
"attributes": {"unit_of_measurement": "kWh", "wh_period": wh},
"last_updated": now.isoformat(), "last_reported": now.isoformat()}
rp.Hass.state = _sensor
rp_start = [UTC0]
FC_OPTS = {"pv_forecast_entity": "sensor.energy_production_today_remaining",
"cycle_cost_threshold_eur": 0.20}
# TARIFF-24 round 2: with a forecast read, a price mode needs the cycle cost
# itself (0.20 here), no longer 1.5 times it (0.30). These scenarios were
# written for a 0.30 gap, and a midday 0.21 gap now plans a grid top-up they
# are not about, so they ask for 0.30 with the forecast; the no-forecast leg
# (`rows_nf`) keeps 0.20, which is 0.30 widened: the same gate on both sides.
GATE_030 = {"cycle_cost_threshold_eur": 0.30}
def seed_profile(c):
if c.house_profile is not None:
c.house_profile = profile(day_w=600.0, evening=3000.0)
def house_flat(w):
return [(UTC0.timestamp() - 10, float(w))]
def run_day(choice, *, fc, soc0, hours=21.0, start_h=0.75, house_w=800.0,
refuse=(), extra=None, patch=seed_profile):
FC_KWH[0] = fc
start = UTC0 + timedelta(hours=start_h)
rp_start[0] = start
rows = []
def cb(c, h, now, pr):
sh = dict(c.allocation.shares) if c.allocation is not None and \
c.allocation.shares else {}
rows.append(dict(
now=now, grid=h.grid(), shares=sh,
action=getattr(c.arb, "action", None),
roles=dict(c.mode_tick.roles) if c.mode_tick else {},
soc={u: p.soc for u, p in h.plants.items()},
targets=c.plan_targets(), plan=c.day_plan, runs=c.mode_runs))
st_, c = rp.run("p3_ls", house_flat(house_w), WPTS, start, 3600 * hours,
check=cb, soc0=soc0, choice=choice, refuse=refuse,
extra=dict(FC_OPTS, **(extra or {})), patch=patch)
return rows, st_, c
SF_LS = {"a": (True, "solar_first", False), "b": (True, "leftover_solar",
False)}
SF_CH = {"a": (True, "solar_first", False), "b": (True, "cheap_hours",
False)}
def invariants(tag, rows, c):
charge = [r for r in rows if r["action"] == arbitrage.CHARGE]
mixed = [r for r in rows if any(v > 0 for v in r["shares"].values())
and any(v < 0 for v in r["shares"].values())]
check(f"{tag}: no opposite-direction split on any cycle", not mixed)
check(f"{tag}: Solar first never charges from the grid (A's share >= 0 "
"while the site charges)",
all(r["shares"].get(A, 0) >= 0 for r in charge))
q = {int(r["now"].timestamp() // 900) for r in charge}
banked = [b.offtake_avg_w for b in c.p1.blocks
if int(b.start.timestamp() // 900) in q]
check(f"{tag}: every banked quarter with a grid charge <= cap - margin "
f"(max {max(banked, default=0):.1f} W, aim {AIM})",
not banked or max(banked) <= AIM + 0.5)
return charge
# Cheap hours on a partly sunny day: ignores the plan, fills as in P3.
rows, st_, c = run_day(SF_CH, fc=14.0, soc0={"a": 60.0, "b": 30.0},
extra=GATE_030)
charge = invariants("cheap hours, partly", rows, c)
top = max(r["soc"]["b"] for r in rows)
print(f" cheap hours partly: B reached {top:.1f} %")
check("Cheap hours gets no planned level",
not any(r["targets"] and B in r["targets"] for r in rows))
rows_nf, _s, c_nf = run_day(SF_CH, fc=None, soc0={"a": 60.0, "b": 30.0})
check("Cheap hours with a sun forecast charges as with none (P3)",
charge and abs(max(r["soc"]["b"] for r in rows_nf) - top) < 1.0
and top > 80.0)
# The forecast goes away mid-run: a charge under way goes on to its level
# (OPT-34; it stopped at once, P3 option A, before). With no charge under way
# the levels go with the forecast (below, and test_opt27.py).
# OPT-27: a sensor that is unavailable is covered by its last fresh reading
# for up to 3 h (`solarfc.Hold`), so "lost" here is a hold that never covers;
# the next scenario is the same loss with the hold (test_opt27.py).
DROP = UTC0 + timedelta(hours=1, minutes=30)
class _NoHold(solarfc.Hold):
def stand_in(self, *a, **k):
return None
def seed_profile_no_hold(c):
seed_profile(c)
c.fc_hold = _NoHold()
rows, st_, c = run_day(SF_LS, fc=lambda now: 1.0 if now < DROP else None,
soc0={"a": 60.0, "b": 10.0}, patch=seed_profile_no_hold)
invariants("forecast lost mid-run", rows, c)
before = [r for r in rows if r["now"] < DROP and r["action"]
== arbitrage.CHARGE]
late = [r for r in rows if r["now"] > DROP + timedelta(
seconds=2 * 60 + 10) and r["action"] == arbitrage.CHARGE]
check("forecast lost mid-run (OPT-34): Leftover solar was charging, and goes "
"on charging past a forecast read (60 s) and a cycle, to its level",
before and late)
rows, st_, c = run_day(SF_LS, fc=lambda now: 1.0 if now < DROP else None,
soc0={"a": 60.0, "b": 10.0})
invariants("forecast unavailable mid-run, covered", rows, c)
check("forecast unavailable mid-run (OPT-27): the last reading covers it, so "
"Leftover solar goes on charging past the point where it was lost",
[r for r in rows if r["now"] < DROP and r["action"]
== arbitrage.CHARGE]
and [r for r in rows if r["now"] > DROP + timedelta(
seconds=2 * 60 + 10) and r["action"] == arbitrage.CHARGE])
# The forecast is far too high (40 kWh, and there is no sun at all): no grid
# charge, so B covers less of the evening - a money risk, never a safety one.
rows, st_, c = run_day(SF_LS, fc=40.0, soc0={"a": 30.0, "b": 30.0},
extra=GATE_030)
invariants("forecast too high", rows, c)
check("forecast too high: no grid charge, and B still keeps its power for "
"the dear run", not [r for r in rows if r["action"]
== arbitrage.CHARGE]
and all(r["roles"].get(B) != modetrade.GIVE for r in rows
if r["now"].astimezone(L).hour not in (19,)))
print()
if fails:
print(f"FAILED: {len(fails)}")
for f in fails:
print(" -", f)
sys.exit(1)
print("all checks passed")
-294
View File
@@ -1,294 +0,0 @@
"""Runnable check for OPT-11 P4, part 6c and 7: a refusal, Off, no house profile, a forecast arriving mid-period, battery modes off; then the Batteries screen and the Simple view.
`python3 test_modes_p4d.py`
Split out of test_modes_p4.py by CI-18 so the slow part 6 runs in pieces (CI
runs files side by side; the one file took ~13 min). The docstring there describes
the whole. Same fake Home Assistant, same engine (tools/opt11p3_replay.py), same
checks, none dropped: the four files print exactly the check lines the one file did.
Read MUTATION.md before you report a survivor."""
import asyncio
import logging
import os
import random
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
logging.disable(logging.WARNING)
from named_absence import nth, present # noqa: E402
import main_files # noqa: E402
import opt11p3_replay as rp # noqa: E402
from app import arbitrage, dayplan, homeview, modetrade, packmode # noqa
from app import priceruns, solarfc, validate # noqa: E402
from app.tariff import BILLING_TZ # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
L = timezone(timedelta(hours=2))
A, B = "inverter-a", "inverter-b"
D0 = datetime(2026, 9, 21, tzinfo=L)
UTC0 = D0.astimezone(timezone.utc)
# ============================================================================ #
def profile(day_w=None, days=1, evening=None, start=UTC0 - timedelta(days=1)):
hp = dayplan.HouseProfile()
t = start
end = start + timedelta(days=days)
while t < end:
h = t.astimezone(L).hour
w = (evening if evening is not None and 17 <= h < 22 else
day_w if day_w is not None else 600.0)
hp.add(t, w)
t += timedelta(seconds=5)
hp.add(t, None)
return hp
P = modetrade.Pack
def pk(name, mode, soc, cap=10.0, **kw):
return P(name, True, mode, False, 2500.0, soc, cap, **kw)
# Prices: cheap 01:00-03:00, dear 19:00-20:00 local (as in test_modes_p3).
DAYW = [0.20] * 96 * 2
for i in list(range(4, 12)) + list(range(100, 108)):
DAYW[i] = 0.02
for i in list(range(76, 80)) + list(range(172, 176)):
DAYW[i] = 0.40
WPTS = [(UTC0 + timedelta(minutes=15 * i), 900, p) for i, p in enumerate(DAYW)]
from app.price import PricePoint # noqa: E402
# ============================================================================ #
print("6. the real controller over a night and a day")
AIM = rp.PEAK_CAP - 50
FC_KWH = [None] # today's forecast in the fake sensor (None: down)
async def _sensor(self, e):
now = rp_start[0] + timedelta(seconds=self.t)
kwh = FC_KWH[0](now) if callable(FC_KWH[0]) else FC_KWH[0]
if kwh is None:
return {"state": "unavailable", "attributes": {},
"last_updated": now.isoformat()}
if e.endswith("tomorrow"):
return None
loc = now.astimezone(L)
d0 = loc.replace(hour=0, minute=0, second=0, microsecond=0)
wh = {(d0 + timedelta(hours=h)).astimezone(timezone.utc).isoformat():
(kwh * 100.0 if 8 <= h < 18 else 0.0) for h in range(24)}
left = sum(v for k, v in wh.items()
if datetime.fromisoformat(k) >= now) / 1000.0
return {"state": f"{left:.3f}",
"attributes": {"unit_of_measurement": "kWh", "wh_period": wh},
"last_updated": now.isoformat(), "last_reported": now.isoformat()}
rp.Hass.state = _sensor
rp_start = [UTC0]
FC_OPTS = {"pv_forecast_entity": "sensor.energy_production_today_remaining",
"cycle_cost_threshold_eur": 0.20}
# TARIFF-24 round 2: with a forecast read, a price mode needs the cycle cost
# itself (0.20 here), no longer 1.5 times it (0.30). These scenarios were
# written for a 0.30 gap, and a midday 0.21 gap now plans a grid top-up they
# are not about, so they ask for 0.30 with the forecast; the no-forecast leg
# (`rows_nf`) keeps 0.20, which is 0.30 widened: the same gate on both sides.
GATE_030 = {"cycle_cost_threshold_eur": 0.30}
def seed_profile(c):
if c.house_profile is not None:
c.house_profile = profile(day_w=600.0, evening=3000.0)
def house_flat(w):
return [(UTC0.timestamp() - 10, float(w))]
def run_day(choice, *, fc, soc0, hours=21.0, start_h=0.75, house_w=800.0,
refuse=(), extra=None, patch=seed_profile):
FC_KWH[0] = fc
start = UTC0 + timedelta(hours=start_h)
rp_start[0] = start
rows = []
def cb(c, h, now, pr):
sh = dict(c.allocation.shares) if c.allocation is not None and \
c.allocation.shares else {}
rows.append(dict(
now=now, grid=h.grid(), shares=sh,
action=getattr(c.arb, "action", None),
roles=dict(c.mode_tick.roles) if c.mode_tick else {},
soc={u: p.soc for u, p in h.plants.items()},
targets=c.plan_targets(), plan=c.day_plan, runs=c.mode_runs))
st_, c = rp.run("p3_ls", house_flat(house_w), WPTS, start, 3600 * hours,
check=cb, soc0=soc0, choice=choice, refuse=refuse,
extra=dict(FC_OPTS, **(extra or {})), patch=patch)
return rows, st_, c
SF_LS = {"a": (True, "solar_first", False), "b": (True, "leftover_solar",
False)}
SF_CH = {"a": (True, "solar_first", False), "b": (True, "cheap_hours",
False)}
def invariants(tag, rows, c):
charge = [r for r in rows if r["action"] == arbitrage.CHARGE]
mixed = [r for r in rows if any(v > 0 for v in r["shares"].values())
and any(v < 0 for v in r["shares"].values())]
check(f"{tag}: no opposite-direction split on any cycle", not mixed)
check(f"{tag}: Solar first never charges from the grid (A's share >= 0 "
"while the site charges)",
all(r["shares"].get(A, 0) >= 0 for r in charge))
q = {int(r["now"].timestamp() // 900) for r in charge}
banked = [b.offtake_avg_w for b in c.p1.blocks
if int(b.start.timestamp() // 900) in q]
check(f"{tag}: every banked quarter with a grid charge <= cap - margin "
f"(max {max(banked, default=0):.1f} W, aim {AIM})",
not banked or max(banked) <= AIM + 0.5)
return charge
# A refusal wins over the plan.
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
refuse=("b",), extra=GATE_030)
invariants("refusal", rows, c)
check("refusal: B refuses to charge, so the plan's charge ends and B is "
"never a charger after it", rows and not [
r for r in rows[len(rows) // 3:]
if r["roles"].get(B) == modetrade.CHARGE])
# Off wins over the plan.
rows, st_, c = run_day({"a": (True, "solar_first", False),
"b": (False, "leftover_solar", False)},
fc=1.0, soc0={"a": 60.0, "b": 30.0})
check("Off: an Off battery never charges from the grid, whatever the plan",
not [r for r in rows if r["action"] == arbitrage.CHARGE]
and all(abs(r["shares"].get(B, 0)) < 1e-6 for r in rows))
# No house profile yet (first day): no plan, P3 option A.
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
patch=None)
check("no house profile yet: no plan, and Leftover solar takes solar only",
all(r["plan"] is None for r in rows)
and not [r for r in rows if r["action"] == arbitrage.CHARGE])
check("...while the profile learns and the store keeps each closed hour",
c.house_profile is not None and len(
c.store.data.get("house_profile") or {}) >= 1)
check("selling stays off (option A)", packmode.SELLING_ENABLED is False)
# A forecast arriving mid-period makes the plan at once, not at the next
# 15-minute period.
COME = datetime(2026, 9, 21, 1, 3, tzinfo=L).astimezone(timezone.utc)
rows, st_, c = run_day(SF_LS, fc=lambda now: None if now < COME else 1.0,
soc0={"a": 60.0, "b": 30.0}, hours=0.5)
first = next((r["now"] for r in rows if r["targets"]), None)
check("a forecast that arrives at 01:03 makes the plan before 01:15",
first is not None and first < COME + timedelta(minutes=3))
# Battery modes off: the forecast is never read.
READS = [0]
_real_sensor = rp.Hass.state
async def _counted(self, e):
READS[0] += 1
return await _real_sensor(self, e)
rp.Hass.state = _counted
FC_KWH[0] = 1.0
rp.run("modes_off", house_flat(800.0), WPTS, UTC0 + timedelta(hours=1),
600.0, extra=dict(FC_OPTS))
rp.Hass.state = _real_sensor
check("battery modes off: the forecast sensor is never read", READS[0] == 0)
# ============================================================================ #
print("7. the Batteries screen and the Simple view")
rows, st_, c = run_day(SF_LS, fc=1.0, soc0={"a": 60.0, "b": 30.0},
hours=0.6)
main_files.live.datetime = datetime
sb = homeview.solar_block(c, c.solar_fc.at)
check("the forecast line names the forecast, what is counted and when",
sb["line"].startswith("Solar still to come today:")
and "we count on" in sb["line"] and sb["state"] == "plan")
why = homeview.day_key(c, B)
check("B's Why key (plan, dark) is tops_up", why == "tops_up")
check("...and says so in plain words, with the level and what it covers "
"(OPT-28)", homeview.why_words(why, pct="82 %", kwh="9.4 kWh")
== "It charges from the grid to 82 %. That covers 9.4 kWh of "
"expensive hours the sun will not.")
_d0, _d1 = homeview.local_day(c.solar_fc.at)
_blocks, _ = homeview.mode_runs(c, _d0, _d1, c.solar_fc.at, False)
_grid = [b for b in _blocks if b["kind"] == "grid" and b["battery"] == 1]
_need = homeview.plan_need(c, B)
check(f"Today: B's grid block is the planned shortfall ({_need:.2f} kWh), "
"not its room to 95 %", _grid and abs(_grid[0]["kwh"] - _need) < 0.01
and _need < 3.0)
_run = c.mode_runs.cheap
_packs = c._mode_packs()
_m1 = c._run_mark("charge", _run, _packs, lambda p: True, ((B, 40.0),))
_m2 = c._run_mark("charge", _run, _packs, lambda p: False, ((B, 50.0),))
check("a level the hysteresis moved opens the run to that battery again",
_m1 and not _m2)
latch, c._charge_latch = c._charge_latch, None
c.solar_fc = None
check("with no charge under way, the levels are dropped as soon as the "
"forecast goes, even before the plan is rebuilt",
c._plan_targets and c.plan_targets() is None)
check("a lost forecast says so: no forecast, Leftover solar solar only",
homeview.solar_block(c, datetime.now(timezone.utc))["state"]
== "no_forecast" and homeview.day_key(c, B) == "no_forecast")
c._charge_latch = latch
# the latch ends at its end time; this replay ran in September, so ask at a
# moment inside it
_real_dt = main_files.live.datetime
main_files.live.datetime = type("_DT", (datetime,), {"now": classmethod(
lambda cls, tz=None: latch[0] - timedelta(hours=1))})
check("OPT-34: with a charge under way (B charged in this run), the level "
"stays: plan_targets() gives it (the line: test_opt34.py)",
latch is not None and c.plan_targets() is not None
and B in c.plan_targets() and c.plan_targets()[B] == c._plan_targets[B])
main_files.live.datetime = _real_dt
check("the Why line wins over 'saves its power' only while holding",
homeview.battery_why(modes_on=True, mode="leftover_solar", off=False,
reading=True, phase="idle", shadow=False,
running=True, held=False, refused=0, peak=False,
sf_ahead=True, role="hold", has_at=True,
day="sun_fills") == "sun_fills"
and homeview.battery_why(modes_on=True, mode="leftover_solar",
off=False, reading=True, phase="idle",
shadow=False, running=True, held=False,
refused=0, peak=False, sf_ahead=True,
role="charge", has_at=True, day="tops_up")
== "grid_charge")
for lang in ("en", "nl"):
homeview._LANG[0] = lang
t = [homeview.why_words(k, pct="82 %", kwh="9.4 kWh")
for k in ("sun_fills", "tops_up", "no_forecast")]
t += [homeview._t("solar.no_forecast"), homeview._t("solar.learning"),
homeview.line_solar(9.2, 6.4, "10:15")]
check(f"{lang}: every P4 sentence is there and short (<= 2 x 12 words)",
all(t) and all(len(s.split()) <= 24 for s in t))
homeview._LANG[0] = "en"
from app import uilayout # noqa: E402
simple = [f.key for _g, _p, f in uilayout.fields() if f.simple]
check("the Simple view has the solar forecast card",
"pv_forecast_entity" in simple)
print()
if fails:
print(f"FAILED: {len(fails)}")
for f in fails:
print(" -", f)
sys.exit(1)
print("all checks passed")
+1 -4
View File
@@ -1148,10 +1148,7 @@ check("⚠️ MAIN.PY ACTUALLY PASSES `weights=`, AND IT PASSES THE METHOD RATHE
"could do - and no fixture anywhere could see that, because every check "
"calls `resolve()` for itself. A method, not a dict, because the "
"weighting is direction-dependent and the direction is stage 2's output",
# MAINT-28 added a second call (`_m28_share()`'s split without the
# paused pack's cap); it must pass the same method, as the cycle's does.
len(_resolve_calls) >= 1
and _w_arg == ["self.pack_weights"] * len(_resolve_calls))
len(_resolve_calls) == 1 and _w_arg == ["self.pack_weights"])
# ⚠️ AC 3 SAYS `unmet_w` MUST BE **VISIBLE**, AND `Allocation.explain()` IS ONLY
# HALF OF THAT. The other half is main.py putting it in the action log, which no
+16 -38
View File
@@ -116,7 +116,6 @@ from math import inf, isinf
from pathlib import Path
from app import messages
from app import ctl_cycle as _ctl_cycle
from app import peakguard
from named_absence import first, given, nth, present
@@ -2788,22 +2787,9 @@ def cycle_claims(run):
return out, (seen[-1] if seen else [])
def run_cycle(ctl, at=None):
"""One `Controller.cycle()`. `at` pins the `now` that cycle() takes
(ctl_cycle.py:49) so a fixture laid up to `at` does not age with host load.
Other modules still read the real clock. CI-17."""
real_dt = _ctl_cycle.datetime
if at is not None:
class _Pinned(datetime):
@classmethod
def now(cls, tz=None):
return at if tz is None else at.astimezone(tz)
_ctl_cycle.datetime = _Pinned
try:
asyncio.get_event_loop_policy().new_event_loop().run_until_complete(
ctl.cycle())
finally:
_ctl_cycle.datetime = real_dt
def run_cycle(ctl):
asyncio.get_event_loop_policy().new_event_loop().run_until_complete(
ctl.cycle())
return ctl
@@ -2815,15 +2801,11 @@ def run_cycle(ctl, at=None):
EVE_MEAN_W = sum(EVE_W) / len(EVE_W)
c_src, _ = built(TMP / "sources.db")
c_src.auto, c_src.batt, c_src.soc = True, 0.0, 100.0
# CI-17: ONE read of the clock, and every cycle on c_src runs AT it. The
# telegrams end here; `cycle()` used to read the real clock again, 1.3 s later
# per cycle under --cpus 0.25, so by the 23rd cycle of the sweep the meter's
# last telegram was older than `max_hold_s` (30 s), the guard counted the gap at
# its ceiling and filed `peak@site` (ctl_cycle.py:49 -> p1.py max_hold_s).
_SRC_NOW = datetime.now(timezone.utc)
_blk_src = datetime.fromtimestamp(
int(_SRC_NOW.timestamp() // QUARTER_S) * QUARTER_S, timezone.utc)
for _i in range(0, int((_SRC_NOW - _blk_src).total_seconds()) + 1, 5):
int(datetime.now(timezone.utc).timestamp() // QUARTER_S) * QUARTER_S,
timezone.utc)
for _i in range(0, int((datetime.now(timezone.utc)
- _blk_src).total_seconds()) + 1, 5):
c_src.p1.submit(sample(_blk_src + timedelta(seconds=_i), EVE_MEAN_W))
c_src.grid = EVE_MEAN_W
@@ -2835,7 +2817,7 @@ SRC_SWEEP = sorted({float(s) for s in range(0, 101, 5)}
IDLE_SRC = {}
for _soc in SRC_SWEEP:
c_src.soc = _soc
_, _cl = cycle_claims(lambda: run_cycle(c_src, at=_SRC_NOW))
_, _cl = cycle_claims(lambda: run_cycle(c_src))
IDLE_SRC[_soc] = frozenset(c.source for c in _cl)
IDLE_SETS = set(IDLE_SRC.values())
print(f" a real idle cycle at {len(SRC_SWEEP)} states of charge "
@@ -3159,7 +3141,7 @@ _b2, _restore_b2 = second_inverter(c_src)
_b2.bms_soc_floor = c_src.inverters[0].bms_soc_floor
_n2_writes_before = len(c_src.hass.per_entity)
try:
_, _cl2 = cycle_claims(lambda: run_cycle(c_src, at=_SRC_NOW))
_, _cl2 = cycle_claims(lambda: run_cycle(c_src))
_n2_target, _n2_reason = c_src.target, c_src.reason
_n2_events = list(c_src.events)
_n2_writes = c_src.hass.per_entity[_n2_writes_before:]
@@ -3355,7 +3337,7 @@ check("...and the action log no longer carries the 'no writer' refusal, "
_nw, _restore_nw = second_inverter(c_src, name="inverter-c", setpoint="")
_nw_writes_before = len(c_src.hass.per_entity)
try:
_, _cl_nw = cycle_claims(lambda: run_cycle(c_src, at=_SRC_NOW))
_, _cl_nw = cycle_claims(lambda: run_cycle(c_src))
_nw_target, _nw_reason = c_src.target, c_src.reason
_nw_events = list(c_src.events)
_nw_writes = c_src.hass.per_entity[_nw_writes_before:]
@@ -3400,21 +3382,16 @@ check("...and the 0 W is NOT what the site target happened to be - the same "
# method is asked, which is what makes this a check on `live_units()` instead of
# a check on a lambda this file wrote.
_bs, _restore_bs = second_inverter(c_src)
# CI-17: from `_SRC_NOW`, the instant the pinned cycles run at; the real clock
# is later, so `live_units()` (real clock) and the cycle (pinned) agree.
_bs.rejected_since = _SRC_NOW - timedelta(seconds=app_main.LINK_STALE_S + 5)
_bs.rejected_since = datetime.now(timezone.utc) - timedelta(
seconds=app_main.LINK_STALE_S + 5)
_bs.last_write_ok = False
_stale_writes_before = len(c_src.hass.per_entity)
try:
check("CI-17: the pinned clock and the real clock agree that inverter B's "
"link is stale, so the cycle and `live_units()` see the same roster",
not _bs.is_live(_SRC_NOW)[0]
and not _bs.is_live(datetime.now(timezone.utc))[0])
check("PRECONDITION: the SHIPPED `live_units()` - not a lambda - drops the "
"inverter whose writes have been rejected for a whole layer-1 window, "
"and keeps the healthy one",
c_src.live_units() == ("inverter-a",))
_, _cl_stale = cycle_claims(lambda: run_cycle(c_src, at=_SRC_NOW))
_, _cl_stale = cycle_claims(lambda: run_cycle(c_src))
_stale_target = c_src.target
_stale_alloc = c_src.allocation
_stale_events = list(c_src.events)
@@ -3456,13 +3433,14 @@ check("⚠️ AND IT DOES NOT ABSORB IT SILENTLY, which is the whole of AC 6 and
# state `live_units()`'s own docstring warns about - the sole inverter dropping
# takes the SITE to 0 W - so it is driven here rather than left as a sentence.
_bd, _restore_bd = second_inverter(c_src)
_gone = _SRC_NOW - timedelta(seconds=app_main.LINK_STALE_S + 5) # CI-17: as above
_gone = datetime.now(timezone.utc) - timedelta(
seconds=app_main.LINK_STALE_S + 5)
_bd.rejected_since, _bd.last_write_ok = _gone, False
c_src.inverters[0].rejected_since = _gone
c_src.inverters[0].last_write_ok = False
_dead_writes_before = len(c_src.hass.per_entity)
try:
_, _cl_dead = cycle_claims(lambda: run_cycle(c_src, at=_SRC_NOW))
_, _cl_dead = cycle_claims(lambda: run_cycle(c_src))
_dead_target, _dead_reason = c_src.target, c_src.reason
_dead_alloc = c_src.allocation
_dead_events = list(c_src.events)
+195 -6
View File
@@ -30,12 +30,7 @@ live), inverter-b Solar first, a house of 1 kW, cap 3500 W, margin 50 W.
quarter's last second.
Mutations (MUTATION.md, purged copies) are listed in the pull request.
CI-18: this file holds parts 1, 2 and 8 (part 8 grades part 2's runs). Parts 3-7 are in
test_safety125b.py, split out so CI can run the pieces side by side (the one
file took ~10 min). Every check is in exactly one file; the two print exactly the
check lines the one file did."""
"""
import asyncio
import logging
@@ -324,7 +319,201 @@ check("the forecast entity is read, in kW, as the live template (SAFETY-118), "
"month peak 5413 W banked, P1 projection"][1]])
# ============================================================================ #
print("\n3. the same for a price trade (modes off) and a maintenance charge")
_ca, _ra, _fa = drive(opts(modes=False, arb=True), peak=PEAK, late=30.0)[:3]
check("modes off, price trading on, a reading 30 s late: every quarter at "
"or under the aim", graded("trade", _fa, AIM_PEAK)
and any(r[3] == "ARBITRAGE_CHARGE" for r in _ra))
def late_feed(gap, every=0.0, look=None):
"""safety84's cheap-window feed, no telegram in each quarter's last
`gap` s, and one only every `every` s (0: every cycle). `look(c, t)`
runs first, on the state the previous cycle left."""
feed = s84.feed(True)
def before(c, t):
if look is not None:
look(c, t)
if ((rig.BASE.timestamp() + t) % QUARTER_S < QUARTER_S - gap
and (not every or t % every < 1e-9)) \
or not getattr(c.hass, "_s84", False):
feed(c, t)
return before
def rig_quarters(rows, load):
"""The safety84 rig's whole quarters: the true average import (W)."""
qs = {}
for r in rows:
q = int((rig.BASE.timestamp() + r[0]) // QUARTER_S)
a = qs.setdefault(q, [0.0, 0])
a[0] += max(0.0, load(r[0]) - sum(v for _u, v in r[2]))
a[1] += 1
return {datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"):
s / k for q, (s, k) in sorted(qs.items())
if k * rig.TICK >= QUARTER_S}
for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)):
_mr, _mc = s84.run(2, load=lambda t, h=house: h, dur=2700.0,
month_peak=peak, before=late_feed(30.0))
_mf = rig_quarters(_mr, lambda t, h=house: h)
check(f"N=2 maintenance charge, house {house:.0f} W, "
f"{'peak banked' if peak else 'no peak banked'}, a reading 30 s "
f"late: every quarter at or under the aim",
graded("maintenance", _mf, aim)
and any(mm.phase == "charge" for mm in _mc.maints))
# ============================================================================ #
print("\n4. a healthy meter: the quarters, and the words")
for name, kw, aim, kw_text in (("month peak banked", dict(peak=PEAK),
AIM_PEAK, "5.4 kW"),
("no peak banked", dict(), AIM_CAP, "3.5 kW")):
_c, _rows, _full, _s = drive(opts(), every=10, **kw)
check(f"{name}: every quarter at or under the aim",
graded(name, _full, aim))
over = [s for s in _s if not s[2] and s[0] > s[1]]
under = [s for s in _s if not s[2] and s[0] <= s[1]]
_o, _u = first(iter(over), "an over sample"), \
first(iter(under), "an under sample")
print(f" over the limit at this rate ({len(over)} samples): "
f"{_o[3] if present(_o) else _o!s} / "
f"{_o[4] if present(_o) else _o!s}")
print(f" under it ({len(under)}): "
f"{_u[3] if present(_u) else _u!s} / "
f"{_u[4] if present(_u) else _u!s}")
check(f"{name}: over the limit at this rate the guard row never says "
f"'under'; it says the grid charge is limited",
present(_o) and all(
"under" not in s[3] and "Peak guard: grid charge limited, "
"at this rate" in s[3] and " over " in s[3] for s in over))
check(f"{name}: ...and the month-peak line says the rate, and that the "
f"grid charge is cut back to stay under {kw_text}",
present(_o) and all(
s[4].startswith("At this rate this 15-minute period reaches")
and s[4].endswith("The grid charge is cut back to stay "
f"under {kw_text}.") for s in over))
check(f"{name}: under the limit both read as before",
present(_u) and all(
s[3].startswith("Peak guard: idle, heading for")
and " under " in s[3]
and s[4].startswith("This 15-minute period is heading for")
and s[4].endswith(f"The batteries step in above {kw_text}.")
for s in under))
# ============================================================================ #
print("\n5. the words on their own")
_en = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True)
_cut = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True,
cut=True)
_ok = messages.row_peak_guard_idle(5200.0, 5413.0, month_peak=True)
print(f" {_en}\n {_cut}\n {_ok}")
check("over, nothing cut: 'idle, at this rate ..., over ...'",
_en == "Peak guard: idle, at this rate 5 814 W, over 5 413 W")
check("over, a grid charge cut",
_cut == "Peak guard: grid charge limited, at this rate 5 814 W, "
"over 5 413 W")
check("under: the 0.19.1 sentence, unchanged",
_ok == "Peak guard: idle, heading for 5 200 W, under this month's "
"5 413 W peak")
check("the Dutch forms say the same",
_cut.nl == "Piekbewaking: laden beperkt, aan dit tempo 5 814 W, "
"boven 5 413 W"
and _en.nl.startswith("Piekbewaking: in rust, aan dit tempo"))
check("the month-peak line in shadow mode says 'would'",
homeview.line_period(5814.0, 5413.0, True, cut=True).endswith(
"The grid charge would be cut back to stay under 5.4 kW.")
and homeview.line_period(5814.0, 5413.0, False).endswith(
"The batteries step in above 5.4 kW."))
# ============================================================================ #
print("\n6. one inverter: the maintenance charge is sized to the room too")
# The start-up quarter on a 10 s meter: the charge's first step is not seen
# until the second reading, so it may land up to START_TOL over the aim; the
# same at N=2 and before this fix. Every later quarter is graded at TOL.
START_TOL = 15.0
N1 = {}
for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)):
for late, every in ((0.0, 0.0), (30.0, 0.0), (20.0, 10.0)):
_r, _c = s84.run(1, load=lambda t, h=house: h, dur=2700.0,
month_peak=peak, before=late_feed(late, every))
_q = rig_quarters(_r, lambda t, h=house: h)
N1[peak, late, every] = (_r, _c)
_vals = list(_q.values())
_tag = (f"N=1, {'peak banked' if peak else 'no peak banked'}, "
f"{'10 s' if every else '5 s'} meter, "
f"{'late ' + format(late, '.0f') + ' s' if late else 'healthy'}")
print(f" {_tag}: quarters "
f"{ {k: round(v, 1) for k, v in _q.items()} } W, aim {aim:.0f}")
check(f"{_tag}: every quarter at or under the aim",
len(_vals) == 3
and all(v <= aim + TOL for v in _vals[1:])
and nth(_vals, 0, "a first quarter")
<= aim + (START_TOL if every else TOL)
and any(mm.phase == "charge" for mm in _c.maints))
_hr, _hc = N1[5413.0, 0.0, 0.0]
_eng = sum(1 for r in _hr if r[-1][1] and r[-1][1][0])
print(f" healthy, peak banked: guard engaged on {_eng} of {len(_hr)} "
f"cycles; A charges on "
f"{sum(1 for r in _hr if dict(r[2])['a'] < -1.0)} cycles")
check("N=1: the guard no longer steps in during the charge (no hand-back), "
"and the battery charges on every cycle, at no more than its rate",
_eng == 0 and all(-2000.0 <= dict(r[2])["a"] < -1.0 for r in _hr)
and not any("suspended" in e for e in _hc.events))
# ============================================================================ #
print("\n7. the row during an N=2 maintenance charge and in shadow mode")
_rows7 = []
def _look(c, t):
pg = c.peak_guard
if t >= QUARTER_S and pg is not None and pg.projected_w is not None \
and not pg.engaged and pg.projected_w > pg.ceiling_w:
_rows7.append(first((r["text"] for r in c.checks()
if r["id"] == "peak_guard"), "guard row"))
def _steps(t):
"""4000 W, 800 W more for the first 30 s of every minute."""
return 4000.0 + (800.0 if t % 60.0 < 30.0 else 0.0)
_m2r, _m2c = s84.run(2, load=_steps, dur=1800.0, month_peak=5413.0,
before=late_feed(0.0, look=_look))
_m2q = rig_quarters(_m2r, _steps)
print(f" N=2 maintenance charge, house steps 4000/4800 W: "
f"{len(_rows7)} over-the-limit rows, e.g. "
f"{first(iter(_rows7), 'a row')}; quarters "
f"{ {k: round(v, 1) for k, v in _m2q.items()} } W")
check("N=2 maintenance charge, over the limit at this rate: the row says the "
"grid charge is limited",
present(first(iter(_rows7), "a row")) and all(
r.startswith("Peak guard: grid charge limited, at this rate")
for r in _rows7)
and all(v <= 5363.0 + TOL for v in _m2q.values()))
_sh_o = dict(opts(), shadow_mode="on")
_csh, _rsh, _fsh, _ssh = drive(_sh_o, peak=PEAK, minutes=17, every=10,
plant=OnItsOwn)
_sh_over = [s for s in _ssh if not s[2] and s[0] > s[1]]
_sh1 = first(iter(_sh_over), "an over sample")
print(f" shadow mode, the inverter charging 5000 W on its own: "
f"{len(_sh_over)} over samples, e.g. "
f"{_sh1[3] if present(_sh1) else _sh1!s} / "
f"{_sh1[4] if present(_sh1) else _sh1!s}")
check("shadow mode: nothing is cut on the wire, so the row says 'idle', "
"never 'grid charge limited', and the line says 'would'",
_csh.shadow and present(_sh1) and all(
s[3].startswith("Peak guard: idle, at this rate")
and "would" in s[4] for s in _sh_over))
# ============================================================================ #
print("\n8. edge cases")
_e45 = drive(opts(), peak=PEAK, late=45.0)
-436
View File
@@ -1,436 +0,0 @@
"""Runnable check for SAFETY-125, a part. `python3 test_safety125b.py`
Split out of test_safety125.py by CI-18 so CI can run the pieces side by side (the one file
took ~10 min). The docstring there describes the whole. It holds parts 3-7 (a price trade and a maintenance charge, a healthy meter, the words, one inverter, N=2 and shadow). Same helpers,
same checks, none dropped: the pieces print exactly the check lines the one file did.
Read MUTATION.md before you report a survivor."""
import asyncio
import logging
import os
import sys
import tempfile
import types
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
logging.disable(logging.WARNING)
import opt11_identity as rig # noqa: E402
import opt11p3_replay as rp # noqa: E402
import safety84_identity as s84 # noqa: E402
import main_files # noqa: E402
import app.main as m # noqa: E402
import app.p1 as p1mod # noqa: E402
from named_absence import first, nth, present # noqa: E402
from app import homeview, messages, peakguard, tariff # noqa: E402
from app import price as _price, static_tariff as _st # noqa: E402
from app.main import Controller # noqa: E402
from app.p1 import make_sample, split_signed # noqa: E402
from app.store import unit_key # noqa: E402
from app.tariff import QUARTER_S, Projection # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
PEAK = 5413.17 # October's banked peak on the live site
AIM_PEAK = PEAK - 50.0
AIM_CAP = 3500.0 - 50.0
TOL = 10.0 # W over the aim a quarter may land (SAFETY-81)
FC = "sensor.piek_prognose_kwartier"
L = timezone(timedelta(hours=1))
START = datetime(2026, 10, 29, 0, 0, tzinfo=L).astimezone(timezone.utc)
PROFILE = ('{"periods": ['
'{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
' "eur_per_kwh": 0.2333},'
'{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
' "eur_per_kwh": 0.2801}]}')
def opts(*, fc=False, modes=True, arb=False):
o = dict(rp.options(modes, arb, 2))
o.update(cycle_cost_threshold_eur=0.03, static_profile=PROFILE,
peak_cap_w=3500, peak_margin_w=50)
o["inverters"][0].update(max_w=5000, capacity_kwh=15.36)
o["inverters"][1].update(max_w=4600, capacity_kwh=20.48)
if fc:
o["peak_forecast_entity"] = FC
return o
class Harder(rp.Plant):
"""Charges harder than asked, as inverter-a did live (asked -4271 W,
measured about -4750 W; asked -5000 W, about -5210 W)."""
def step(self, dt, floor):
c = self.cmd
if c < 0:
self.cmd = max(c * 1.11, -5216.0)
try:
super().step(dt, floor)
finally:
self.cmd = c
async def _no_fetch(*a, **k):
raise AssertionError("the tariff task reached for a price feed")
class OnItsOwn(rp.Plant):
"""Charges 5000 W whatever it is asked (shadow mode: nothing is
written, the inverter charges on its own)."""
def step(self, dt, floor):
self.cmd = -5000.0
super().step(dt, floor)
def drive(o, *, peak=None, late=0.0, minutes=31, every=0, start=None,
period=0.0, fc_unit="kW", plant=Harder):
"""The real Controller from `start` (00:00 local) for `minutes` at a 1 s
cycle (OPT-15's lag). `late`: no P1 telegram in each quarter's last
`late` s; `period`: one telegram every `period` s (0: every cycle).
-> (controller, rows, {quarter start: true grid average}, samples), the
samples taken every `every` cycles from the second quarter (the first
starts before the first reading): (projection, ceiling, engaged,
peak_guard row, month-peak line)."""
store = rp._Store()
for u, mode in (("a", "cheap_hours"), ("b", "solar_first")):
store.data[unit_key(f"inverter-{u}", "pack_use")] = True
store.data[unit_key(f"inverter-{u}", "pack_mode")] = mode
store.data[unit_key(f"inverter-{u}", "pack_sell")] = False
rows, samples, sums = [], [], {}
t0 = start or START
async def go():
lag = rp.Lag()
hass = rp.Hass(("a", "b"), lambda t: 1000.0, {"a": 11.0, "b": 10.0},
limits={"a": (-5000.0, 5000.0),
"b": (-4600.0, 4600.0)}, lag=lag)
hass.plants["a"].__class__ = plant
fc_kw = [0.0]
async def state(e):
# The HA quarter projection, in kW like the live template.
return None if e != FC else {
"state": (f"{fc_kw[0]:.3f}" if fc_unit == "kW"
else f"{fc_kw[0] * 1000.0:.0f}"),
"attributes": {"unit_of_measurement": fc_unit}}
hass.state = state
tmp = tempfile.mkdtemp(prefix="s125-")
db = os.path.join(tmp, "tariff.db")
if peak is not None:
tariff.PeakStore(db)._db.execute(
"INSERT INTO monthly_peak VALUES (?, ?, ?, NULL)",
(tariff.month_key(t0), peak,
"2026-10-21T20:15:00+00:00")).connection.commit()
c = Controller(dict(o), hass, store, rp._Pub(), stop=asyncio.Event(),
peak_db_path=db,
price_history_path=os.path.join(tmp, "ph.json"))
c.inverters[0].dev_min, c.inverters[0].dev_max = -5000.0, 5000.0
c.inverters[1].dev_min, c.inverters[1].dev_max = -4600.0, 4600.0
c.auto = True
real = main_files.live.datetime, homeview.datetime, p1mod.time
clock, simt = [t0], [0.0]
class _DT(real[0]):
@classmethod
def now(cls, tz=None):
return clock[0] if tz is None else clock[0].astimezone(tz)
main_files.live.datetime = homeview.datetime = _DT
p1mod.time = types.SimpleNamespace(monotonic=lambda: 1e6 + simt[0])
real_load = _price.load_prices, _st.load_prices
_price.load_prices = _st.load_prices = _no_fetch
task = asyncio.create_task(c.run_tariff_refresh())
try:
hass.advance(0.0, 10.0)
t, n = 0.0, 0
while t < minutes * 60:
now = t0 + timedelta(seconds=t)
hass.t, simt[0], clock[0] = t, t, now
if t == 0.0:
for _ in range(500):
if c.tariff_plan is not None:
break
await asyncio.sleep(0)
q = int(now.timestamp() // QUARTER_S)
acc = sums.setdefault(q, [0.0, 0])
g_now = hass.grid()
fc_kw[0] = (acc[0] + g_now * (QUARTER_S - acc[1])) \
/ QUARTER_S / 1000.0
if now.timestamp() % QUARTER_S < QUARTER_S - late \
and t >= lag.p1_s \
and (not period or t % period < 1e-9):
imp, exp = split_signed(hass._past(lag.meter_s
+ lag.p1_s)[0])
c.p1.submit(make_sample(
"ha_signed", imp, exp, phases=1,
ingest_ts=now - timedelta(seconds=lag.p1_s),
ingest_mono=1e6 + t))
await c.read_inputs(now_mono=t)
await c.cycle()
hass.advance(lag.tick, 10.0)
acc[0] += max(0.0, hass.grid())
acc[1] += 1
rows.append((now, c.target, hass.plants["a"].p,
getattr(c.arb, "action", None)))
pg = c.peak_guard
if every and n % every == 0 and t >= QUARTER_S \
and pg is not None and pg.projected_w is not None:
row = first((r["text"] for r in c.checks(now)
if r["id"] == "peak_guard"), "guard row")
samples.append((pg.projected_w, pg.ceiling_w, pg.engaged,
row, homeview.month_peak(c, now)["line"]))
t += lag.tick
n += 1
finally:
task.cancel()
try:
await task
except asyncio.CancelledError:
pass
main_files.live.datetime, homeview.datetime, p1mod.time = real
_price.load_prices, _st.load_prices = real_load
return c
c = asyncio.run(go())
full = {datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"):
s / k for q, (s, k) in sorted(sums.items()) if k >= QUARTER_S}
return c, rows, full, samples
def into(now):
return now.timestamp() % QUARTER_S
# ============================================================================ #
def graded(label, full, aim):
print(f" {label}: quarters "
f"{ {k: round(v, 1) for k, v in full.items()} } W, aim {aim:.0f}")
return len(full) >= 2 and all(v <= aim + TOL for v in full.values())
def cut_and_back(rows):
"""The charge is off in each quarter's last 5 s, and back (A charging
over 2 kW) within the next quarter's first minute."""
ends = [r for r in rows if into(r[0]) >= QUARTER_S - 5]
starts = {}
for r in rows:
if into(r[0]) < 60:
q = int(r[0].timestamp() // QUARTER_S)
starts[q] = starts.get(q, False) or r[2] < -2000.0
return (present(first(iter(ends), "a quarter end"))
and all(r[1] > -1.0 for r in ends)
and len(starts) >= 2 and all(starts.values()))
# ============================================================================ #
print("\n3. the same for a price trade (modes off) and a maintenance charge")
_ca, _ra, _fa = drive(opts(modes=False, arb=True), peak=PEAK, late=30.0)[:3]
check("modes off, price trading on, a reading 30 s late: every quarter at "
"or under the aim", graded("trade", _fa, AIM_PEAK)
and any(r[3] == "ARBITRAGE_CHARGE" for r in _ra))
def late_feed(gap, every=0.0, look=None):
"""safety84's cheap-window feed, no telegram in each quarter's last
`gap` s, and one only every `every` s (0: every cycle). `look(c, t)`
runs first, on the state the previous cycle left."""
feed = s84.feed(True)
def before(c, t):
if look is not None:
look(c, t)
if ((rig.BASE.timestamp() + t) % QUARTER_S < QUARTER_S - gap
and (not every or t % every < 1e-9)) \
or not getattr(c.hass, "_s84", False):
feed(c, t)
return before
def rig_quarters(rows, load):
"""The safety84 rig's whole quarters: the true average import (W)."""
qs = {}
for r in rows:
q = int((rig.BASE.timestamp() + r[0]) // QUARTER_S)
a = qs.setdefault(q, [0.0, 0])
a[0] += max(0.0, load(r[0]) - sum(v for _u, v in r[2]))
a[1] += 1
return {datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"):
s / k for q, (s, k) in sorted(qs.items())
if k * rig.TICK >= QUARTER_S}
for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)):
_mr, _mc = s84.run(2, load=lambda t, h=house: h, dur=2700.0,
month_peak=peak, before=late_feed(30.0))
_mf = rig_quarters(_mr, lambda t, h=house: h)
check(f"N=2 maintenance charge, house {house:.0f} W, "
f"{'peak banked' if peak else 'no peak banked'}, a reading 30 s "
f"late: every quarter at or under the aim",
graded("maintenance", _mf, aim)
and any(mm.phase == "charge" for mm in _mc.maints))
# ============================================================================ #
print("\n4. a healthy meter: the quarters, and the words")
for name, kw, aim, kw_text in (("month peak banked", dict(peak=PEAK),
AIM_PEAK, "5.4 kW"),
("no peak banked", dict(), AIM_CAP, "3.5 kW")):
_c, _rows, _full, _s = drive(opts(), every=10, **kw)
check(f"{name}: every quarter at or under the aim",
graded(name, _full, aim))
over = [s for s in _s if not s[2] and s[0] > s[1]]
under = [s for s in _s if not s[2] and s[0] <= s[1]]
_o, _u = first(iter(over), "an over sample"), \
first(iter(under), "an under sample")
print(f" over the limit at this rate ({len(over)} samples): "
f"{_o[3] if present(_o) else _o!s} / "
f"{_o[4] if present(_o) else _o!s}")
print(f" under it ({len(under)}): "
f"{_u[3] if present(_u) else _u!s} / "
f"{_u[4] if present(_u) else _u!s}")
check(f"{name}: over the limit at this rate the guard row never says "
f"'under'; it says the grid charge is limited",
present(_o) and all(
"under" not in s[3] and "Peak guard: grid charge limited, "
"at this rate" in s[3] and " over " in s[3] for s in over))
check(f"{name}: ...and the month-peak line says the rate, and that the "
f"grid charge is cut back to stay under {kw_text}",
present(_o) and all(
s[4].startswith("At this rate this 15-minute period reaches")
and s[4].endswith("The grid charge is cut back to stay "
f"under {kw_text}.") for s in over))
check(f"{name}: under the limit both read as before",
present(_u) and all(
s[3].startswith("Peak guard: idle, heading for")
and " under " in s[3]
and s[4].startswith("This 15-minute period is heading for")
and s[4].endswith(f"The batteries step in above {kw_text}.")
for s in under))
# ============================================================================ #
print("\n5. the words on their own")
_en = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True)
_cut = messages.row_peak_guard_idle(5814.0, 5413.0, month_peak=True,
cut=True)
_ok = messages.row_peak_guard_idle(5200.0, 5413.0, month_peak=True)
print(f" {_en}\n {_cut}\n {_ok}")
check("over, nothing cut: 'idle, at this rate ..., over ...'",
_en == "Peak guard: idle, at this rate 5 814 W, over 5 413 W")
check("over, a grid charge cut",
_cut == "Peak guard: grid charge limited, at this rate 5 814 W, "
"over 5 413 W")
check("under: the 0.19.1 sentence, unchanged",
_ok == "Peak guard: idle, heading for 5 200 W, under this month's "
"5 413 W peak")
check("the Dutch forms say the same",
_cut.nl == "Piekbewaking: laden beperkt, aan dit tempo 5 814 W, "
"boven 5 413 W"
and _en.nl.startswith("Piekbewaking: in rust, aan dit tempo"))
check("the month-peak line in shadow mode says 'would'",
homeview.line_period(5814.0, 5413.0, True, cut=True).endswith(
"The grid charge would be cut back to stay under 5.4 kW.")
and homeview.line_period(5814.0, 5413.0, False).endswith(
"The batteries step in above 5.4 kW."))
# ============================================================================ #
print("\n6. one inverter: the maintenance charge is sized to the room too")
# The start-up quarter on a 10 s meter: the charge's first step is not seen
# until the second reading, so it may land up to START_TOL over the aim; the
# same at N=2 and before this fix. Every later quarter is graded at TOL.
START_TOL = 15.0
N1 = {}
for peak, house, aim in ((5413.0, 4000.0, 5363.0), (None, 2500.0, AIM_CAP)):
for late, every in ((0.0, 0.0), (30.0, 0.0), (20.0, 10.0)):
_r, _c = s84.run(1, load=lambda t, h=house: h, dur=2700.0,
month_peak=peak, before=late_feed(late, every))
_q = rig_quarters(_r, lambda t, h=house: h)
N1[peak, late, every] = (_r, _c)
_vals = list(_q.values())
_tag = (f"N=1, {'peak banked' if peak else 'no peak banked'}, "
f"{'10 s' if every else '5 s'} meter, "
f"{'late ' + format(late, '.0f') + ' s' if late else 'healthy'}")
print(f" {_tag}: quarters "
f"{ {k: round(v, 1) for k, v in _q.items()} } W, aim {aim:.0f}")
check(f"{_tag}: every quarter at or under the aim",
len(_vals) == 3
and all(v <= aim + TOL for v in _vals[1:])
and nth(_vals, 0, "a first quarter")
<= aim + (START_TOL if every else TOL)
and any(mm.phase == "charge" for mm in _c.maints))
_hr, _hc = N1[5413.0, 0.0, 0.0]
_eng = sum(1 for r in _hr if r[-1][1] and r[-1][1][0])
print(f" healthy, peak banked: guard engaged on {_eng} of {len(_hr)} "
f"cycles; A charges on "
f"{sum(1 for r in _hr if dict(r[2])['a'] < -1.0)} cycles")
check("N=1: the guard no longer steps in during the charge (no hand-back), "
"and the battery charges on every cycle, at no more than its rate",
_eng == 0 and all(-2000.0 <= dict(r[2])["a"] < -1.0 for r in _hr)
and not any("suspended" in e for e in _hc.events))
# ============================================================================ #
print("\n7. the row during an N=2 maintenance charge and in shadow mode")
_rows7 = []
def _look(c, t):
pg = c.peak_guard
if t >= QUARTER_S and pg is not None and pg.projected_w is not None \
and not pg.engaged and pg.projected_w > pg.ceiling_w:
_rows7.append(first((r["text"] for r in c.checks()
if r["id"] == "peak_guard"), "guard row"))
def _steps(t):
"""4000 W, 800 W more for the first 30 s of every minute."""
return 4000.0 + (800.0 if t % 60.0 < 30.0 else 0.0)
_m2r, _m2c = s84.run(2, load=_steps, dur=1800.0, month_peak=5413.0,
before=late_feed(0.0, look=_look))
_m2q = rig_quarters(_m2r, _steps)
print(f" N=2 maintenance charge, house steps 4000/4800 W: "
f"{len(_rows7)} over-the-limit rows, e.g. "
f"{first(iter(_rows7), 'a row')}; quarters "
f"{ {k: round(v, 1) for k, v in _m2q.items()} } W")
check("N=2 maintenance charge, over the limit at this rate: the row says the "
"grid charge is limited",
present(first(iter(_rows7), "a row")) and all(
r.startswith("Peak guard: grid charge limited, at this rate")
for r in _rows7)
and all(v <= 5363.0 + TOL for v in _m2q.values()))
_sh_o = dict(opts(), shadow_mode="on")
_csh, _rsh, _fsh, _ssh = drive(_sh_o, peak=PEAK, minutes=17, every=10,
plant=OnItsOwn)
_sh_over = [s for s in _ssh if not s[2] and s[0] > s[1]]
_sh1 = first(iter(_sh_over), "an over sample")
print(f" shadow mode, the inverter charging 5000 W on its own: "
f"{len(_sh_over)} over samples, e.g. "
f"{_sh1[3] if present(_sh1) else _sh1!s} / "
f"{_sh1[4] if present(_sh1) else _sh1!s}")
check("shadow mode: nothing is cut on the wire, so the row says 'idle', "
"never 'grid charge limited', and the line says 'would'",
_csh.shadow and present(_sh1) and all(
s[3].startswith("Peak guard: idle, at this rate")
and "would" in s[4] for s in _sh_over))
print()
if fails:
print(f"{len(fails)} FAILED:")
for f in fails:
print(f" - {f}")
sys.exit(1)
print("all checks passed")
+122 -5
View File
@@ -25,11 +25,7 @@ quarter's edge as on the rig.
4. The page and the "Why" on a decision within the aim.
Mutations (MUTATION.md, purged copies) are listed in the pull request.
CI-18: this file holds parts 1 and 4 (part 4 grades part 1's nights). Parts 2 and 3 are in test_safety126b.py, split out so
CI can run the pieces side by side (the one file took ~13 min). Every check is in
exactly one file; the two print exactly the check lines the one file did."""
"""
import asyncio
import dataclasses
@@ -311,6 +307,127 @@ check("fix reverted, at 0.01 s: the ERROR, the notification and the "
_b["errors"] and _b["notes"] and any(s[3] for s in _b["seen"]))
# ============================================================================ #
print("\n2. a real overrun under the reserve still alarms")
def evening(t):
"""600 W, then an oven and a car charger from 20 minutes on."""
return 600.0 if t < 1200 else 6500.0
for tag, onset, kw in (
("night grid charge, then 6500 W", 1200.0, dict(house=evening)),
("modes off, 5500 W all along", 0.0,
dict(house=5500.0, modes=None, socs=(15.0, 12.0)))):
o = opts(modes=kw.get("modes", OWNER) is not None)
head = drive(o, minutes=35, **kw)
base = without_fix(lambda: drive(o, minutes=35, **kw))
show("head " + tag, head)
show("fix reverted", base)
# From the load's onset: before it, the fix reverted shows the night's
# false alarm (part 1).
first_h = next((s[0] for s in head["seen"] if s[6] and s[0] >= onset),
None)
first_b = next((s[0] for s in base["seen"] if s[6] and s[0] >= onset),
None)
check(f"⭐ {tag}: the ERROR and the notification, naming both "
f"batteries",
head["errors"] and head["notes"]
and all("inverter-a and inverter-b" in n for _t, n in head["notes"]))
_th = [t for t, _n in head["notes"]]
_tb = [t for t, _n in base["notes"] if t >= onset]
print(f" notifications at {_th} s; with the fix reverted {_tb} s")
check(f"{tag}: the first at the same cycle as before the fix "
f"({first_h} s, {first_b} s), and none that was not raised before",
first_h is not None and first_h == first_b
and present(nth(_th, 0)) and nth(_th, 0) == nth(_tb, 0)
and set(_th) <= set(_tb))
check(f"{tag}: the red peak row and its banner while it stands",
any(s[4] for s in head["seen"]))
def burst(t):
"""600 W, a 6 500 W load from 20 to 25 minutes, then 600 W again while
the night charge goes on."""
return 6500.0 if 1200 <= t < 1500 else 600.0
# F3 (review): `_peak_landing()` resets its latch when the guard lets go, so
# a real overrun does not keep the later landing errors alarming.
_bh = drive(opts(), house=burst, off=0.99, minutes=61)
_bb = without_fix(lambda: drive(opts(), house=burst, off=0.99,
minutes=61))
show("head real overrun, then the night again", _bh)
show("fix reverted", _bb)
# The burst banked a new month peak, which the later quarters stay under.
_new_peak = _bh["c"].peak_guard.ceiling_w
def _late(r):
"""From the next quarter on: the overrun's own quarter ends over."""
return [x for x in r["seen"] if x[0] >= 1800]
print(f" notifications at {[t for t, _n in _bh['notes']]} s; with the fix "
f"reverted {[t for t, _n in _bb['notes']]} s; limit after the burst "
f"{_new_peak:.0f} W")
check("⭐ after a real overrun ends, the latch is reset: the alarm came "
"during the overrun, and the later quarters' landings are quiet "
"(no notification, no 'Why' peak, no red row) and under the new peak",
any(1200 <= t < 1500 for t, _n in _bh["notes"])
and not [t for t, _n in _bh["notes"] if t >= 1800]
and not any(x[3] or x[4] or x[5] for x in _late(_bh))
and present(nth([v for k, v in _bh["quarters"].items()
if k >= "22:30"], 0))
and all(v <= _new_peak for k, v in _bh["quarters"].items()
if k >= "22:30"))
check("...not vacuous: the guard wanted power at those landings, and with "
"the fix reverted they show the 'Why' peak or an alarm",
any(x[2] for x in _late(_bh))
and (any(x[3] or x[4] or x[5] for x in _late(_bb))
or bool([t for t, _n in _bb["notes"] if t >= 1800])))
# ============================================================================ #
print("\n3. misses_aim() on its own")
START = datetime(2026, 10, 30, 21, 15, tzinfo=timezone.utc)
def proj(projected, elapsed, held):
return Projection(projected, projected, elapsed, 1.0, True, START, held)
check("the rig's case: 3452 W against 3450 W, 0.3 s left, charging "
"1250 W from the grid: not a miss",
not peakguard.misses_aim(proj(3452.0, 899.7, 3452.0), batt_w=-1250.0,
target_w=AIM_CAP))
check("...although decide() wants power there (its gain, 900 / 0.3 s)",
(peakguard.decide(proj(3452.0, 899.7, 3452.0), batt_w=-1250.0,
cap_w=3500, margin_w=50, reading=None,
achievable_w=0.0, soc=10.0, soc_floor=20.0)
.wanted_w or 0.0) > 1000.0)
check("a quarter heading 11 W over the aim with the batteries at 0 W is a "
"miss", peakguard.misses_aim(proj(3461.0, 899.7, 3461.0), batt_w=0.0,
target_w=AIM_CAP))
check("...and 10 W is not (ALARM_MISS_W, as for 'Load too high')",
not peakguard.misses_aim(proj(3460.0, 899.7, 3460.0), batt_w=0.0,
target_w=AIM_CAP))
check("the add-on's own grid charge counts as stoppable: 4000 W on the "
"meter mid-quarter, 3000 W of it charging, is not a miss",
not peakguard.misses_aim(proj(2500.0, 450.0, 4000.0), batt_w=-3000.0,
target_w=AIM_CAP))
check("...and a house of 6000 W the batteries are covering is one",
peakguard.misses_aim(proj(1000.0, 450.0, 0.0), batt_w=6000.0,
target_w=AIM_CAP))
check("no battery reading, or no seconds left: not a miss (decide() files "
"nothing there)",
not peakguard.misses_aim(proj(9000.0, 450.0, 9000.0), batt_w=None,
target_w=AIM_CAP)
and not peakguard.misses_aim(proj(9000.0, 900.0, 9000.0), batt_w=0.0,
target_w=AIM_CAP))
# ============================================================================ #
print("\n4. the page and the 'Why' on a decision within the aim")
_c = NIGHTS["aim 3450, cycle 0.01 s before the edge"][0]["c"]
-382
View File
@@ -1,382 +0,0 @@
"""Runnable check for SAFETY-126, a part. `python3 test_safety126b.py`
Split out of test_safety126.py by CI-18 so CI can run the pieces side by side (the one file
took ~13 min). The docstring there describes the whole. It holds parts 2 and 3 (a real overrun still alarms, misses_aim()). Same helpers,
same checks, none dropped: the pieces print exactly the check lines the one file did.
Read MUTATION.md before you report a survivor."""
import asyncio
import dataclasses
import io
import logging
import os
import sys
import tempfile
import types
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
sys.path.insert(0, os.path.join(HERE, "tools"))
import opt11p3_replay as rp # noqa: E402
from named_absence import first, nth, present # noqa: E402
import main_files # noqa: E402
import app.main as m # noqa: E402
import app.p1 as p1mod # noqa: E402
from app import homeview, messages, peakguard, tariff # noqa: E402
from app import price as _price, static_tariff as _st # noqa: E402
from app.main import Controller # noqa: E402
from app.p1 import make_sample, split_signed # noqa: E402
from app.store import unit_key # noqa: E402
from app.tariff import QUARTER_S, Projection # noqa: E402
logging.disable(logging.NOTSET)
logging.getLogger().setLevel(logging.CRITICAL)
_ERRORS = io.StringIO()
_h = logging.StreamHandler(_ERRORS)
_h.setLevel(logging.ERROR)
logging.getLogger("goodwe").addHandler(_h)
logging.getLogger("goodwe").setLevel(logging.ERROR)
logging.getLogger("goodwe").propagate = False
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
PEAK = 5413.17 # October's banked peak on the live site
AIM_CAP = 3500.0 - 50.0
AIM_PEAK = PEAK - 50.0
TOL = 10.0 # W over the aim a quarter may land (SAFETY-81)
L = timezone(timedelta(hours=1))
NIGHT = datetime(2026, 10, 30, 22, 0, tzinfo=L).astimezone(timezone.utc)
PROFILE = ('{"periods": ['
'{"name": "night", "days": "all", "from": "22:00", "to": "07:00",'
' "eur_per_kwh": 0.2333},'
'{"name": "day", "days": "all", "from": "07:00", "to": "22:00",'
' "eur_per_kwh": 0.2801}]}')
OWNER = {"a": "leftover_solar", "b": "cheap_hours"}
def opts(*, modes=True, arb=False):
o = dict(rp.options(modes, arb, 2))
o.update(cycle_cost_threshold_eur=0.03, static_profile=PROFILE,
peak_cap_w=3500, peak_margin_w=50)
o["inverters"][0].update(max_w=5000, capacity_kwh=15.36)
o["inverters"][1].update(max_w=4600, capacity_kwh=20.48)
return o
class Harder(rp.Plant):
"""Charges harder than asked, as inverter-a did live (test_safety125.py:
asked -4271 W, measured about -4750 W; asked -5000 W, about -5210 W), up
to `cap` W. So a charge sized to the aim lands a few W over it, as on the
rig (worst +7 W)."""
cap = -5216.0
def step(self, dt, floor):
c = self.cmd
if c < 0:
self.cmd = max(c * 1.11, self.cap)
try:
super().step(dt, floor)
finally:
self.cmd = c
async def _no_fetch(*a, **k):
raise AssertionError("the tariff task reached for a price feed")
def without_fix(fn):
"""release/1.0 cc9bbeb: no decision is ever within the aim."""
real = getattr(Controller, "_peak_landing", None)
if real is None:
return fn()
Controller._peak_landing = lambda self, decision: decision
try:
return fn()
finally:
Controller._peak_landing = real
def drive(o, *, modes=OWNER, socs=(10.0, 10.0), house=600.0, minutes=46,
start=NIGHT, off=0.7, peak=None):
"""The real Controller from `start` + `off` s for `minutes` at a 1 s
cycle with OPT-15's lag, so a cycle lands `1 - off` s before each
quarter's end. `house` is W or a function of t. Returns a dict: the
quarters' true grid averages, the commands, the reserve notifications,
the ERROR lines, and per cycle where the guard engaged: (t, floor
limited, within the aim, battery "Why" peak, red reserve row, red
saturated row, alarm latched)."""
store = rp._Store()
for u, mode in (modes or {}).items():
store.data[unit_key(f"inverter-{u}", "pack_use")] = True
store.data[unit_key(f"inverter-{u}", "pack_mode")] = mode
store.data[unit_key(f"inverter-{u}", "pack_sell")] = False
load = house if callable(house) else (lambda t: float(house))
t0 = start + timedelta(seconds=off)
out = {"cmds": [], "notes": [], "seen": [], "sums": {}}
_ERRORS.seek(0)
_ERRORS.truncate()
async def go():
lag = rp.Lag()
hass = rp.Hass(("a", "b"), load, {"a": socs[0], "b": socs[1]},
limits={"a": (-5000.0, 5000.0),
"b": (-4600.0, 4600.0)}, lag=lag)
for u, cap in (("a", -5216.0), ("b", -4800.0)):
hass.plants[u].__class__ = Harder
hass.plants[u].cap = cap
real_set = hass.set_number
async def set_number(e, v):
out["cmds"].append((round(hass.t, 3), e, float(v)))
return await real_set(e, v)
async def call(*a):
if a[:2] == ("persistent_notification", "create") \
and a[2]["notification_id"] == messages.ID_PEAK_RESERVE:
out["notes"].append((hass.t, a[2]["message"]))
return True
hass.set_number, hass.call = set_number, call
tmp = tempfile.mkdtemp(prefix="s126-")
db = os.path.join(tmp, "tariff.db")
if peak is not None:
tariff.PeakStore(db)._db.execute(
"INSERT INTO monthly_peak VALUES (?, ?, ?, NULL)",
(tariff.month_key(t0), peak,
"2026-10-21T20:15:00+00:00")).connection.commit()
c = Controller(dict(o), hass, store, rp._Pub(), stop=asyncio.Event(),
peak_db_path=db,
price_history_path=os.path.join(tmp, "ph.json"))
c.inverters[0].dev_min, c.inverters[0].dev_max = -5000.0, 5000.0
c.inverters[1].dev_min, c.inverters[1].dev_max = -4600.0, 4600.0
c.auto = True
real = main_files.live.datetime, homeview.datetime, p1mod.time
clock, simt = [t0], [0.0]
class _DT(real[0]):
@classmethod
def now(cls, tz=None):
return clock[0] if tz is None else clock[0].astimezone(tz)
main_files.live.datetime = homeview.datetime = _DT
p1mod.time = types.SimpleNamespace(monotonic=lambda: 1e6 + simt[0])
real_load = _price.load_prices, _st.load_prices
_price.load_prices = _st.load_prices = _no_fetch
task = (asyncio.create_task(c.run_tariff_refresh())
if o.get("battery_modes_enabled") or o.get("arbitrage_enabled")
else None)
try:
hass.advance(0.0, 10.0)
t = 0.0
while t < minutes * 60:
now = t0 + timedelta(seconds=t)
hass.t, simt[0], clock[0] = t, t, now
if t == 0.0 and task is not None:
for _ in range(500):
if c.tariff_plan is not None:
break
await asyncio.sleep(0)
q = int(now.timestamp() // QUARTER_S)
acc = out["sums"].setdefault(q, [0.0, 0])
if t >= lag.p1_s:
imp, exp = split_signed(hass._past(lag.meter_s
+ lag.p1_s)[0])
c.p1.submit(make_sample(
"ha_signed", imp, exp, phases=1,
ingest_ts=now - timedelta(seconds=lag.p1_s),
ingest_mono=1e6 + t))
await c.read_inputs(now_mono=t)
await c.cycle()
hass.advance(lag.tick, 10.0)
acc[0] += max(0.0, hass.grid())
acc[1] += 1
g = c.peak_guard
if g is not None and g.engaged and g.blind is None:
rows = {r["id"]: r for r in c.checks(now)}
row = rows.get("peak_guard", {})
red = row.get("ok") is False and not row.get("warn")
out["seen"].append((
t, g.floor_limited, getattr(g, "within_aim", False),
homeview.peak_engaged(c),
red and "banner" in row,
red and "banner" not in row,
c._peak_floor_limited))
t += lag.tick
finally:
if task is not None:
task.cancel()
try:
await task
except asyncio.CancelledError:
pass
main_files.live.datetime, homeview.datetime, p1mod.time = real
_price.load_prices, _st.load_prices = real_load
return c
out["c"] = asyncio.run(go())
out["quarters"] = {
datetime.fromtimestamp(q * QUARTER_S, L).strftime("%H:%M"): s / k
for q, (s, k) in sorted(out["sums"].items()) if k >= QUARTER_S - 1}
out["errors"] = [x for x in _ERRORS.getvalue().splitlines()
if "PEAK_GUARD_FLOOR_LIMITED" in x]
return out
def show(tag, r):
print(f" {tag}: quarters "
f"{ {k: round(v, 1) for k, v in r['quarters'].items()} }, "
f"guard cycles {len(r['seen'])}, floor-limited "
f"{sum(1 for s in r['seen'] if s[1])}, within-aim "
f"{sum(1 for s in r['seen'] if s[2])}, Why peak "
f"{sum(1 for s in r['seen'] if s[3])}, notes {len(r['notes'])}, "
f"errors {len(r['errors'])}")
def quiet(r):
"""No reserve alarm in any form: ERROR, notification, red row, latch,
"Why" peak, and no red saturated row."""
return (not r["errors"] and not r["notes"]
and not any(s[3] or s[4] or s[5] or s[6] for s in r["seen"]))
def on_aim(r, aim):
q = r["quarters"]
return len(q) >= 3 and all(v <= aim + TOL for v in q.values())
# ============================================================================ #
print("\n2. a real overrun under the reserve still alarms")
def evening(t):
"""600 W, then an oven and a car charger from 20 minutes on."""
return 600.0 if t < 1200 else 6500.0
for tag, onset, kw in (
("night grid charge, then 6500 W", 1200.0, dict(house=evening)),
("modes off, 5500 W all along", 0.0,
dict(house=5500.0, modes=None, socs=(15.0, 12.0)))):
o = opts(modes=kw.get("modes", OWNER) is not None)
head = drive(o, minutes=35, **kw)
base = without_fix(lambda: drive(o, minutes=35, **kw))
show("head " + tag, head)
show("fix reverted", base)
# From the load's onset: before it, the fix reverted shows the night's
# false alarm (part 1).
first_h = next((s[0] for s in head["seen"] if s[6] and s[0] >= onset),
None)
first_b = next((s[0] for s in base["seen"] if s[6] and s[0] >= onset),
None)
check(f"⭐ {tag}: the ERROR and the notification, naming both "
f"batteries",
head["errors"] and head["notes"]
and all("inverter-a and inverter-b" in n for _t, n in head["notes"]))
_th = [t for t, _n in head["notes"]]
_tb = [t for t, _n in base["notes"] if t >= onset]
print(f" notifications at {_th} s; with the fix reverted {_tb} s")
check(f"{tag}: the first at the same cycle as before the fix "
f"({first_h} s, {first_b} s), and none that was not raised before",
first_h is not None and first_h == first_b
and present(nth(_th, 0)) and nth(_th, 0) == nth(_tb, 0)
and set(_th) <= set(_tb))
check(f"{tag}: the red peak row and its banner while it stands",
any(s[4] for s in head["seen"]))
def burst(t):
"""600 W, a 6 500 W load from 20 to 25 minutes, then 600 W again while
the night charge goes on."""
return 6500.0 if 1200 <= t < 1500 else 600.0
# F3 (review): `_peak_landing()` resets its latch when the guard lets go, so
# a real overrun does not keep the later landing errors alarming.
_bh = drive(opts(), house=burst, off=0.99, minutes=61)
_bb = without_fix(lambda: drive(opts(), house=burst, off=0.99,
minutes=61))
show("head real overrun, then the night again", _bh)
show("fix reverted", _bb)
# The burst banked a new month peak, which the later quarters stay under.
_new_peak = _bh["c"].peak_guard.ceiling_w
def _late(r):
"""From the next quarter on: the overrun's own quarter ends over."""
return [x for x in r["seen"] if x[0] >= 1800]
print(f" notifications at {[t for t, _n in _bh['notes']]} s; with the fix "
f"reverted {[t for t, _n in _bb['notes']]} s; limit after the burst "
f"{_new_peak:.0f} W")
check("⭐ after a real overrun ends, the latch is reset: the alarm came "
"during the overrun, and the later quarters' landings are quiet "
"(no notification, no 'Why' peak, no red row) and under the new peak",
any(1200 <= t < 1500 for t, _n in _bh["notes"])
and not [t for t, _n in _bh["notes"] if t >= 1800]
and not any(x[3] or x[4] or x[5] for x in _late(_bh))
and present(nth([v for k, v in _bh["quarters"].items()
if k >= "22:30"], 0))
and all(v <= _new_peak for k, v in _bh["quarters"].items()
if k >= "22:30"))
check("...not vacuous: the guard wanted power at those landings, and with "
"the fix reverted they show the 'Why' peak or an alarm",
any(x[2] for x in _late(_bh))
and (any(x[3] or x[4] or x[5] for x in _late(_bb))
or bool([t for t, _n in _bb["notes"] if t >= 1800])))
# ============================================================================ #
print("\n3. misses_aim() on its own")
START = datetime(2026, 10, 30, 21, 15, tzinfo=timezone.utc)
def proj(projected, elapsed, held):
return Projection(projected, projected, elapsed, 1.0, True, START, held)
check("the rig's case: 3452 W against 3450 W, 0.3 s left, charging "
"1250 W from the grid: not a miss",
not peakguard.misses_aim(proj(3452.0, 899.7, 3452.0), batt_w=-1250.0,
target_w=AIM_CAP))
check("...although decide() wants power there (its gain, 900 / 0.3 s)",
(peakguard.decide(proj(3452.0, 899.7, 3452.0), batt_w=-1250.0,
cap_w=3500, margin_w=50, reading=None,
achievable_w=0.0, soc=10.0, soc_floor=20.0)
.wanted_w or 0.0) > 1000.0)
check("a quarter heading 11 W over the aim with the batteries at 0 W is a "
"miss", peakguard.misses_aim(proj(3461.0, 899.7, 3461.0), batt_w=0.0,
target_w=AIM_CAP))
check("...and 10 W is not (ALARM_MISS_W, as for 'Load too high')",
not peakguard.misses_aim(proj(3460.0, 899.7, 3460.0), batt_w=0.0,
target_w=AIM_CAP))
check("the add-on's own grid charge counts as stoppable: 4000 W on the "
"meter mid-quarter, 3000 W of it charging, is not a miss",
not peakguard.misses_aim(proj(2500.0, 450.0, 4000.0), batt_w=-3000.0,
target_w=AIM_CAP))
check("...and a house of 6000 W the batteries are covering is one",
peakguard.misses_aim(proj(1000.0, 450.0, 0.0), batt_w=6000.0,
target_w=AIM_CAP))
check("no battery reading, or no seconds left: not a miss (decide() files "
"nothing there)",
not peakguard.misses_aim(proj(9000.0, 450.0, 9000.0), batt_w=None,
target_w=AIM_CAP)
and not peakguard.misses_aim(proj(9000.0, 900.0, 9000.0), batt_w=0.0,
target_w=AIM_CAP))
# ============================================================================ #
print()
if fails:
print(f"{len(fails)} SAFETY-126 check(s) FAILED:")
for f in fails:
print(f" - {f}")
sys.exit(1)
print("all SAFETY-126 checks passed")
+1 -18
View File
@@ -481,17 +481,6 @@ print("\n8. the N=1 and N=2 digests")
# quarter's room, as at N=2, so the guard no longer steps in and discharges.
# The banked quarters go 3461.9 -> 3450.0 W (aim 3450) and 3938.9 -> 3950.0
# W (aim 3950). n1_charge_dear (no cheap window) is unchanged.
# MAINT-28 re-pinned n2_charge_banked: in the 5000 W load (over the 3950 W
# aim) the maintenance charge no longer restarts at -125 W after each guard
# stop (t=1550 s, 64 of 480 rows); the pause is held until the load is gone
# (DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md). MAINT-28 fix-forward
# re-pinned it again: while the pause holds A gives at most the largest part
# of the guard's floor placed on it this period, so rows 288-479 (t = 1440 s
# on, 192 of 480) differ: a "peak hold" limit claim on A and A's share. Round 5
# (H-1) re-pinned it again: one site limit, the period's largest floor, so the
# batteries give only what the guard needs. Its banked quarters stay at or
# under the aim 3950 W (3349 and 3950 W; f3f9483 3349 and 2527 W), graded
# below. The other five are equal.
PINNED = {
"n1_charge":
"00f0a16b3ac1bd2830e9e0aaac8923fd9d1736c2bc6c543669bdd35b2fb542e9",
@@ -504,14 +493,8 @@ PINNED = {
"n2_charge_dear":
"aa2bbc677a8e2274b25ba1170de1b1635e08a3bd93105e2a38a9bb1575b5b6db",
"n2_charge_banked":
"358ebd2a23fe7c7f52f441b60391e40c6605e32bcfb109fa0ff4502d4070745e",
"a6973faea916e4c88ca1770047f94478346eeb1efa4889b154fad0747f91267f",
}
_nb_rows, _nb = s84.run(**s84.SCENARIOS["n2_charge_banked"])
print(f" n2_charge_banked banked quarters {[round(v, 1) for v in banked(_nb)]}"
f" W (aim 3950)")
check("...and in the re-pinned n2_charge_banked every banked quarter is at or "
"under the aim 3950 W",
len(banked(_nb)) >= 2 and all(v <= 3950.0 + 1.0 for v in banked(_nb)))
_now = s84.digests()
for k in PINNED:
print(f" {k} {'same' if _now[k] == PINNED[k] else 'DIFFERS'} "
+2 -3
View File
@@ -637,10 +637,9 @@ _routes = sorted({(r.method, r.get_info().get("path"))
for r in _app.router.routes() if r.method != "HEAD"})
print(" " + " ".join(f"{m} {p}" for m, p in _routes))
check("the configuration surface adds five routes, UX-13 one GET and "
"UX-54 one more GET (the Forecast tab), EV-03 one read-only GET (the car "
"charger probe), and none touches the three "
"UX-54 one more GET (the Forecast tab), and none touches the three "
"that were there",
_routes == [("GET", "/"), ("GET", "/config"), ("GET", "/config/charger"), ("GET", "/config/model"),
_routes == [("GET", "/"), ("GET", "/config"), ("GET", "/config/model"),
("GET", "/forecast"), ("GET", "/ha/entities"),
("GET", "/status"),
("POST", "/action"), ("POST", "/config/restart"),
+4 -5
View File
@@ -80,13 +80,12 @@ for _g in LAYOUT["groups"]:
_flat += [(_g["id"], _s) for _s in _f.get("fields", [])]
_keys = [f["key"] for _g, f in _flat]
FIELD = {f["key"]: f for _g, f in _flat}
check("the seven groups, in the design's order",
check("the six groups, in the design's order",
[g["id"] for g in LAYOUT["groups"]]
== ["meter", "inverters", "tariff", "safety", "car", "maintenance",
"tuning"]
== ["meter", "inverters", "tariff", "safety", "maintenance", "tuning"]
and [g["name"] for g in LAYOUT["groups"]]
== ["Meter", "Inverters and batteries", "Tariff and prices",
"Safety limits", "Car charger", "Maintenance", "Control tuning"])
"Safety limits", "Maintenance", "Control tuning"])
check(f"every field of the table is on the page once ({len(_keys)} fields)",
sorted(_keys) == sorted(f.key for _g, _p, f in L.fields())
and len(_keys) == len(set(_keys)))
@@ -147,7 +146,7 @@ check("a page-only field names the option keys it writes, for the grey key "
== ["pv_entities", "pv_entity", "pv_invert_entities"]
and "static_profile" in field(FIELD, "ui.contract")["writes"])
check("without a Supervisor schema the page still draws, with no ranges",
len(uipage.layout([], {})["groups"]) == 7)
len(uipage.layout([], {})["groups"]) == 6)
# --------------------------------------------------------------------------- #
print("\n2. the page script names no option key")
+2 -3
View File
@@ -205,11 +205,10 @@ print("\n4. task ordering, and the labels that carry it")
# prefixes appear in the file as CONTIGUOUS RUNS in the task order. A group
# whose members are scattered renders as a jumble however good each label is.
GROUPS = ["Hardware", "Meter", "Limits", "Tariff", "Maintenance", "Safety",
"Car charger", "Advanced"]
"Advanced"]
NL_GROUPS = {"Hardware": "Hardware", "Meter": "Meter", "Limits": "Grenzen",
"Tariff": "Tarief", "Maintenance": "Onderhoud",
"Safety": "Veiligheid", "Car charger": "Laadpaal",
"Advanced": "Geavanceerd"}
"Safety": "Veiligheid", "Advanced": "Geavanceerd"}
_prefixes = []
for key in ORDER:
name = TR["en"]["configuration"][key]["name"]
-378
View File
@@ -1,378 +0,0 @@
#!/usr/bin/env python3
"""EV-03: a model of an Alfen car charger behind Home Assistant, for the unit
tests and, later, for TEST-23.
EV-04 ADDS THE WRITE SIDE: `request_current()` and `request_phases()` are what
the add-on's writes reach. The new state is taken after `lag_s` seconds of
model time (the read-back lag), the power RAMPS to it, and `refuse` makes the
charger ignore a write ("ignore": Home Assistant says yes, the charger does not
change) or Home Assistant refuse it ("error"). `log` records every write with
the model's clock and the power and setpoint at that moment, so a test can
prove the safe phase sequence (0 A first, under 100 W before the phases move).
WHERE IT LIVES, AND WHY. The rig's hardware sims (`hwsim.py`, `plantsim.py`) are
in the infra repo admin/goodwe under `sim/`, pinned by `.gitea/infra-pin`; there
is no `sim/` in this repository. This card may write only to this repository, so
the model sits beside the add-on's other tools. Moving it next to `hwsim.py` is a
copy: it imports nothing from the add-on.
WHAT IT MODELS (every entity the add-on's Alfen driver reads, with the names and
units the leeyuentuen/alfen_wallbox integration gives, from the owner's export):
* mode3 state A (no car), B (connected, not charging), C (charging)
* power that RAMPS to what the car takes (`RAMP_W_S`), 1 or 3 phases
* the current setpoint, its read-back, the station limit (16 A at the owner's)
* a full car (it stops by itself: state B with the current still allowed)
* the integration going unavailable, and the login sensor off
from chargersim import SimCharger, FakeHa
c = SimCharger("wallbox"); c.plug_in(); c.set_current(10); c.tick(30)
ha = FakeHa(c) # a Home Assistant that serves its states
`FakeHa` has the methods the add-on calls (`state`, `number`, `states`,
`set_number`, `call`) and RECORDS every write, so a test can prove none happened.
`python3 chargersim.py --selftest` runs the model's own checks. `serve(port)`
answers the REST calls the add-on makes (`GET /api/states[/<id>]`), for a rig.
"""
import json
import sys
VOLTS = 230.0
RAMP_W_S = 3000.0 # how fast the power follows its target
MIN_A = 6.0
class SimCharger:
def __init__(self, name="wallbox", station_a=16.0, setpoint_a=10.0,
phases_allowed=1, kwh=4004.85):
self.x = name
self.station_a = float(station_a)
self.setpoint_a = float(setpoint_a)
self.readback_a = float(setpoint_a)
self.phases_allowed = phases_allowed
self.car_phases = 3 # what the car can use
self.state = "A"
self.full = False
self.power_w = 0.0
self.kwh = float(kwh)
self.unavailable = False
self.login_on = True
self.error = "0: No Error"
# EV-04: the write side
self.t = 0.0 # model seconds
self.lag_s = 0.0 # a write shows in the read-back this late
self.refuse = None # None | "ignore" | "error"
self._snap = None # `freeze()`: the readings stop moving
self._frozen_w = None # `freeze_power()`: only the power does
self.no_energy = False # a charger with no energy entity
self.ramp_w_s = RAMP_W_S # how fast the power follows its target
self.stop_delay_s = 0.0 # mode3 stays C this long after 0 A
self._c_hold = 0.0
self.log = [] # (t, what, value, power_w, setpoint_a)
self._pending = []
# -- the world acts on it -------------------------------------------------
def plug_in(self, car_phases=3):
self.car_phases = car_phases
self.full = False
self.state = "B"
def unplug(self):
self.state, self.power_w = "A", 0.0
def car_full(self):
self.full = True
def set_current(self, a):
"""What an automation (or, later, this add-on) does to the setpoint."""
a = max(0.0, min(float(a), self.station_a))
self.setpoint_a = self.readback_a = a
def set_phases(self, n):
self.phases_allowed = 3 if n == 3 else 1
def fault(self, letter="E"):
"""mode3 E or F: the charger's own error states."""
self.state, self.power_w = letter, 0.0
# -- what the add-on's writes reach (EV-04) ----------------------------------
def request_current(self, a):
"""`number.set_value` on the current. False: Home Assistant refused it
(out of the entity's 0-40 A range, or `refuse == "error"`)."""
a = float(a)
if a != a or a < 0.0 or a > 40.0 or self.refuse == "error":
return False
self.log.append((self.t, "current", a, self.power_w, self.setpoint_a))
if self.refuse == "ignore":
return True
self._later("current", a)
return True
def request_phases(self, n):
"""`select.select_option` on the installation's allowed phases."""
if self.refuse == "error" or n not in (1, 3):
return False
self.log.append((self.t, "phases", n, self.power_w, self.setpoint_a))
if self.refuse == "ignore":
return True
self._later("phases", n)
return True
def _later(self, what, v):
if self.lag_s <= 0:
self._apply(what, v)
else:
self._pending.append((self.t + self.lag_s, what, v))
def _apply(self, what, v):
if what == "current":
self.setpoint_a = self.readback_a = max(0.0, min(v, self.station_a))
else:
self.phases_allowed = 3 if v == 3 else 1
def writes(self, what=None):
return [x for x in self.log if what in (None, x[1])]
def go_unavailable(self, on=True):
self.unavailable = bool(on)
def login(self, on=True):
self.login_on = bool(on)
# -- time -----------------------------------------------------------------
@property
def phases_used(self):
return min(self.car_phases, self.phases_allowed)
def target_w(self):
if self.state == "A" or self.full or self.setpoint_a < MIN_A:
return 0.0
return self.setpoint_a * VOLTS * self.phases_used
def tick(self, seconds=1.0):
for _ in range(int(max(1, round(seconds)))):
self.t += 1.0
for p in [x for x in self._pending if x[0] <= self.t]:
self._pending.remove(p)
self._apply(p[1], p[2])
if self.state in ("E", "F"): # a fault: nothing flows, it stays
self.power_w = 0.0
continue
if self.state != "A":
if self.target_w() > 0:
self.state, self._c_hold = "C", 0.0
elif self.state == "C" and self._c_hold < self.stop_delay_s:
self._c_hold += 1.0 # the car has not let go yet
else:
self.state = "B"
tgt = self.target_w()
step = self.ramp_w_s
if self.power_w < tgt:
self.power_w = min(tgt, self.power_w + step)
else:
self.power_w = max(tgt, self.power_w - step)
self.kwh += self.power_w / 3.6e6
# -- what Home Assistant would serve ---------------------------------------
def _amps(self):
per = (self.power_w / (VOLTS * self.phases_used)
if self.phases_used and self.power_w else 0.0)
return [per if i < self.phases_used else 0.0 for i in range(3)]
def freeze(self, on=True):
"""A stuck sensor: Home Assistant goes on serving the readings of this
moment, whatever the charger does after it."""
self._snap = self._build() if on else None
def freeze_power(self, on=True):
"""Only the power sensor sticks, at what it reads now; the energy meter
and the rest go on telling the truth."""
self._frozen_w = self.power_w if on else None
def states(self) -> dict:
return self._snap if self._snap is not None else self._build()
def _build(self) -> dict:
x = self.x
bad = "unavailable" if self.unavailable else None
def st(eid, value, unit=None, **attrs):
a = dict(attrs)
if unit:
a["unit_of_measurement"] = unit
return eid, {"entity_id": eid,
"state": bad or str(value), "attributes": a}
amps = self._amps()
rows = [
st(f"number.{x}_power_connector_max_current_socket_1",
f"{self.setpoint_a:g}", "A", min=0, max=40, step=1),
st(f"sensor.{x}_main_active_max_current_socket_1",
f"{self.readback_a:g}", "A"),
st(f"sensor.{x}_mode3_state_socket_1", f"STATE_{self.state}"),
st(f"sensor.{x}_display_state_socket_1",
{"A": "Available", "B": "EV Connected",
"C": "Charging Normal"}.get(self.state, "Error")),
st(f"sensor.{x}_active_power_total_socket_1",
f"{self.power_w if self._frozen_w is None else self._frozen_w:.0f}",
"W"),
st(f"sensor.{x}_meter_reading_socket_1", f"{self.kwh:.2f}",
"kWh"),
st(f"sensor.{x}_current_l1_socket_1", f"{amps[0]:.1f}", "A"),
st(f"sensor.{x}_current_l2_socket_1", f"{amps[1]:.1f}", "A"),
st(f"sensor.{x}_current_l3_socket_1", f"{amps[2]:.1f}", "A"),
st(f"number.{x}_max_station_current", f"{self.station_a:g}", "A"),
st(f"sensor.{x}_main_station_active_max_current_socket_1",
f"{self.station_a:g}", "A"),
st(f"select.{x}_installation_max_allowed_phases",
"3 Phases" if self.phases_allowed == 3 else "1 Phase"),
st(f"sensor.{x}_connector_1_max_allowed_of_phases",
"3 Phases" if self.phases_allowed == 3 else "1 Phase"),
st(f"sensor.{x}_display_error_number_socket_1", self.error),
(f"binary_sensor.{x}_https_api_login_status",
{"entity_id": f"binary_sensor.{x}_https_api_login_status",
"state": bad or ("on" if self.login_on else "off"),
"attributes": {"device_class": "connectivity"}}),
]
out = dict(rows)
if self.no_energy:
out.pop(f"sensor.{x}_meter_reading_socket_1", None)
return out
class FakeHa:
"""A Home Assistant that serves a `SimCharger` (and any `extra` states) and
records every service call and number write it is given."""
session = None
token = ""
read_only = False
def __init__(self, charger=None, extra=None):
self.charger = charger
self.extra = dict(extra or {})
self.calls = [] # (domain, service, data)
self.sets = [] # (entity, value)
def _all(self):
out = dict(self.extra)
if self.charger is not None:
out.update(self.charger.states())
return out
async def state(self, entity_id):
return self._all().get(entity_id)
async def states(self):
return list(self._all().values())
async def number(self, entity_id, invert=False):
s = self._all().get(entity_id)
try:
v = float(s["state"])
except (TypeError, ValueError, KeyError):
return None
return -v if invert else v
async def limits(self, _entity_id):
return (-5000.0, 5000.0, 1.0)
async def set_number(self, entity_id, value):
self.sets.append((entity_id, value))
c = self.charger
if c is not None and entity_id == \
f"number.{c.x}_power_connector_max_current_socket_1":
return c.request_current(value)
return True
async def call(self, domain, service, data=None):
self.calls.append((domain, service, data))
c = self.charger
if c is not None and domain == "select" and service == "select_option" \
and (data or {}).get("entity_id") == \
f"select.{c.x}_installation_max_allowed_phases":
return c.request_phases(
3 if "3" in str((data or {}).get("option")) else 1)
return True
def charger_writes(self):
"""Every write or service call that names a charger entity."""
x = self.charger.x if self.charger else "\0"
hits = [s for s in self.sets if x in s[0]]
hits += [c for c in self.calls if x in json.dumps(c[2] or {})]
return hits
def serve(sim, port=8123):
"""Answer `GET /api/states` and `GET /api/states/<id>` from `sim`, for a
rig. Reads only: any POST answers 405, so nothing can write the model."""
import http.server
class H(http.server.BaseHTTPRequestHandler):
def do_GET(self):
rows = sim.states()
path = self.path.split("?")[0].rstrip("/")
if path.endswith("/api/states"):
body = list(rows.values())
else:
body = rows.get(path.rsplit("/api/states/", 1)[-1])
self.send_response(200 if body is not None else 404)
self.send_header("Content-Type", "application/json")
self.end_headers()
self.wfile.write(json.dumps(body).encode())
def do_POST(self):
self.send_response(405)
self.end_headers()
def log_message(self, *_a):
pass
srv = http.server.ThreadingHTTPServer(("0.0.0.0", port), H)
return srv
def _selftest():
c = SimCharger()
assert c.states()[f"sensor.wallbox_mode3_state_socket_1"]["state"] == "STATE_A"
c.plug_in(); c.tick(1)
assert c.state == "B" or c.state == "C"
c.set_current(10); c.set_phases(3); c.tick(5)
assert c.state == "C" and abs(c.power_w - 10 * 230 * 3) < 1, c.power_w
c.set_phases(1); c.tick(5)
assert abs(c.power_w - 2300) < 1
c.set_current(5); c.tick(5)
assert c.state == "B" and c.power_w == 0 # under 6 A: paused
c.set_current(10); c.car_full(); c.tick(5)
assert c.state == "B" and c.power_w == 0 and c.readback_a == 10
# EV-04: writes, the read-back lag, a refusal
w = SimCharger(); w.plug_in(); w.tick(1)
assert w.request_current(12) and w.setpoint_a == 12
assert not w.request_current(41) and not w.request_current(-1)
w.lag_s = 3.0
assert w.request_current(8) and w.readback_a == 12
w.tick(2); assert w.readback_a == 12
w.tick(1); assert w.readback_a == 8
w.refuse = "ignore"
assert w.request_current(6) and w.readback_a == 8
w.refuse = "error"
assert not w.request_current(6) and not w.request_phases(3)
w.refuse = None; w.lag_s = 0.0
assert w.request_phases(3) and w.phases_allowed == 3
assert [x[1] for x in w.writes()] == ["current", "current", "current",
"phases"], w.writes()
c.go_unavailable()
assert c.states()[f"sensor.wallbox_active_power_total_socket_1"]["state"] \
== "unavailable"
c.go_unavailable(False); c.login(False)
assert c.states()["binary_sensor.wallbox_https_api_login_status"]["state"] == "off"
print("chargersim selftest ok")
if __name__ == "__main__":
if "--selftest" in sys.argv:
_selftest()
else:
srv = serve(SimCharger(), int(sys.argv[1]) if len(sys.argv) > 1 else 8123)
print("serving the charger model, GET only; Ctrl-C stops it")
srv.serve_forever()
-153
View File
@@ -1,153 +0,0 @@
#!/usr/bin/env python3
"""EV-04: the real Controller on the SAFETY-81 plant, plus a car charger.
python3 tools/ev04_peak.py # a few runs and what they raised
A 1 s cycle, a 3500 W cap, one battery switched Off (so only the peak guard
makes it give, at most `rating` W), a P1 meter that publishes 0.3 s before each
cycle, and `chargersim.SimCharger` behind the same Home Assistant: its power
is part of the load the meter sees, and the add-on reads and writes it through
the real driver. `events` is `{second: fn(plant, controller)}`, run before that
cycle: unplug, freeze the reading, step the house, change the user's current.
Used by test_ev04.py (sections 9 to 11) and, later, by the rig test."""
import asyncio
import logging
import os
import sys
import tempfile
import time
from datetime import timedelta
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import opt11_identity as rig # noqa: E402
import main_files # noqa: E402
import safety81_sim as s81 # noqa: E402
from app import packmode # noqa: E402
from app.main import Controller # noqa: E402
from app.p1 import make_sample, split_signed # noqa: E402
from app.store import unit_key # noqa: E402
from chargersim import SimCharger # noqa: E402
SET = "number.wallbox_power_connector_max_current_socket_1"
PHASES = "select.wallbox_installation_max_allowed_phases"
ALARMS = ("goodwe_peak_saturated", "goodwe_peak_soc_floor")
OVER = "goodwe_car_over"
class CarPlant(s81._Plant):
"""The SAFETY-81 plant with a charger on the same meter: the grid sees the
house, the car and what the battery does."""
def __init__(self, house, rating, soc, charger):
super().__init__(lambda at: house(at) + charger.power_w, rating, soc)
self.ch = charger
async def state(self, entity_id):
return self.ch.states().get(entity_id)
async def set_number(self, e, v):
if e == SET:
return self.ch.request_current(float(v))
return await super().set_number(e, v)
async def call(self, domain, service, data=None):
if domain == "select" and service == "select_option":
n = 3 if "3" in str((data or {}).get("option")) else 1
return self.ch.request_phases(n)
return await super().call(domain, service, data)
def drive(house, *, dur=300.0, rating=2000.0, soc=60.0, cap=3500.0, margin=50,
opts=None, plug=True, setpoint=16, phases=3, mode="manual",
user_a=16, events=None, sim=None, store=None):
"""Run it. Returns a namespace-like dict: plant, controller, charger, the
notification ids raised with their second, and the controller's rows."""
sim = sim or SimCharger(setpoint_a=setpoint)
if plug:
sim.plug_in()
sim.phases_allowed = phases
o = rig._options(1, dict({
"meter_source": "ha_signed", "p1_net_entity": "sensor.net",
"meter_phases": 1, "peak_cap_w": cap, "peak_margin_w": margin,
"battery_modes_enabled": True, "max_w": rating,
"ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
"ev_current_entity": SET}, **(opts or {})))
store = store or rig._Store()
store.data[unit_key("inverter-a", packmode.USE_KEY)] = False
store.data[packmode.USE_KEY] = False
db = os.path.join(tempfile.mkdtemp(prefix="ev4-"), "tariff.db")
out = {}
async def go():
plant = CarPlant(house, rating, soc, sim)
c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
peak_db_path=db)
for i in c.inverters:
i.dev_min, i.dev_max = -5000.0, 5000.0
c.auto = True
clock = [0.0]
c.car_now = lambda: clock[0]
if hasattr(c.charger, "_sleep"):
async def sleep(s):
sim.tick(s)
clock[0] += s
c.charger._sleep = sleep
c.charger._clock = lambda: clock[0]
real_dt = main_files.live.datetime
class _DT(real_dt):
@classmethod
def now(cls, tz=None):
return rig.BASE + timedelta(seconds=clock[0])
main_files.live.datetime = _DT
c.car_mode, c.car_n, c.car_a = mode, phases, float(user_a)
snaps = []
try:
t = 0.0
while t < dur:
plant.t = clock[0] = t
fn = events_in.get(int(t)) if t == int(t) else None
if fn is not None:
fn(plant, c)
sim.tick(1.0)
ts = t - s81.SAMPLE_LEAD_S
plant.meter = plant.grid(ts)
imp, exp = split_signed(plant.meter)
c.p1.submit(make_sample(
"ha_signed", imp, exp, phases=1,
ingest_ts=rig.BASE + timedelta(seconds=ts),
ingest_mono=time.monotonic()))
await c.read_inputs(now_mono=t)
await c.cycle()
await c.car_settle()
snaps.append((t, c.car_explains, c.car_over,
(c.peak_guard.engaged if c.peak_guard else None),
plant.batt(t), sim.power_w))
t += s81.TICK
finally:
main_files.live.datetime = real_dt
raised = [(at, nid) for at, nid in plant.notes]
out.update(plant=plant, c=c, sim=sim, raised=raised, snaps=snaps,
store=store)
events_in = events or {}
asyncio.run(go())
return out
def ids(out, *wanted):
return [(t, n) for t, n in out["raised"] if n in wanted]
if __name__ == "__main__":
logging.disable(logging.CRITICAL)
for name, kw in (
("car 11 kW, house 1.1 kW, Manual",
dict(house=s81.constant(1100.0))),
("same, Off", dict(house=s81.constant(1100.0), mode="off"))):
r = drive(**kw)
print(f"{name:34s} alarms {ids(r, *ALARMS)} "
f"car notice {ids(r, OVER)}")
+2 -12
View File
@@ -116,15 +116,10 @@ class Lag:
after the reading (the HA source's debounce), so a cycle just after a
quarter boundary can still see the old block; `tick` the cycle period;
`tau_s` / `ramp_w_s` the battery's own lag (TEST-23's plant: `dead_s` 1,
no lag or ramp). `batt_period_s` (MAINT-28): the battery register is
published every that many seconds and held between (the rig: 10 s), so its
reading is `batt_s` plus up to a period older than the meter's; None keeps
the constant age."""
no lag or ramp)."""
def __init__(self, dead_s=1.0, meter_s=1.0, batt_s=1.0, p1_s=0.35,
tick=1.0, sub=0.25, tau_s=3.0, ramp_w_s=800.0,
batt_period_s=None):
self.batt_period_s = batt_period_s
tick=1.0, sub=0.25, tau_s=3.0, ramp_w_s=800.0):
self.dead_s, self.meter_s, self.batt_s = dead_s, meter_s, batt_s
self.p1_s, self.tick, self.sub = p1_s, tick, sub
self.tau_s, self.ramp_w_s = tau_s, ramp_w_s
@@ -216,11 +211,6 @@ class Hass:
if e.startswith("sensor.batt"):
# A real reading jitters by a few watts; a dead-flat one is a
# stale register to the add-on (SAFETY-37), which is not modelled.
if self.lag is not None and self.lag.batt_period_s:
per = self.lag.batt_period_s
ts = math.floor((self.t - self.lag.batt_s) / per) * per
j = (ord(u) * 31 + int(ts)) % 7 - 3
return float(round(self._past(self.t - ts)[1][u]) + j)
j = (ord(u) * 31 + int(self.t)) % 7 - 3
p = self.plants[u].p if self.lag is None else \
self._past(self.lag.batt_s)[1][u]
+3 -100
View File
@@ -36,7 +36,7 @@ sys.path.insert(0, os.path.join(HERE, "tools"))
from aiohttp import web as aioweb # noqa: E402
from app import chargers, freshness, homeview, packmode, web # noqa: E402
from app import homeview, packmode, web # noqa: E402
from app.main import Controller # noqa: E402
from app.maintenance import DRAIN # noqa: E402
from app.setuponly import SetupOnly # noqa: E402
@@ -44,7 +44,6 @@ from app.peakguard import PeakDecision # noqa: E402
from app.price import PricePoint, PriceProduct, PriceRead # noqa: E402
from app.static_tariff import TariffPlan # noqa: E402
import translations_lint as TL # noqa: E402
from chargersim import SimCharger # noqa: E402
PRICES = [.24, .22, .21, .20, .21, .22, .24, .27, .26, .22, .18, .16, .15,
.14, .16, .19, .23, .28, .33, .36, .34, .29, .26, .24]
@@ -105,61 +104,6 @@ class Hass:
return STATES
# EV-03: the car states. A charger model behind the demo's Home Assistant; the
# real `Controller._read_charger()` reads it, so the card is what the add-on
# draws, not a picture.
CAR_STATES = ("car", "car_none", "car_waiting", "car_full", "car_unreach",
"car_setup", "car_manual_cover", "car_manual_over")
CAR_ENTITY = "number.wallbox_power_connector_max_current_socket_1"
SIM = SimCharger()
class CarHass(Hass):
async def state(self, e):
return SIM.states().get(e) or await super().state(e)
async def states(self):
return list(STATES) + list(SIM.states().values())
def car_setup(state):
"""Put the model in the state's situation."""
global SIM
SIM = SimCharger(name="other" if state == "car_setup" else "wallbox")
if state in ("car", "car_unreach", "car_manual_cover", "car_manual_over"):
SIM.plug_in()
SIM.set_phases(3)
SIM.set_current(16)
elif state == "car_waiting":
SIM.plug_in()
SIM.set_current(0)
elif state == "car_full":
SIM.plug_in()
SIM.set_current(10)
SIM.car_full()
SIM.tick(12)
async def car_feed(c, state):
"""The cycle's own read, once a second, like the control loop."""
backdated = False
n = 0
while True:
n += 1
if state == "car_unreach" and n == 4:
SIM.go_unavailable()
SIM.tick(1)
await c._read_charger(freshness.monotonic())
if state == "car_unreach" and c.car.bad_since is not None \
and not backdated:
backdated = True # 12 minutes in, so the row and the note show
c.car.bad_since -= 720.0
c.car.bad_since_utc -= timedelta(seconds=720)
if state == "car_full" and c.car.b_since is not None and n < 3:
c.car.b_since -= 120.0 # the full dwell has passed
await asyncio.sleep(1.0)
KETTLE_READS = (-10, 1990, 1990, -10)
KETTLE_COUNT = [0]
@@ -300,13 +244,7 @@ def controller(state):
opts = dict(OPTS, shadow_mode="on" if state == "shadow" else "off")
if state in P3:
opts["battery_modes_enabled"] = True
hass = Hass()
if state in CAR_STATES:
car_setup(state)
opts.update(ev_charger="alfen_ha", ev_current_entity=CAR_ENTITY,
ev_max_a=16, ev_phases="auto")
hass = CarHass()
c = Controller(opts, hass, Store(), Pub(), stop=asyncio.Event())
c = Controller(opts, Hass(), Store(), Pub(), stop=asyncio.Event())
c.auto = True
now = datetime.now(timezone.utc)
day0, _day1 = homeview.local_day(now)
@@ -326,33 +264,6 @@ def controller(state):
inv.last_write = 0.0
c.grid = -10.0 if state != "shadow" else -2810.0
c.pv_w = 3900.0
if state in CAR_STATES:
# 11 kW to the car on top of a 1.6 kW house, all from the roof
c.grid, c.pv_w = 0.0, (12600.0 if state == "car" else 2400.0)
for inv in c.inverters:
inv.batt = 0.0
c.car.stale_s = 15.0
if state in ("car_manual_cover", "car_manual_over"):
# EV-04, Manual at 16 A on 3 phases. First moment: the batteries give
# 5 kW and the period stays on the aim. Second: they are at the peak
# reserve, so the charge you set sets the month's peak.
c.car_mode, c.car_a, c.car_n = "manual", 16.0, 3
if state == "car_manual_cover":
c.pv_w, c.grid = 4100.0, 3450.0
for inv in c.inverters:
inv.batt = 2500.0
c.peak_guard = PeakDecision(
engaged=True, floor_w=3000.0, ceiling_w=3500.0,
ceiling_from="cap", projected_w=3450.0, excess_w=1500.0)
else:
c.pv_w, c.grid = 2400.0, 10200.0
for inv in c.inverters:
inv.soc, inv.batt = 19.0, 0.0
c.peak_guard = PeakDecision(
engaged=True, floor_w=0.0, ceiling_w=3500.0,
ceiling_from="cap", projected_w=10200.0, excess_w=6750.0,
floor_limited=True, soc=19.0, soc_floor=20.0)
c.car_over = c.car_explains = True
if state == "alarm":
c.inverters[0].sign_wd.tripped = True
if state in P3:
@@ -416,17 +327,9 @@ async def main(state, port, host="127.0.0.1"):
battery_modes_enabled=state in P3,
inverters=[dict(i, bms_soc_floor=10)
for i in OPTS["inverters"]])
stored.update(ev_charger=c.o.get("ev_charger", "off"),
ev_current_entity=c.o.get("ev_current_entity", ""),
ev_max_a=c.o.get("ev_max_a", 16),
ev_phases=c.o.get("ev_phases", "auto"))
app = web.build_app(c, Supervisor(stored))
runner = aioweb.AppRunner(app)
runner = aioweb.AppRunner(web.build_app(c, Supervisor(stored)))
await runner.setup()
await aioweb.TCPSite(runner, host, port).start()
if state in CAR_STATES:
asyncio.get_running_loop().create_task(car_feed(c, state))
main.app = app
print(f"serving {state} on http://127.0.0.1:{port}/", flush=True)
await asyncio.Event().wait()
-18
View File
@@ -283,24 +283,6 @@ configuration:
shadow_mode:
name: "Safety · Shadow mode"
description: "The add-on makes every decision but keeps every inverter at 0 W. 'auto' does this while control is stopped, 'on' always, 'off' never."
ev_charger:
name: "Car charger · Charger"
description: "Which car charger the add-on drives. Off leaves everything as it is. In Off mode the add-on only reads the charger and never changes it."
ev_current_entity:
name: "Car charger · Current setting entity"
description: "The entity that sets the charger's current. The add-on finds the charger's other entities from its name."
ev_max_a:
name: "Car charger · Charger limit (A)"
description: "The most current the charger may ever be asked for. Never above what the charger reports. Lower it for a weaker fuse or cable."
ev_phases:
name: "Car charger · Phases"
description: "How many phases the charger may use: 1, 3, or 1 and 3 (auto)."
ev_batt_cover:
name: "Car charger · Batteries help with the peak"
description: "While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak."
ev_mode_start:
name: "Car charger · Mode after a restart"
description: "Keep the last mode, or start in Off. A restart never changes the charger's current."
auto_start:
name: "Advanced · Start control on boot"
description: "Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart."
-18
View File
@@ -264,24 +264,6 @@ configuration:
shadow_mode:
name: "Veiligheid · Schaduwmodus"
description: "De add-on neemt elke beslissing maar houdt elke omvormer op 0 W. 'auto' doet dit zolang de regeling gestopt is, 'on' altijd, 'off' nooit."
ev_charger:
name: "Laadpaal · Laadpaal"
description: "Welke laadpaal de add-on stuurt. Uit laat alles zoals het is. In modus Uit leest de add-on de laadpaal alleen en wijzigt niets."
ev_current_entity:
name: "Laadpaal · Entiteit van de laadstroom"
description: "De entiteit die de stroom van de laadpaal instelt. De add-on vindt de andere entiteiten van de laadpaal via de naam."
ev_max_a:
name: "Laadpaal · Laadpaalgrens (A)"
description: "De hoogste stroom die aan de laadpaal gevraagd mag worden. Nooit hoger dan wat de laadpaal meldt. Verlaag ze voor een zwakkere zekering of kabel."
ev_phases:
name: "Laadpaal · Fasen"
description: "Hoeveel fasen de laadpaal mag gebruiken: 1, 3, of 1 en 3 (auto)."
ev_batt_cover:
name: "Laadpaal · Batterijen helpen met de piek"
description: "Terwijl de auto laadt. Aan: de batterijen dekken ze tot de piekreserve. Uit: de piekbewaking laat de auto buiten beschouwing, dus de auto alleen kan de piek bepalen."
ev_mode_start:
name: "Laadpaal · Modus na een herstart"
description: "De laatste modus houden, of starten in Uit. Een herstart verandert de stroom van de laadpaal nooit."
auto_start:
name: "Geavanceerd · Regeling starten bij opstarten"
description: "Staat standaard uit. Laat het uit tot de installatie in dienst is, zodat iemand na elke herstart op Start drukt."