Compare commits

..
11 Commits
Author SHA1 Message Date
ems-agentandClaude Opus 5.5 368f24e097 EV-05 round 9: pin that no cut goes to the plan of a car another writer runs
checks / unit (pull_request) Successful in 27m11s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-19 00:37:22 +01:00
ems-agentandClaude Opus 5.5 c9a95f3c10 EV-05 round 9: one test of control; another writer's phases are a hold
checks / unit (pull_request) Successful in 31m31s
infra-pin / fresh (pull_request) Successful in 2s
SolarWriter.in_control is the single test of "Solar has the charger":
writing, read-back current and phases are Solar's own, no hold, no write
refused, given up or owed. Alarm grading, banking, the own-pause grace and
the cut use it. A phase change Solar did not make is another writer:
nothing written over it, hold after 30 s, no select back after 10 min.
While Solar's own switch waits, a lower current is written at once, and
the arithmetic uses the phases the car draws on. A car another writer
starts inside the own-pause grace is no longer graded out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-18 23:49:47 +01:00
ems-agentandClaude e348a808ff EV-05 round 8: Off respects the owed-only rule; grade out only a car Solar runs
checks / unit (pull_request) Successful in 26m14s
infra-pin / fresh (pull_request) Successful in 1s
Review of fa11dc3:
- Solar to Off writes no 0 A when Solar never had the charger (shadow or a
  stopped control since the start) or its not-writing 0 A is already taken
  (N10, Expected 11), as the shutdown does since round 7.
- car_solar_can_cut() also needs a car Solar runs: plan.a > 0, its own phase
  change, or its own 0 A inside EV-15's OWN_PAUSE_MAX_S.

Tests: the four p_off shapes (and Manual); p_paused at 1000 s and 890 s and
an own pause older than 85 s, each against an Off twin; the near-end rule
with slow batteries that keep headroom (review p_ne2).

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 22:17:21 +01:00
ems-agentandClaude fa11dc3d85 EV-05 round 7: Solar watches while not writing; shadow start writes nothing
checks / unit (pull_request) Successful in 24m28s
infra-pin / fresh (pull_request) Successful in 2s
Review of b4a222f, brief v6 Expected 11 (owner 2026-11-18):
- Solar keeps watching for another writer while it is not writing (Stop,
  shadow, safety stop), so hold is true for every reader: the exit, the
  shutdown, the peak alarms, and Start afterwards.
- car_solar_can_cut() also needs Solar to be writing: the peak alarms stand
  as in Off and the quarter is banked.
- A start or restart in Solar with shadow on writes nothing (the
  not-writing 0 A is owed only when Solar had the charger before).
- Once that exit 0 A is taken, nothing more is written, shutdown included.

Tests: alarm rows for Stop, shadow on and safety stop against an Off twin;
shutdown after another writer in shadow and Stop; a start in shadow with the
car already charging; Start after a stop; two variants inside the 30 s watch.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 20:17:58 +01:00
ems-agentandClaude b4a222f9e8 EV-05 round 6: grade the car out only while Solar can cut it
checks / unit (pull_request) Successful in 25m32s
infra-pin / fresh (pull_request) Successful in 1s
Review of 69f5818:
- Solar grades the car out of the peak alarms only while it can really cut
  it (not under another writer's hold, a refused or given-up write, an
  untaken way-out 0 A, a charger fault, an unreadable charger). Otherwise
  the alarms stand as in Off and the quarter is banked as the car's.
- A battery refusing to give counts for nothing at every N (N=1:
  Controller.batt_refused); the site safety stops leave none able; a
  battery switched Off still counts (the guard draws on it).
- Only pressing Solar lifts Solar's other-writer hold: leaving Solar, or
  setting Manual's values, no longer writes over another writer (N10).

Tests: Solar vs Off twins for another writer, a refused cut write and a
refused fault 0 A; N=1 refusing battery against a car-Off twin; N10 on every
exit and on Manual value changes; the able_w cap; batteries switched Off.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 18:50:37 +01:00
ems-agentandClaude 69f58181bc EV-05 round 5: headroom counts only the batteries that can give
checks / unit (pull_request) Successful in 24m24s
infra-pin / fresh (pull_request) Successful in 2s
Review of 8818768: the headroom test compared the output with the site
rating, which still counted a battery refusing to give (SAFETY-73) or under
a safety stop, so the 15 s wait ran at the real maximum (N4). Now only the
units that can give (above their cut-out, not refusing, not stopped,
switched on) count, in what they give and in their ratings.

Tests: R5a (A refuses, B at full rating, against a car-Off twin: the cut at
910, period 3361 W), R5b (headroom and a slow battery: the cut at exactly
15 s), R5c (floor-limited alone decides: cut at once). DOCS wrapped to 79.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 17:27:17 +01:00
ems-agentandClaude 8818768dab EV-05 round 4: the cut waits only while the batteries have headroom
checks / unit (pull_request) Successful in 23m43s
infra-pin / fresh (pull_request) Successful in 1s
Review of d2504ef, brief v5 Expected 8 (owner 2026-11-18): the 15 s wait
needs batteries that can still raise their output: above the cut-out, the
guard neither saturated nor floor-limited, and their output more than 100 W
under what they can give. Otherwise the car is cut at once.

Tests: R4/N4 rows against a car-Off twin (house to 25900 and 25950 W, aim
3400 W) land under the aim; T21/T22 cut at once beyond the batteries; the
T21b catch rows and T44 (0 cut pauses) stay green.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 16:02:01 +01:00
ems-agentandClaude d2504efa82 EV-05 round 3: a refused way-out 0 A is tried again; one cut per excess
checks / unit (pull_request) Successful in 24m5s
infra-pin / fresh (pull_request) Successful in 2s
Review of 17a7b29:
- Critical: every way out of Solar (Off, Stop, shadow, safety stop, charger
  error, stuck reading, no car) now owes a 0 A until the charger takes it:
  tried again 60 s apart, 3 times (EV-04's rule), then the gave-up row and
  CHARGER_REFUSED; never over another writer. Shutdown does not trust last_a
  while a write of ours is unconfirmed. The card no longer says paused while
  the 0 A is not taken.
- Major: an excess episode is taken off the car once, measured from the car's
  power when it began, until the car shows it and 15 s more.

Tests: refused-then-accepted 0 A for each exit, a 0 A never taken, shutdown
during a start write's read-back, a cut from 16 A with a slow car; the fuzz
checks refused exits of every kind (N9).

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 12:15:00 +01:00
ems-agentandClaude 17a7b299d2 EV-05 round 2: the peak cut waits 15 s while a battery can give
checks / unit (pull_request) Successful in 23m32s
infra-pin / fresh (pull_request) Successful in 1s
Owner 2026-11-18 (dev finding 1, brief v4 Expected 8): while a battery is
above its cut-out, the car's peak cut waits until the guard has wanted power
for 15 s in a row (CUT_WAIT_S), so a cloud edge the batteries catch does not
pause the car. It cuts at once with no battery able, or with 120 s or less of
the 15-minute period left (CUT_NEAR_END_S: waiting 15 s then costs at most
8/7 of the cut, taken off the car at once).

Tests: T21/T22 cut at 15 s and not sooner, the period lands under the aim;
T21b a house step and a cloud edge the batteries catch: no cut, no pause;
T24 (c) late in the period: the cut at once, under the aim; T12's cut row
with the batteries at their cut-out. The harness's battery level model was
1000x too fast (round 1); fixed. The 10-hour day: 0 cut pauses in both
priorities.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 10:13:02 +01:00
ems-agentandClaude 8ba3e1c337 EV-05: shutdown keeps one command_site_release() call site
checks / unit (pull_request) Successful in 24m44s
infra-pin / fresh (pull_request) Successful in 1s
CI run 1737: test_sma10_two_idle_states counts the call lines of
command_site_release() in main.py (the Stop button and shutdown, 2); the
Solar-first branch had made it 3. Same order as before: in Solar the
charger's 0 A first, in Manual the inverters first.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 00:29:05 +01:00
ems-agentandClaude 29480fda47 EV-05: car Solar mode (spare sun to the car, Batteries or Car first, cut first for the peak)
checks / unit (pull_request) Failing after 24m58s
infra-pin / fresh (pull_request) Successful in 1s
Solar charges the car from the signed spare sun (car + battery charge - grid
import), less the batteries' room (Batteries first) and the sun kept back,
whole amps rounded down, at most one change per 30 s and only on 1 A. It
starts after ev_start_min of enough sun, holds 6 A for ev_pause_min, then 0 A.
Auto phases through EV-04's safe sequence (4.5 kW / 3 min up, 4.0 kW / 5 min
down, one switch per 10 min). What the peak guard would ask the batteries for
is taken off the car first, at once. Every way out of Solar ends at 0 A,
written once; at shutdown before the inverters go to 0 W.

- app/carmode.py: SolarPlan (pure) and SolarWriter (ManualWriter's one write
  site, its sequence and watch); spare_w, car_target_w, amps_for.
- app/ctl_car.py: Solar inputs, the cut, the solar kWh, EV-15's grace for
  Solar's own 0 A, no "set by the car" for Solar; main.py: shutdown order.
- Home card, HA select.goodwe_car_sun_first, sensor car_today_solar_kwh,
  three options with defaults, strings EN/NL, DOCS, DECISIONS, CHANGELOG.
- test_ev05.py, test_ev05_long.py, tools/ev05_sun.py; test_ev03/ev04 checks
  that pinned "Solar is refused" / "three entities" updated.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-17 23:54:06 +01:00
31 changed files with 4669 additions and 1092 deletions
+2 -1
View File
@@ -49,10 +49,11 @@ SERIAL="test_loop.py test_freeze.py test_safety87.py"
# 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.
# EV-05: ev05_long ~500 and ev05 ~375 alone (the Solar simulations).
# 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"
HEAVY="test_opt36.py test_safety119.py test_ev05_long.py test_opt34.py test_ev05.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"
#
JOBS=${CI_JOBS:-10}
cd "${TESTS_DIR:-/w/goodwe-addon/goodwe_controller}"
+1
View File
@@ -3,6 +3,7 @@
### Not in a release yet
- When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]).
- The car can charge from spare sun only (Solar mode), with the batteries or the car first, and it is cut first when the 15-minute period heads over the peak limit. Three new options with defaults ([[EV-05]]).
## 0.24.0
@@ -97,10 +97,10 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
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 explains
nothing; a stale, stuck or uncorroborated figure is `None` and the normal
alarms stand while it is (EV-18 below). There is no minimum car power: the
comparison itself is what separates car from house.
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.
- **The period without the car is not clipped at 0 W** (EV-10b). The rig showed
EV-10 failing: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
give more than the house uses, so the house alone is an export; `car_exclude`
@@ -137,18 +137,6 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
drew in the pause is kept apart (`ws_p`), so `car_exclude`, the guard's
input, the claim, floor and writes are unchanged. A house overload still fails
the test without the car, so it alarms as on Off.
- **The batteries as they give now, and no latch from an unknown** (EV-18, EV-15
rig F-A). At the reserve the loop still gives some battery power; "without the
car, batteries at 0 W" counted it as house, `_car_need_excl` latched at the
quarter's start and the floor alarm stood for the quarter with the excess
smaller than the car. Owner 2026-11-19: without the car the batteries keep
giving what they give now (the lower of two readings, every cycle); a miss so
(`_car_need_house`) seen with a trusted car figure stays latched to the
quarter's end. The car explains where the period with it misses on the same
batteries (`_car_over_now`), or by the EV-10 test above. A `None` car figure
or battery reading explains nothing in that cycle and latches nothing. After
a restart or a gap the car's share of what is done is unknown (`_carq`
`whole`), so only the rest of the period is graded without the car.
- **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.
@@ -0,0 +1,162 @@
# EV-05 — Solar mode: spare sun to the car
The design is `reports/EV-01-design-report.md` (sections 2 to 5, decisions 2 and
5) and the EV-05 brief v3 (owner answers Q1 and Q4, 2026-11-17). This record
keeps what the code had to decide.
## Where it lives
`carmode.SolarPlan` decides (pure, monotonic clock): what current, on what
phases. `carmode.SolarWriter` makes the charger match it. It is a subclass of
`ManualWriter`, so the write, the read-back, the phase sequence and the
other-writer watch are Manual's and there is still one `write_current` and one
`write_phases` call in `app/` (test_ev04.py's AST check). `ctl_car` builds the
inputs (`car_sun_inputs`) and runs the writer in the same background task.
## The rules the brief left open
- **Entering Solar starts at 0 A.** Choosing Solar, a restart in Solar, the
charger or Home Assistant coming back, a charger error or a stuck reading
clearing, and control starting again all reset the plan: 0 A if the charger
shows more, then the start rule. Switching from Manual to Solar therefore
pauses a Manual charge for the start dwell. Simple and on the safe side.
- **The peak cut is what the guard would ask the batteries for.** The excess is
taken off the car only when the guard is engaged and wants a discharge
(`wanted_w > 0`), and by `min(excess, wanted)`. Batteries that only stop
charging in a cloud's first seconds are not "asked", so a cloud does not cut
the car. A partial cut caps the car for the rest of that 15-minute period.
- **The cut waits 15 s while a battery can still give** (owner 2026-11-18,
round 2): `ctl_car.CUT_WAIT_S`, counted from the first cycle in a row in
which the guard wants power. A battery "can give" when it is above its own
cut-out level, not refusing to give and not under a safety stop
(`_car_batt_able`). It cuts at once with nothing able, or with 120 s or less
of the period left (`CUT_NEAR_END_S`): waiting 15 s with R s left raises what
must come off afterwards by R / (R - 15), at most 8/7 at 120 s, and the cut
then takes it off the car at once. test_ev05.py T21 (a step beyond the
batteries, cut at 15 s) and T24 (c) (a late step, cut at once) show the period
landing under the aim; the 10-hour day of test_ev05_long.py has no cut
pause at the shipped `slew_w` 0.
- **The 4.0 to 4.14 kW band on 3 phases.** 3 phases need 4.14 kW at 6 A, the
switch back to 1 phase is under 4.0 kW. Inside that band the car holds 6 A on
3 phases with no pause count (the hysteresis the design chose). Under 4.0 kW
the down-switch comes after 5 minutes; if the 10-minute gap blocks it, the
pause rule does instead.
- **A phase switch also waits for the 30 s write rule**, so the current set
after a switch is never sooner than 30 s after the one before it.
- **The meter's age.** The spare is not computed from a meter reading older
than `stale_input_s`, also when `meter_max_age_s` (P1) is longer.
- **A stale, stuck or not corroborated charging car makes the spare unknown**:
hold, then 0 A after *Pause after*. A paused or idle car with a fresh reading
counts 0 W (`car_w_trusted` is None outside mode3 C).
- **A stuck reading's 0 A is written whatever the frozen read-back says**, since
that read-back means nothing then. Every other exit skips the write when the
charger already shows 0 A, and never writes over another writer.
- **The guard's alarm path** uses the Solar car like Manual's
(`car_alarm_w`), and Solar's own 0 A (pause, cut, phase change) gets EV-15's
bounded grace (`_car_solar_pause`). A Solar quarter is never banked as "set
by the car", and Solar shows no *Car over the peak limit*.
- **Shadow mode** runs the plan without writing, so the card says what it would
set; the charger got its one 0 A when shadow mode came on.
## Round 3 (review of 17a7b29)
- **A way-out 0 A is written until the charger takes it** (`SolarWriter.
_exit_zero`): Off, Stop, shadow, a safety stop, a charger error, a stuck
reading and no car each owe a 0 A; one that is not taken is tried again by
EV-04's rule (`RETRY_S` 60 s apart, `MAX_TRIES` 3), then the gave-up row and
`CHARGER_REFUSED`. Once taken, or once the charger shows 0 A, nothing more.
Never over another writer. A stuck reading cannot confirm a write, so there
only a taken write counts (up to 3 tries). At shutdown there is one try, and
a write of ours not yet confirmed (cancelled during its read-back) means the
current is unknown, so the 0 A is written.
- **One excess, one cut** (`SolarPlan.ep`): an excess episode is measured from
the car's power when it began, so the same excess is not taken off again
while the meter still shows the old power. A new cut needs the car to show
the lower power and `CUT_SETTLE_S` (15 s) more for the meter.
## Round 4 (review of d2504ef, brief v5)
- **The wait needs headroom** (owner 2026-11-18): `ctl_car._car_batt_headroom`.
The 15 s wait runs only while a battery is above its cut-out, the guard is
neither saturated nor floor-limited (peak reserve), and the batteries'
output is more than `HEADROOM_W` (100 W) under what they can give
(`guard.able_w`, else the site rating). Otherwise the cut comes at once.
Before, "above the cut-out" alone let the car run 15 s while the batteries
were already at full output, and the period landed over the aim (review
repro: house 25 900 and 25 950 W, test_ev05.py R4/N4 against a car-Off twin).
## Round 5 (review of 8818768)
- **Headroom counts only the batteries that can give** (`ctl_car._car_giving`):
above their cut-out, not refusing to give (SAFETY-73), not under a safety
stop, switched on. Their output is compared with their own ratings (and
`guard.able_w` when the guard names it). Before, the site rating still
counted a refusing unit, so a battery that gave its full rating looked like
it had headroom and the cut waited (review repro: battery A refuses, house to
20 950 W, period 3436 W against the twin's 3363 W).
## Round 6 (review of 69f5818)
- **Solar grades the car out of the peak alarms only while it can cut it**
(`ctl_car.car_solar_can_cut`): not while another writer holds the charger,
a write of ours was refused or given up, a way-out 0 A is not taken, the
charger shows a fault or cannot be read. Otherwise the normal alarms stand
as in Off, and the quarter is banked as the car's (it can set the peak).
- **A refusing battery counts for nothing at every N**: at N=1 the refusal is
`Controller.batt_refused` (SAFETY-52). The site's own safety stops (circulation,
site sign) leave no battery able to give.
- **A battery switched Off still counts for the headroom**: the peak guard's
floor draws on it, so it can catch a cloud edge.
- **Only pressing Solar lifts Solar's other-writer hold.** Leaving Solar (Off,
Manual) or setting Manual's current or phases is not the user taking the
charger back, so nothing is written over that writer (N10).
## Round 7 (review of b4a222f, brief v6 Expected 11)
- **Solar keeps watching for another writer while it is not writing** (Stop,
shadow, a safety stop), so `hold` is true for every reader: the exit 0 A,
the shutdown, the peak alarms and Start afterwards (Solar holds off until
Solar is pressed or the read-back matches).
- **The peak alarms stand while Solar is not writing**: `car_solar_can_cut()`
also needs `car_writing()`. The quarter is banked as the car's.
- **A start or restart in Solar with shadow on writes nothing** (owner
2026-11-18), even with a car already charging under another writer: N10
wins over the restart 0 A. The not-writing 0 A is owed only when Solar had
the charger before (`had_control`).
- **Once that exit 0 A is taken, nothing more is written**, shutdown
included. A shutdown while Solar is writing still sends its 0 A before the
inverters (T26).
## Round 8 (review of fa11dc3)
- **Off follows the same owed-only rule as the shutdown**: no 0 A when Solar
never had the charger (shadow or a stopped control since the start), or
when its not-writing 0 A is already taken. Manual writes only as Manual
does (nothing in shadow).
- **Solar grades out only a car it runs**: `car_solar_can_cut()` also needs
`plan.a > 0`, a phase change of its own, or its own 0 A still inside EV-15's
`OWN_PAUSE_MAX_S`. A car another writer starts while Solar waits at 0 A for
sun gets the alarms as in Off.
## Round 9 (review of e348a80)
- **One test of control**: `SolarWriter.in_control`. Solar writes, the
read-back current AND phases are what it set (`own_rb`), there is no hold,
and no write of its own is refused, given up or owed. The alarm grading,
the banking, EV-15's own-pause grace and the cut all use it.
- **A phase change Solar did not make is another writer**, like a current
change: nothing is written over it, and after `WRITER_S` the hold
(CHARGER_OTHER). Solar no longer selects its own phases back after the
10 minutes. A select the charger did not confirm counts both phases as
Solar's until the read-back shows one.
- **While Solar's own phase switch waits** (`PHASE_GAP_S`), a lower current
(the cut, the hold's 6 A) is written at once. The arithmetic uses the
phases the car draws on.
- **The own-pause grace ends when the read-back is not Solar's 0 A**: a car
another writer starts inside it gets the alarms as in Off.
## Solar kWh
Per cycle in Solar: `min(car power, max(0, spare - room))` Batteries first,
`min(car power, max(0, spare))` Car first; never above today's kWh; reset at the
day change; kept in the store (`car_sun`).
+89 -27
View File
@@ -256,7 +256,10 @@ The label and description each setting shows on the Configuration tab, in tab or
| 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. |
| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current. |
| Car charger | Sun kept back (W) | `ev_margin_w` | Solar: this much spare sun is never given to the car. |
| Car charger | Start after (minutes) | `ev_start_min` | Solar: the car starts after this long with enough spare sun. |
| Car charger | Pause after (minutes) | `ev_pause_min` | Solar: with too little sun the car holds 6 A this long, then pauses. |
| 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. |
@@ -3278,9 +3281,10 @@ 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.
The card has three modes in this version: **Off** (the add-on only reads the
charger and writes nothing), **Manual** (the add-on sets the current and the
phases you choose) and **Solar** (the car charges from spare sun only). Night
mode comes in a later version.
| option | meaning |
|---|---|
@@ -3290,6 +3294,9 @@ phases you choose). Solar and Night modes come in later versions.
| `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. |
| `ev_margin_w` | Solar: spare sun never given to the car, 0 to 1000 W (default 100). |
| `ev_start_min` | Solar: minutes of enough sun before the car starts, 1 to 30 (default 2). |
| `ev_pause_min` | Solar: minutes the car holds 6 A with too little sun before it pauses, 1 to 30 (default 5). |
**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
@@ -3320,24 +3327,70 @@ checks within 10 seconds that the charger took it.
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
**Solar mode.** Choose *Solar* on Home (or `Solar` on
`select.goodwe_car_mode`) and where spare sun goes first: **Batteries** or
**Car** (`select.goodwe_car_sun_first`). Both apply at once, with no restart.
- *Spare sun* is solar production less the house, measured without a solar
sensor: the car's power, plus what the batteries charge, less what the grid
gives. A grid charge of the batteries, or batteries giving more than the
house uses, is never spare sun.
- *Batteries first*: the car gets what is left after the full rating of every
battery that may still charge (switched on, not refusing, not full), less
*Sun kept back*. So the car gets sun only when the batteries charge at full
power or are full. *Car first*: the car gets the spare sun less *Sun kept
back*, and the batteries charge with what it leaves.
- The current is whole amps, rounded down, from 6 A to the charger limit. It
changes at most once per 30 seconds, and only by 1 A or more.
- The car starts after *Start after* (2 minutes) of sun for at least 7 A. With
too little sun it holds 6 A for *Pause after* (5 minutes), from the batteries
where they can, then pauses at 0 A: the card says *Waiting for sun*.
- With `ev_phases` `auto` a start goes on 1 phase. It moves to 3 phases after
3 minutes at 4.5 kW or more, and back to 1 phase after 5 minutes under 4 kW,
at most once per 10 minutes, always through the safe phase steps above. A car
that draws one phase while three are allowed is counted on one phase.
- **The car is cut first for the peak limit.** When the 15-minute period heads
over the limit and the peak guard would ask the batteries for power, that is
taken off the car first, down to 0 A if needed. While the batteries can
still raise their output, the add-on first waits 15 seconds, so a cloud
the batteries catch does not pause the car. It cuts at once when they
cannot: already at full power, at the peak reserve, at their cut-out
level or refusing to give. It also cuts at once in the last 2 minutes of
the 15-minute period. A Solar charge never sets the month's peak.
- **Every way out of Solar leaves the charger at 0 A**: a stop or
restart of the add-on (before the inverters go to 0 W), stopping control, a
safety stop, shadow mode turned on, choosing Off, an unplugged car, a charger
error or a stuck reading. If the charger does not take the 0 A, the add-on
tries again a minute later, three times, then shows *Charger did not take
it* and a warning. Once taken, nothing more is written. After the charger
or Home Assistant was away, the add-on first sets 0 A, then starts again
by the rules. A meter that stops gives a hold for *Pause after*, then 0 A.
Choosing Manual leaves it to Manual.
- Another writer stops the add-on's writes after 30 seconds, with an amber row
and a warning, until you press the mode again or the charger shows the
add-on's value again. A change of the current or of the phases counts. In
the meantime nothing is written over it and the peak alarms stand.
- The card shows *{kWh} charged today, {kWh} from the sun*, also as
`sensor.goodwe_car_today_solar_kwh`. Only the sun the car could take counts,
not the battery or grid share of a hold, and not Manual.
**The car is never slowed for the peak limit in Manual.** 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.
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
@@ -3364,9 +3417,10 @@ charger* shows for an hour after a change. That is expected while you migrate.
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.)
3. On the next sunny day, choose **Solar**, with *Spare sun goes first to* set
as your priority switch was (*Batteries* or *Car*), and *Sun kept back* as
your automation's margin. Watch the card's *Why* through a cloud: the car
holds 6 A for 5 minutes, then waits for the sun.
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.
@@ -3377,9 +3431,10 @@ 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.
`goodwe_car_power`, `goodwe_car_state`, `goodwe_car_today_kwh` and
`goodwe_car_today_solar_kwh`, and the four controls named above. A saved
("retained") command is never applied, so a restart of Home Assistant cannot
change the charger.
### Site
@@ -3516,6 +3571,13 @@ 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.
### Charger error, car paused
In Solar mode the charger reports an error, so the add-on set the car to 0 A
and writes nothing more until the error clears. Then the car starts again by
the Solar rules. Check the charger itself. The notification goes by itself when
the error clears.
### For installers: notifications
A fixed tariff beside the price service raises no notification: it is the
+660 -5
View File
@@ -1,4 +1,5 @@
"""EV-04: the car charger's Manual mode, the one place the add-on WRITES to it.
"""EV-04 and EV-05: the car charger's Manual and Solar modes, 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-
@@ -24,21 +25,38 @@ THE RULES, each tested in test_ev04.py:
mode or a value again.
* A charger that comes back after being unavailable gets the setting again only
if its read-back differs.
EV-05, SOLAR (`SolarPlan` decides, `SolarWriter` writes; test_ev05.py,
DECISIONS/EV-05-solar-mode.md): the car gets the spare sun, `spare = car +
battery charge - grid import`, less the batteries' room (Batteries first) and
the margin. Whole amps rounded down, at most one write per 30 s and only on a
1 A change. Start after `ev_start_min` of enough sun, hold 6 A for
`ev_pause_min` below it, then 0 A. The peak guard's excess is taken off the
car first, at once. Every way out of Solar leaves the charger at 0 A, written
once. Both writers share `ManualWriter._write`, so there is still one
`write_current` and one `write_phases` call in the add-on.
"""
from __future__ import annotations
import logging
import math
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)
OFF, MANUAL, SOLAR = "off", "manual", "solar"
#: the modes offered. Night is a later card (EV-02).
MODES = (OFF, MANUAL, SOLAR)
#: Home Assistant's select labels, English and pinned.
MODE_LABELS = {OFF: "Off", MANUAL: "Manual"}
MODE_LABELS = {OFF: "Off", MANUAL: "Manual", SOLAR: "Solar"}
#: EV-05: where the spare sun goes first (`select.goodwe_car_sun_first`).
KEY_FIRST = "car_sun_first"
FIRST_BATT, FIRST_CAR = "batteries", "car"
FIRSTS = (FIRST_BATT, FIRST_CAR)
FIRST_LABELS = {FIRST_BATT: "Batteries", FIRST_CAR: "Car"}
DEFAULT_FIRST = FIRST_BATT
START_KEEP, START_OFF = "keep", "off"
KEY_MODE, KEY_A, KEY_PHASES = "car_mode", "car_current", "car_phases"
@@ -378,3 +396,640 @@ class ManualWriter:
self.rev_applied = None
return
q["t1"] = now - SETTLE_S + 5.0 # again in 5 s
# =========================================================================== #
# EV-05: Solar. `SolarPlan` decides what the car should get, `SolarWriter`
# makes the charger match it through ManualWriter's one write site.
# =========================================================================== #
MIN_A = CH.MIN_A
VOLTS = 230.0 # per phase: the amps a figure in watts is worth
SOLAR_WRITE_S = 30.0 # at most one current change per this
SOLAR_STEP_A = 1.0 # ... and only on a change of this or more
UP_W, UP_S = 4500.0, 180.0 # auto phases: to 3 at this for this long
DOWN_W, DOWN_S = 4000.0, 300.0 # ... back to 1 under this for this long
ONE_PHASE_S = 10.0 # one phase drawing while 3 are allowed this long
ONE_PHASE_MIN_W = 500.0 # ... with the car drawing at least this
# EV-05 round 3: one excess episode is taken off the car ONCE, measured from
# the car's power when it began, until the car shows the lower power
# (within CUT_SEEN_W) and then CUT_SETTLE_S more for the meter to see it (a
# DSMR4 telegram is 10 s). Only then can a still standing excess cut again.
CUT_SEEN_W = 100.0
CUT_SETTLE_S = 15.0
def _num(v):
try:
f = float(v)
except (TypeError, ValueError):
return None
return f if math.isfinite(f) else None
def spare_w(car_w, batt_w, grid_w):
"""The spare sun, signed and not clipped: what the car takes, plus what the
batteries charge, less what the grid gives. `batt_w` is the add-on's own
battery figure (discharge positive) and `grid_w` the meter (import
positive), so this is `car - batt - grid` = solar production less the
house. A grid charge of the batteries, or batteries giving more than the
house uses, is never spare sun. None when a figure is missing or not a
number."""
c, b, g = _num(car_w), _num(batt_w), _num(grid_w)
if c is None or b is None or g is None:
return None
return c - b - g
def car_target_w(spare, room_w, margin_w, first):
"""What the car may take: Batteries first `spare - room - margin`, Car
first `spare - margin`. None while the spare is unknown."""
s = _num(spare)
if s is None:
return None
room = float(room_w or 0.0) if first == FIRST_BATT else 0.0
return s - room - float(margin_w)
def amps_for(car_w, n, clamp=None):
"""Whole amps for `car_w` on `n` phases, ROUNDED DOWN, never above the
clamp. None for a figure that is not a number."""
w = _num(car_w)
if w is None or n not in (1, 3):
return None
a = math.floor(w / (VOLTS * n) + 1e-9)
hi = CH.ENTITY_MAX_A if _num(clamp) is None else float(clamp)
return float(max(0, min(a, math.floor(hi))))
def solar_option(opts: dict, key: str) -> float:
"""`ev_margin_w`, `ev_pause_min` or `ev_start_min` as a number, the shipped
default when it is not one (the validator refuses it anyway)."""
v = _num((opts or {}).get(key))
return float(CH.EV_OPTION_DEFAULTS[key]) if v is None else v
class SunInputs:
"""One cycle's inputs for Solar, built by the Controller."""
def __init__(self, target_w=None, hold=False, cut_w=0.0, car_w=None,
key=None, auto=True, fixed_n=1, start_s=120.0,
pause_s=300.0, spare_w=None, room_w=0.0, margin_w=100.0,
first=DEFAULT_FIRST):
self.target_w, self.hold, self.cut_w = target_w, hold, cut_w
self.car_w, self.key, self.auto, self.fixed_n = car_w, key, auto, \
fixed_n
self.start_s, self.pause_s = start_s, pause_s
self.spare_w, self.room_w, self.margin_w = spare_w, room_w, margin_w
self.first = first
class SolarPlan:
"""What Solar wants set, one `step()` per cycle. Pure: monotonic `now` from
the caller and no driver, so in shadow mode it runs the same and the card
says what it would set. `a` is the current wanted (0: paused), `n` the
phases it is meant for."""
def __init__(self, n=1):
self.reset(n)
def reset(self, n=1, why="paused"):
self.a = 0.0
self.n = n if n in (1, 3) else 1
self.set_at = None # when `a` last changed (the 30 s rule)
self.ok_since = None # enough sun to start, since
self.low_since = None # under 6 A worth, holding 6 A, since
self.unknown_since = None # the spare cannot be measured, since
self.up_since = self.down_since = None
self.cap_a = self.cap_key = None # the peak cut, for this period
self.ep = None # the cut episode: [base W, target W, seen]
self.why = self.pause_why = why
self.target_w = None
def _pause(self, why):
self.a, self.set_at = 0.0, None
self.ok_since = self.low_since = self.unknown_since = None
self.up_since = self.down_since = None
self.why = self.pause_why = why
def _gate(self, now) -> bool:
return self.set_at is None or now - self.set_at >= SOLAR_WRITE_S
def _switch(self, n, target_w, now, clamp):
self.n = n
a = amps_for(target_w, n, clamp) or 0.0
if a >= MIN_A:
self.low_since = None
elif self.low_since is None:
self.low_since = now
a = max(a, MIN_A)
if self.cap_a is not None:
a = max(MIN_A, min(a, self.cap_a))
self.a, self.set_at = a, now
self.up_since = self.down_since = None
self.why = "running"
def step(self, now, *, target_w, n_calc, auto, fixed_n, clamp,
start_s, pause_s, hold=False, cut_w=0.0, car_w=None, key=None,
gap_ok=True):
if key != self.cap_key:
self.cap_a = self.cap_key = None
if hold: # readings late, under the stale bound
return
self.target_w = target_w
# The peak guard's excess comes off the car first, at once (no 30 s
# rule, no hold). Nothing starts while the period heads over the aim.
if not (cut_w and cut_w > 0.0):
self.ep = None
if cut_w and cut_w > 0.0:
self.ok_since = None
if self.a > 0.0:
cw = _num(car_w)
ep = self.ep
if ep is not None and ep[2] is None \
and (cw is None or cw <= ep[1] + CUT_SEEN_W):
ep[2] = now # the car shows the cut
if ep is None or (ep[2] is not None
and now - ep[2] >= CUT_SETTLE_S):
base = self.a * VOLTS * n_calc
if cw is not None:
base = min(base, cw)
ep = self.ep = [base, base, None]
# Measured from the episode's start, so the same excess is not
# taken off again while the meter still shows the old power.
new = amps_for(ep[0] - float(cut_w), n_calc, clamp)
if new is not None:
ep[1] = min(ep[1], new * VOLTS * n_calc)
if new is None or new < MIN_A:
self._pause("cut")
elif new < self.a:
self.a, self.set_at, self.why = new, now, "cut"
self.cap_a, self.cap_key = new, key
return
if target_w is None: # the sun cannot be measured: hold, then 0 A
self.ok_since = None
if self.a > 0.0:
if self.unknown_since is None:
self.unknown_since = now
if now - self.unknown_since >= pause_s:
self._pause("unknown")
else:
self.why = "unknown"
return
self.unknown_since = None
hi = None if _num(clamp) is None else math.floor(float(clamp))
if self.a <= 0.0: # paused: the start rule
n0 = 1 if auto else fixed_n
if target_w >= (MIN_A + 1.0) * VOLTS * n0:
if self.ok_since is None:
self.ok_since = now
self.why = "start"
if now - self.ok_since >= start_s:
a = amps_for(target_w, n0, clamp)
if a is not None and self.cap_a is not None:
a = min(a, self.cap_a)
if a is not None and a >= MIN_A:
self.a, self.n, self.set_at = a, n0, now
self.ok_since = self.low_since = None
self.up_since = self.down_since = None
self.why = "running"
else:
self.ok_since = None
self.why = self.pause_why
return
if hi is not None and self.a > hi: # the clamp came down
if hi < MIN_A:
self._pause("paused")
return
self.a, self.set_at = float(hi), now
if auto: # auto phases, by their own dwells
if self.n == 1:
self.down_since = None
if target_w >= UP_W:
self.up_since = self.up_since if self.up_since is not None \
else now
else:
self.up_since = None
if self.up_since is not None and now - self.up_since >= UP_S \
and gap_ok and self._gate(now):
self._switch(3, target_w, now, clamp)
return
else:
self.up_since = None
if target_w < DOWN_W:
self.down_since = self.down_since \
if self.down_since is not None else now
else:
self.down_since = None
if self.down_since is not None \
and now - self.down_since >= DOWN_S and gap_ok and self._gate(now):
self._switch(1, target_w, now, clamp)
return
want = amps_for(target_w, n_calc, clamp)
if want is not None and want >= MIN_A:
self.low_since = None
if self.cap_a is not None:
want = min(want, self.cap_a)
self.why = "running"
if abs(want - self.a) >= SOLAR_STEP_A and self._gate(now):
self.a, self.set_at = want, now
return
if auto and self.n == 3 and target_w >= DOWN_W:
# Inside the phase hysteresis (4.0 kW to 6 A x 690 W): 3 phases at
# 6 A stand, as the switch rule says; no pause count.
self.low_since = None
self.why = "running"
if self.a != MIN_A and self._gate(now):
self.a, self.set_at = MIN_A, now
return
if self.low_since is None:
self.low_since = now
self.why = "hold"
if now - self.low_since >= pause_s:
self._pause("paused")
return
if self.a != MIN_A and self._gate(now):
self.a, self.set_at = MIN_A, now
class SolarWriter(ManualWriter):
"""What Solar does to the charger, one `step()` per cycle. It shares
ManualWriter's write, phase sequence and other-writer watch; what differs
is that every way out ends at 0 A, and that an interrupted phase change is
never undone to the old current. The way-out 0 A is written until the
charger takes it (EV-04's rule: `RETRY_S` apart, `MAX_TRIES`, then the
gave-up row and warning), and once taken nothing more."""
def __init__(self):
super().__init__()
self.plan = SolarPlan()
self.engaged = False # Solar has run since it was chosen
self.reinit = True # start again from 0 A and the start rule
self.out = False # not writing (shadow, Stop, safety stop)
self.had_control = False # Solar wrote since it was chosen/started
self.zero_for = None # the way out a 0 A is owed for
self.zero_ok = False # ... and the charger has taken it
self.inflight = None # a current being written, not yet back
self.fault = None # "error" | "stuck" while it holds
self.warned = False # the charger error warning, once
self.single = False # a one-phase car on a 3-phase allowance
self._one_since = None
self.zero_at = None # EV-15: our own latest 0 A, sent then
self.sent_a = None # the current we last decided to write
# Round 9: the phases Solar knows as its own (None: not yet taken;
# both after a select the charger did not confirm), whether the
# latest read-back (current and phases) is Solar's own, and the
# phases the car draws on while they differ from the plan's.
self.ph_known = None
self.own_rb = True
self.n_draw = None
# ------------------------------------------------------------------ help
def _mark(self, r, now) -> None:
"""A car that draws one phase while 3 are allowed is a one-phase car
for the session: the sun arithmetic then uses 1 phase."""
if r.state == "A":
self.single, self._one_since = False, None
return
drawing = [x for x in (r.current_a or ()) if x >= CH.IDLE_A]
one = (r.phases_allowed == 3 and r.charging is True
and r.power_w is not None and r.power_w >= ONE_PHASE_MIN_W
and len(r.current_a or ()) >= 3 and len(drawing) == 1)
if not one:
self._one_since = None
return
if self._one_since is None:
self._one_since = now
if now - self._one_since >= ONE_PHASE_S and not self.single:
self.single = True
_LOG.info("The car draws one phase while three are allowed, so "
"the add-on counts one phase for this charge.")
def _watch(self, cur, now, ph=None) -> None:
"""As Manual's, for the current AND (round 9) the phases: a read-back
that is not what Solar set (`own_rb` False) is another writer's, and
after `WRITER_S` the hold. In Solar the hold is a warning: the add-on
stops writing until you press the mode or the read-back matches."""
known = [x for x in (self.last_a, self.attempted_a, self.prior_a)
if x is not None]
a_known = bool(known) and cur is not None
a_bad = a_known and not any(abs(cur - k) <= TOL_A for k in known)
p_known = ph in (1, 3) and bool(self.ph_known)
p_bad = p_known and ph not in self.ph_known
if p_known and not p_bad:
self.ph_known = {ph} # a select confirmed late
self.own_rb = not (a_bad or p_bad)
if self.own_rb:
self.mismatch_since = None
if self.hold and (a_known or p_known):
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
if p_bad:
_LOG.info("Something else changed the charger's phases, so "
"the add-on stops writing to it until you change "
"it.")
else:
_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])
_LOG.warning("Something else changes the charger, so the add-on "
"stops writing to it: CHARGER_OTHER.")
@property
def in_control(self) -> bool:
"""Round 9, the one test of "Solar has the charger now": it writes,
the read-back current and phases are what it set, no other writer's
hold, and no write of its own refused, given up or owed. Every place
that acts as if Solar can cut the car asks this."""
return bool(self.had_control and not self.out and self.own_rb
and not self.hold and not self.gave_up
and self.fail_at is None and self.attempted_a is None
and self.fault is None and not self.zero_owed)
@property
def n_calc(self) -> int:
"""The phases the sun arithmetic uses: those the car draws on."""
if self.single:
return 1
return self.n_draw or self.plan.n
def amps_out(self, clamp) -> float:
"""The plan's current, never above the clamp; 0 when under 6 A."""
a = float(self.plan.a)
if _num(clamp) is not None:
a = min(a, float(math.floor(float(clamp))))
return a if a >= CH.MIN_A else 0.0
def user_changed(self) -> None:
"""As Manual's, and Solar says its current again (another writer's
hold is lifted by pressing the mode)."""
super().user_changed()
self.sent_a = None
# Round 9: Solar takes the charger as it is (current and phases), so
# the other writer's value is no longer a difference.
self.last_a = None
self.ph_known, self.own_rb = None, True
async def _write(self, drv, a, was, now, tracker) -> bool:
self.inflight = a # cleared only when the write returns
ok = await super()._write(drv, a, was, now, tracker)
self.inflight = None
return ok
def _zero_done(self) -> None:
"""No way out is under way any more: forget its 0 A and its tries."""
if self.zero_for is not None:
self.zero_for, self.zero_ok = None, False
self.fails, self.fail_at, self.gave_up = 0, None, False
async def _exit_zero(self, why, drv, cur, now, tracker,
force=False) -> None:
"""0 A on the way out (`why`), until the charger takes it: a write
that is not taken is tried again `RETRY_S` later, `MAX_TRIES` times,
then the gave-up row and warning. Once taken, or once the charger
shows 0 A, nothing more. Never over another writer. `force`: the
reading is stuck, so its 0 A means nothing; only a taken write
counts."""
if self.zero_for != why:
self.zero_for, self.zero_ok = why, False
self.fails, self.fail_at, self.gave_up = 0, None, False
if self.zero_ok or self.hold:
return
if not force and cur is not None and cur <= TOL_A:
self.zero_ok = True
self.fails, self.fail_at = 0, None
return
if self.gave_up or (self.fail_at is not None
and now - self.fail_at < RETRY_S):
return
self.zero_at, self.sent_a = now, 0.0
if await self._write(drv, 0.0, cur, now, tracker):
self.zero_ok = True
self.fails, self.fail_at = 0, None
else:
self._failed(now)
@property
def zero_owed(self) -> bool:
"""A way-out 0 A the charger has not taken yet (for the card)."""
return self.zero_for is not None and not self.zero_ok and not self.hold
def _leave(self) -> None:
self.engaged, self.seq, self.would = False, None, None
self.out = self.had_control = False
self._zero_done()
self.fault = None
self.reinit = True
self.sent_a = None
self.ph_known, self.own_rb, self.n_draw = None, True, None
self.plan.reset(self.plan.n)
def _plan_step(self, sun, now, clamp) -> None:
gap = self.last_switch is None or now - self.last_switch >= PHASE_GAP_S
self.plan.step(
now, target_w=sun.target_w, hold=sun.hold, n_calc=self.n_calc,
auto=sun.auto and not self.single,
fixed_n=1 if self.single else sun.fixed_n, clamp=clamp,
cut_w=sun.cut_w, car_w=sun.car_w, key=sun.key,
start_s=sun.start_s, pause_s=sun.pause_s,
gap_ok=gap and not self.phases_gave_up)
# ------------------------------------------------------------------ step
async def step(self, drv, r, *, mode, sun, clamp, now, tracker, writing,
status, clock=None):
"""One cycle. `sun` is `SunInputs`; `writing` is False in shadow mode,
while control is stopped, under a safety stop and while stopping."""
self._clock = clock or (lambda: now)
if r is None or not r.available:
self.was_available = False # nothing is tried while it is down
return
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
self._mark(r, now)
if not self.was_available:
self.was_available = True
self.reinit = True # back: 0 A first, then the rules
self.ph_known = None # ... on the phases it came back on
cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
if mode != SOLAR:
self.would = None
if not self.engaged:
return
if mode != MANUAL: # Off: 0 A until taken, then nothing
self.seq = None
# Round 8: not when Solar never had the charger (shadow or a
# stopped control since the start) or its not-writing 0 A is
# already taken: nothing over another writer (N10).
if not (self.out and (self.zero_ok or not self.had_control)):
await self._exit_zero("off", drv, cur, now, tracker)
if self.zero_owed:
return # tried again next cycle (or gave up)
self._leave() # Manual writes its own current
return
self.engaged = True
if sun is None:
return
if not writing:
# Shadow, Stop, a safety stop, stopping: 0 A until taken, then
# nothing. The plan goes on, so the card says what it would set.
# Round 7 (brief v6, Expected 11): only if Solar had the charger
# before; a start or restart in shadow writes nothing. And Solar
# keeps watching for another writer, so `hold` stays true for
# every reader (the exit, the shutdown, the peak alarms).
self.seq = None
self.out = True
self.n_draw = None
if self.had_control:
await self._exit_zero("out", drv, cur, now, tracker)
self._watch(cur, now, r.phases_allowed)
self._plan_step(sun, now, clamp)
self.would = (self.amps_out(clamp), self.n_calc)
self.reinit = True
return
self.out = False
self.had_control = True
self.would = None
fault = ("error" if (r.error or r.state in ("E", "F")) else
"stuck" if tracker is not None and tracker.stuck(now)
else None)
if fault is not None:
# 0 A once, then no write until it clears; then the start rule.
self.seq = None
if self.fault != fault:
self.fault = fault
if fault == "error" and not self.warned:
self.warned = True
_LOG.warning("The charger reports an error, so the add-on "
"sets the car to 0 A: CHARGER_ERROR.")
await self._exit_zero(fault, drv, cur, now, tracker,
force=fault == "stuck")
self.plan.reset(self.plan.n, why=fault)
self.reinit = True
return
if self.fault is not None:
self.fault = None
self.warned = False
if r.state == "A" or status == CH.NONE_:
# No car: the standing current is 0 A, written until taken.
self.seq = None
await self._exit_zero("none", drv, cur, now, tracker)
self.plan.reset(self.plan.n, why="none")
self.reinit = False
return
self._zero_done() # no way out under way now
if self.reinit:
self.reinit = False
self.seq = None
self.mismatch_since = None
self.sent_a = None
n = r.phases_allowed if r.phases_allowed in (1, 3) else self.plan.n
self.plan.reset(n)
if self.ph_known is None and r.phases_allowed in (1, 3):
self.ph_known = {r.phases_allowed} # Solar takes the charger
if status == CH.FULL: # the car is full: nothing written
self.plan.why = "full"
return
self.n_draw = None
if self.seq is None:
self._watch(cur, now, r.phases_allowed)
if self.hold:
return
if not self.own_rb:
# Round 9: another writer's current or phases, not yet held
# (`WRITER_S`): the plan goes on, nothing is written over it.
self._plan_step(sun, now, clamp)
return
if r.phases_allowed in (1, 3) and cur is not None \
and cur >= CH.MIN_A:
self.n_draw = r.phases_allowed # what the car draws on
self._plan_step(sun, now, clamp)
if self.seq is not None:
q = self.seq
if self.plan.a < CH.MIN_A:
self.seq = None # paused or cut: it stays at 0 A
return
pf = self.phase_fails
await self._advance(drv, r, cur, now, tracker, self.amps_out(clamp)
or CH.MIN_A, clamp, None)
if "t1" in q and not q.get("ph_set"):
q["ph_set"] = True # the select is out: whose phases
self.ph_known = {q["n"]} if self.phase_fails == pf \
else {x for x in (q.get("from"), q["n"]) if x in (1, 3)}
if self.phase_fails > pf and q.get("from") in (1, 3):
self.plan.n = q["from"] # the select was not taken
if self.seq is None:
self.sent_a = self.last_a
return
want = self.amps_out(clamp)
if want >= CH.MIN_A and not self.single and not self.phases_gave_up \
and r.phases_allowed in (1, 3) \
and r.phases_allowed != self.plan.n:
if self.last_switch is not None \
and now - self.last_switch < PHASE_GAP_S:
self.blocked = True
# Round 9: the switch waits, a lower current does not (the
# cut, the hold's 6 A; a pause is 0 A and never waits here).
if not (cur is not None and cur > want + TOL_A):
return
else:
self.blocked = False
self.zero_at, self.sent_a = now, 0.0
await self._begin(drv, r, cur, self.plan.n, now, tracker)
if self.seq is not None:
self.seq["from"] = r.phases_allowed
return
if self.sent_a is not None and abs(self.sent_a - want) <= TOL_A \
and self.fail_at is None:
return # nothing new: a read-back that differs is `_watch`'s
if cur is not None and abs(cur - want) <= TOL_A:
self.sent_a = want
self.fails, self.fail_at = 0, None
if self.last_a is None or abs(self.last_a - cur) > TOL_A:
self.last_a = cur
return
if self.gave_up or (self.fail_at is not None
and now - self.fail_at < RETRY_S):
return
if want <= 0.0:
self.zero_at = now
self.sent_a = want
if await self._write(drv, want, cur, now, tracker):
self.fails, self.fail_at = 0, None
else:
self._failed(now)
async def release(self, drv, r, now, tracker) -> None:
"""The add-on stops in Solar: 0 A before the inverters go to 0 W, one
try (it is stopping). A phase change in the middle is not undone to
the old current. A write of ours that is not confirmed (cancelled
while it waited for its read-back) means the charger's current is not
known, so the 0 A is written."""
self.seq = None
if r is not None and r.available:
cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
else:
cur = None
if self.inflight is not None or self.attempted_a is not None:
cur = None # a write of ours is not confirmed: assume nothing
elif 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:
cur = self.last_a # the reading predates our own write
self._clock = self._clock or (lambda: now)
self.inflight = None
# Round 7: not writing (shadow, Stop, a safety stop) and the way-out
# 0 A already taken, or Solar never had the charger: nothing more,
# shutdown included (N10).
if self.out and (self.zero_ok or not self.had_control):
return
# One try: the add-on is stopping, bounded by `ctl_car.RELEASE_WAIT_S`.
if not self.hold and not (cur is not None and cur <= TOL_A):
self.zero_at, self.sent_a = now, 0.0
await self._write(drv, 0.0, cur, now, tracker)
self.out = True
+12 -4
View File
@@ -5,8 +5,8 @@ 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
EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, in Manual and (EV-05) in
Solar (`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
@@ -42,7 +42,13 @@ 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"}
"ev_batt_cover": True, "ev_mode_start": "keep",
# EV-05, Solar: the sun kept back, and the two dwells
"ev_margin_w": 100, "ev_pause_min": 5,
"ev_start_min": 2}
#: EV-05: the ranges config.yaml's schema and the validator both hold.
SOLAR_RANGES = {"ev_margin_w": (0, 1000), "ev_pause_min": (1, 30),
"ev_start_min": (1, 30)}
def max_a(opts: dict):
@@ -553,7 +559,9 @@ class AlfenHaDriver(ChargerDriver):
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)."""
is a stand-alone device and the current is the user's setting). Solar's
0 A goes through `carmode` (`SolarWriter.release`), the one write
site, so nothing is written here."""
return True
+385 -88
View File
@@ -1,17 +1,21 @@
"""EV-04: the Controller's side of the car's Manual mode.
"""EV-04 and EV-05: the Controller's side of the car's Manual and Solar modes.
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.
EV-05 (DECISIONS/EV-05-solar-mode.md): Solar's inputs (`car_sun_inputs`), the
peak guard's excess taken off the car first (`car_cycle`), the 0 A at shutdown
before the inverters, and the solar kWh of today.
"""
import asyncio
import dataclasses
import logging
import math
from datetime import timezone
from . import carmode, chargers, messages, peakguard
from . import carmode, chargers, messages, packmode, packshare, peakguard
from .tariff import QUARTER_S
_LOG = logging.getLogger("goodwe")
@@ -31,6 +35,24 @@ OVER_OFF_HOLD_S = 180.0
OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S
+ carmode.MAX_TRIES * 15.0 + 10.0)
OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S
CAR_SUN_KEY = "car_sun" # EV-05: {day, kwh} charged from the sun today
# EV-05 round 2 (owner 2026-11-18): while a battery can still give power the
# peak cut waits until the guard has wanted power this long in a row, so a
# cloud edge the batteries catch does not pause the car. It cuts at once when
# no battery can give (all at their cut-out) or with this little of the
# 15-minute period left: waiting 15 s with R s left raises what must come off
# afterwards by R / (R - 15), at most 8/7 at R = 120 s, and the cut takes it
# off the car at once then (test_ev05.py T21, T21b, T24c: the period lands
# under the aim).
CUT_WAIT_S = 15.0
CUT_NEAR_END_S = 120.0
# Round 4 (owner 2026-11-18, brief v5): the wait needs HEADROOM, batteries that
# can still raise their output. Within this many W of their rating they are
# at full output.
HEADROOM_W = 100.0
# EV-05: at shutdown the charger's 0 A waits at most this long, then the
# inverters are released whatever the charger did.
RELEASE_WAIT_S = 15.0
class CarMixin:
@@ -52,6 +74,26 @@ class CarMixin:
self.car_n = n if n in ok else ok[0]
self.car_rev = 0
self.car_writer = carmode.ManualWriter()
self.car_solar = carmode.SolarWriter() # EV-05
first = data.get(carmode.KEY_FIRST)
self.car_first = first if first in carmode.FIRSTS \
else carmode.DEFAULT_FIRST
self.car_cut_w = 0.0
self._car_key = None
self._car_late_s = None
self._car_want_since = None # EV-05: the guard wants power since
self._car_sun_last = None
self._car_error_notified = False
sun = data.get(CAR_SUN_KEY)
self.car_sun = {"day": None, "kwh": 0.0}
if isinstance(sun, dict):
try:
self.car_sun = {"day": sun.get("day"),
"kwh": max(0.0, float(sun.get("kwh") or 0.0))}
except (TypeError, ValueError):
pass
self._car_sun_mono = None
self._car_sun_saved = round(self.car_sun["kwh"], 2)
self._car_task = None
self._car_step_failed = False
self.car_explains = False # the car alone explains the excess
@@ -60,7 +102,6 @@ class CarMixin:
self._car_over_gone = None
self._car_batt_prev = None
self._car_need_real = self._car_need_excl = False # EV-10 latches
self._car_need_house = self._car_over_now = False # EV-18 latches
self._car_latch_block = None
self._car_over_notified = None # the session a notice was raised for
self._car_session = 0
@@ -82,6 +123,12 @@ class CarMixin:
return (self.charger.configured()
and self.car_mode == carmode.MANUAL)
def car_solar_mode(self) -> bool:
"""EV-05: a charger is set up and the mode is Solar."""
ch = getattr(self, "charger", None)
return bool(ch is not None and ch.configured()
and getattr(self, "car_mode", None) == carmode.SOLAR)
def car_clamp(self):
return carmode.clamp_for(self.o, self.car.reading)
@@ -105,6 +152,17 @@ class CarMixin:
return {"error": messages.car_refused("value")}
self.car_mode = value
self.store.set(carmode.KEY_MODE, value)
elif what == "car_sun_first":
# EV-05: arithmetic only, from the next cycle; not a user change of
# the writers (the 30 s rule and the other-writer hold stand).
if value not in carmode.FIRSTS:
return {"error": messages.car_refused("value")}
self.car_first = value
self.store.set(carmode.KEY_FIRST, value)
self.log_event(f"car sun first set to {value} by operator",
hint=messages.hint("car_sun_first"))
return {"mode": self.car_mode, "current": self.car_a,
"phases": self.car_n, "sun_first": self.car_first}
elif what == "car_current":
clamp = self.car_clamp()
if isinstance(value, bool):
@@ -127,6 +185,12 @@ class CarMixin:
self.store.set(carmode.KEY_PHASES, value)
self.car_rev += 1
self.car_writer.user_changed()
if what == "car_mode" and value == carmode.SOLAR:
# EV-05 round 6: only pressing Solar lifts Solar's other-writer
# hold. Leaving Solar, or setting Manual's current or phases, is
# not the user taking the charger back, so nothing is written over
# that writer (N10).
self.car_solar.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,
@@ -136,7 +200,8 @@ class CarMixin:
"""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)}
"car_phases": str(self.car_n),
"car_sun_first": carmode.FIRST_LABELS[self.car_first]}
# ------------------------------------------------------------- the writer
def car_kick(self) -> None:
@@ -150,6 +215,15 @@ class CarMixin:
return
self._car_task = asyncio.ensure_future(self._car_run())
def _car_hold_kick(self) -> None:
"""EV-05: a cycle that holds for a missing or late reading returns
before `car_kick()`. Solar still steps (it holds, counts its dwell from
the first missing reading, and an exit still writes its 0 A); Manual is
left exactly as it was."""
if self.car_solar_engaged():
self.car_cut_w = 0.0
self.car_kick()
async def car_settle(self) -> None:
"""Wait for the writer step in flight (the checks use it)."""
t = self._car_task
@@ -172,14 +246,30 @@ class CarMixin:
else:
self._car_step_failed = False
def car_solar_engaged(self) -> bool:
"""EV-05: Solar is the mode, or its 0 A on the way out is still due."""
w = getattr(self, "car_solar", None)
return bool(self.charger.configured() and w is not None
and (self.car_mode == carmode.SOLAR or w.engaged))
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)."""
"""The add-on stops: no new write. Manual: a phase change in the middle
is undone by giving the car its current back, the current stands
otherwise. Solar (EV-05): 0 A, once, waited for at most
`RELEASE_WAIT_S` (`Controller.shutdown` calls this first in Solar)."""
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 self.car_solar_engaged():
try:
await asyncio.wait_for(self.car_solar.release(
self.charger, self.car.reading, self.car_now(), self.car),
RELEASE_WAIT_S)
except Exception: # noqa: BLE001
_LOG.warning("The car charger could not be set to 0 A before "
"the add-on stopped: CHARGER_RELEASE.")
return
if not self.charger.configured() \
or getattr(self, "car_writer", None) is None \
or self.car_writer.seq is None:
@@ -198,19 +288,144 @@ class CarMixin:
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)
if self.car_mode != carmode.SOLAR:
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)
w = self.car_solar
if self.car_mode == carmode.SOLAR or w.engaged:
await w.step(
self.charger, self.car.reading, mode=self.car_mode,
sun=(self.car_sun_inputs(now)
if self.car_mode == carmode.SOLAR else None),
clamp=self.car_clamp(), now=now, tracker=self.car,
writing=self.car_writing(), status=self.car.status(now, True),
clock=self.car_now)
# ------------------------------------------------------- EV-05: Solar
def car_may_charge(self, inv) -> bool:
"""May this battery take the sun? On (battery modes), not refusing a
charge, its level read and under full."""
if self.modes_on and not self.pack_mode(inv).use:
return False
if (inv.refused or 0) < 0 or inv.sign_wd.tripped:
return False
if len(self.inverters) == 1 and (self.batt_refused or 0) < 0:
return False
return inv.soc is not None and float(inv.soc) < packshare.FULL_PCT
def car_room_w(self) -> float:
"""Batteries first: the RATINGS of the batteries that may charge."""
return float(sum(inv.rating_w() for inv in self.inverters
if self.car_may_charge(inv)))
def car_spare_w(self, mono):
"""The signed spare sun now, or None when it cannot be measured: a
missing meter or battery figure, readings late past the stale bound,
or a charging car whose figure is stale, stuck or not corroborated. A
paused or idle car with a fresh reading counts as 0 W."""
if not self.inputs_ok:
return None
stale = float(self.o.get("stale_input_s", 15))
late = self._car_late_s
if late is not None and late >= stale:
return None
if self.p1_enabled:
# The meter's own bound (`meter_max_age_s`) may be longer than
# `stale_input_s`; a car write never comes from an older reading.
age = self.p1.age_s()
if age is None or age > stale:
return None
r = self.car.reading
if r is None or not r.available or not self.car.fresh(mono):
return None
if r.charging is True:
car = self.car.car_w_trusted(mono)
else:
car = 0.0
return carmode.spare_w(car, self.site_batt_w, self.grid)
def car_sun_inputs(self, mono) -> "carmode.SunInputs":
o = self.o
spare = self.car_spare_w(mono)
late = self._car_late_s
hold = late is not None and late < float(o.get("stale_input_s", 15))
room = self.car_room_w()
margin = carmode.solar_option(o, "ev_margin_w")
ph = str(o.get("ev_phases", chargers.EV_OPTION_DEFAULTS["ev_phases"]))
self._car_sun_last = carmode.SunInputs(
target_w=carmode.car_target_w(spare, room, margin,
self.car_first),
hold=hold, cut_w=self.car_cut_w,
car_w=self.car.car_w(mono), key=self._car_key,
auto=ph not in ("1", "3"), fixed_n=3 if ph == "3" else 1,
start_s=60.0 * carmode.solar_option(o, "ev_start_min"),
pause_s=60.0 * carmode.solar_option(o, "ev_pause_min"),
spare_w=spare, room_w=room, margin_w=margin,
first=self.car_first)
return self._car_sun_last
def _car_sun_tick(self, mono) -> None:
"""Solar kWh: per cycle, in Solar only, the car's power up to the sun
it may take (`spare - room` Batteries first, `spare` Car first). The
hold's battery or grid share and Manual do not count."""
if not self.car_solar_mode():
self._car_sun_mono = None
return
day = self.car.day
if day is not None and self.car_sun.get("day") != day:
self.car_sun = {"day": day, "kwh": 0.0}
self.store.set(CAR_SUN_KEY, dict(self.car_sun))
self._car_sun_saved = 0.0
last, self._car_sun_mono = self._car_sun_mono, mono
if last is None:
return
dt = min(max(mono - last, 0.0), 5.0)
p = self.car.car_w(mono)
spare = self.car_spare_w(mono)
if p is None or spare is None or dt <= 0.0:
return
sun = spare - (self.car_room_w() if self.car_first == carmode.FIRST_BATT
else 0.0)
share = min(float(p), max(0.0, sun))
if share <= 0.0:
return
self.car_sun["kwh"] += share * dt / 3.6e6
if round(self.car_sun["kwh"], 2) != self._car_sun_saved:
self._car_sun_saved = round(self.car_sun["kwh"], 2)
self.store.set(CAR_SUN_KEY, {"day": self.car_sun["day"],
"kwh": round(self.car_sun["kwh"], 4)})
def car_sun_kwh(self):
"""Today's kWh from the sun, never above today's kWh; None without a
reading of today."""
if self.car.today_kwh is None or self.car_sun.get("day") != self.car.day:
return None if self.car.today_kwh is None else 0.0
return max(0.0, min(float(self.car_sun["kwh"]),
float(self.car.today_kwh)))
async def check_car_error(self) -> None:
"""EV-05: in Solar a charger error sets the car to 0 A and raises one
warning notification; it is taken down when the error clears."""
bad = self.car_solar_mode() and self.car_solar.fault == "error"
if bad and not self._car_error_notified:
self._car_error_notified = True
await self.hass.call("persistent_notification", "create",
messages.charger_error().data())
elif not bad and self._car_error_notified:
self._car_error_notified = False
await self.hass.call("persistent_notification", "dismiss",
messages.charger_error_gone().data())
# ------------------------------------------- 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():
"""The car's power for the guard's alarm path: Manual and Solar, 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() or self.car_solar_mode()):
return None
return self.car.car_w_trusted(self.car_now())
@@ -220,6 +435,8 @@ class CarMixin:
until the current is set again, then at most one corroboration window.
No when it was aborted (Off, Stop, shadow, unplug, another writer), a
write was refused, or it ran past its own maximum."""
if self.car_solar_mode():
return self._car_solar_pause(mono)
wr = getattr(self, "car_writer", None)
if wr is None or (wr.seq is None and wr.phase_done_at is None
and wr.zero_sent_at is None) or wr.hold:
@@ -236,15 +453,91 @@ class CarMixin:
<= OWN_PAUSE_MAX_S
return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
def _car_idle(self, mono) -> bool:
"""EV-18: is the car known to draw nothing? A fresh reading that says
it is not charging (mode3 A or B) at under `CAR_PEAK_MIN_W`. Not an
unknown figure: the house's own need is graded in such a cycle."""
r = getattr(self.car, "reading", None)
if r is None or not r.available or r.charging is not False:
def car_solar_can_cut(self) -> bool:
"""EV-05 round 6: can Solar really cut the car now? Not while another
writer holds the charger, a write of ours was refused or given up, a
way-out 0 A is not taken, the charger shows a fault, or it cannot be
read, and not while Solar is not writing (Stop, shadow, a safety stop:
round 7), and not a car Solar is not running (round 8). Only then may
the car be graded out of the peak alarms. Round 9: all of that, and a
read-back current and phases that are Solar's own, is
`SolarWriter.in_control`, the one test."""
w = getattr(self, "car_solar", None)
r = self.car.reading
if not (w is not None and r is not None and r.available
and self.car_writing() # round 7: Stop, shadow, latch
and w.in_control):
return False
p = self.car.car_w(mono)
return p is not None and p < CAR_PEAK_MIN_W
# Round 8: Solar cuts only a car it runs (`plan.a > 0`). While paused
# at 0 A a car that draws is someone else's, unless it is Solar's own
# 0 A or phase change still inside EV-15's bound.
return bool(w.plan.a > 0.0 or w.seq is not None
or self._car_solar_pause(self.car_now()))
def _car_giving(self) -> list:
"""EV-05: the batteries the peak guard can draw on now: above their
own cut-out level, not refusing to give (SAFETY-73: `inv.refused` at
N>=2, `Controller.batt_refused` at N=1), not under a safety stop (the
unit's own, the site's, the circulation stop). A battery switched Off
in battery modes still counts: the guard's floor uses it (round 6)."""
n = len(self.inverters)
if self.circ_wd.tripped or (n > 1 and self.site_sign_wd.tripped):
return []
out = []
for inv in self.inverters:
soc, floor = inv.soc, inv.bms_soc_floor
refused = inv.refused if n > 1 else self.batt_refused
if soc is None or floor is None or inv.sign_wd.tripped \
or (refused or 0) > 0:
continue
if float(soc) > float(floor):
out.append(inv)
return out
def _car_batt_able(self) -> bool:
"""EV-05: can a battery still give power at all?"""
return bool(self._car_giving())
def _car_batt_headroom(self, guard) -> bool:
"""EV-05 rounds 4 and 5: can the batteries still RAISE their output?
The guard is neither saturated nor at the peak reserve, and the units
that can give (`_car_giving`) give more than `HEADROOM_W` under their
own ratings (and under `guard.able_w` when the guard names it). A unit
that refuses or is stopped counts neither in what is given nor in what
could be."""
giving = self._car_giving()
if not giving or guard is None or guard.saturated \
or guard.floor_limited:
return False
if any(inv.batt is None for inv in giving):
return False
batt = sum(float(inv.batt) for inv in giving)
top = sum(float(inv.rating_w()) for inv in giving)
if guard.able_w is not None:
top = min(top, float(guard.able_w))
return batt < top - HEADROOM_W
def _car_solar_pause(self, mono) -> bool:
"""EV-05: Solar's own 0 A (a pause, the peak cut, the phase change)
gets EV-15's grace, bounded the same way: from the moment it is sent,
at most `OWN_PAUSE_MAX_S`; a phase change as in Manual. None for Stop,
shadow, an unplugged car or another writer."""
wr = getattr(self, "car_solar", None)
r = self.car.reading
if wr is None or not wr.in_control or not self.car_writing() \
or r is None or not r.available or r.state == "A":
return False # round 9: only a charger Solar has
q = wr.seq
if q is not None:
return not q.get("failed") and 0.0 <= mono - q["t0"] \
<= OWN_PAUSE_MAX_S
if wr.zero_sent_at is not None:
return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S
if wr.zero_at is not None and 0.0 <= mono - wr.zero_at \
<= OWN_PAUSE_MAX_S:
return True
return wr.phase_done_at is not None \
and 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
def _car_quarter(self, proj, w, mono, wg=None) -> None:
"""The car's energy in the open quarter, for the average the guard's
@@ -255,20 +548,17 @@ class CarMixin:
key = None if proj is None else proj.block_start
last = q["mono"]
if key != q["key"]:
# EV-18: `whole` when the count covers the block: it follows on
# from the block before, or starts in its first seconds (not
# after a restart or a gap).
whole = key is not None and (
float(proj.elapsed_s) <= 5.0 or (
last is not None and q["key"] is not None
and (key - q["key"]).total_seconds() == QUARTER_S))
self._car_bank(q)
q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0
q["whole"] = whole
q["key"], q["ws"], q["ws_p"], q["ws_b"] = key, 0.0, 0.0, 0.0
if key is not None and last is not None:
dt = min(max(mono - last, 0.0), 5.0)
if w is not None:
q["ws"] += float(w) * dt
if not self.car_solar_mode() or not self.car_solar_can_cut():
# EV-05: a Solar charge runs on spare sun and is cut first,
# so it is not "set by the car"; one the add-on cannot cut
# (round 6: another writer, a refused write, a fault) is.
q["ws_b"] = q.get("ws_b", 0.0) + float(w) * dt
elif wg is not None:
q["ws_p"] = q.get("ws_p", 0.0) + float(wg) * dt
q["mono"] = mono
@@ -278,7 +568,7 @@ class CarMixin:
key = q["key"]
if key is None:
return
avg = q["ws"] / QUARTER_S
avg = q.get("ws_b", q["ws"]) / QUARTER_S
if avg < CAR_PEAK_MIN_W:
return
self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg)
@@ -336,13 +626,42 @@ class CarMixin:
"""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()
# EV-05: the period's own key, and the excess Solar takes off the car
# first (the writer step that follows this cycle acts on it at once).
self._car_key = None if real_proj is None else real_proj.block_start
self.car_cut_w = 0.0
# What the guard would ASK the batteries to give (`wanted_w`, its floor
# before the rating) is taken off the car instead, up to the excess:
# batteries that only stop charging are not asked for anything.
cut = 0.0
if self.car_solar_mode() and real_proj is not None \
and target_w is not None and real_proj.block_start is not None \
and guard is not None and guard.engaged and guard.blind is None:
ex = peakguard.excess_w(real_proj, target_w)
want = guard.wanted_w
if ex is not None and want is not None and math.isfinite(ex) \
and math.isfinite(want) and ex > 0.0 and want > 0.0:
cut = float(min(ex, want))
if cut > 0.0:
if self._car_want_since is None:
self._car_want_since = mono
left = QUARTER_S - float(real_proj.elapsed_s)
w9 = self.car_solar
if (not self._car_batt_headroom(guard) or left <= CUT_NEAR_END_S
or mono - self._car_want_since >= CUT_WAIT_S) \
and w9.own_rb and not w9.hold:
# Round 9: never for a car another writer runs (its current
# or phases): the plan keeps no cut it cannot write.
self.car_cut_w = cut
else:
self._car_want_since = None
self._car_sun_tick(mono)
w = self.car_alarm_w()
# EV-15: the figure for grading only. Our own phase change holds the
# car at 0 A and the energy meter cannot corroborate it then, so for
# that bounded time its fresh, not stuck figure stands in.
wg = w
own = (w is None or float(w) <= 0.0) and self._car_own_pause(mono)
if w is None and own:
if w is None and self._car_own_pause(mono):
wg = self.car.car_w_paused(mono)
self._car_quarter(real_proj, w, mono, wg)
self._car_session_tick(mono)
@@ -350,15 +669,14 @@ class CarMixin:
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.
# EV-18: a car known to draw nothing counts as 0 W for the latches
# (the house's own need); it and a 0 W figure explain nothing,
# but in our own pause (EV-15).
idle = wg is None and self._car_idle(mono)
graded = self._car_explains_alarm(real_proj, guard, target_w,
0.0 if idle else wg)
if idle or (w is not None and float(w) <= 0.0 and not own):
graded = False
if self.car_cover:
graded = self._car_explains_alarm(real_proj, guard, target_w, wg)
if self.car_solar_mode():
# EV-05: Solar is cut first, so it is never "over"; its own
# 0 A must not leave the house's alarm graded with the car.
# Round 6: only while it really can cut the car. Otherwise
# the normal alarms stand, as in Off.
explains = graded and self.car_solar_can_cut()
elif self.car_cover:
explains = over = graded
elif w is not None:
ex = float(real_proj.projected_w) - float(target_w)
@@ -387,41 +705,35 @@ class CarMixin:
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 (`_car_need_real`, and `_car_need_excl` without the car).
EV-18 (owner 2026-11-19): without the car, the batteries keep giving
what they give now (the lower of two readings), re-checked every cycle;
a miss seen so (`_car_need_house`) never lets the car explain for the
rest of the quarter. The car also explains where the period with it,
on the same batteries, misses (`_car_over_now`). Only a trusted figure
latches: an untrusted car (`w` None) or an unknown battery reading
explains nothing in that cycle only. All reset at a new quarter and
when the guard no longer wants power, whatever the cover option says
(this runs every cycle). DECISIONS/EV-04-manual-mode.md (EV-18)."""
now, prev = self.site_batt_w, self._car_batt_prev
self._car_batt_prev = now
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 or not wants:
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
self._car_need_house = self._car_over_now = False
batt = now
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_alarm(real_proj, w)
if wants and batt is not None:
self._car_need_real = self._car_need_real or \
peakguard.misses_aim(real_proj, batt_w=batt,
target_w=target_w)
self._car_over_now = self._car_over_now or \
self._car_lands_over(real_proj, now, batt, target_w)
if w is not None:
whole = self._carq.get("whole", True)
self._car_need_excl = self._car_need_excl or \
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)
self._car_need_house = self._car_need_house or \
self._car_lands_over(excl, now, batt, target_w, whole)
if w is None or batt is None or not wants \
or not (guard.saturated or guard.floor_limited):
return False
@@ -431,8 +743,7 @@ class CarMixin:
rating = guard.able_w
else:
return bool(not guard.within_aim and self._car_need_real
and not self._car_need_house
and (self._car_over_now or not self._car_need_excl))
and not self._car_need_excl)
def high(p):
return peakguard.load_too_high(
@@ -440,20 +751,6 @@ class CarMixin:
achievable_w=rating)
return bool(high(real_proj) and not high(excl))
@staticmethod
def _car_lands_over(p, now, gives, target_w, whole=True) -> bool:
"""EV-18: does the period end more than `ALARM_MISS_W` over the aim
with the batteries giving `gives` W from now on (`now`: what they gave
in the meter's figure)? Not `whole`: the car's share of what is done
is not known (a restart, a gap), so only the rest is graded."""
if whole:
return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w,
achievable_w=gives)
if QUARTER_S - float(p.elapsed_s) <= 0.0:
return False
rest = float(p.held_w) + float(now) - float(gives)
return rest - float(target_w) > peakguard.ALARM_MISS_W
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."""
+5 -1
View File
@@ -253,6 +253,7 @@ class CycleMixin:
stale_after = float(self.o.get("stale_input_s", 15))
late_s = self._readings_late(site_standing) # SAFETY-128
self._car_late_s = late_s # EV-05: Solar holds, then the stale rule
self._late_zero = late_s is not None and late_s >= stale_after
# ⚠️ `any`, NOT the sole unit's. The hold exists so a single missed
# poll does not become a fault; a LATCHED inverter must still reach the
@@ -272,6 +273,7 @@ class CycleMixin:
# this cycle's. (DECISIONS/MAIN-orchestration-archive.md)
self.why_words = messages.why_waiting(bad_for)
self._why_waiting_since = now - timedelta(seconds=bad_for)
self._car_hold_kick() # EV-05: Solar counts from now
return
if late_s is not None and late_s < stale_after and self.inputs_ok \
and (self.auto or self.shadow) \
@@ -279,6 +281,7 @@ class CycleMixin:
and not (n_units > 1 and self.site_sign_wd.tripped):
self.reason = f"readings late {late_s:.0f}s" # SAFETY-128: hold
self.why_words = messages.why_late()
self._car_hold_kick() # EV-05: Solar holds its current
return
claims = []
@@ -1065,7 +1068,8 @@ class CycleMixin:
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_car_error() # EV-05: Solar's charger error
self.car_kick() # EV-04/05: in the background
await self.check_fixed_note()
# SAFETY-31's alarm, and its boundary is the LATCH, not a number: it
+21 -2
View File
@@ -205,7 +205,20 @@ class StatusMixin:
"text": messages.row_charger_unreach(
f"{brussels(self.car.bad_since_utc):%H:%M}")})
w = self.car_writer
if self.car_mode == "manual":
sw = self.car_solar
if self.car_mode == "solar":
# EV-05: in Solar another writer stops the add-on's writes: amber,
# the same words as in Manual.
if sw.other:
out.append({"ok": False, "warn": True, "id": "charger_other",
"text": messages.row_charger_other()})
if sw.gave_up:
out.append({"ok": False, "warn": True, "id": "charger_refused",
"text": messages.row_charger_refused()})
if sw.phases_gave_up:
out.append({"ok": False, "warn": True, "id": "charger_phases",
"text": messages.row_charger_phases()})
elif 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.
@@ -218,6 +231,10 @@ class StatusMixin:
if w.phases_gave_up:
out.append({"ok": False, "warn": True, "id": "charger_phases",
"text": messages.row_charger_phases()})
elif self.car_mode != "manual" and sw.engaged and sw.gave_up:
# EV-05: Solar to Off whose 0 A the charger never took.
out.append({"ok": False, "warn": True, "id": "charger_refused",
"text": messages.row_charger_refused()})
elif self.car.other_writer(datetime.now(timezone.utc)):
out.append({"ok": True, "warn": True, "id": "charger_writer",
"text": messages.row_charger_writer()})
@@ -250,6 +267,8 @@ class StatusMixin:
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)),
"car_today_solar_kwh": (PAYLOAD_NONE if self.car_sun_kwh() is None
else round(self.car_sun_kwh(), 3)),
}
# -- UI ------------------------------------------------------------------
@@ -922,7 +941,7 @@ 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"):
if what in ("car_mode", "car_current", "car_phases", "car_sun_first"):
return self._car_action(what, value, now)
if what == "auto_toggle":
self.auto = not self.auto
+86 -7
View File
@@ -1147,7 +1147,8 @@ def month_peak(c, now):
# 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()
# EV-05: Manual only. A Solar charge is cut first for the peak.
w = c.car_alarm_w() if c.car_manual() else None
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"]),
@@ -1330,6 +1331,68 @@ def _car_manual_why(c, key):
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
def _names(invs) -> str:
names = [str(i.name) for i in invs]
return " " .join(names[:1]) if len(names) == 1 else \
", ".join(names[:-1]) + " " + _t("car.and") + " " + names[-1]
def _car_solar_why(c, key):
"""EV-05: the Why of Solar, from what the plan did this cycle. Plan
lines: two sentences of at most 12 words."""
w = c.car_solar
p = w.plan
o = getattr(c, "o", {}) or {}
if w.other:
return _t("car.why.solar_other")
if w.zero_owed:
# EV-05 round 3: the way-out 0 A is not taken yet; never "paused".
return _t("car.why.solar_zero_failed" if w.gave_up
else "car.why.solar_zeroing")
if c.shadow:
a, n = w.would if w.would is not None else (0.0, p.n)
if a and a >= 6:
return _t("car.why.manual_would", a=f"{float(a):.0f}",
phases=car_phases_word(n))
return _t("car.why.solar_would")
if not c.auto or not c.car_writing():
return _t("car.why.solar_stopped")
if w.fault in ("error", "stuck"):
return _t("car.why.solar_" + w.fault)
if key in ("none", "full"):
return _t("car.why." + key)
why = p.why
if why == "running":
sun = getattr(c, "_car_sun_last", None)
if sun is None or sun.spare_w is None:
return _t("car.why.solar_unknown")
if sun.first == carmode.FIRST_CAR:
return _t("car.why.solar_car",
kw=_kw(max(0.0, sun.spare_w - sun.margin_w)),
phases=car_phases_word(w.n_calc))
room = [i for i in c.inverters if c.car_may_charge(i)]
full = [i for i in c.inverters if not c.car_may_charge(i)
and i.soc is not None and float(i.soc) >= 100.0]
left = _kw(max(0.0, sun.spare_w - sun.room_w))
m = watts_text(sun.margin_w)
if room and full:
return _t("car.why.solar_batt", a=_names(room), b=_names(full),
kw=left, m=m)
if room:
return _t("car.why.solar_batt_room", a=_names(room), kw=left,
m=m)
return _t("car.why.solar_batt_full", kw=left, m=m)
mins = {"hold": "ev_pause_min"}.get(why, "ev_start_min")
s = f"{carmode.solar_option(o, mins):.0f}"
if why in ("hold", "start", "cut", "unknown"):
return _t("car.why.solar_" + why, s=s)
return _t("car.why.solar_paused", s=s)
def watts_text(w) -> str:
return f"{float(w):.0f} W"
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)."""
@@ -1342,12 +1405,22 @@ def car_block(c, now):
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"
if configured and c.car.today_kwh is not None:
sun = c.car_sun_kwh() if hasattr(c, "car_sun_kwh") else None
today = (_t("car.today_sun", kwh=_kwh(c.car.today_kwh),
sun=_kwh(sun))
if mode == "solar" and sun is not None
else _t("car.today", kwh=_kwh(c.car.today_kwh)))
why = _car_why(key, c, good)
if mode == "manual" and key in ("charging", "waiting", "none", "full"):
why = _car_manual_why(c, key)
if mode == "solar" and key in ("charging", "waiting", "none", "full",
"fault"):
why = _car_solar_why(c, key)
# EV-05: a car Solar holds at 0 A is waiting for the sun.
if key == "waiting" and c.car_solar.plan.a <= 0.0:
key = "paused"
out = {
"state": key or "wait",
"chip": car_state_word(key),
@@ -1360,11 +1433,13 @@ def car_block(c, now):
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).
# EV-04: what the page can set. EV-05 adds Solar and where its spare
# sun goes first (Night is a later card, so it is not offered).
clamp = c.car_clamp()
hi = int(clamp) if clamp is not None and clamp >= 6 else 6
out["modes"] = ["off", "manual"]
out["modes"] = list(carmode.MODES)
out["first"] = {"value": getattr(c, "car_first", carmode.DEFAULT_FIRST),
"choices": list(carmode.FIRSTS)}
out["current"] = {"value": round(float(c.car_a)), "min": 6,
"max": hi}
out["phases"] = {"value": c.car_n,
@@ -1883,8 +1958,12 @@ def _samples() -> list:
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)))
pct="20 %", phases=car_phases_word(3),
b="inverter-b", m="100 W", s="5"))
for k in words["car"]["why"]]
out += [("plan", _t("car.why.solar_batt", a="inverter-a",
b="inverter-b", kw="2.0 kW", m="100 W")),
("plan", _t("car.today_sun", kwh="14.2 kWh", sun="3.1 kWh"))]
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"))]
+8 -1
View File
@@ -1040,8 +1040,15 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
self.stopping = True
_LOG.info(handback.log_shutdown(handback.current())
or "shutting down - commanding 0 W on every inverter")
# EV-05: Solar's fail state is 0 A, and it goes out BEFORE the
# inverters go to 0 W (bounded by `ctl_car.RELEASE_WAIT_S`). Manual
# keeps EV-04's order: the inverters first, then undo a phase change.
solar = self.car_solar_engaged()
if solar:
await self.car_shutdown()
await self.command_site_release()
await self.car_shutdown() # EV-04: undo a phase change half way
if not solar:
await self.car_shutdown()
self.mqtt.close()
+27
View File
@@ -190,6 +190,8 @@ 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_CHARGER_ERROR = "Charger error, car paused"
T_CHARGER_ERROR_NL = "Laadpaalfout, auto gepauzeerd"
T_NO_PRICES = "No prices"
T_NO_PRICES_NL = "Prijzen ontbreken"
@@ -204,6 +206,7 @@ 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"
ID_CHARGER_ERROR = "goodwe_charger_error"
# 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"
@@ -510,6 +513,22 @@ def car_over(a_text) -> Notice:
body_nl=f"{T_CAR_OVER_NL}. {nl}")
def charger_error() -> Notice:
"""EV-05: in Solar the charger reports an error, so the add-on set the car
to 0 A. Said once per error, taken down when it clears."""
en = ("The charger reports an error, so the add-on paused the car until "
"it clears.")
nl = ("De laadpaal meldt een fout, dus de add-on pauzeert de auto tot die "
"verdwijnt.")
return Notice(ID_CHARGER_ERROR, WARNING, T_CHARGER_ERROR, en,
body_nl=f"{T_CHARGER_ERROR_NL}. {nl}")
def charger_error_gone() -> Dismiss:
"""EV-05: takes the 'Charger error, car paused' notification down."""
return Dismiss(ID_CHARGER_ERROR)
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 "
@@ -1484,6 +1503,7 @@ HINTS = {
"car_mode": "Car mode set",
"car_current": "Car current set",
"car_phases": "Car phases set",
"car_sun_first": "Where spare sun goes first 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",
@@ -1822,6 +1842,7 @@ def samples() -> list:
no_prices(),
charger_unreachable("09:12"),
car_over("16"),
charger_error(),
]
@@ -1891,6 +1912,9 @@ LABELS = {
"ev_batt_cover": "Batteries help with the peak",
"ev_mode_start": "Mode after a restart",
"ev_phases": "Phases",
"ev_margin_w": "Sun kept back",
"ev_pause_min": "Pause after",
"ev_start_min": "Start after",
}
@@ -1977,6 +2001,9 @@ LABELS_NL = {
"ev_batt_cover": "Batterijen helpen met de piek",
"ev_mode_start": "Modus na een herstart",
"ev_phases": "Fasen",
"ev_margin_w": "Zon achtergehouden",
"ev_pause_min": "Pauzeren na",
"ev_start_min": "Starten na",
}
# The inverter list shows two of them under a shorter name.
UNIT_LABELS_NL = {"setpoint_entity": "Setpoint-entiteit",
+18 -4
View File
@@ -144,6 +144,8 @@ OPTIONAL_SENSORS = [
("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"),
# EV-05: what of today's charge came from the sun (Solar mode only).
("car_today_solar_kwh", "goodwe_car_today_solar_kwh", "Car solar energy today", "kWh", "energy", "total_increasing", "mdi:solar-power"),
]
# ⚠️ HA's OWN "this sensor has no value" PAYLOAD, and the one place this add-on
@@ -200,7 +202,8 @@ def optional_keys(opts: dict) -> tuple:
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")
out += ("car_power", "car_state", "car_today_kwh",
"car_today_solar_kwh")
return out
@@ -524,18 +527,24 @@ def mode_payloads(units, modes) -> list:
# --- 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_MODE_LABELS = {"off": "Off", "manual": "Manual", # English, pinned
"solar": "Solar"} # EV-05
# EV-05: where spare sun goes first; mirrors carmode.FIRST_LABELS (this module
# imports nothing from the package, test_ev05.py checks the two agree).
CAR_FIRST_LABELS = {"batteries": "Batteries", "car": "Car"}
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_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases|sun_first)/set")
_CAR_CONFIG_RE = re.compile(
rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases)/config")
rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases|sun_first)"
rf"/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"),
("sun_first", "select", "Car spare sun first", "mdi:solar-power"), # EV-05
]
@@ -560,6 +569,8 @@ def car_payloads(car) -> list:
cfg["options"] = list(CAR_MODE_LABELS.values())
elif key == "phases":
cfg["options"] = [str(n) for n in phases]
elif key == "sun_first":
cfg["options"] = list(CAR_FIRST_LABELS.values())
else:
cfg.update({"min": CAR_MIN_A, "max": int(max_a), "step": 1,
"unit_of_measurement": "A", "device_class": "current",
@@ -607,6 +618,9 @@ def parse_car_command(topic, payload, retained):
None)
elif key == "phases":
value = {"1": 1, "3": 3}.get(text)
elif key == "sun_first":
value = next((k for k, v in CAR_FIRST_LABELS.items() if v == text),
None)
else:
try:
f = float(text)
+10 -2
View File
@@ -160,8 +160,9 @@
$("#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.
// EV-04: Off and Manual; EV-05: Solar and where its spare sun goes first.
// The mode, the phases and the choice 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;
@@ -182,6 +183,13 @@
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 sol = c.mode === "solar" && !!c.first;
$("#car-solar").hidden = !sol;
if (sol) {
$("#car-first").replaceChildren(...c.first.choices.map((f) => h("button", {
type: "button", role: "radio", "aria-checked": String(c.first.value === f),
onclick: () => carAct("car_sun_first", f) }, t("car.first_" + f))));
}
const on = c.mode === "manual" && !!c.current;
$("#car-manual").hidden = !on;
if (!on) return;
+5
View File
@@ -52,6 +52,11 @@
<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 id="car-solar" hidden>
<div class="small car-lab" data-t="car.first"></div>
<div class="seg" role="radiogroup" id="car-first" data-t-label="car.first"></div>
<p class="tiny muted" style="margin:6px 0 0" data-t="car.first_help.description"></p>
</div>
<div class="car-why small"><span class="muted" data-t="car.why"></span><span id="car-why"></span></div>
</div>
+21 -5
View File
@@ -91,7 +91,7 @@
"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"},
"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", "mode_solar": "Solar", "help_solar": {"description": "Charges only from spare sun and pauses when there is too little."}, "first": "Spare sun goes first to", "first_batteries": "Batteries", "first_car": "Car", "first_help": {"description": "Batteries: the car gets sun only when the batteries charge at full power or are full."}},
"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"},
@@ -302,11 +302,11 @@
"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."},
"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", "paused": "Waiting for sun"},
"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.", "paused": "Waiting for spare sun."},
"phase_one": "1 phase",
"phase_many": "{n} phases",
"today": "{kwh} charged today.",
"today": "{kwh} charged today.", "today_sun": "{kwh} charged today, {sun} from the sun.", "and": "and",
"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.",
@@ -329,7 +329,23 @@
"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."
"manual_blocked": "The phases change once per 10 minutes at most. This waits.",
"solar_batt": "Batteries first: {a} at full power, {b} is full. The car gets the {kw} left, less {m} kept back.",
"solar_batt_room": "Batteries first: {a} at full power. The car gets the {kw} left, less {m} kept back.",
"solar_batt_full": "Batteries first, and the batteries are full. The car gets the {kw} left, less {m} kept back.",
"solar_car": "Car first: the car takes {kw} on {phases}. The batteries get the rest of the sun.",
"solar_hold": "Too little spare sun, so the car holds 6 A for now. It pauses after {s} minutes like this.",
"solar_paused": "Too little spare sun for the car's minimum of 6 A. It starts after {s} minutes of enough sun.",
"solar_start": "There is enough spare sun now. The car starts after {s} minutes of it.",
"solar_cut": "The car was cut first to stay under the peak limit. It starts again after {s} minutes of enough sun.",
"solar_unknown": "The add-on cannot measure the spare sun now. The car pauses if this lasts.",
"solar_would": "Shadow mode: the add-on would keep the car paused.",
"solar_stopped": "Control is stopped, so the add-on paused the car.",
"solar_error": "The charger reports an error, so the add-on paused the car.",
"solar_stuck": "The charger reading may be stuck, so the add-on paused the car.",
"solar_other": "Something else changes the charger, so the add-on leaves it alone.",
"solar_zeroing": "The charger has not taken 0 A yet. The add-on tries again.",
"solar_zero_failed": "The charger did not take 0 A. Check it at the charger itself."
}
},
"peak": {
+21 -5
View File
@@ -88,7 +88,7 @@
"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"},
"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", "mode_solar": "Zon", "help_solar": {"description": "Laadt alleen met zonne-overschot en pauzeert als er te weinig is."}, "first": "Zonne-overschot gaat eerst naar", "first_batteries": "Batterijen", "first_car": "Auto", "first_help": {"description": "Batterijen: de auto krijgt pas zon als de batterijen op vol vermogen laden of vol zijn."}},
"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"},
@@ -256,11 +256,11 @@
"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."},
"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", "paused": "Wacht op zon"},
"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.", "paused": "Wacht op zonne-overschot."},
"phase_one": "1 fase",
"phase_many": "{n} fasen",
"today": "Vandaag {kwh} geladen.",
"today": "Vandaag {kwh} geladen.", "today_sun": "Vandaag {kwh} geladen, {sun} van de zon.", "and": "en",
"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.",
@@ -283,7 +283,23 @@
"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."
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.",
"solar_batt": "Eerst de batterijen: {a} op vol vermogen, {b} is vol. De auto krijgt de {kw} die overblijft, min {m} marge.",
"solar_batt_room": "Eerst de batterijen: {a} op vol vermogen. De auto krijgt de {kw} die overblijft, min {m} marge.",
"solar_batt_full": "Eerst de batterijen, en die zijn vol. De auto krijgt de {kw} die overblijft, min {m} marge.",
"solar_car": "Eerst de auto: die neemt {kw} op {phases}. De batterijen krijgen de rest van de zon.",
"solar_hold": "Te weinig zonne-overschot, dus de auto houdt nu 6 A. Na {s} minuten zo pauzeert ze.",
"solar_paused": "Te weinig zonne-overschot voor het minimum van de auto, 6 A. Ze start na {s} minuten genoeg zon.",
"solar_start": "Er is nu genoeg zonne-overschot. De auto start na {s} minuten daarvan.",
"solar_cut": "De auto werd eerst teruggeschroefd voor de piekgrens. Ze start weer na {s} minuten genoeg zon.",
"solar_unknown": "De add-on kan het zonne-overschot nu niet meten. De auto pauzeert als dit duurt.",
"solar_would": "Schaduwmodus: de add-on zou de auto gepauzeerd houden.",
"solar_stopped": "De regeling is gestopt, dus de add-on pauzeert de auto.",
"solar_error": "De laadpaal meldt een fout, dus de add-on pauzeert de auto.",
"solar_stuck": "De laadpaal meet mogelijk niet meer, dus de add-on pauzeert de auto.",
"solar_other": "Iets anders wijzigt de laadpaal, dus de add-on laat haar met rust.",
"solar_zeroing": "De laadpaal nam 0 A nog niet aan. De add-on probeert opnieuw.",
"solar_zero_failed": "De laadpaal nam 0 A niet aan. Controleer ze aan de laadpaal zelf."
}
},
"peak": {
+3
View File
@@ -234,6 +234,9 @@ GROUPS = (
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),
Field("ev_margin_w", SLIDER, "W", step=10, show=_CAR),
Field("ev_start_min", SLIDER, "min", show=_CAR),
Field("ev_pause_min", SLIDER, "min", show=_CAR),
)),
)),
Group("maintenance", (
+11
View File
@@ -688,6 +688,17 @@ def _charger_problems(opts: dict, writers: dict) -> list[str]:
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.")
# EV-05: Solar's sun kept back and its two dwells, each in its range.
for key, (lo, hi) in chargers.SOLAR_RANGES.items():
raw = opts.get(key, chargers.EV_OPTION_DEFAULTS[key])
try:
v = float(raw)
ok = not isinstance(raw, bool) and v == v and lo <= v <= hi
except (TypeError, ValueError):
ok = False
if not ok:
out.append(f"{S(key)} is {messages.shown(raw)}. Set it from {lo} "
f"to {hi}.")
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 "
+1 -1
View File
@@ -62,7 +62,7 @@ _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")
CAR_ACTIONS = ("car_mode", "car_current", "car_phases", "car_sun_first")
# MAINT-11: start or stop one battery's maintenance cycle (the unit is optional).
MAINT_ACTIONS = ("maint_start", "maint_abort")
+13 -5
View File
@@ -873,20 +873,25 @@ options:
shadow_mode: "auto"
# ==========================================================================
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar)
# ==========================================================================
# `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.
# mode (Off, Manual or Solar), the current, the phases and where spare sun
# goes first 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. Solar: `ev_margin_w` sun kept back, and the car
# starts after `ev_start_min` of enough sun and pauses after `ev_pause_min`.
ev_charger: "off"
ev_current_entity: ""
ev_max_a: 16
ev_phases: "auto"
ev_batt_cover: true
ev_mode_start: "keep"
ev_margin_w: 100
ev_start_min: 2
ev_pause_min: 5
# ==========================================================================
# ADVANCED - the control law and diagnostics
@@ -1266,7 +1271,7 @@ schema:
shadow_mode: list(auto|on|off)
# ==========================================================================
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar)
# ==========================================================================
# `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
@@ -1277,6 +1282,9 @@ schema:
ev_phases: list(1|3|auto)
ev_batt_cover: bool
ev_mode_start: list(keep|off)
ev_margin_w: int(0,1000)
ev_start_min: int(1,30)
ev_pause_min: int(1,30)
# ==========================================================================
# ADVANCED - the control law and diagnostics
+7 -5
View File
@@ -905,16 +905,18 @@ check("it stays for an hour and then goes",
# --------------------------------------------------------------------------- #
print("\n9. THE MQTT SENSORS")
# --------------------------------------------------------------------------- #
check("the three car sensors are announced only with a charger on",
check("the car sensors (EV-05: four, with today's solar kWh) are announced "
"only with a charger on",
mqtt.optional_keys(CAR) == ("pv", "car_power", "car_state",
"car_today_kwh")
"car_today_kwh", "car_today_solar_kwh")
and mqtt.optional_keys(BASE) == ("pv",))
pl = dict(mqtt.discovery_payloads(include=mqtt.optional_keys(CAR)))
names = sorted(k for k in pl if "_car_" in k)
check(f"discovery announces three sensors, goodwe_car_power, "
f"goodwe_car_state and goodwe_car_today_kwh ({names})",
check(f"discovery announces the sensors goodwe_car_power, goodwe_car_state, "
f"goodwe_car_today_kwh and (EV-05) goodwe_car_today_solar_kwh ({names})",
[pl[k]["object_id"] for k in names] == [
"goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh"]
"goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh",
"goodwe_car_today_solar_kwh"]
and all(k.startswith("homeassistant/sensor/") for k in names))
check("...and no command entity (no select, number or switch for the car)",
not [k for k in pl if "car" in k and not k.startswith(
+25 -23
View File
@@ -248,7 +248,7 @@ async def part2():
w = World()
out = {}
out["manual"] = await w.act("car_mode", "manual")
out["bad_mode"] = await w.act("car_mode", "solar") # not in this card
out["bad_mode"] = await w.act("car_mode", "bogus") # EV-05 accepts Solar
out["night"] = await w.act("car_mode", "night")
out["a12"] = await w.act("car_current", 12)
out["a5"] = await w.act("car_current", 5)
@@ -266,7 +266,7 @@ w2, o2 = run(part2())
check("Manual is chosen at once, no restart", o2["manual"] == {
"mode": "manual", "current": 6.0, "phases": 1} and w2.c.car_mode == "manual"
or w2.c.car_mode == "manual")
check("Solar and Night are not accepted (EV-05, EV-02)",
check("Night (EV-02) and an unknown mode are not accepted",
"error" in o2["bad_mode"] and "error" in o2["night"]
and w2.c.car_mode == "manual")
check("a current between 6 A and the clamp is accepted and stored",
@@ -307,7 +307,7 @@ check("ev_phases 1: 3 phases cannot be chosen, 1 can",
async def part2c():
out = {}
for start, stored in (("keep", "manual"), ("off", "manual"),
("keep", None), ("keep", "solar")):
("keep", None), ("keep", "night")):
st = _Store()
if stored:
st.data["car_mode"] = stored
@@ -322,7 +322,7 @@ check("ev_mode_start keep: a restart keeps Manual",
check("ev_mode_start off: a restart starts in Off and the store says so",
o2c[("off", "manual")] == ("off", "off"))
check("no stored mode, or one this build does not know, is Off",
o2c[("keep", None)][0] == "off" and o2c[("keep", "solar")][0] == "off")
o2c[("keep", None)][0] == "off" and o2c[("keep", "night")][0] == "off")
# =========================================================================== #
print("\n3. MANUAL WRITES THE CURRENT ONCE PER USER CHANGE")
@@ -1606,13 +1606,14 @@ pl = dict(mqtt.car_payloads((16, (1, 3))))
sel = pl["homeassistant/select/goodwe_ctl_car_mode/config"]
num = pl["homeassistant/number/goodwe_ctl_car_current/config"]
ph = pl["homeassistant/select/goodwe_ctl_car_phases/config"]
check("three entities: select.goodwe_car_mode, number.goodwe_car_current, "
"select.goodwe_car_phases", len(pl) == 3
check("four entities: select.goodwe_car_mode, number.goodwe_car_current, "
"select.goodwe_car_phases and (EV-05) select.goodwe_car_sun_first",
len(pl) == 4
and sel["object_id"] == "goodwe_car_mode"
and num["object_id"] == "goodwe_car_current"
and ph["object_id"] == "goodwe_car_phases")
check("the mode's labels are English and pinned: Off, Manual (Solar and Night "
"are not offered)", sel["options"] == ["Off", "Manual"])
check("the mode's labels are English and pinned: Off, Manual, Solar (EV-05; "
"Night is not offered)", sel["options"] == ["Off", "Manual", "Solar"])
check("the current is 6 A to the clamp, whole amps", num["min"] == 6
and num["max"] == 16 and num["step"] == 1
and num["unit_of_measurement"] == "A")
@@ -1629,7 +1630,7 @@ check("nothing is announced without a charger (and the default announcement "
"is as it was)", mqtt.car_payloads(None) == []
and mqtt.discovery_payloads() == mqtt.discovery_payloads(car=None))
check("the car entities come after every other row",
[t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-3:]
[t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-4:]
== [t for t, _ in mqtt.car_payloads((16, (1, 3)))])
cmd = mqtt.parse_car_command
check("a command parses: mode, current, phases",
@@ -1641,8 +1642,8 @@ check("a command parses: mode, current, phases",
== ("car_phases", 3, None))
check("a retained command is dropped",
cmd("goodwe_ctl/car/mode/set", b"Manual", True)[2] == "retained")
check("Solar, Night, junk and a long payload are refused",
cmd("goodwe_ctl/car/mode/set", b"Solar", False)[1] is None
check("Night, an unknown mode, junk and a long payload are refused",
cmd("goodwe_ctl/car/mode/set", b"Bogus", False)[1] is None
and cmd("goodwe_ctl/car/mode/set", b"Night", False)[1] is None
and cmd("goodwe_ctl/car/current/set", b"abc", False)[1] is None
and cmd("goodwe_ctl/car/phases/set", b"2", False)[1] is None
@@ -1660,7 +1661,7 @@ async def ha_story():
out = {"mode": w.c.car_mode, "a": w.c.car_a, "rb": w.sim.readback_a,
"pub": list(w.c.mqtt.values)[-1]}
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Off", True) # retained
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Solar", False)
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Night", False)
await w.c.mqtt_command("goodwe_ctl/car/current/set", b"99", False)
await w.c.mqtt_command("goodwe_ctl/car/phases/set", b"2", False)
await w.step(5)
@@ -1678,8 +1679,8 @@ check("HA commands go through handle_action(): Manual and 13 A are applied "
"and written, and the new state is published",
ha["mode"] == "manual" and ha["a"] == 13.0 and ha["rb"] == 13
and ha["pub"] == {"car_mode": "Manual", "car_current": 13,
"car_phases": "1"})
check("a retained command, Solar, 99 A and 2 phases change nothing",
"car_phases": "1", "car_sun_first": "Batteries"})
check("a retained command, Night, 99 A and 2 phases change nothing",
ha["after"] == ("manual", 13.0, 1))
check("the three states are in the published values",
ha["state"].get("car_mode") == "Manual"
@@ -1700,11 +1701,11 @@ st_ = _S()
car_, retract_ = _main.car_announcement(CAR, st_)
check("with a charger the entities are announced and their topics kept",
car_ == (16.0, (1, 3)) and not retract_ and len(
st_.data["mqtt_car_configs"]) == 3)
st_.data["mqtt_car_configs"]) == 4)
car2, retract2 = _main.car_announcement(BASE, st_)
check("turning the charger off removes exactly those entities",
car2 is None and sorted(retract2) == sorted(st_.data["mqtt_car_configs"])
and len(retract2) == 3)
and len(retract2) == 4)
st2 = _S()
check("a site that never had a charger publishes nothing and its store is "
"not written",
@@ -1734,7 +1735,7 @@ async def web_story():
("manual", {"action": "car_mode", "value": "manual"}),
("a", {"action": "car_current", "value": 12}),
("n", {"action": "car_phases", "value": 3}),
("solar", {"action": "car_mode", "value": "solar"}),
("solar", {"action": "car_mode", "value": "night"}),
("big", {"action": "car_current", "value": 40})):
async with s.post(root + "action", json=body) as r:
out[key] = (r.status, await r.json(content_type=None))
@@ -1753,21 +1754,22 @@ check("POST /action car_mode, car_current and car_phases store and answer",
web["manual"] == (200, {"ok": True, "result": {
"mode": "manual", "current": 6.0, "phases": 1}})
and web["a"][0] == 200 and web["n"][0] == 200)
check("...Solar and 40 A (above the clamp) are a 400 with a plain reason",
check("...Night and 40 A (above the clamp) are a 400 with a plain reason",
web["solar"][0] == 400 and web["solar"][1]["ok"] is False
and web["solar"][1]["error"] == messages.car_refused("value")
and web["big"][0] == 400)
car_s = web["status_en"]["car"]
check("/status gives the page what it needs: the mode, the modes offered (Off "
"and Manual only), the current's range, the phases",
car_s["mode"] == "manual" and car_s["modes"] == ["off", "manual"]
check("/status gives the page what it needs: the mode, the modes offered (Off, "
"Manual and, EV-05, Solar), the current's range, the phases",
car_s["mode"] == "manual"
and car_s["modes"] == ["off", "manual", "solar"]
and car_s["current"] == {"value": 12, "min": 6, "max": 16}
and car_s["phases"] == {"value": 3, "choices": [1, 3]})
check("/status in Dutch has the Dutch Why",
web["status_nl"]["car"]["why"].startswith("U stelde 12 A in"))
check("the page has the controls and no Solar or Night button",
check("the page has the controls and no Night button (EV-05 adds Solar)",
'id="car-manual"' in web["page"] and 'id="car-a"' in web["page"]
and "mode_solar" not in web["page"] and "mode_night" not in web["page"])
and "mode_night" not in web["page"])
check("the page names the Manual strings in both languages",
"Handmatig" in web["page"] and "Manual" in web["page"])
File diff suppressed because it is too large Load Diff
+474
View File
@@ -0,0 +1,474 @@
"""EV-05: the car's Solar mode, the long runs. `python3 -B test_ev05_long.py`
Split from test_ev05.py so CI's parallel batch stays short: the shadow-mode
twin (T39), the acceptance day (T44), the fuzz (T45), and the hour-long
"nothing else changes" comparisons (T50, T51). Same harness,
`tools/ev05_sun.py`; the rows are named by their test-plan id.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import logging
import math
import os
import random
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
import ev05_sun as S # noqa: E402
from chargersim import SimCharger # noqa: E402
logging.disable(logging.CRITICAL)
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
def const(w):
return lambda t: float(w)
def steps(*pairs):
def f(t):
v = pairs[0][1]
for at, w in pairs:
if t >= at:
v = w
return float(v)
return f
def cur(r):
return S.writes(r, "current")
def ph(r):
return S.writes(r, "phases")
FULL = {"a": 100.0, "b": 100.0}
ABLE = {"a": 60.0, "b": 60.0}
def quarters(r, aim):
"""(start, import average, car average) of each whole quarter."""
out = []
tr = r["trace"]
for q0 in range(0, int(tr[-1]["t"]) + 1 - 900, 900):
xs = [x for x in tr if q0 <= x["t"] < q0 + 900]
if len(xs) < 890:
continue
g = sum(max(0.0, x["grid"]) for x in xs) / len(xs)
car = sum(x["car"] for x in xs) / len(xs)
out.append((q0, g, car))
return out
def seq_ok(r):
"""Every select: a 0 A write before it, the car under 100 W or out of C or
20 s after the 0 A, then 10 s or more to the next current; no other write
in between."""
log = r["sim"].log
state = {x["t"]: x["st"] for x in r["trace"]}
bad = []
for i, x in enumerate(log):
if x[1] != "phases":
continue
prev = log[i - 1] if i else None
nxt = log[i + 1] if i + 1 < len(log) else None
if prev is None or prev[1] != "current" or prev[2] != 0.0:
bad.append(("no 0 A before", x))
continue
quiet = (x[3] < 100.0 or state.get(x[0] - 1) != "C"
or x[0] - prev[0] >= 20.0)
if not quiet or x[4] != 0.0:
bad.append(("select under load", x))
if nxt is not None and (nxt[1] != "current" or nxt[0] - x[0] < 10.0):
bad.append(("current too soon or not next", x, nxt))
return bad
def inv_sets(r):
return [x for x in r["plant"].sets if x[1].startswith("number.sp_")]
# =========================================================================== #
print("\nT39. SHADOW MODE: NOTHING WRITTEN, THE CARD SAYS WHAT IT WOULD SET (N10)")
# =========================================================================== #
def cloudy(t):
k = int(t) // 240
return 900.0 + (2600.0 if k % 3 else 400.0) + 300.0 * (k % 5)
twin = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
opts={"ev_phases": "1"}, dur=3600)
for name, kw in (("on", dict(opts={"ev_phases": "1", "shadow_mode": "on"})),
("auto, control stopped",
dict(opts={"ev_phases": "1", "shadow_mode": "auto"},
events={0: lambda p, c: setattr(c, "auto", False)}))):
sh = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
dur=3600, **kw)
diff = [(a["t"], a["a"], (b["would"] or (None,))[0])
for a, b in zip(twin["trace"], sh["trace"])
if b["would"] is not None and a["a"] != b["would"][0]]
check(f"T39 shadow {name}: the charger log is empty for a cloudy hour, and "
f"every second the card's 'would set' is the current of a twin run "
f"without shadow mode ({len(diff)} seconds differ: {diff[:3]})",
sh["sim"].log == [] and not diff
and len({a['a'] for a in twin['trace']}) >= 3)
# =========================================================================== #
print("\nT50, T51. NOTHING ELSE CHANGES FOR THE GUARD AND THE ZERO-GRID LOOP")
# =========================================================================== #
h50 = steps((0, 400.0), (600, 2600.0), (900, 800.0), (1800, 4200.0),
(2100, 300.0), (3000, 1500.0))
r50 = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600)
r50o = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600,
opts={"ev_charger": "off"})
check(f"T50: Solar with no car for an hour: the guard's floor and every battery "
f"command are identical to the run with no charger "
f"({len(inv_sets(r50))} commands)", inv_sets(r50) == inv_sets(r50o)
and [x["floor"] for x in r50["trace"]]
== [x["floor"] for x in r50o["trace"]] and cur(r50) == [])
sun51 = steps((0, 3000.0), (700, 5200.0), (1500, 2500.0))
r51 = S.drive(house=const(400.0), sun=sun51, first="car", socs=ABLE,
dur=2000)
carp = {int(x["t"]): x["car"] for x in r51["trace"]}
r51o = S.drive(house=lambda t: 400.0 + carp.get(math.ceil(t), 0.0),
sun=sun51, socs=ABLE, dur=2000, opts={"ev_charger": "off"})
check(f"T51: Car first, the zero-grid loop: the same meter series with the car "
f"as a Solar car and as house load gives the same battery commands "
f"({len(inv_sets(r51))} commands)", inv_sets(r51) == inv_sets(r51o)
and max(carp.values()) > 3000)
check("T51: the batteries charge with what the car leaves (Car first)",
-300 <= r51["plant"].batt(1999) <= 0)
# =========================================================================== #
print("\nT44. THE ACCEPTANCE DAY: 08:00-18:00, CLOUDS, HOUSE STEPS (A2)")
# =========================================================================== #
_rnd44 = random.Random(44)
CLOUDS44 = []
for _i in range(12):
a = _rnd44.randint(600, 34000)
CLOUDS44.append((a, a + _rnd44.randint(60, 480)))
STEPS44 = [(8000, 8300), (17000, 17300), (26000, 26300)]
def sun44(t):
base = max(0.0, 7500.0 * math.sin(math.pi * t / 36000.0))
return base * (0.15 if any(a <= t < b for a, b in CLOUDS44) else 1.0)
def house44(t):
w = 1450.0 + 1050.0 * math.sin(t / 1700.0)
return w + (3000.0 if any(a <= t < b for a, b in STEPS44) else 0.0)
long44 = sum(1 for a, b in CLOUDS44 if b - a > 300)
for first, race in (("batteries", False), ("car", True)):
# The batteries' levels move with their charge (A 15.36 kWh, B 20.48 kWh),
# so with Batteries first the car gets sun once they are full.
r44 = S.drive(house=house44, sun=sun44, first=first, socs={"a": 40.0,
"b": 60.0},
caps={"a": 15.36, "b": 20.48}, dur=36000, race=race,
opts={"slew_w": 0})
# `slew_w` 0 is the shipped default. With the harness's usual 400 W a
# cycle (the SAFETY-81 rig) this day also has no cut pause (dev report,
# round 2).
# On the harness clock, as the trace (the model's own clock runs ahead).
w44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "current"]
p44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "phases"]
# A phase change's own 0 A (a select follows within 25 s) is not a pause.
seq0 = {t for t, v in w44 if v == 0.0 and any(0 < pt - t <= 25
for pt, _n in p44)}
starts, pauses, paused, pause_t = 0, 0, True, []
for t, v in w44:
if v == 0.0 and t not in seq0:
paused = True
pauses += 1
pause_t.append(t)
elif v > 0 and paused:
starts += 1
paused = False
why_at = {x["t"]: x["why"] for x in r44["trace"]}
cut_t = [t for t in pause_t if why_at.get(t) == "cut"
or why_at.get(t - 1) == "cut"]
# Car first: no hold pause from a cloud under 300 s. Batteries first: a
# battery that gave power in the cloud is under 100 % again, so its
# rating is room and the car waits for it (the brief's room rule).
short_hit = [t for t in pause_t if t not in cut_t and first == "car"
and any(a <= t <= b + 2 for a, b in CLOUDS44 if b - a <= 300)]
print(f" pauses (second, why): {[(t, why_at.get(t)) for t in pause_t]}")
# N5 on the whole day: a start 120 s or more after its pause, a hold
# pause after 300 s of holding, non-zero writes 30 s apart.
nz = [t for t, v in w44 if v > 0]
n5 = [("30 s", b) for a, b in zip(nz, nz[1:]) if b - a < 30]
last_p = None
for t, v in w44:
if v == 0.0 and t not in seq0:
last_p = t
elif v > 0 and last_p is not None:
if t - last_p < 120:
n5.append(("start", t))
last_p = None
for t in pause_t:
if why_at.get(t) == "paused":
run = 0
while why_at.get(t - 1 - run) == "hold":
run += 1
if run < 298:
n5.append(("pause", t, run))
# The loop turns at most `slew_w` per cycle, so for some 15 s after each
# current step, cloud edge and house step the grid covers the change:
# counted apart (dev report). The rest is the car on grid power while
# the loop is settled, outside the holds.
edges = [t for t, v in w44] + [e for ab in CLOUDS44 + STEPS44 for e in ab]
edges.sort()
def settling(t):
return any(0 <= t - e < 15 for e in edges)
grid_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
if x["why"] not in ("hold",) and not settling(x["t"])) / 3600.0
slew_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
if settling(x["t"])) / 3600.0
steps44 = edges
over44 = [(q, round(g)) for q, g, car in quarters(r44, 3400.0)
if g > 3410.0 and g - car <= 3410.0]
gaps = [b[0] - a[0] for a, b in zip(p44, p44[1:])]
check(f"T44 {first} first ({'race' if race else 'step'}): starts {starts} "
f"(<= 1 + {long44} long clouds, Car first); peak-cut pauses "
f"{len(cut_t)} (round 2: none, the batteries catch the cloud edges)"
f"; pauses {pauses}; N5 dwells {n5[:3]}; selects {len(p44)} "
f"(gaps >= 600 s: {gaps[:4]}); no pause from a short cloud "
f"{short_hit[:3]}; the car's grid energy outside holds {grid_wh:.1f} "
f"Wh (and {slew_wh:.1f} Wh in the loop's 15 s after "
f"{len(steps44)} steps and edges); quarters over the aim by the car "
f"{over44}",
starts >= 1 and not n5 and all(g >= 600 for g in gaps)
and not cut_t and (first != "car" or starts <= 1 + long44)
and not seq_ok(r44) and not short_hit and grid_wh <= 10.0
and not over44)
# =========================================================================== #
print("\nT45. THE FUZZ: 14 SITES, 16800 STEPS (N1-N10)")
# The plan asks 14 x 400 steps; a busy site rarely has the 60 s calm a start
# needs, so each site runs 1200 steps to make enough writes to judge.
# =========================================================================== #
def fuzz(seed):
rnd = random.Random(seed)
stations = [10.0, 13.0, 16.0]
st = {"sun": rnd.uniform(0, 9000), "house": rnd.uniform(200, 3000),
"n": {}, "acts": [], "undo": [], "exits": []}
def exit_check(p, c, kind="off"):
"""N9: a way out of Solar (Off, Stop, shadow) with the charger above
0 A, reachable and not held by another writer. Round 3: also while
the charger refuses writes (judged after the refusal ends)."""
ch = p.ch
if c.car_mode == "solar" and c.car_writing() and not c.car_solar.hold \
and not ch.unavailable and ch.readback_a > 0.5 \
and not p.ha_down:
st["exits"].append((p.t, kind, ch.refuse))
def at(t, fn):
st["undo"].append((t, fn))
def later(p, fn):
st["undo"].append((p.t + rnd.randint(10, 40), fn))
def ev(p, c):
for due in [u for u in st["undo"] if u[0] <= p.t]:
st["undo"].remove(due)
due[1]()
if st.get("back") is not None and p.t >= st["back"]:
st["back"] = None # the user goes back to Solar
st["acts"].append(p.t)
return c.handle_action("car_mode", value="solar")
if st.get("press") is not None and p.t >= st["press"]:
st["press"] = None # the user presses the mode
st["acts"].append(p.t)
return c.handle_action("car_mode", value=c.car_mode)
r = rnd.random()
ch = p.ch
if r < 0.012:
st["sun"] = rnd.choice([0.0, 1000.0, 2500.0, 5000.0, 8000.0,
8000.0, 6500.0])
elif r < 0.02:
st["house"] = rnd.uniform(200, 4000)
elif r < 0.08:
st["sun"] = max(0.0, st["sun"] + rnd.uniform(-600, 600))
elif r < 0.082:
if ch.state != "A":
ch.unplug()
later(p, ch.plug_in)
st["n"]["plug"] = st["n"].get("plug", 0) + 1
elif r < 0.084:
ch.go_unavailable(True)
later(p, lambda: ch.go_unavailable(False))
st["n"]["down"] = st["n"].get("down", 0) + 1
elif r < 0.087:
ch.set_current(rnd.randint(0, 16))
st["n"]["other"] = st["n"].get("other", 0) + 1
st["press"] = p.t + rnd.randint(20, 90)
elif r < 0.089:
ch.refuse = rnd.choice(["ignore", "error"])
later(p, lambda: setattr(ch, "refuse", None))
elif r < 0.091:
p.meter_on = False
later(p, lambda: setattr(p, "meter_on", True))
st["n"]["meter"] = st["n"].get("meter", 0) + 1
elif r < 0.093:
exit_check(p, c, "out")
c.o["shadow_mode"] = "on"
later(p, lambda: c.o.__setitem__("shadow_mode", "off"))
st["n"]["shadow"] = st["n"].get("shadow", 0) + 1
elif r < 0.095:
exit_check(p, c, "out")
c.auto = False
later(p, lambda: setattr(c, "auto", True))
st["n"]["stop"] = st["n"].get("stop", 0) + 1
elif r < 0.098:
m = rnd.choice(["solar", "solar", "solar", "off", "manual"])
st["n"]["mode"] = st["n"].get("mode", 0) + 1
st["acts"].append(p.t)
if m == "off":
exit_check(p, c)
return c.handle_action("car_mode", value=m)
elif r < 0.1:
ch.station_a = rnd.choice(stations)
elif r < 0.1015 and c.car_mode == "solar" and c.car_writing() \
and p.ch.readback_a > 0.5 and st.get("back") is None \
and not p.ch.unavailable and p.ch.refuse is None:
# Round 3: the charger refuses for 5 s, and a way out comes now
# and stands 100-150 s.
kind = rnd.choice(["off", "stop", "shadow"])
p.ch.refuse = rnd.choice(["error", "ignore"])
at(p.t + 5, lambda: setattr(p.ch, "refuse", None))
exit_check(p, c, "off" if kind == "off" else "out")
stay = rnd.randint(100, 150)
st["n"]["refused_exit_made"] = \
st["n"].get("refused_exit_made", 0) + 1
if kind == "stop":
c.auto = False
at(p.t + stay, lambda: setattr(c, "auto", True))
elif kind == "shadow":
c.o["shadow_mode"] = "on"
at(p.t + stay, lambda: c.o.__setitem__("shadow_mode", "off"))
else:
st["acts"].append(p.t)
st["back"] = p.t + stay
return c.handle_action("car_mode", value="off")
elif r < 0.103 and c.car_mode == "solar" and p.ch.readback_a > 0.5 \
and st.get("back") is None:
exit_check(p, c) # leave Solar while it charges
st["acts"].append(p.t)
st["back"] = p.t + rnd.randint(30, 120)
return c.handle_action("car_mode", value="off")
elif r < 0.2 and c.car_solar.seq is not None:
st["n"]["mid"] = st["n"].get("mid", 0) + 1
exit_check(p, c)
return c.handle_action("car_mode", value="off")
ctx = []
def note(p, c, t):
ctx.append((t, c.car_mode, c.car_writing(), c.car_solar.single,
p.ch.refuse, p.ch.unavailable, p.ch.setpoint_a,
c.car_solar.hold, p.ch.station_a))
r = S.drive(house=lambda t: st["house"], sun=lambda t: st["sun"],
first="car", opts={"ev_margin_w": 0, "ev_start_min": 1,
"ev_pause_min": 1}, socs=FULL, dur=1200,
events={t: ev for t in range(1, 1200)}, on_cycle=note,
race=seed % 2 == 1, sim=SimCharger(setpoint_a=rnd.choice(
[0, 10, 16])))
bad = []
by_t = {x[0]: x for x in ctx}
log = r["plant"].wlog # on the harness clock
last_sel, last_nz = None, None
for t, what, v, power, sp in log:
# A write logged at second t comes after that second's actions.
x = by_t.get(t) or by_t.get(t - 1)
mode = x[1] if x else "?"
if what == "current" and v > min(16.0, x[8] if x else 16.0) + 1e-9:
bad.append(("N1 over the clamp", t, v))
if what == "phases":
if sp != 0.0:
bad.append(("N2 select with the setpoint up", t))
if last_sel is not None and t - last_sel < 600:
bad.append(("N2 two selects in 600 s", t))
last_sel = t
if what == "current" and mode == "off" and v > 0:
bad.append(("N10 a non-zero write in Off", t, v))
if what == "current" and x is not None and not x[2] and v > 0 \
and mode == "solar":
bad.append(("N10 a non-zero Solar write while not writing", t, v))
if what == "current" and v > 0 and mode == "solar":
near_act = any(abs(t - a) <= 3 for a in st["acts"])
if last_nz is not None and t - last_nz < 30 and not near_act:
bad.append(("N5 two non-zero writes under 30 s", t, v))
last_nz = t
for te, kind, ref in st["exits"]:
if ref is None:
if not any(x[1] == "current" and x[2] == 0.0
and te <= x[0] <= te + 3 for x in log):
bad.append(("N9 a way out left the current up", te, kind))
continue
# Round 3: the charger refused when the way out came. Judged when the
# refusal ended within 60 s and the way out still stands 80 s on (the
# 0 A is tried again 60 s after the first try, +10 s read-back).
span = [x for x in ctx if te <= x[0] <= te + 80]
ends = next((x[0] for x in span if x[4] is None), None)
still = len(span) >= 80 and all(
(x[1] == "off" if kind == "off" else
(x[1] == "solar" and not x[2])) and not x[5] and not x[7]
for x in span)
if ends is None or ends > te + 60 or not still:
continue
st["n"]["refused_exits"] = st["n"].get("refused_exits", 0) + 1
if not any(x[6] <= 0.5 for x in span): # reached 0 A in it
bad.append(("N9 a refused way-out 0 A was not tried again", te,
kind))
if r["c"].charger.clamp_faults:
bad.append(("N1 clamp fault", r["c"].charger.clamp_faults))
st["n"]["exits"] = len(st["exits"])
return bad, len(log), st["n"]
fz_bad, fz_n, fz_counts = [], 0, {}
for _seed in range(14):
_b, _n, _c = fuzz(_seed)
fz_bad += _b
fz_n += _n
for k, v in _c.items():
fz_counts[k] = fz_counts.get(k, 0) + v
check(f"T45: {fz_n} charger writes over 14 random Solar sites and 16800 steps "
f"(outages, unplugs, refusals, other writers, a silent meter, shadow and "
f"Stop, mode changes, half racing): none over the clamp, no select with "
f"the setpoint up or two in 600 s, every Solar to Off at 0 A (N9), no "
f"non-zero write in Off, in shadow "
f"or stopped, none under 30 s apart ({fz_bad[:3]})",
not fz_bad and fz_n > 100)
check(f"T45: each disturbance happened, and exits while the charger refused "
f"were judged ({fz_counts})",
all(fz_counts.get(k, 0) > 2 for k in ("plug", "down", "other", "meter",
"shadow", "stop", "mode",
"exits"))
and fz_counts.get("refused_exits", 0) >= 1)
print()
if fails:
print(f"{len(fails)} FAILED")
for f in fails:
print(" -", f)
sys.exit(1)
print("all passed")
-681
View File
@@ -1,681 +0,0 @@
"""EV-18: no floor alarm at a quarter's start while the car explains the excess
(EV-15 rig F-A). `python3 -B test_ev18.py`
The rig: both batteries at the peak reserve, the car charging, and
PEAK_GUARD_FLOOR_LIMITED + `goodwe_peak_soc_floor` at a quarter's start, red
for most of the quarter, while the grid excess was smaller than the car. Two
causes, both latched for the quarter by `_car_need_excl`:
C1 one cycle with no trusted car figure set the latch (T1);
C2 "without the car" assumed the batteries give 0 W from now on, so what
the loop still gives below the reserve counted as house (T2).
The rule now (owner 2026-11-19, Q1-Q3): without the car the batteries keep
giving what they give now (the lower of the last two readings, re-checked
every cycle); a house need seen with a trusted car figure stays latched to the
quarter's end; an unknown car figure keeps the alarm only while it is unknown.
T-ids are the test plan's (reports/EV-18-test-plan.md). "base" is 9fdce02.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
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 chargers as CH, ctl_car, tariff # noqa: E402
from chargersim import SimCharger # noqa: E402
from named_absence import first, nth, present # noqa: E402
import ev04_peak as P # noqa: E402
import ev18_peak as H # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
AIM = H.AIM
CAR = 1380.0
E = H.E
# Measured on base 9fdce02 with this file's own runs: the seconds of
# goodwe_peak_soc_floor in the honest shapes, which must not come later now. An
# honest shape steps the house at E, and the meter shows it at E+1.
T5_BASE = [E + 1] # also T6 (T5 shape), T8, T9(a), T10(b) T5
T7_BASE = E + 72
T9B_BASE = [] # 400 W real: never uncorroborated (Findings)
T9C_BASE = E + 1 # 100 W real: never trusted at the edge
T10A_T5_BASE = [E + 2] # the guard disengages at E+1 (no battery reading)
T11_BASE = [E + 13] # SAFETY-87: ALARM_HOLD_S after the step
T13_BASE = [E + 301]
T15_T5_BASE = [E + 10] # x10: one cycle
# =========================================================================== #
print("1. UNIT: car_cycle ACROSS A QUARTER EDGE (a real `_carq`, not preset)")
# =========================================================================== #
BS = datetime(2026, 11, 17, 21, 15, tzinfo=timezone.utc) # the edge E
class _Car(ctl_car.CarMixin):
def __init__(self):
self.o = {"ev_batt_cover": True}
self.w = CAR
self._now = 0.0
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
self.car_init({}, self.store)
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"
class _G:
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
def __init__(self, wants=True, within_aim=False):
self.floor_limited, self.saturated = True, False
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, AIM + 50.0
self.engaged, self.blind = True, None
self.wanted_w = 300.0 if wants else 0.0
self.within_aim = within_aim
def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None):
"""`car_cycle` once per entry of `secs` (seconds from the edge E, `x` fake
seconds apart). `grid(t)` is the meter (house + car - batteries),
`batt(t)` the site battery reading, `w(t)` the trusted car figure. Returns
(car, {t: car_explains})."""
c = c or _Car()
mono_x = x if mono_x is None else mono_x
done, out = {}, {}
for t in secs:
q = t // 900
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
g = float(grid(t))
d = done.get(bs, g * el)
p = tariff.Projection(
projected_w=(d + g * (900 - el)) / 900.0,
elapsed_w=(d / el if el else g), elapsed_s=float(el),
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
done[bs] = d + g * x
c._now = 10000.0 + t * mono_x / x
c.w, c.site_batt_w = w(t), batt(t)
c.car_cycle(p, guard(t) if guard else _G(), AIM, None)
out[t] = c.car_explains
return c, out
def const(v):
return lambda t: v
def run_of(d, t0, t1):
return [d[t] for t in sorted(d) if t0 <= t <= t1]
# --- T1: the car figure untrusted for the edge's first cycles --------------- #
def t1(x=1, mono_x=None):
_c, ex = urun(range(-30, 121, x), const(13000.0 + CAR), const(0.0),
lambda t: None if 0 <= t <= 2 * x else CAR, x=x,
mono_x=mono_x)
return ex
ex = t1()
print(f" T1 explains E-1..E+5: {run_of(ex, -1, 5)}")
check("T1 PRECONDITION: before the edge the car (trusted) explains the "
"excess (house 13 000 W, car 1 380 W, grid 14 380 W)",
all(run_of(ex, -30, -1)) and len(run_of(ex, -30, -1)) == 30)
check("T1 (Expected 5): while the car figure is unknown (E+0..E+2) it "
"explains nothing, so the alarm stands", not any(run_of(ex, 0, 2)))
_c1b, ex1b = urun(range(-30, 121), const(12500.0 + CAR - 800.0), const(800.0),
lambda t: None if 0 <= t <= 2 else CAR)
check("T1b (the EV-10 path: the grid lands under the aim, the batteries at "
"0 W would miss; house 12 500 W, b 800 W): unknown E+0..E+2, released "
"at E+3 and explained to E+120",
not any(run_of(ex1b, 0, 2)) and all(run_of(ex1b, 3, 120))
and len(run_of(ex1b, 3, 120)) == 118)
check("T1 (Expected 3): released at the first trusted cycle (E+3) and "
"explained to E+120 (base: latched False to E+120)",
all(run_of(ex, 3, 120)) and len(run_of(ex, 3, 120)) == 118)
# --- T2c: the battery W boundary, graded on the lower of two readings ------- #
def t2c(b_of):
_c, ex = urun(range(0, 6), lambda t: 14000.0 + CAR - b_of(t), b_of,
const(CAR))
return run_of(ex, 0, 5)
e391, e389 = t2c(const(391.0)), t2c(const(389.0))
e395 = t2c(lambda t: 395.0 if t == 0 else 385.0)
print(f" T2c 391 W {e391}, 389 W {e389}, 395 then 385 W {e395}")
check("T2c: b steady at 391 W (house alone with the real batteries lands "
"13 609 W, aim + 9 W): the car explains from E+0", all(e391)
and len(e391) == 6)
check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0",
not any(e389) and len(e389) == 6)
check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from "
"the second cycle on", not any(e395[1:]) and len(e395) == 6)
# --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- #
e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0),
const(CAR))[1], 0, 5)
e11 = run_of(urun(range(0, 6), const(13611.0 + CAR), const(0.0),
const(CAR))[1], 0, 5)
check("T4 unit: the house alone at aim + 9 W: the car explains from E+0; at "
"aim + 11 W it does not", all(e09) and len(e09) == 6 and not any(e11))
# --- T8 / N2: 0 W and tiny cars ---------------------------------------------- #
e0 = run_of(urun(range(-5, 30), const(14000.0 - 800.0), const(800.0),
const(0.0))[1], -5, 29)
e50 = run_of(urun(range(-5, 30), const(14090.0 + 50.0), const(0.0),
const(50.0))[1], -5, 29)
check("T8 unit: a 0 W car never explains, whatever the batteries give (T2 "
"shape, b 800 W)", not any(e0) and len(e0) == 35)
check("T8 unit: a 50 W car with the house at 14 090 W never explains",
not any(e50) and len(e50) == 35)
# N2: a car that drew 11 kW earlier in the quarter and now reports 0 W
c0, ex0 = urun(range(0, 400), lambda t: 2600.0 + (11040.0 if t < 300 else 0.0),
const(0.0), lambda t: 11040.0 if t < 300 else 0.0)
check("N2: a trusted 0 W figure explains nothing, also after the car drew "
"earlier in the quarter", not any(run_of(ex0, 300, 399)))
# --- T8 unit: a car known to draw nothing is not an unknown car ------------- #
class _Tracker:
"""The two things `_car_idle` reads: the reading, and its fresh power."""
def __init__(self, available):
self.reading = CH.ChargerReading(available=available, state="B",
charging=False, power_w=0.0)
def car_w(self, _now):
return 0.0 if self.reading.available else None
@staticmethod
def status(*_a):
return "charging"
def idle_then_charging(available):
c = _Car()
c.car = _Tracker(available)
_c, ex = urun(range(0, 900),
lambda t: 14090.0 if t < 60 else 13000.0 + CAR, const(0.0),
lambda t: None if t < 60 else CAR, c=c)
return ex
exi, exu = idle_then_charging(True), idle_then_charging(False)
check("T8 unit: a car known idle (mode3 B, 0 W, fresh) while the house alone "
"misses (14 090 W): that house need is latched, so the car charging "
"from E+60 does not explain the quarter (test_ev10's `swapped` case)",
not any(run_of(exi, 0, 899)))
check("T8 unit: the same with the charger unavailable (unknown car): the "
"alarm stands while unknown and is released at E+60 (Expected 5)",
not any(run_of(exu, 0, 59)) and all(run_of(exu, 60, 899)))
# --- T10(a) unit: the battery reading lost for one cycle --------------------- #
cA, eA = urun(range(-3, 10), const(14000.0 + CAR - 800.0),
lambda t: None if t == 1 else 800.0, const(CAR))
check("T10(a) unit, T2 shape: the cycle with no battery reading explains "
"nothing (no last-known W credited); the next ones do",
eA.get(1) is False and eA.get(0) is True and all(run_of(eA, 2, 9))
and len(run_of(eA, 2, 9)) == 8)
# --- T13 unit: a house need seen with a trusted car stays latched ----------- #
c13, e13 = urun(range(-5, 1000),
lambda t: (15500.0 if 300 <= t < 360 else 13000.0) + CAR,
const(0.0), const(CAR))
check("T13 unit: the house steps to 15 500 W at E+300 for 60 s (landing "
"without the car 14 667 W): not explained from E+300 to the quarter's "
"end, though the house is back at 13 000 W from E+360",
all(run_of(e13, 0, 299)) and not any(run_of(e13, 300, 899))
and len(run_of(e13, 300, 899)) == 600)
check("T13 unit: ...and released by the new quarter", all(run_of(e13, 900, 999)))
c13g, e13g = urun(range(0, 400),
lambda t: (15500.0 if 100 <= t < 160 else 13000.0) + CAR,
const(0.0), const(CAR),
guard=lambda t: _G(wants=not (t == 250)))
check("T13 unit: ...or by the guard no longer wanting power (EV-10)",
not any(run_of(e13g, 100, 249)) and all(run_of(e13g, 251, 399)))
# --- T14: no flicker --------------------------------------------------------- #
def floor_edges(ex):
"""Per quarter, False -> True edges of the floor alarm the stub implies
(floor-limited, within_aim False, not explained)."""
out, was = {}, False
for t in sorted(ex):
al = not ex[t]
if al and not was:
out[t // 900] = out.get(t // 900, 0) + 1
was = al
return out
_ca, eta = urun(range(0, 1200),
lambda t: 13610.0 + (40.0 if int(t // 7) % 2 else -40.0) + CAR,
const(0.0), const(CAR))
_cb, etb = urun(range(0, 1200),
lambda t: 14000.0 + CAR - (400.0 if int(t // 7) % 2 else 800.0),
lambda t: 400.0 if int(t // 7) % 2 else 800.0, const(CAR))
fa, fb = floor_edges(eta), floor_edges(etb)
print(f" T14 alarm edges per quarter: (a) {fa} (b) {fb}")
check("T14(a): the house alone straddles aim + 10 W by 40 W every 7 s: at "
"most one alarm edge per quarter", all(v <= 1 for v in fa.values()))
check("T14(b): T2 shape with b alternating 400 / 800 W every 7 s: no alarm "
"edge at all (base: one per quarter)", fb == {})
# --- T15 unit: x10 ------------------------------------------------------------ #
ex10 = t1(x=10)
check("T15 unit x10 (wall and mono 10 s a cycle): T1 the same; released "
"within 1 cycle (E+30, the first trusted cycle)",
not any(run_of(ex10, 0, 20)) and all(run_of(ex10, 30, 120))
and all(run_of(ex10, -30, -10)))
ex10m = t1(x=10, mono_x=1)
check("T15 unit, mono x1 and wall x10: the same verdicts (the edge comes from "
"the projection's block_start, not from mono)",
not any(run_of(ex10m, 0, 20)) and all(run_of(ex10m, 30, 120)))
# =========================================================================== #
print("\n2. THE REAL CONTROLLER ACROSS THE EDGE (N=2, both at the reserve)")
# =========================================================================== #
RUNS = [] # (name, alarm edges) of every run, for N5
def summary(name, r, tr):
RUNS.append((name, H.edges(tr)))
w = H.window(tr, E - 120, E + 900)
lim = [x for x in w if x["lim"]]
print(f" {name}: alarms {[t - E for t in H.alarms(r)]} edges "
f"{[t - E for t in H.edges(tr)]} red {len(H.red_secs(tr))} s "
f"(first {[t - E for t in H.red_secs(tr)[:1]]}) errors "
f"{len(H.errors(tr))} limited {len(lim)} explained "
f"{sum(1 for x in lim if x['explains'])} cmd {H.commands(r, tr)}")
return w, lim
def quiet(r, tr):
"""No floor notification, no ERROR, no red peak_guard row, E-120..E+900."""
return H.alarms(r) == [] and H.red_secs(tr) == [] and H.errors(tr) == []
def all_explained(lim, t0=E - 120):
return bool(lim) and all(x["explains"] for x in lim if x["t"] >= t0)
ZERO = const(0.0)
def honest(w):
"""An honest shape steps at the edge, so Off has no alarm before it."""
return H.shape(w, at=E)
# --- T2: the rig F-A shape ---------------------------------------------------- #
r2, tr2 = H.run(H.shape(14000.0), a=ZERO, b=const(800.0))
w2, lim2 = summary("T2", r2, tr2)
check("T2 PRECONDITION: limited at the reserve from the edge, the car trusted, "
"b 800 W, grid excess 980 W < car",
present(first(x for x in w2 if x["t"] == E and x["lim"]))
and all(x["w"] == CAR and x["batt"] == 800.0 for x in lim2))
check("T2: no goodwe_peak_soc_floor, no PEAK_GUARD_FLOOR_LIMITED ERROR, no "
"red peak_guard row in E-120..E+900 (base: alarm at E+0, red to E+900)",
quiet(r2, tr2))
check("T2: the car explains every floor-limited cycle, E+0..E+10 among them",
all_explained(lim2) and len([x for x in lim2 if x["t"] <= E + 10]) == 11)
# --- T2b: the batteries give less later --------------------------------------- #
r2i, tr2i = H.run(H.shape(14000.0), a=ZERO,
b=lambda t: 800.0 if t < E + 300 else 0.0)
summary("T2b(i)", r2i, tr2i)
a2i = H.alarms(r2i)
check("T2b(i): b drops to 0 W at E+300 (landing without the car 13 733 W): "
"the alarm fires within 1 cycle of E+300",
len(a2i) == 1 and E + 300 <= nth(a2i, 0) <= E + 301)
check("T2b(i): ...and stays to the quarter's end (a house need with a "
"trusted car is latched)", all(x["alarm"] and x["red"] for x in
H.window(tr2i, E + 302, E + 899)))
r2ii, tr2ii = H.run(H.shape(14000.0), a=ZERO,
b=lambda t: 800.0 if t < E + 300 else 400.0)
summary("T2b(ii)", r2ii, tr2ii)
check("T2b(ii): b drops to 400 W (landing 13 467 W): no alarm to E+900",
quiet(r2ii, tr2ii))
# --- T3: batteries at 0 W, and the 11 kW car ---------------------------------- #
r3, tr3 = H.run(H.shape(13000.0), a=ZERO, b=ZERO)
w3, lim3 = summary("T3", r3, tr3)
check("T3: batteries 0 W, house 13 000 W, car 1 380 W: no alarm, no red row, "
"the car explains every limited cycle incl. E+0..E+10, one car notice",
quiet(r3, tr3) and all_explained(lim3)
and len(P.ids(r3, P.OVER)) == 1
and all(x["explains"] for x in lim3 if x["t"] <= E + 10))
def plug_at(t0):
return {t0: lambda p, c: p.ch.plug_in()}
r3k, tr3k = H.run(H.shape(2600.0, before=2600.0), a=ZERO, b=ZERO, car_a=16,
phases=3, aim=6344.0, plug=False, extra=plug_at(E - 120))
w3k, lim3k = summary("T3 11 kW", r3k, tr3k)
check("T3 11 kW: house 2 600 W, car 11 kW, aim 6 344 W (base P 21:30): no "
"alarm, the car explains every limited cycle",
quiet(r3k, tr3k) and all_explained(lim3k)
and len(P.ids(r3k, P.OVER)) == 1)
# --- T4 controller ------------------------------------------------------------ #
r409, tr409 = H.run(H.shape(13609.0), a=ZERO, b=ZERO)
summary("T4 13 609", r409, tr409)
check("T4: the house alone at aim + 9 W: no alarm", quiet(r409, tr409))
r411, tr411 = H.run(H.shape(13611.0), a=ZERO, b=ZERO)
r411o, tr411o = H.run(H.shape(13611.0), a=ZERO, b=ZERO, mode="off")
summary("T4 13 611", r411, tr411)
summary("T4 13 611 Off", r411o, tr411o)
check("T4: at aim + 11 W the alarm at the same cycle as Off (and as base, "
"E+0)", H.alarms(r411) == H.alarms(r411o) == [E])
# --- T5: an honest alarm ------------------------------------------------------ #
r5, tr5 = H.run(honest(14090.0), a=ZERO, b=ZERO)
r5o, tr5o = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off")
summary("T5", r5, tr5)
summary("T5 Off", r5o, tr5o)
check("T5: grid excess 1 870 W > car 1 380 W: the alarm and the ERROR at the "
"same second as Off and as base (E+1, the step's first sample)",
H.alarms(r5) == H.alarms(r5o) == T5_BASE
and nth(H.errors(tr5), 0) == nth(H.errors(tr5o), 0) == E + 1)
check("T5: the car explains no cycle", not any(x["explains"] for x in tr5))
# --- T6: the car figure unknown across the edge ------------------------------- #
def unavailable(t0, t1):
return {t0: lambda p, c: p.ch.go_unavailable(True),
t1: lambda p, c: p.ch.go_unavailable(False)}
r6, tr6 = H.run(H.shape(13000.0), a=ZERO, b=ZERO,
extra=unavailable(E - 20, E + 60))
summary("T6 T3 shape", r6, tr6)
back = first(x["t"] for x in tr6 if x["t"] >= E + 60 and x["w"] is not None)
check("T6 T3 shape: while unknown the car explains nothing and the alarm "
"stands from E+0, as base",
H.alarms(r6) == [E] and not any(
x["explains"] for x in H.window(tr6, E - 5, E + 59))
and all(x["alarm"] for x in H.window(tr6, E, E + 59)))
check("T6 T3 shape: released within 1 cycle of the first trusted cycle after "
"E+60, no new alarm edge to E+900 (base: red to E+900)",
present(back) and all(not x["alarm"] and x["explains"] for x in
H.window(tr6, back + 1, E + 899))
and H.edges(tr6) == [E])
r6h, tr6h = H.run(honest(14090.0), a=ZERO, b=ZERO,
extra=unavailable(E - 20, E + 60))
summary("T6 T5 shape", r6h, tr6h)
check("T6 T5 shape: the alarm at the base second and it stands throughout",
H.alarms(r6h) == T5_BASE and all(x["alarm"] for x in
H.window(tr6h, E + 1, E + 899)))
# --- T7: a frozen car figure, the car really stops ---------------------------- #
def frozen_stop(p, c):
p.ch.freeze()
p.ch.car_full()
r7, tr7 = H.run(honest(14090.0), a=ZERO, b=ZERO, extra={E - 30: frozen_stop})
summary("T7", r7, tr7)
first7 = nth(H.alarms(r7), 0)
untr = first(x["t"] for x in tr7 if x["t"] >= E - 30 and x["w"] is None)
check("T7: the alarm within 114 s of the stop (max(60, 40 Wh / 1.38 kW) "
"+ 10), no later than base",
present(first7) and first7 <= E - 30 + 114 and first7 <= T7_BASE)
check("T7: never explained after the figure goes untrusted",
present(untr) and not any(x["explains"] for x in tr7 if x["t"] >= untr))
# --- T8: a car at 0 W, and a 50 W car ----------------------------------------- #
class Draw(SimCharger):
"""A charger that draws `real_w` while charging and reports `say_w`."""
def __init__(self, real_w, say_w, **kw):
super().__init__(**kw)
self.real_w, self.say_w = real_w, say_w
def target_w(self):
return 0.0 if super().target_w() <= 0.0 else self.real_w
def _build(self):
keep, self._frozen_w = self._frozen_w, self.say_w
try:
return super()._build()
finally:
self._frozen_w = keep
def full(p, c):
p.ch.car_full()
for nm, kw in (("house 14 090 W", dict(house=honest(14090.0), b=ZERO)),
("T2 shape", dict(house=honest(14000.0), b=const(800.0)))):
r8, tr8 = H.run(a=ZERO, extra={1: full}, **kw)
r8o, tr8o = H.run(a=ZERO, extra={1: full}, mode="off", **kw)
summary(f"T8 0 W, {nm}", r8, tr8)
summary(f"T8 0 W, {nm}, Off", r8o, tr8o)
check(f"T8: a car plugged at 0 W, {nm}: the alarm at the same second as "
f"Off, nothing explained", H.alarms(r8) == H.alarms(r8o)
and H.alarms(r8) != [] and not any(x["explains"] for x in tr8))
r8s, tr8s = H.run(honest(14090.0), a=ZERO, b=ZERO,
sim=Draw(50.0, 50.0, setpoint_a=6))
r8so, tr8so = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off",
sim=Draw(50.0, 50.0, setpoint_a=6))
summary("T8 50 W", r8s, tr8s)
check("T8: a 50 W car, house 14 090 W: the alarm at the same second as Off, "
"nothing explained", H.alarms(r8s) == H.alarms(r8so) == T5_BASE
and not any(x["explains"] for x in tr8s))
# --- T9: a wrong charger reply ------------------------------------------------ #
r9a, tr9a = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(1380.0, 11000.0, setpoint_a=6))
summary("T9(a)", r9a, tr9a)
check("T9(a): reports 11 kW, read-back 6 A 1-ph (cap 1 518 W): the house "
"alone misses, the alarm at the base second",
H.alarms(r9a) == T5_BASE and all(x["w"] is None or x["w"] <= 1518.0
for x in tr9a))
r9b, tr9b = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(400.0, 1380.0, setpoint_a=6))
summary("T9(b)", r9b, tr9b)
check("T9(b): reports 1 380 W, draws 400 W: the same alarms as base (none: "
"400 W corroborates a 1 380 W figure, CORR_RATIO 0.5; see the dev "
"report's Findings)", H.alarms(r9b) == T9B_BASE)
r9c, tr9c = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(100.0, 1380.0, setpoint_a=6))
summary("T9(c)", r9c, tr9c)
a9c = nth(H.alarms(r9c), 0)
check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure "
"is uncorroborated, at most 104 s + 10 s after the edge, no later than "
"base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE)
print(f" T9(c) alarm edges {[t - E for t in H.edges(tr9c)]} (base: one; "
f"the meter's 10 Wh step re-corroborates the figure every 360 s and "
f"Expected 3/5 release the alarm then: see the dev report)")
# --- T10: a lost battery reading, an unavailable charger ---------------------- #
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T5", dict(house=honest(14090.0), b=ZERO))):
r10, tr10 = H.run(a=ZERO, lost={"b": {E + 1}}, **kw)
summary(f"T10(a) {nm}", r10, tr10)
gap = first(x for x in tr10 if x["t"] == E + 1)
nxt = first(x for x in tr10 if x["t"] == E + 2)
check(f"T10(a) {nm}: inverter-b's reading lost at E+1: that cycle grades "
f"nothing (P_SAFETY owns a missing input), the next one grades on "
f"what is measured", present(gap, nxt) and gap["batt"] is None
and nxt["batt"] == (800.0 if nm == "T2" else 0.0))
if nm == "T2":
check("T10(a) T2: no alarm edge (base: E+0)", quiet(r10, tr10))
else:
check("T10(a) T5: the same alarm seconds as base",
H.alarms(r10) == T10A_T5_BASE)
r10b, tr10b = H.run(a=ZERO, extra=unavailable(E + 1, E + 2), **kw)
summary(f"T10(b) {nm}", r10b, tr10b)
if nm == "T2":
check("T10(b) T2: the charger unavailable for one cycle (E+1): the "
"alarm stands for that cycle only (Expected 5)",
H.edges(tr10b) == [E + 1]
and all(not x["alarm"] for x in H.window(tr10b, E + 2, E + 899))
and all(x["explains"] for x in H.window(tr10b, E + 2, E + 899)
if x["lim"]))
else:
check("T10(b) T5: the alarm at the base second and it stands",
H.alarms(r10b) == T5_BASE and all(
x["alarm"] for x in H.window(tr10b, E + 1, E + 899)))
# --- T11: one battery first (SAFETY-87) --------------------------------------- #
for nm, house in (("(i) 17 500 W", 17500.0), ("(ii) 19 000 W", 19000.0)):
r11, tr11 = H.run(honest(house), soc={"a": 19.0, "b": 35.0})
summary(f"T11{nm}", r11, tr11)
if house < 18000.0:
check("T11(i): b able, house 17 500 W, car 1 380 W: no alarm across E",
H.alarms(r11) == [] and P.ids(r11, *P.ALARMS) == [])
else:
check("T11(ii): house 19 000 W: the alarm at the base second",
[t for t, _n in P.ids(r11, *P.ALARMS)] == T11_BASE)
# --- T12 (record only): plug-in at E+0, the reserve at E+180 ------------------ #
def reserve_at(p, c):
p.socs.update({"a": 19.0, "b": 19.0})
r12, tr12 = H.run(H.shape(13000.0), soc={"a": 40.0, "b": 40.0}, plug=False,
extra={E: lambda p, c: p.ch.plug_in(), E + 180: reserve_at})
summary("T12 (record, F-B)", r12, tr12)
# --- T13 controller: the latch is kept ---------------------------------------- #
r13, tr13 = H.run(H.shape(lambda t: 15500.0 if E + 300 <= t < E + 360
else 13000.0), a=ZERO, b=ZERO)
summary("T13", r13, tr13)
check("T13: the house steps to 15 500 W at E+300 for 60 s: the alarm at "
"the base second (E+301, the step's first sample), and red to the "
"quarter's end", H.alarms(r13) == T13_BASE and all(
x["alarm"] and x["red"] for x in H.window(tr13, E + 301, E + 899)))
# --- T16: the edge paths ------------------------------------------------------ #
for nm, kw in (("(a)(b)(c) SAFETY-91 roll, modes on", {}),
("(d) the guard not wanting at the edge",
dict(lost={"b": {E}}))):
r16, tr16 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, **kw)
w16, lim16 = summary(f"T16{nm}", r16, tr16)
f16 = first(x for x in tr16 if x["t"] >= E and x["lim"])
pre = first(x for x in tr16 if x["t"] == E - 1)
check(f"T16{nm}: the car explains from the first limited cycle of the "
f"new block, no alarm, no red row, `_carq` key = block_start",
present(f16) and quiet(r16, tr16) and all(
x["explains"] and x["key"] == x["block"]
for x in tr16 if x["t"] >= f16["t"] and x["lim"]))
if not kw:
print(f" T16(c): within_aim at E-1 {pre['within_aim'] if present(pre) else pre}"
" (SAFETY-126's latch carried; not asserted)")
else:
g0 = first(x for x in tr16 if x["t"] == E)
check("T16(d) PRECONDITION: the guard did not want power at E+0",
present(g0) and not g0["wants"])
# --- T17: a restart ----------------------------------------------------------- #
def restart_at(t0):
return {t0: lambda p, c: H.restart(c)}
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T3", dict(house=H.shape(13000.0), b=ZERO)),
("T5", dict(house=honest(14090.0), b=ZERO))):
rr0, tr0 = H.run(a=ZERO, **kw)
for at in (E + 2, E + 300):
rr, trr = H.run(a=ZERO, extra=restart_at(at), **kw)
summary(f"T17 {nm} restart at E+{at - E}", rr, trr)
if nm == "T5":
check(f"T17 T5, restart at E+{at - E}: the alarm at the base "
f"second and again on the first cycle after the restart, "
f"as base; red throughout",
H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr))
== len(H.red_secs(tr0)))
else:
check(f"T17 {nm}, restart at E+{at - E}: the same as without "
f"(no floor notice, no ERROR, no red row)",
quiet(rr, trr) and quiet(rr0, tr0))
print(f" T17 {nm} car-over notices: twin "
f"{[t - E for t, _n in P.ids(rr0, P.OVER)]}, restarted "
f"{[t - E for t, _n in P.ids(rr, P.OVER)]} (EV-11's "
f"once-per-session state does not survive a restart, as on "
f"base)")
# --- T15 controller: x10 ------------------------------------------------------ #
# F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at
# 10 s a cycle half the car's energy is counted, and late in the quarter the
# house alone seems to miss the aim (T2 from about E+540, T3 E+820, as on base
# for T3). The x10 verdicts are graded to E+500; what comes after is printed.
F2_FROM = E + 500
for nm, kw, want in (
("T2", dict(house=H.shape(14000.0), b=const(800.0)), "quiet"),
("T3", dict(house=H.shape(13000.0), b=ZERO), "quiet"),
("T5", dict(house=honest(14090.0), b=ZERO), "alarm"),
("T6", dict(house=H.shape(13000.0), b=ZERO,
extra=unavailable(E - 20, E + 60)), "release")):
rx, trx = H.run(a=ZERO, x=10, **kw)
summary(f"T15 x10 {nm}", rx, trx)
early = [x for x in trx if x["t"] < F2_FROM]
print(f" T15 x10 {nm}: alarms after E+500 (F2) "
f"{[t - E for t in H.alarms(rx) if t >= F2_FROM]}")
if want == "quiet":
check(f"T15 x10 {nm}: no alarm, no red row, every limited cycle "
f"explained, E-120..E+500",
not [t for t in H.alarms(rx) if t < F2_FROM]
and H.red_secs(trx, t1=F2_FROM - 1) == []
and all_explained([x for x in early if x["lim"]]))
elif want == "alarm":
check("T15 x10 T5: the alarm at the base second (E+10, one cycle)",
H.alarms(rx) == T15_T5_BASE)
else:
bk = first(x["t"] for x in trx if x["t"] >= E + 60
and x["w"] is not None)
check("T15 x10 T6: the alarm while unknown, released within 1 cycle "
"(10 fake s) of the first trusted one, no new edge to E+500",
present(bk) and bk <= E + 70
and all(not x["alarm"] for x in H.window(trx, bk, F2_FROM - 1))
and [t for t in H.edges(trx) if t < F2_FROM] == [E])
# --- N4: the alarm decision changes no command -------------------------------- #
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T5", dict(house=honest(14090.0), b=ZERO))):
ra, tra = H.run(a=ZERO, **kw)
rb, trb = H.run(a=ZERO, explain_off=True, **kw)
check(f"N4 {nm}: the claim, the floor, the battery setpoints and the "
f"charger writes are identical whether the car explains or not",
H.commands(ra, tra) == H.commands(rb, trb))
# --- N5: at most one floor-alarm edge per quarter ---------------------------- #
def per_quarter(ts):
out = {}
for t in ts:
out[(t - E) // 900] = out.get((t - E) // 900, 0) + 1
return out
many = [(nm, ts) for nm, ts in RUNS
if not nm.startswith("T9(c)")
and any(v > 1 for v in per_quarter(
[t for t in ts if not nm.startswith("T15 x10") or t < F2_FROM])
.values())]
check(f"N5: at most one floor-alarm edge per quarter in every run "
f"({len(RUNS)} runs; T9(c) apart, x10 to E+500): {many}", many == [])
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)
+295
View File
@@ -0,0 +1,295 @@
#!/usr/bin/env python3
"""EV-05: the real Controller on a sunny plant with N batteries and a car.
python3 tools/ev05_sun.py # mock-up scenario 2, both priorities
A 1 s cycle, a P1 meter that publishes 0.3 s before each cycle, N batteries
each with ITS OWN rating and level (switched On, so the zero-grid loop charges
them from the export), and `chargersim.SimCharger` behind the same Home
Assistant. The meter sees `house + car - sun - batteries` (battery discharge
positive), so the spare sun the add-on computes is `sun - house` whatever it
does. A battery at 100 % takes no charge. `events` is `{second: fn(plant, c)}`,
run before that cycle. `race=True` uses the production order (read, the writer
task settles, then the cycle), as test_ev04.py's `World.step_race`.
Used by test_ev05.py and, later, by the rig test."""
import asyncio
import logging
import os
import sys
import tempfile
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
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
from app import p1 as _p1 # 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")
RESPONSE_S = 0.5 # a battery reaches its new command this much later
SAMPLE_LEAD_S = 0.3
class SunPlant:
"""The house, the sun, N batteries and the charger on one meter."""
def __init__(self, house, sun, ratings, socs, charger):
self.house, self.sun = house, sun
self.ratings, self.socs = dict(ratings), dict(socs)
self.ch = charger
self.t = 0.0
self.hists = {u: [(-1e9, 0.0)] for u in self.ratings}
self.notes = [] # (t, notification id) raised
self.dismissed = []
self.sets = [] # (t, entity, value): every number write
# Every charger write the model took, as `SimCharger.log` has it but
# on THIS clock (the model's own runs ahead while a write waits).
self.wlog = []
self.meter = 0.0
self.meter_on = True # False: the meter stops publishing
self.batt_nan = set() # units whose battery figure reads None
self.utc_off = 0.0 # the wall clock jumps, the model clock not
self.ha_down = False # Home Assistant answers nothing (SAFETY-112)
self.response_s = RESPONSE_S # a slow battery takes longer
def batt_of(self, u, at):
w = 0.0
for when, v in self.hists[u]:
if when <= at:
w = v
r = self.ratings[u]
w = max(-r, min(r, float(round(w))))
if self.socs[u] >= 100.0 and w < 0.0:
w = 0.0 # a full battery takes no charge
return w
def batt(self, at):
return sum(self.batt_of(u, at) for u in self.ratings)
def grid(self, at):
return self.house(at) + self.ch.power_w - self.sun(at) - self.batt(at)
# -- Home Assistant -----------------------------------------------------
async def limits(self, e):
return (-5000.0, 5000.0, 1.0)
async def state(self, entity_id):
if self.ha_down:
return None
return self.ch.states().get(entity_id)
async def states(self):
if self.ha_down:
return []
return list(self.ch.states().values())
async def call(self, domain, service, data=None):
if self.ha_down:
return False
if service == "create":
self.notes.append((self.t, (data or {}).get("notification_id")))
if service == "dismiss":
self.dismissed.append((self.t, (data or {}).get("notification_id")))
if domain == "select" and service == "select_option":
n = 3 if "3" in str((data or {}).get("option")) else 1
return self._logged("phases", n, self.ch.request_phases)
return True
def _logged(self, what, v, fn):
n0, row = len(self.ch.log), (self.t, what, v, self.ch.power_w,
self.ch.setpoint_a)
ok = fn(v)
if len(self.ch.log) > n0:
self.wlog.append(row)
return ok
async def number(self, e, invert=False):
if self.ha_down:
return None
for u in self.ratings:
if e == "sensor.soc_" + u:
return self.socs[u]
if e == "sensor.batt_" + u:
return None if u in self.batt_nan else self.batt_of(u, self.t)
if e in ("sensor.grid", "sensor.net"):
return self.meter
return None
async def set_number(self, e, v):
if self.ha_down:
return False
self.sets.append((self.t, e, float(v)))
if e == SET:
return self._logged("current", float(v), self.ch.request_current)
if e.startswith("number.sp_"):
self.hists[e[-1]].append((self.t + self.response_s, float(v)))
return True
def drive(house, sun, *, dur=600.0, ratings=None, socs=None, cap=3500.0,
margin=100, opts=None, plug=True, setpoint=0, phases=1, mode="solar",
first="batteries", events=None, sim=None, store=None, race=False,
on_cycle=None, car_phases=3, t0=0.0, caps=None):
"""Run it. Returns a dict: plant, controller, charger, notifications with
their second, and a per-second trace. `caps` ({unit: kWh}) lets each
battery's level move with what it charges or gives; without it the
levels stand still."""
ratings = ratings or {"a": 5000.0, "b": 4600.0}
socs = socs or {u: 50.0 for u in ratings}
sim = sim or SimCharger(setpoint_a=setpoint)
if plug:
sim.plug_in(car_phases=car_phases)
sim.phases_allowed = phases
units = sorted(ratings)
o = rig._options(len(units), 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,
"ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
"ev_current_entity": SET}, **(opts or {})))
if len(units) == 1:
o["max_w"] = ratings[units[0]]
else:
o["inverters"] = [dict(x, max_w=ratings[x["name"][-1]])
for x in o["inverters"]]
store = store or rig._Store()
store.data["car_mode"] = mode
store.data["car_sun_first"] = first
for u in units:
store.data[unit_key("inverter-" + u, packmode.USE_KEY)] = True
db = os.path.join(tempfile.mkdtemp(prefix="ev5-"), "tariff.db")
out = {}
events_in = events or {}
async def go():
plant = SunPlant(house, sun, ratings, socs, sim)
c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
peak_db_path=db)
for i in c.inverters:
r = ratings[i.name[-1]] if len(units) > 1 else ratings[units[0]]
i.dev_min, i.dev_max = -r, r
c.auto = True
clock = [t0]
c.car_now = lambda: clock[0]
real_time = _p1.time
class _Time:
"""The meter's age on the model clock, so a silent meter goes
stale in model seconds."""
def __getattr__(self, k):
return getattr(real_time, k)
@staticmethod
def monotonic():
return clock[0]
_p1.time = _Time()
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] + plant.utc_off)
main_files.live.datetime = _DT
trace = []
try:
t = t0
while t < t0 + dur:
plant.t = clock[0] = t
fn = events_in.get(int(t)) if t == int(t) else None
if fn is not None:
r = fn(plant, c)
if asyncio.iscoroutine(r):
await r
sim.tick(1.0)
ts = t - SAMPLE_LEAD_S
if plant.meter_on and not plant.ha_down:
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=ts))
await c.read_inputs(now_mono=t)
if race:
await c.car_settle()
await c.cycle()
else:
await c.cycle()
await c.car_settle()
w = c.car_solar
g = c.peak_guard
trace.append(dict(
t=t, a=w.plan.a, why=w.plan.why, n=w.plan.n,
sp=sim.setpoint_a, rb=sim.readback_a,
ph=sim.phases_allowed, car=sim.power_w, st=sim.state,
grid=plant.grid(t), batt=plant.batt(t),
house=plant.house(t), sun=plant.sun(t),
cut=c.car_cut_w, explains=c.car_explains,
lim=bool(g is not None and (g.floor_limited
or g.saturated)),
floor=(None if g is None else g.floor_w),
excess=(None if g is None else g.excess_w),
want=(None if g is None else g.wanted_w),
since=c._car_want_since,
able=c._car_batt_able(), socs=dict(plant.socs),
proj=(None if g is None else g.projected_w),
target=(None if g is None else g.target_w),
would=w.would, single=w.single,
spare=c.car_spare_w(t), ok=w.plan.ok_since,
red=[x["id"] for x in c.checks()
if x["ok"] is False and not x["warn"]]
if on_cycle == "rows" else []))
if callable(on_cycle):
on_cycle(plant, c, t)
for u, kwh in (caps or {}).items():
# 1 s of W, as a percent of kWh: W / 3600 / (kWh x 1000) x 100
lv = plant.socs[u] - plant.batt_of(u, t) / 36000.0 / kwh
plant.socs[u] = max(0.0, min(100.0, lv))
t += 1.0
await c.car_settle()
finally:
main_files.live.datetime = real_dt
_p1.time = real_time
out.update(plant=plant, c=c, sim=sim, trace=trace, store=store,
raised=list(plant.notes))
asyncio.run(go())
return out
def ids(out, *wanted):
return [(t, n) for t, n in out["raised"] if n in wanted]
def writes(out, what="current"):
"""(t, value) of every charger write of that kind, in model seconds."""
return [(x[0], x[2]) for x in out["sim"].writes(what)]
def const(w):
return lambda t: float(w)
if __name__ == "__main__":
logging.disable(logging.CRITICAL)
for first in ("batteries", "car"):
r = drive(const(900.0), const(7900.0), dur=600, first=first,
socs={"a": 71.0, "b": 100.0})
print(f"scenario 2, {first} first: writes {writes(r)} phases "
f"{writes(r, 'phases')} batteries {r['plant'].batt(599):.0f} W "
f"grid {r['plant'].grid(599):.0f} W")
-207
View File
@@ -1,207 +0,0 @@
"""EV-18: the real Controller across one quarter edge `E`, N=2, both units at
the peak reserve and the car charging (`ev04_peak.drive`). Used by test_ev18.py.
The run starts `E` s before an edge (rig.BASE is moved back for the run), with
a light house so the first quarter does not raise the month's peak (the aim
stays `AIM`). At `E - 120` the house steps to the shape, so the guard first
wants power at the edge, as on the rig (EV-15 F-A). `force` makes a unit give
what the loop gives below the reserve whatever it is told; `lost` drops its
reading for some seconds (the grid still sees it). The trace is one dict per
cycle, taken after it.
"""
import hashlib
import logging
import os
import sys
from datetime import timedelta
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import ev04_peak as P # noqa: E402
import opt11_identity as rig # noqa: E402
import safety81_sim as s81 # noqa: E402
from app import peakguard # noqa: E402
E = 150 # the edge, in run seconds
AIM = 13600.0
MARGIN = 50.0
PRE_W = 5000.0 # the first quarter's house: under the cap
FLOOR = "goodwe_peak_soc_floor"
OPTS = {"peak_soc_floor": 20, "inverters": [
{"name": "inverter-a", "setpoint_entity": "number.sp_a",
"soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a",
"max_w": 5000, "bms_soc_floor": 10},
{"name": "inverter-b", "setpoint_entity": "number.sp_b",
"soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b",
"max_w": 4600, "bms_soc_floor": 10}]}
class _Errors(logging.Handler):
def __init__(self):
super().__init__(logging.ERROR)
self.rec = []
def emit(self, r):
self.rec.append(r.getMessage())
ERR = _Errors()
_lg = logging.getLogger("goodwe")
_lg.addHandler(ERR)
_lg.setLevel(logging.ERROR)
_lg.propagate = False
class Plant(P.CarPlantN):
force = {}
lost = {}
def batt_of(self, u, at):
f = self.force.get(u)
if f is not None:
return float(f(at))
return super().batt_of(u, at)
async def number(self, e, invert=False):
for u, secs in self.lost.items():
if e == "sensor.batt_" + u and int(self.t) in secs:
return None
return await super().number(e, invert)
def shape(after, before=PRE_W, at=None):
"""The house: `before` until `at` (E - 120), then `after` (W or fn(t))."""
at = E - 120 if at is None else at
return lambda t: before if t < at else (after(t) if callable(after)
else after)
def run(house, *, a=None, b=None, lost=None, car_a=6, phases=1, aim=AIM,
mode="manual", dur=None, extra=None, sim=None, soc=None, plug=True,
x=1, mono_x=None, explain_off=False):
"""One run; returns (run, trace). `x`: fake seconds per cycle (wall and
monotonic both; `mono_x` sets the monotonic rate apart). `explain_off`:
the car never explains (for the control-identity check)."""
force = {}
if a is not None:
force["a"] = a
if b is not None:
force["b"] = b
cls = type("Plant", (Plant,), {"force": force, "lost": lost or {}})
tr = []
n_err = [len(ERR.rec)]
dur = E + 900 if dur is None else dur
def hook(plant, c):
orig = c.car_settle
if explain_off:
c._car_explains_alarm = lambda *a_, **k_: False
if mono_x is not None and mono_x != x:
c.car_now = (lambda f=c.car_now: f() * mono_x / x)
async def settle():
await orig()
g = c.peak_guard
red = []
if plant.t >= E - 130:
red = [r_["id"] for r_ in c.checks()
if r_["ok"] is False and not r_["warn"]
and r_["id"] == "peak_guard"]
errs = [m for m in ERR.rec[n_err[0]:]
if "may not draw the battery lower" in m]
n_err[0] = len(ERR.rec)
cl = peakguard.claim(g) if g is not None else None
tr.append({
"t": plant.t, "explains": c.car_explains,
"lim": bool(g is not None and (g.floor_limited
or g.saturated)),
"within_aim": bool(g is not None and g.within_aim),
"wants": bool(g is not None and g.engaged
and (g.wanted_w or 0.0) > 0.0),
"alarm": c._peak_floor_limited, "red": red, "err": errs,
"w": c.car_alarm_w(), "batt": c.site_batt_w,
"key": c._carq["key"],
"block": (c._peak_proj_real.block_start
if c._peak_proj_real is not None else None),
"floor_w": g.floor_w if g is not None else None,
"lo": getattr(cl, "lo", None),
"sp": tuple(i.last_write for i in c.inverters)})
c.car_settle = settle
ev = {0: hook}
for t, fn in (extra or {}).items():
if t == 0:
ev[0] = (lambda p, c, fn=fn: (hook(p, c), fn(p, c)))
else:
ev[t] = fn
socs = soc or {"a": 19.0, "b": 19.0}
s = sim
if s is None:
from chargersim import SimCharger
s = SimCharger(setpoint_a=car_a)
if x != 1:
tick = s.tick
s.tick = lambda secs=1.0: tick(secs * x)
base, step = rig.BASE, s81.TICK
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
try:
r = P.drive(house, dur=dur, rating=5000.0, soc=socs,
cap=aim + MARGIN, phases=phases, n=2, plant_cls=cls,
opts=OPTS, dev_w=5000.0, setpoint=car_a, user_a=car_a,
mode=mode, events=ev, sim=s, plug=plug)
finally:
rig.BASE, s81.TICK = base, step
return r, tr
def alarms(r):
"""Seconds of each goodwe_peak_soc_floor notification."""
return [t for t, n in r["raised"] if n == FLOOR]
def window(tr, t0, t1):
return [x for x in tr if t0 <= x["t"] <= t1]
def edges(tr):
"""Seconds at which the floor alarm goes False -> True."""
out, was = [], False
for x in tr:
if x["alarm"] and not was:
out.append(x["t"])
was = x["alarm"]
return out
def red_secs(tr, t0=None, t1=None):
t0 = E - 120 if t0 is None else t0
t1 = E + 900 if t1 is None else t1
return [x["t"] for x in window(tr, t0, t1) if x["red"]]
def errors(tr):
return [x["t"] for x in tr if x["err"]]
def commands(r, tr):
"""A digest of every command: the units' setpoints, the charger's writes,
and the guard's floor and claim per cycle (N4)."""
h = hashlib.sha256()
for u in sorted(r["plant"].hists):
h.update(repr((u, r["plant"].hists[u])).encode())
h.update(repr(r["sim"].writes()).encode())
h.update(repr([(x["t"], x["floor_w"], x["lo"], x["sp"])
for x in tr]).encode())
return h.hexdigest()[:16]
def restart(c):
"""A restart as the car side sees it: a fresh `car_init` and an empty
corroboration history, and no floor alarm standing."""
mode, n, a = c.car_mode, c.car_n, c.car_a
c.car_init(c.o, c.store)
c.car_mode, c.car_n, c.car_a = mode, n, a
c.car._hist.clear()
c._peak_floor_limited = False
+10 -1
View File
@@ -300,7 +300,16 @@ configuration:
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."
description: "Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current."
ev_margin_w:
name: "Car charger · Sun kept back (W)"
description: "Solar: this much spare sun is never given to the car."
ev_start_min:
name: "Car charger · Start after (minutes)"
description: "Solar: the car starts after this long with enough spare sun."
ev_pause_min:
name: "Car charger · Pause after (minutes)"
description: "Solar: with too little sun the car holds 6 A this long, then pauses."
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."
+10 -1
View File
@@ -281,7 +281,16 @@ configuration:
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."
description: "De laatste modus houden, of starten in Uit. In Zon zet een herstart de laadpaal eerst op 0 A, andere modi laten haar stroom."
ev_margin_w:
name: "Laadpaal · Zon achtergehouden (W)"
description: "Zon: zoveel zonne-overschot krijgt de auto nooit."
ev_start_min:
name: "Laadpaal · Starten na (minuten)"
description: "Zon: de auto start na zo lang genoeg zonne-overschot."
ev_pause_min:
name: "Laadpaal · Pauzeren na (minuten)"
description: "Zon: met te weinig zon houdt de auto zo lang 6 A en pauzeert dan."
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."