Compare commits

...
9 Commits
Author SHA1 Message Date
Claude 646f61e730 EV-10 round 2: judge the car against the alarm's own landing; test failed writes; honest hold wording
checks / unit (pull_request) Successful in 22m4s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 18:07:25 +01:00
Claude a60342e4e8 EV-10: test_ev10 points at MUTATION.md and guards its indexed reads
checks / unit (pull_request) Successful in 20m36s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 16:12:42 +01:00
Claude 50d5ae90d2 EV-11: the end of a charging session clears the car-over state at once
checks / unit (pull_request) Failing after 29m5s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 15:41:57 +01:00
Claude 8efc385956 EV-10, EV-11, EV-12: car-alone peak alarm, steady car-over row, own write not another writer
checks / unit (pull_request) Failing after 2m13s
infra-pin / fresh (pull_request) Successful in 2s
EV-10: the car is the cause when the period without it (projected minus the car's
fresh, corroborated average) is at or under the aim, also with the projection
still under it. EV-11: car_over stays on until the test has been false for 180 s.
EV-12: the tracker's own-write mute opens before the write and runs 15 s from its
return.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 15:27:46 +01:00
admin 75ebe22a4d Merge pull request 'EV-04: car Manual mode, never throttled for the peak, no false guard alarms' (#257) from EV-04 into release/1.0
infra-pin / fresh (push) Successful in 1s
2026-11-16 09:21:04 +01:00
glenn schrooyenandClaude 6e6344eb02 EV-04 round 3: guard the L4 test's reads for test_named_absence
checks / unit (pull_request) Successful in 21m33s
infra-pin / fresh (pull_request) Successful in 2s
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 08:22:16 +01:00
glenn schrooyenandClaude f31dcb62b6 EV-04 round 3: undo restores the current in shadow mode too, energy rule catches a frozen 6 A figure, settle after a refused select
checks / unit (pull_request) Failing after 21m10s
infra-pin / fresh (pull_request) Successful in 1s
N1 the undo gives the old current back (clamped) in shadow mode; DECISIONS records it as the one write shadow mode allows.
N2 the corroboration looks back to a stretch with at least 40 Wh expected (60 s at 2.4 kW and up, 104 s at 1.38 kW).
L4 the current comes back 10 s after the phase select returned, also when it was refused.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 07:59:15 +01:00
glenn schrooyenandClaude 661a3b009a EV-04 round 2: race-free another-writer check, refused phase select, undo before the select, clamped restore, energy-corroborated car figure
checks / unit (pull_request) Successful in 21m14s
infra-pin / fresh (pull_request) Successful in 1s
M1 the writer ignores a reading taken before its latest confirmed write.
M2 a refused phase select gives the current back and stops after 3 tries (amber row).
M3 Off, shadow mode or a control/safety stop before the select undoes the change.
M4 the restore on shutdown (and the undo) is clamped.
M5 the car's power reaches the alarm path only while the charger's energy meter agrees with it.
L1 fuzz other-writer branch reachable and shown to run. L2 one wording. L3 Batteries-help-off text.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 06:51:15 +01:00
glenn schrooyenandClaude 0c92239a63 EV-04: car Manual mode, never throttled for the peak, no false guard alarms
checks / unit (pull_request) Successful in 21m48s
infra-pin / fresh (pull_request) Successful in 2s
Off and Manual (runtime state, Home and Home Assistant): the current (6 A to
the clamp) and the phases (1 or 3) are written once per user change through
the safe phase sequence, read back within 10 s, clamped to
min(ev_max_a, station limit, entity range). Shadow mode gates the writes.
The car's fresh power goes to the peak guard's alarm path: no false "Load too
high" or "Battery stopped limiting the peak", one grey notice per session.
ev_batt_cover and ev_mode_start options, peak line "set by the car", HA
entities, sim writes, DOCS, CHANGELOG, test_ev04.py.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-16 05:24:36 +01:00
28 changed files with 4416 additions and 85 deletions
+5
View File
@@ -1,5 +1,10 @@
# Changelog
### Not in a release yet
- The *Car* card can now charge: choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. The car is never slowed for the peak limit, the add-on says so instead of raising false peak alarms, and the batteries help cover it unless you switch that off. Off still writes nothing ([[EV-04]]).
- Car charger fixes: when the car alone takes the batteries to the peak reserve, the add-on no longer raises "Battery stopped limiting the peak" (the grey "Car over the peak limit" note says it instead); that note and the Car card's reason stay steady instead of flickering; and switching to Off right after the add-on's own change no longer shows "Something else changes the charger".
## 0.23.0
**A minor bump: the add-on can now read a car charger (Alfen, through Home Assistant), and with two inverters a maintenance charge stays paused during a real peak. Four new options were added, all with defaults, and none needs setting.**
@@ -0,0 +1,146 @@
# EV-04 — Manual mode: the first write to a car charger
The design is `reports/EV-01-design-report.md` (sections 2 to 5), accepted on
2026-11-15 with all eight decisions as recommended. This record keeps what the
code had to decide that the design left open.
## What writes, and who may
`app/carmode.py` `ManualWriter` is the only caller of `write_current` and
`write_phases` (test_ev03.py greps for any other). It runs in a background task
(`ctl_car.CarMixin.car_kick`), never in the control cycle: a write waits up to
10 s for the charger's read-back, and the cycle must never wait for a charger.
- **Off writes nothing.** The mode is runtime state in the store (`car_mode`,
`car_current`, `car_phases`), changed on Home or from Home Assistant with no
restart. Solar and Night are not accepted (EV-05, EV-02).
- **Once per user change.** A user change sets a flag the writer clears when the
charger has what was asked. A difference nobody asked for is the other-writer
detector's business, not a reason to write.
- **No car or a full car: nothing is written**, and the setting waits for a car.
- **Shadow mode and a stopped control write nothing**; the card says what the add-on
would set.
- **The clamp is the driver's too.** The writer asks for at most the clamp, and
`AlfenHaDriver.write_current` refuses anything above
`min(ev_max_a, station limit read now, entity range max)`: it sends nothing,
logs `CHARGER_CLAMP` at ERROR (the OUTPUT_CLAMP shape) and answers False.
- **"Taken"** means the read-back followed within 10 s. A write that was not
taken is tried again after a minute, three times, then it waits for the user
(an amber row). A late read-back is adopted, never called another writer.
## The phase sequence
0 A, wait until the charger reports under 100 W or mode3 leaves C (20 s at most),
select the phases, wait 10 s, write the current. One switch per 10 minutes. A
charger that does not take the 0 A never gets the phases select. A sequence that
has begun is finished whatever the mode, because it leaves the car at 0 A
otherwise; a stop of the add-on in the middle gives the car its current back
(`car_shutdown`).
## Another writer
A read-back that differs from what the add-on last wrote (or tried to write, or
saw before a refused write) for 30 s is another writer: a grey row, and no write
until the user changes the mode or a value. EV-03's detector still serves Off;
the tracker mutes its own detector for 15 s after each of our writes, so Manual
back to Off does not show the add-on as a second writer.
## The peak guard's alarm path
`Controller` passes the car's power to the guard's alarm path (`car_cycle`).
**The car explains the excess when the house alone would land the period under
the aim**: the car's average over the whole period (what it drew so far, and its
power now for the rest, `car_avg_w`) is at least how far the projected period is
over the aim. With decision 1 on it also needs the guard to be unable to hold
it (saturated or at the peak reserve). Then "Load too high" and "Battery stopped
limiting the peak" are not raised, the rows are not red, and one grey notice per
charging session says so. The claim, the floor and the commands are unchanged.
The brief's wording is `car_w >= projected excess over the aim`. The
instantaneous form (`car_w >= excess_w`, the watts to come off the meter now)
stops holding late in a period that the car already pushed over, because
`excess_w` grows as the seconds run out; the average form does not, and it is the
same test for a steady car.
**A stale, stuck or frozen car figure must never hide a real overload.** Only
`CarTracker.car_w_trusted` is used: fresh (the EV-03 rules, which also make an
unavailable reading None at once), not stuck after a write (SAFETY-37's shape),
never above what the read-back allows, and CORROBORATED by the charger's energy
meter (round 2). The rule (`CarTracker.corroborated`, constants `CORR_*` in
`chargers.py`): the charger reports charging (mode3 C) and has an energy entity,
and, looking back over unbroken charging readings to the shortest stretch that
is at least 55 s long and over which the reported power adds up to at least
40 Wh, the meter has gained at least 50 % of that, less 15 Wh (the meter shows
10 Wh steps, so at 40 Wh it must show one step; an honest car can fall one step
short and still passes). Readings are kept 180 s. A gap, a state other than C or
a meter that goes back starts the history again. With no such stretch yet (a
session just began, or the add-on just started) the figure is believed, so a
charge does not raise false alarms for its first minute; a frozen figure is
believed for that long only. No energy entity: never corroborated, so the normal
alarms stand. **Bound:** a frozen figure of P watts on a car that has really
stopped is caught within max(60 s, 40 Wh / P): 60 s from 2.4 kW up, 104 s at
1.38 kW (6 A, 1 phase, the lowest charge), plus the alarms' own 10 s hold. Below
about 0.8 kW (40 Wh over the 180 s kept) the figure is believed; it cannot hide
an overload that matters. (Round 2 had a 15 Wh slack that cancelled the 50 % rule
up to 1.8 kW; the 40 Wh floor fixes that.)
## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3)
- **The car is the cause when the alarm's own test says so** (EV-10).
`car_cycle` (`_car_explains_alarm`) grades the alarm's test on the period as it
is and on the period without the car's fresh, corroborated average
(`car_exclude`): the car explains the alarm only if the test is true with it
and false without it. The test is the alarm's own landing (`_car_grade`: the
batteries give only what they still can, `load_too_high` for a saturated guard
and for a floor with other batteries, `misses_aim` for a floor with none), not
the plain projection, which still counts the batteries' help. So the car alone
taking the batteries to the reserve is silent (rig: 5888 W against 6000 W),
while a house-caused drain with a small car still alarms. No minimum car power
is needed: a car that changes nothing cannot flip the test. A stale, stuck or
uncorroborated figure is `None` and the normal alarms stand.
- **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter
became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so
the test crossed the aim every few seconds. `car_over` (row, card, notice) now
stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (longer than
the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a
quarter) and a gap does not restart the 10 s
on-count. `car_explains`, which the alarms read, has no hold.
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
own detector opens before the write and runs 15 s from when it returns, because
the read-back reaches the cycle while the write still waits for it.
## The one write shadow mode allows
When the add-on has paused the car (0 A) for a phase change and has not yet
selected the phases, Off, a stop of control, a safety latch or shadow mode ends
the change. The old current is given back (clamped, `_restore_a`) in every one of
those cases, shadow mode included. With the shipped `shadow_mode: auto`, stopping
control turns shadow on, so without this the car would stay at 0 A for as long
as control is stopped, while the design's Manual column says the current
stands. Undoing our own half-done change is not a new command; it is the same
write the shutdown restore makes. Nothing else is written in shadow mode: no
phase switch, and no write afterwards.
## Decision 1 (`ev_batt_cover`)
On (the default): the guard works as it does and the batteries cover the car down
to the peak reserve. Off: the projection the guard sees leaves the car out
(`house - car_w`, with the car's average so far), so it does not force the
batteries to discharge for it, and the period goes over by the car alone. The
car is never throttled either way. The projection the guard sees is also the
one `charge_room_w` reads, so with the switch off a grid charge of the batteries
sees the room the car leaves; that is the owner's trade and DOCS says so.
## Deviations from the design text
- **Titles and setting names** follow STYLE.md (at most 5 and 6 words):
"Car over the peak limit" (the design: "Car charge over the peak limit"),
setting "Batteries help with the peak" (the design: "... while the car
charges", which is in its description).
- **No "or choose Solar"** in the Why or the notice: Solar is not in this card.
- **The Why lines** are two sentences of at most 12 words, as test_messages.py
asks; `peak.car` says "The car takes {car} and the batteries cover {cov}."
without "of it".
- **`peak.set_by_car`** keeps its first sentence only ("The batteries were at the
peak reserve" is not true with decision 1 off). A quarter counts as set by the
car when the car drew half the peak or more over it.
+88 -22
View File
@@ -251,10 +251,12 @@ The label and description each setting shows on the Configuration tab, in tab or
| Safety | Opposing inverters time (s) | `circulation_hold_s` | For two or more inverters: how long they may push against each other before a safety stop. Derived value, leave it unchanged. |
| Safety | Not delivering alarm after (s) | `delivery_hold_s` | For two or more inverters: how long one may fall short of its share before an alarm, which changes nothing. Derived value, leave it unchanged. |
| Safety | Shadow mode | `shadow_mode` | The add-on makes every decision but keeps every inverter at 0 W. 'auto' does this while control is stopped, 'on' always, 'off' never. |
| Car charger | Charger | `ev_charger` | Which car charger the add-on reads. Off leaves everything as it is. This version only reads the charger and never changes it. |
| Car charger | Charger | `ev_charger` | Which car charger the add-on drives. Off leaves everything as it is. In Off mode the add-on only reads the charger and never changes it. |
| Car charger | Current setting entity | `ev_current_entity` | The entity that sets the charger's current. The add-on finds the charger's other entities from its name. |
| Car charger | Charger limit (A) | `ev_max_a` | The most current the charger may ever be asked for. Never above what the charger reports. Lower it for a weaker fuse or cable. |
| Car charger | Phases | `ev_phases` | How many phases the charger may use: 1, 3, or 1 and 3 (auto). |
| Car charger | Batteries help with the peak | `ev_batt_cover` | While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak. |
| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. A restart never changes the charger's current. |
| Advanced | Start control on boot | `auto_start` | Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart. |
| Advanced | Control gain | `gain` | How much of the remaining error control corrects each cycle. Measured on real hardware, do not raise it. |
| Advanced | Largest change per cycle (W) | `slew_w` | How far the command may move in one cycle. 0 follows “Inverter rating” and is recommended. |
@@ -3275,9 +3277,10 @@ it.
### Car charger
The add-on can read your car charger and show it on **Home**, on a *Car* card. In
this version it only reads. It never changes the charger, so it is safe to run
beside your own automation. Later versions will add charging modes.
The add-on can drive your car charger and shows it on **Home**, on a *Car* card.
The card has two modes in this version: **Off** (the add-on only reads the
charger and writes nothing) and **Manual** (the add-on sets the current and the
phases you choose). Solar and Night modes come in later versions.
| option | meaning |
|---|---|
@@ -3285,44 +3288,98 @@ beside your own automation. Later versions will add charging modes.
| `ev_current_entity` | The charger's current setting, for example `number.wallbox_power_connector_max_current_socket_1`. The add-on finds the charger's other entities from this name. |
| `ev_max_a` | The most current the charger may ever be asked for. It cannot be higher than the station limit the charger reports. |
| `ev_phases` | `1`, `3` or `auto` (1 and 3). |
| `ev_batt_cover` | On (the default): the batteries help cover the car down to the peak reserve. Off: the car is left out of what the peak guard protects. |
| `ev_mode_start` | `keep` (the default) or `off`: the mode after a restart. |
**What the Car card shows.** The state (Charging, Connected waiting, No car
connected, Car is full, Charger not reachable), the power and current, and the
energy charged today. The car's power is taken out of the **House** tile and out
of the house profile that plans the batteries' night charge, so the batteries
no longer buy energy for a car that charged last night. The peak limit works as
before: the car is still part of what the grid meter sees.
no longer buy energy for a car that charged last night.
**Manual mode.** Choose *Manual* on Home, then set the current (6 A up to the
charger limit) and 1 or 3 phases. The same three are Home Assistant entities
when MQTT is on: `select.goodwe_car_mode` (Off, Manual), `number.goodwe_car_current`
and `select.goodwe_car_phases`. The mode, the current and the phases apply at
once, with no restart. The add-on writes each one once, when you change it, and
checks within 10 seconds that the charger took it.
- The current is never higher than the smallest of the charger limit, the station
limit the charger reports and the charger's own range. A value above that is a
software fault: it is logged and never sent.
- With no car connected, or a full car, nothing is written. The setting waits
until a car is connected.
- A phase change always goes through the same steps: 0 A, wait until the
charger draws under 100 W (at most 20 seconds), select the phases, wait 10
seconds, set the current again. At most one phase change per 10 minutes.
- Shadow mode keeps the charger alone, as it keeps the inverters alone: the card
says what the add-on *would* set. Nothing is written either while control is
stopped.
- A restart, stopping control and a safety stop leave the charger at its
current. When the charger answers again after being away, the add-on sets your
current again only if the charger shows a different one.
- Off writes nothing, ever.
**The car is never slowed for the peak limit.** A Manual charge goes on whatever
the 15-minute peak does. With the default `ev_batt_cover` on, the batteries help
cover it down to the peak reserve; a 3-phase 16 A charge (11 kW) can empty two
batteries to the reserve in about 1.5 hours, and the month's peak then rises by
what the car drew. When the car alone is why the batteries cannot hold the
period, the add-on does **not** raise *Battery stopped limiting the peak* or
*Load too high for battery*. It shows a grey note *Car over the peak
limit* once per charging session, a grey row, and says so in the car's *Why*.
This holds only while the car's reading is fresh and the charger's energy
meter confirms it (the meter must have gained at least half of what the power
adds up to over the last minute). A stale, stuck or frozen reading, or a
charger with no energy entity, never hides a real overload of the house: the
normal alarms stand. With `ev_batt_cover` off, the peak
guard protects the house without the car, so it does not spend the batteries on
it. Normal zero-grid control can still discharge them for the car, and a grid
charge of the batteries can bring the period to the peak limit plus the car.
The period can go over by the car alone. When the month's peak was set by a car
charge, Home's peak line says so.
**When the charger does not answer.** After 30 seconds the card says *Charger
not reachable* and one amber row appears. After 5 minutes one notification
follows. While the car reading is older than 15 seconds the House tile shows no
reading, and that moment is left out of the house profile, rather than guessing
how much the car took.
how much the car took. A reading that does not move for a minute after the
add-on changed the current shows the amber row *Charger reading may be stuck*;
the add-on goes on writing. If the charger does not take a phase change three
times, an amber row says so and the add-on stops trying until you change
something; the car gets its current back each time.
**Another controller.** If the charger's current changes while the add-on writes
nothing, something else sets it, usually your own automation. The page then shows
the grey row *Another controller changes the charger*. That is expected while
you migrate.
**Another writer.** In Manual, if the charger shows a different current than the
add-on set, for 30 seconds, something else is setting it, usually your own
automation. The page shows a grey row, and the add-on writes nothing over it until
you change the mode or a value. In Off the grey row *Something else changes the
charger* shows for an hour after a change. That is expected while you migrate.
**Moving your own automation to the add-on.** Each step can be undone.
1. Install this version and set `ev_charger` to `alfen_ha`. The add-on reads the
charger and writes nothing. Compare the card with your automation for a few
days.
2. When a later version adds charging modes, switch your automation **off**
(do not delete it) in the evening with the car unplugged, then choose the
add-on's Manual mode with the current your helper held. Plug in and check the
current on the card and on the charger's display.
1. Install this version and set `ev_charger` to `alfen_ha`. The mode starts in
**Off**: the add-on reads the charger and writes nothing. Compare the card
with your automation for a few days.
2. Cut-over, in the evening with the car unplugged: in Home Assistant switch your
automation **off** (do not delete it). On the card choose **Manual** with the
current your helper held (`input_number.ev_manual_current`). Plug in and check
the current on the card and on the charger's display.
3. On the next sunny day, choose Solar, with *spare sun goes first to* set as
your priority switch was.
your priority switch was. (Solar comes in a later version; until then keep
Manual or Off.)
4. Keep your Home Assistant helpers for a week. To go back, set the add-on mode
to Off and switch the automation on. After that you can delete the helpers and
the automation.
Never let the automation and the add-on both write the charger.
**Never let the automation and the add-on both write the charger.** Two writers
fight over the one setting and neither can tell which won. Turn the automation
off before you choose Manual, and the add-on off (mode Off) before you turn the
automation on.
**Home Assistant entities.** With MQTT the add-on adds three sensors:
`goodwe_car_power`, `goodwe_car_state` and `goodwe_car_today_kwh`.
**Home Assistant entities.** With MQTT the add-on adds the sensors
`goodwe_car_power`, `goodwe_car_state` and `goodwe_car_today_kwh`, and the three
controls named above. A saved ("retained") command is never applied, so a
restart of Home Assistant cannot change the charger.
### Site
@@ -3451,6 +3508,14 @@ last setting. The add-on changes nothing on the charger in any case. Check the
charger's integration in Home Assistant. The notification goes by itself when
the charger answers again.
### Car over the peak limit
The car charge you set (Manual) takes the 15-minute period over the peak limit,
and the batteries cannot hold it because they are at the peak reserve or at
their full power. The add-on never slows the car, so this is information, not an
alarm. It is raised once per charging session. To stay under the limit, lower the
current.
### For installers: notifications
A fixed tariff beside the price service raises no notification: it is the
@@ -3478,6 +3543,7 @@ default `info` hides it.
| Battery cycle did not finish | warning | `goodwe_maint_failed_<name>` | MAINT-13 |
| No prices | warning | `goodwe_no_prices` | PRICE-01 |
| Charger not reachable | warning | `goodwe_charger_unreachable` | EV-03 |
| Car over the peak limit | info | `goodwe_car_over` | EV-04 |
**The Details link.** Home Assistant 2026.2 and newer show add-on pages at
`/config/app/<slug>/documentation`; 2026.5 removed the old
+367
View File
@@ -0,0 +1,367 @@
"""EV-04: the car charger's Manual mode, the one place the add-on WRITES to it.
Pure but for the driver it is handed: no clock of its own (`now` is monotonic
seconds from the caller), no Home Assistant, no store. DECISIONS/EV-04-manual-
mode.md has the record; the design is reports/EV-01-design-report.md sections
2, 3 and 4.
THE RULES, each tested in test_ev04.py:
* Off writes NOTHING. Manual writes the current (6 A to the clamp) and the
phases (1 or 3), each ONCE PER USER CHANGE, and only with a car connected
and not full: with no car, or a full one, the current stands and the write
waits for the car.
* Every current is clamped to `min(ev_max_a, the station limit the charger
reports, the entity's own range)`. The driver refuses anything above it; this
module never asks for more.
* Phases change only through the SAFE SEQUENCE: 0 A, wait until the charger
reports under `QUIET_W` or mode3 leaves C (at most `ZERO_WAIT_S`), select the
phases, wait `SETTLE_S`, write the current again. At most one switch per
`PHASE_GAP_S`. A sequence that has begun is always finished, because it
leaves the car at 0 A otherwise.
* A read-back that differs from the add-on's own last write for `WRITER_S` is
ANOTHER WRITER: an info row, and no write over it until the user changes the
mode or a value again.
* A charger that comes back after being unavailable gets the setting again only
if its read-back differs.
"""
from __future__ import annotations
import logging
from . import chargers as CH
_LOG = logging.getLogger("goodwe")
OFF, MANUAL = "off", "manual"
#: the modes this card offers. Solar and Night are later cards (EV-05, EV-02).
MODES = (OFF, MANUAL)
#: Home Assistant's select labels, English and pinned.
MODE_LABELS = {OFF: "Off", MANUAL: "Manual"}
START_KEEP, START_OFF = "keep", "off"
KEY_MODE, KEY_A, KEY_PHASES = "car_mode", "car_current", "car_phases"
DEFAULT_A = 6.0
DEFAULT_PHASES = 1
QUIET_W = 100.0 # "paused": under this, or mode3 has left C
ZERO_WAIT_S = 20.0 # at most this long for the car to stop drawing
SETTLE_S = 10.0 # after the phases select, before the current
PHASE_GAP_S = 600.0 # at most one phase switch per this
WRITER_S = 30.0 # a differing read-back this long is another writer
RETRY_S = 60.0 # a write the charger did not take, tried again after
MAX_TRIES = 3 # ... this many times, then it waits for the user
TOL_A = CH.TOOK_TOL_A
def allowed_phases(opts: dict) -> tuple:
"""The phase counts the user may pick: the `ev_phases` setting says what
the installation allows (`auto` is 1 and 3)."""
v = str((opts or {}).get("ev_phases", CH.EV_OPTION_DEFAULTS["ev_phases"]))
return (1,) if v == "1" else (3,) if v == "3" else (1, 3)
def start_mode(opts: dict, stored) -> str:
"""The mode after a restart: the stored one (`keep`), or Off."""
if str((opts or {}).get("ev_mode_start")
or CH.EV_OPTION_DEFAULTS["ev_mode_start"]) == START_OFF:
return OFF
return stored if stored in MODES else OFF
def clamp_for(opts: dict, reading) -> float | None:
"""The most a write may ask for, from the options and the last reading:
`min(ev_max_a, the station limit, 40 A)`. None when the limit setting is
not a number. (The driver reads the entity's own range as well.)"""
amps = CH.max_a(opts)
if amps is None:
return None
lim = [amps, CH.ENTITY_MAX_A]
st = getattr(reading, "station_a", None)
if st is not None:
lim.append(float(st))
return min(lim)
def value_a(raw, clamp: float | None):
"""A current the user asked for, as a whole number of amps inside
`[6, clamp]`, or None when it is not a number. Above the clamp is the
clamp: the user's value never reaches the driver bigger than it."""
try:
v = float(raw)
except (TypeError, ValueError):
return None
if v != v:
return None
v = round(v)
hi = CH.ENTITY_MAX_A if clamp is None else max(CH.MIN_A, float(clamp))
return float(min(max(v, CH.MIN_A), hi))
class ManualWriter:
"""What Manual does to the charger, one `step()` per cycle."""
def __init__(self):
self.rev_applied = None # the user's last change we have acted on
self.last_a = None # the last current the charger took from us
self.attempted_a = None # a write it did not take ...
self.prior_a = None # ... and what the charger showed before it
self.mismatch_since = None
self.hold = False # another writer: no write until the user
self.other = False # ... and the info row says so
self.reapply = True # first reading, or the charger came back
self.was_available = False
self.fails = 0
self.fail_at = None
self.gave_up = False
self.seq = None # a phase change under way
self.last_switch = None
self.blocked = False # a phase change waits for PHASE_GAP_S
self.would = None # (amps, phases): what it would set
self.log = [] # (kind, value, now, ok), for the checks
self.last_done = None # when our latest write was confirmed
self._clock = None
self.phase_fails = 0 # phase selects the charger did not take
self.phases_gave_up = False
self.undone = 0 # sequences undone before the select
# ------------------------------------------------------------------ user
def user_changed(self) -> None:
"""The user changed the mode or a value: one more write is allowed,
and another writer's hold is lifted."""
self.rev_applied = None
self.hold = self.other = False
self.mismatch_since = None
self.fails, self.fail_at, self.gave_up = 0, None, False
self.phase_fails, self.phases_gave_up = 0, False
self.attempted_a = self.prior_a = None
# ------------------------------------------------------------------ step
async def step(self, drv, r, *, mode, want_a, want_phases, rev, clamp,
now, tracker, writing, status, shadow=False, clock=None):
"""One cycle. `r` is the latest `ChargerReading`; `writing` is False in
shadow mode and while control is stopped (the step then only works out
what it WOULD set, in `self.would`)."""
self._clock = clock or (lambda: now)
if r is None or not r.available:
self.was_available = False
return
# A reading taken before our latest write was confirmed says nothing
# about it (the writer runs beside the cycle and can finish between a
# read and the step that follows): wait for one taken after.
if self.last_done is not None and tracker is not None \
and tracker.obs_at is not None \
and tracker.obs_at <= self.last_done:
return
if not self.was_available:
self.was_available = True
self.reapply = True # on return: only if it differs
cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
if self.seq is not None:
if self.seq["stage"] in ("zero", "select") \
and (mode != MANUAL or not writing):
await self._undo(drv, now, tracker, clamp, shadow)
return
await self._advance(drv, r, cur, now, tracker, want_a, clamp, rev)
return
self.would = None
if mode != MANUAL:
return
if clamp is None or clamp < CH.MIN_A:
return
n_eff = want_phases if want_phases in (1, 3) else DEFAULT_PHASES
target = min(max(float(want_a), CH.MIN_A), float(clamp))
self.would = (target, n_eff)
# No car, or a full one: the current stands, nothing is written. The
# setting waits (rev stays unapplied) until a car is there.
if r.state == "A" or status in (CH.NONE_, CH.FULL):
self.mismatch_since = None
return
if not writing:
return
self._watch(cur, now)
if self.hold:
return
phases_need = (r.phases_allowed is not None
and r.phases_allowed != n_eff
and not self.phases_gave_up)
cur_need = cur is None or abs(cur - target) > TOL_A
need_user = rev != self.rev_applied
if not (phases_need or cur_need):
self.rev_applied, self.reapply = rev, False
self.fails, self.blocked = 0, False
if cur is not None:
self.last_a = cur # adopt what is already set
return
if not (need_user or self.reapply):
return # a difference nobody asked for: `_watch()` judges
if self.gave_up or (self.fail_at is not None
and now - self.fail_at < RETRY_S):
return
if phases_need:
if self.last_switch is not None \
and now - self.last_switch < PHASE_GAP_S:
self.blocked = True
else:
self.blocked = False
await self._begin(drv, r, cur, n_eff, now, tracker)
return
if cur_need:
ok = await self._write(drv, target, cur, now, tracker)
if not ok:
self._failed(now)
return
self.fails, self.fail_at = 0, None
if not phases_need:
self.rev_applied, self.reapply = rev, False
# ------------------------------------------------------------- internals
def _failed(self, now) -> None:
self.fails += 1
self.fail_at = now
if self.fails >= MAX_TRIES:
self.gave_up = True
_LOG.warning("The charger did not take the current, so the add-on "
"stops asking until you change it: CHARGER_REFUSED.")
_LOG.debug("The charger refused the current %d times.", self.fails)
def _watch(self, cur, now) -> None:
"""Is the read-back what we wrote? A difference that stands for
`WRITER_S` is another writer."""
known = [x for x in (self.last_a, self.attempted_a, self.prior_a)
if x is not None]
if not known or cur is None:
self.mismatch_since = None
return
if any(abs(cur - k) <= TOL_A for k in known):
self.mismatch_since = None
if self.hold:
self.hold = self.other = False
return
if self.mismatch_since is None:
self.mismatch_since = now
elif now - self.mismatch_since >= WRITER_S and not self.hold:
self.hold = self.other = True
_LOG.info("Something else changes the charger (read-back %.0f A, "
"the add-on set %.0f A), so the add-on stops writing "
"to it until you change it.", cur, known[0])
async def _write(self, drv, a, was, now, tracker) -> bool:
tracker.begin_write() # EV-12: the read-back is ours
try:
ok = await drv.write_current(a)
finally:
self._stamp(now)
tracker.end_write(self.last_done)
tracker.note_write(now, was, a)
tracker.end_write(self.last_done)
self.log.append(("current", a, now, ok))
if ok:
self.last_a = a
self.attempted_a = self.prior_a = None
else:
self.attempted_a, self.prior_a = a, was
return ok
def _stamp(self, now) -> None:
self.last_done = (self._clock or (lambda: now))()
@staticmethod
def _restore_a(prev, clamp):
"""The current to give back: what it was, never above the clamp."""
if prev is None:
return None
hi = CH.ENTITY_MAX_A if clamp is None else float(clamp)
a = min(float(prev), hi)
return a if a >= CH.MIN_A else None
async def _undo(self, drv, now, tracker, clamp, shadow) -> None:
"""Off, shadow mode or a stopped control while the car is paused and the
phases have NOT been selected: no switch. The old current comes back
(clamped), in shadow mode too: it undoes the add-on's own half-done
change (as the shutdown restore does) and is the one write shadow mode
allows. Nothing else is written afterwards."""
q, self.seq = self.seq, None
self.undone += 1
self.rev_applied, self.reapply = None, True
a = self._restore_a(q.get("prev"), clamp)
if a is not None:
await self._write(drv, a, 0.0, now, tracker)
async def _begin(self, drv, r, cur, n, now, tracker) -> None:
"""Step 1 of the safe sequence: 0 A. A charger that does not take it
stops the sequence before the phases are touched."""
ok = await self._write(drv, 0.0, cur, now, tracker)
if not ok:
self._failed(now)
return
self.seq = {"stage": "zero", "t0": now, "n": n, "tries": 0,
"prev": cur}
async def abandon(self, drv, now, tracker, clamp=None) -> None:
"""The add-on is stopping in the middle of a phase change: give the car
its current back (a stopped add-on must not leave it at 0 A), clamped
like every write. The phases stay as the select left them."""
q, self.seq = self.seq, None
a = None if q is None else self._restore_a(q.get("prev"), clamp)
if a is not None:
self._clock = self._clock or (lambda: now)
await self._write(drv, a, 0.0, now, tracker)
async def _advance(self, drv, r, cur, now, tracker, want_a, clamp, rev):
q = self.seq
if q["stage"] in ("zero", "select") and cur is not None \
and cur >= CH.MIN_A:
# Something else raised the current while the car was being
# paused. The phases are never selected under that: give up the
# change, and leave the charger to whoever set it until the user
# changes something.
self.seq = None
self.hold = self.other = True
self.last_a = self.attempted_a = self.prior_a = None
_LOG.info("Something else raised the charger's current during a "
"phase change, so the phases were not touched.")
return
if q["stage"] == "zero":
quiet = ((r.power_w is not None and r.power_w < QUIET_W)
or (r.state is not None and r.state != "C"))
if not quiet and now - q["t0"] < ZERO_WAIT_S:
return
q["stage"] = "select"
if q["stage"] == "select":
ok = await drv.write_phases(q["n"])
self._stamp(now)
self.last_switch = now
self.log.append(("phases", q["n"], now, ok))
q["stage"], q["t1"] = "settle", self.last_done # from its return
if not ok:
# The charger did not take it: the car gets its current back
# on the old phases after the same SETTLE_S as a taken select
# (HA may have taken it and only the read-back be late), and
# the change is tried again after PHASE_GAP_S, MAX_TRIES times.
self.phase_fails += 1
if self.phase_fails >= MAX_TRIES:
self.phases_gave_up = True
_LOG.warning("The charger did not take the phases, so the "
"add-on stops trying until you change "
"something: CHARGER_PHASES.")
return
if now - q["t1"] < SETTLE_S:
return
hi = CH.ENTITY_MAX_A if clamp is None else float(clamp)
a = min(max(float(want_a), CH.MIN_A), hi)
if await self._write(drv, a, 0.0, now, tracker):
# Judged afresh next cycle: a value the user changed meanwhile is
# still wanted, and one that is in place is adopted.
self.seq, self.rev_applied, self.reapply = None, None, False
self.fails, self.blocked = 0, False
return
q["tries"] += 1
if q["tries"] >= MAX_TRIES:
# Left at 0 A is the safe side; the next reading re-applies.
self.seq, self.last_a, self.reapply = None, None, True
self._failed(now)
self.rev_applied = None
return
q["t1"] = now - SETTLE_S + 5.0 # again in 5 s
+235 -18
View File
@@ -5,10 +5,12 @@ 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.
THIS CARD NEVER WRITES TO THE CHARGER. `write_current`, `write_phases` and
`release` are defined so the seam is whole, and NOTHING in the controller calls
them: Off is the only mode. test_ev03.py greps the controller for a call and
proves a full cycle makes no service call that names a charger entity.
EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, and only in Manual
(`app/carmode.py` is the one caller). `write_current` is clamped to
`min(ev_max_a, the station limit the charger reports, the entity's own range)`
and a value above that is NEVER SENT: it is a software fault, logged in the
OUTPUT_CLAMP shape. It says True only when the charger's read-back followed
within `TOOK_S`. Off writes nothing (EV-03's no-write test still holds for it).
VALUES ARE BELIEVED ONLY IN THEIR OWN UNIT (as TEL-11 does for power): power in
a power unit, energy in a kWh unit, current in A. A reading in another unit is
@@ -20,12 +22,17 @@ as an argument, so the checks need no sleep.
from __future__ import annotations
import asyncio
import logging
import re
from dataclasses import dataclass
import time
from dataclasses import dataclass, field
from .hass import BAD_STATES
from .solarfc import KWH_PER
_LOG = logging.getLogger("goodwe")
OFF = "off"
ALFEN_HA = "alfen_ha"
#: the `ev_charger` values the options accept
@@ -34,7 +41,8 @@ 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_max_a": 16, "ev_phases": "auto",
"ev_batt_cover": True, "ev_mode_start": "keep"}
def max_a(opts: dict):
@@ -58,6 +66,31 @@ FULL_C_S = 600.0 # mode3 C under FULL_C_W this long: car full
FULL_C_W = 200.0
WRITER_HOLD_S = 3600.0 # "another controller" stays shown this long
IDLE_A = 1.0 # a phase under this draws nothing
TOOK_S = 10.0 # a write is "taken" when the read-back follows by then
TOOK_TOL_A = 0.5 # ... to within this
STUCK_S = 60.0 # EV-04: power and read-back unchanged after a write
STUCK_MIN_A = 1.0 # ... that moved the setpoint by at least this
OWN_WRITE_MUTE_S = 15.0 # the tracker's two-writer detector ignores our own
# Volts used to bound a car figure by what the read-back allows (a physical
# ceiling for the alarm path, never a setpoint).
CEILING_V = 253.0
# EV-04 round 2: the car's power may be used by the peak guard's alarm path only
# while the charger's energy meter CORROBORATES it. Looking back over readings
# (all in mode3 C, no gap) to the shortest stretch that is at least CORR_WINDOW_S
# long AND over which the reported power adds up to at least CORR_MIN_WH, the
# meter must have advanced by at least CORR_RATIO of that, less CORR_SLACK_WH (the
# meter shows 10 Wh steps, so at 40 Wh expected it must show one step). Readings
# are kept for CORR_KEEP_S. Until such a stretch exists (a session just began, or
# the add-on just started) the figure is believed, as it was before. A frozen
# figure of P watts on a car that has really stopped is caught within
# max(CORR_WINDOW_S, CORR_MIN_WH / P) seconds: 60 s at 2.4 kW and up, 104 s at
# 1.38 kW (6 A, 1 phase). Below CORR_MIN_WH over CORR_KEEP_S (about 0.8 kW) the
# figure is believed; it cannot hide an overload that matters.
CORR_WINDOW_S = 60.0
CORR_RATIO = 0.5
CORR_SLACK_WH = 15.0
CORR_MIN_WH = 40.0
CORR_KEEP_S = 180.0
# role -> (entity domain, suffix after `<x>_`). `current` is the setpoint, the
# one the installer names; the rest are derived by swapping its suffix.
@@ -350,7 +383,12 @@ class ChargerDriver:
async def read(self) -> ChargerReading:
raise NotImplementedError
# --- the write side. DEFINED, UNUSED BY THE CONTROLLER IN THIS CARD. ----
# --- the write side (EV-04). `app/carmode.py` is the one caller. ---------
async def clamp_a(self) -> float:
"""The most a write may ask for: `min(ev_max_a, the station limit read
from the charger, the entity's own range max)`."""
raise NotImplementedError
async def write_current(self, a: float) -> bool:
raise NotImplementedError
@@ -376,6 +414,12 @@ class AlfenHaDriver(ChargerDriver):
self._ents = entities_for(self.current_entity)
self._hass = None
self._getter = None
# Seams for the checks: how a write waits for the read-back, and the
# clock it counts on.
self._sleep = asyncio.sleep
self._clock = time.monotonic
self.clamp_faults = [] # (asked, clamp), newest last, for the log
self.sent = [] # every number value actually sent
@classmethod
def from_options(cls, opts: dict) -> "AlfenHaDriver":
@@ -414,7 +458,6 @@ class AlfenHaDriver(ChargerDriver):
return dict(self._ents)
async def _states(self, roles=_ROLE_ORDER) -> dict:
import asyncio
hass = self._h()
got = await asyncio.gather(*(hass.state(self._ents[r]) for r in roles))
return dict(zip(roles, got))
@@ -434,20 +477,84 @@ class AlfenHaDriver(ChargerDriver):
by_ent = {self._ents[r]: o for r, o in st.items()}
return probe_from(self.current_entity, by_ent.get)
# --- the write side, UNUSED in EV-03 --------------------------------------
# --- the write side -------------------------------------------------------
async def clamp_a(self) -> float:
"""`min(ev_max_a, station limit, entity range max)`. A limit the charger
did not answer is not a limit (the other two still bound the write)."""
st = await self._states(("current", "station", "station_active"))
station = _first(_amps(st["station_active"]), _amps(st["station"]))
rng = ENTITY_MAX_A
attrs = (st["current"] or {}).get("attributes") \
if isinstance(st.get("current"), dict) else None
if isinstance(attrs, dict):
try:
rng = min(rng, float(attrs["max"]))
except (KeyError, TypeError, ValueError):
pass
return min(x for x in (self.max_a, station, rng) if x is not None)
async def write_current(self, a: float) -> bool:
a = max(0.0, min(float(a), self.max_a, ENTITY_MAX_A))
return await self._h().set_number(self.current_entity, a)
"""Set the current, once. True only when the charger took it: the
read-back followed within `TOOK_S`. A value above `clamp_a()` is a
SOFTWARE FAULT: nothing is sent, it is logged (the clamp watchdog's
shape) and the answer is False."""
try:
a = float(a)
except (TypeError, ValueError):
a = float("nan")
clamp = await self.clamp_a()
if a != a or a < 0.0 or a > clamp + 1e-9:
self.clamp_faults.append((a, clamp))
del self.clamp_faults[:-20]
_LOG.error("Software fault: the add-on was about to ask the charger "
"for more than its limit, so nothing was sent: "
"CHARGER_CLAMP.")
_LOG.debug("Asked for %.1f A against a limit of %.1f A.", a, clamp)
return False
hass = self._h()
self.sent.append(a)
del self.sent[:-50]
if not await hass.set_number(self.current_entity, a):
return False
return await self._took(a)
async def _took(self, a: float) -> bool:
"""Did the read-back follow the write, within `TOOK_S`?"""
t0 = self._clock()
while True:
st = await self._states(("readback", "current"))
seen = _first(_amps(st["readback"]), _amps(st["current"]))
if seen is not None and abs(seen - a) <= TOOK_TOL_A:
return True
if self._clock() - t0 >= TOOK_S:
return False
await self._sleep(1.0)
async def write_phases(self, n: int) -> bool:
"""Select 1 or 3 phases. ONLY THROUGH `carmode`'s safe sequence: the
setting moves the contactors, so it is touched with the car paused."""
if n not in (1, 3):
return False
return await self._h().call("select", "select_option", {
"entity_id": self._ents["phases_set"],
"option": "1 Phase" if n == 1 else "3 Phases"})
want = "1 Phase" if n == 1 else "3 Phases"
if not await self._h().call("select", "select_option", {
"entity_id": self._ents["phases_set"], "option": want}):
return False
t0 = self._clock()
while True:
st = await self._states(("phases_read", "phases_set"))
seen = _phases(st["phases_read"])
if seen is None:
seen = _phases(st["phases_set"])
if seen == n:
return True
if self._clock() - t0 >= TOOK_S:
return False
await self._sleep(1.0)
async def release(self, mode: str) -> bool:
return await self.write_current(0.0) if mode == "solar" else True
"""The mode's fail state. Manual and Off keep the current (the charger
is a stand-alone device and the current is the user's setting)."""
return True
class UnavailableCharger(ChargerDriver):
@@ -473,6 +580,9 @@ class UnavailableCharger(ChargerDriver):
async def limits(self) -> tuple:
return None, None, None
async def clamp_a(self) -> float:
return 0.0
async def read(self) -> ChargerReading:
return ChargerReading(why=self.why)
@@ -546,6 +656,14 @@ class CarTracker:
c_low_since: float | None = None
writer_at_utc: object = None
_prev: tuple | None = None
# EV-04: our own writes, and the stuck-reading rule (SAFETY-37's shape)
mute_until: float = 0.0
armed_at: float | None = None
armed_sig: tuple | None = None
sig: tuple | None = None
stuck_now: bool = False
obs_at: float | None = None # monotonic second of the latest reading
_hist: list = field(default_factory=list) # (t, power W, energy Wh)
# today's energy
day: str | None = None
today_kwh: float | None = None
@@ -554,6 +672,8 @@ class CarTracker:
def observe(self, r: ChargerReading, now: float, now_utc, day: str):
self.reading = r
self.obs_at = now
self._corr_note(r, now)
usable = r.available and r.power_w is not None
if r.available:
self.bad_since = None
@@ -564,7 +684,8 @@ class CarTracker:
self.last_ok = now
self.last_good, self.last_good_utc = r, now_utc
if r.available:
self._writer(r, now_utc)
self._sig(r, now)
self._writer(r, now_utc, now)
self._energy(r, day)
self._timers(r, now)
self._status_edge(now, now_utc)
@@ -594,11 +715,107 @@ class CarTracker:
except (TypeError, ValueError):
return None
# -- EV-04: the stuck-reading rule -------------------------------------------
def begin_write(self) -> None:
"""EV-12: a write of ours is in flight. Its read-back can reach the
tracker before `note_write` runs (the write waits for it), so the mute
is open until `end_write`."""
self.mute_until = float("inf")
def end_write(self, now: float) -> None:
"""EV-12: the write returned (or failed). The mute runs
`OWN_WRITE_MUTE_S` from now, not from before the write."""
self.mute_until = now + OWN_WRITE_MUTE_S
def note_write(self, now: float, was_a, to_a) -> None:
"""The add-on wrote the current. Its own change is not "another
writer" for `OWN_WRITE_MUTE_S`, and a write that moved the setpoint by
`STUCK_MIN_A` or more arms the stuck check: power and read-back that
have not changed `STUCK_S` later are a stuck reading, not a car."""
self.mute_until = now + OWN_WRITE_MUTE_S
try:
moved = was_a is None or abs(float(to_a) - float(was_a)) \
>= STUCK_MIN_A
except (TypeError, ValueError):
moved = False
if moved and self.armed_at is None:
self.armed_at, self.armed_sig = now, self.sig
def _sig(self, r, now: float) -> None:
sig = (r.power_w, r.allowed_a)
if self.armed_at is not None and self.armed_sig is not None \
and sig != self.armed_sig:
self.armed_at = self.armed_sig = None # it moved: alive
self.stuck_now = False
elif self.armed_at is not None and self.armed_sig is None:
self.armed_sig = sig
self.sig = sig
if self.armed_at is not None and now - self.armed_at >= STUCK_S:
self.stuck_now = True
def _corr_note(self, r, now: float) -> None:
"""Keep the last `CORR_WINDOW_S` of (power, energy) while the charger is
charging. Any gap, a car that is not in mode3 C, a reading without
power or energy, or a meter that goes back starts the window again."""
h = self._hist
ok = (r.available and r.charging is True and r.power_w is not None
and r.energy_kwh is not None)
if not ok or (h and r.energy_kwh * 1000.0 < h[-1][2] - 0.5):
h.clear()
if not ok:
return
h.append((now, float(r.power_w), r.energy_kwh * 1000.0))
while len(h) > 2 and now - h[1][0] >= CORR_KEEP_S:
h.pop(0)
def corroborated(self, now: float) -> bool:
"""Does the charger's energy meter agree with the power it reports? No
energy entity, or not charging: no. Less than a window of readings: yes
(the first minute of a session is believed). Otherwise the energy the
meter gained over the window must be at least `CORR_RATIO` of what the
power adds up to, less `CORR_SLACK_WH`. A frozen power figure on a car
that has stopped fails this within a window, and so does everything
frozen together."""
r = self.reading
h = self._hist
if r is None or not r.available or r.charging is not True \
or r.energy_kwh is None or not h:
return False
exp_wh = 0.0
for k in range(len(h) - 1, 0, -1):
(t0, p0, e0), (t1, _p1, _e1) = h[k - 1], h[k]
exp_wh += p0 * (t1 - t0) / 3600.0
if h[-1][0] - t0 >= CORR_WINDOW_S - 5.0 and exp_wh >= CORR_MIN_WH:
got_wh = h[-1][2] - e0
return got_wh >= CORR_RATIO * exp_wh - CORR_SLACK_WH
return True
def stuck(self, now: float) -> bool:
"""Power and read-back unchanged `STUCK_S` after a write that moved the
setpoint. Cleared the moment either moves."""
return self.stuck_now
def car_w_trusted(self, now: float):
"""The car's power for the peak guard's ALARM PATH, or None. Fresh (the
EV-03 rules), not stuck after a write, corroborated by the energy meter
(`corroborated`), and never above what the read-back allows the car to
draw: an old or frozen figure must not hide a house overload."""
w = self.car_w(now)
if w is None or self.stuck(now) or not self.corroborated(now):
return None
r = self.reading
a = r.allowed_a if r.allowed_a is not None else r.setpoint_a
if a is not None:
n = r.phases_allowed if r.phases_allowed in (1, 3) else 3
w = min(w, max(0.0, float(a)) * CEILING_V * n)
return w
# -- the two-writer detector ----------------------------------------------
def _writer(self, r, now_utc):
def _writer(self, r, now_utc, now=None):
cur = (r.setpoint_a, r.allowed_a)
prev = self._prev
if prev is not None:
muted = now is not None and now < self.mute_until
if prev is not None and not muted:
for a, b in zip(prev, cur):
if a is not None and b is not None and a != b:
self.writer_at_utc = now_utc
+5 -1
View File
@@ -233,6 +233,9 @@ class AlarmsMixin:
# persistent overload is still notified once per quarter.
high = bool(
g is not None and g.saturated and p is not None
# EV-04: not when the car you set explains the excess (a fresh,
# trusted car reading only; `ctl_car.car_cycle`).
and not getattr(self, "car_explains", False)
and p.block_start is not None and not self._peak_rolled
and peakguard.load_too_high(
p, batt_w=batt, ceiling_w=g.ceiling_w,
@@ -276,7 +279,8 @@ class AlarmsMixin:
the floor binds this guard only; the loop has no SoC floor and goes on
discharging. Edge-triggered. (DECISIONS/MAIN-orchestration-archive.md)"""
g = self.peak_guard
limited = bool(g is not None and g.floor_limited)
limited = bool(g is not None and g.floor_limited
and not getattr(self, "car_explains", False))
if limited and (g.floor_w or 0.0) > 0.0:
limited = self._reserve_short(g)
else:
+365
View File
@@ -0,0 +1,365 @@
"""EV-04: the Controller's side of the car's Manual mode.
The writes themselves are `carmode.ManualWriter`'s; this mixin owns the state
(mode, current, phases: runtime state in the store, like OPT-11's modes), the
actions, the background step that never holds up a control cycle, and what the
car means for the peak guard's ALARM PATH. DECISIONS/EV-04-manual-mode.md.
"""
import asyncio
import dataclasses
import logging
from datetime import timezone
from . import carmode, chargers, messages, peakguard
from .tariff import QUARTER_S
_LOG = logging.getLogger("goodwe")
CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W}
CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept
CAR_PEAK_KEEP = 3200 # about a month of quarters
OVER_HOLD_S = peakguard.ALARM_HOLD_S
# EV-11: the card, the row and Why stay on this long after the car stops being
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
# sampling) and shorter than a quarter, or until the session really ends.
OVER_OFF_HOLD_S = 180.0
class CarMixin:
# ------------------------------------------------------------------ state
def car_init(self, opts, store) -> None:
"""Mode, current and phases from the store; `ev_mode_start` says what a
restart does with the mode. A site with no charger keeps defaults and
writes nothing."""
data = getattr(store, "data", None) or {}
self.car_mode = carmode.start_mode(opts, data.get(carmode.KEY_MODE))
if carmode.start_mode(opts, carmode.MANUAL) == carmode.OFF \
and data.get(carmode.KEY_MODE) not in (None, carmode.OFF):
store.set(carmode.KEY_MODE, carmode.OFF)
clamp = carmode.clamp_for(opts, None)
a = carmode.value_a(data.get(carmode.KEY_A, carmode.DEFAULT_A), clamp)
self.car_a = carmode.DEFAULT_A if a is None else a
n = data.get(carmode.KEY_PHASES, carmode.DEFAULT_PHASES)
ok = carmode.allowed_phases(opts)
self.car_n = n if n in ok else ok[0]
self.car_rev = 0
self.car_writer = carmode.ManualWriter()
self._car_task = None
self._car_step_failed = False
self.car_explains = False # the car alone explains the excess
self.car_over = False # ... held: the card and row say so
self._car_over_since = None
self._car_over_gone = None
self._car_batt_prev = None
self._car_needed = False # EV-10: SAFETY-126's latch without the car
self._car_over_notified = None # the session a notice was raised for
self._car_session = 0
self._car_prev_state = None
self._carq = {"key": None, "ws": 0.0, "mono": None}
self._peak_proj_real = None
saved = data.get(CAR_PEAK_KEY)
self.car_peak_q = dict(saved) if isinstance(saved, dict) else {}
@property
def car_cover(self) -> bool:
"""Decision 1: do the batteries help cover the car down to the peak
reserve? Default yes."""
v = self.o.get("ev_batt_cover")
return bool(chargers.EV_OPTION_DEFAULTS["ev_batt_cover"]
if v is None else v)
def car_manual(self) -> bool:
return (self.charger.configured()
and self.car_mode == carmode.MANUAL)
def car_clamp(self):
return carmode.clamp_for(self.o, self.car.reading)
def car_writing(self) -> bool:
"""May the add-on write to the charger now? Control runs, shadow mode is
off, no safety stop is latched and the add-on is not shutting down. Shadow mode gates charger
writes exactly as it gates inverter writes."""
latched = (any(i.sign_wd.tripped for i in self.inverters)
or self.site_sign_wd.tripped or self.circ_wd.tripped)
return bool(self.auto and not self.shadow and not latched
and not getattr(self, "stopping", False))
# ---------------------------------------------------------------- actions
def _car_action(self, what, value, now) -> dict:
"""The mode, the current or the phases, from the page or from Home
Assistant. Store state, applied by the next step with no restart."""
if not self.charger.configured():
return {"error": messages.car_refused("off")}
if what == "car_mode":
if value not in carmode.MODES:
return {"error": messages.car_refused("value")}
self.car_mode = value
self.store.set(carmode.KEY_MODE, value)
elif what == "car_current":
clamp = self.car_clamp()
if isinstance(value, bool):
return {"error": messages.car_refused("value")}
a = carmode.value_a(value, clamp)
try:
inside = a is not None and abs(float(value) - a) < 0.5
except (TypeError, ValueError):
inside = False
if not inside:
return {"error": messages.car_refused("value")}
self.car_a = a
self.store.set(carmode.KEY_A, a)
else:
if value not in (1, 3) or isinstance(value, bool):
return {"error": messages.car_refused("value")}
if value not in carmode.allowed_phases(self.o):
return {"error": messages.car_refused("phases")}
self.car_n = value
self.store.set(carmode.KEY_PHASES, value)
self.car_rev += 1
self.car_writer.user_changed()
self.log_event(f"car {what[4:]} set to {value} by operator",
hint=messages.hint(what))
return {"mode": self.car_mode, "current": self.car_a,
"phases": self.car_n}
def car_command_values(self) -> dict:
"""The MQTT state of the three car entities."""
return {"car_mode": carmode.MODE_LABELS[self.car_mode],
"car_current": round(self.car_a),
"car_phases": str(self.car_n)}
# ------------------------------------------------------------- the writer
def car_kick(self) -> None:
"""Start one writer step in the background, unless one is running. A
write waits up to 10 s for the charger's read-back, and a control cycle
never waits for the charger."""
if not self.charger.configured():
return
t = self._car_task
if t is not None and not t.done():
return
self._car_task = asyncio.ensure_future(self._car_run())
async def car_settle(self) -> None:
"""Wait for the writer step in flight (the checks use it)."""
t = self._car_task
if t is not None:
await asyncio.gather(t, return_exceptions=True)
async def _car_run(self) -> None:
try:
await self.car_step()
except asyncio.CancelledError:
raise
except Exception: # noqa: BLE001
# Once at WARNING-and-above, then quietly: a step that fails
# fails every second.
if not self._car_step_failed:
self._car_step_failed = True
_LOG.exception("The car charger step failed")
else:
_LOG.debug("The car charger step failed again", exc_info=True)
else:
self._car_step_failed = False
async def car_shutdown(self) -> None:
"""The add-on stops: no new write, and a phase change in the middle is
undone by giving the car its current back. The current stands
otherwise (Manual's fail state)."""
t, self._car_task = getattr(self, "_car_task", None), None
if t is not None and not t.done():
t.cancel()
await asyncio.gather(t, return_exceptions=True)
if not self.charger.configured() \
or getattr(self, "car_writer", None) is None \
or self.car_writer.seq is None:
return
try:
await asyncio.wait_for(self.car_writer.abandon(
self.charger, self.car_now(), self.car, self.car_clamp()),
15.0)
except Exception: # noqa: BLE001
_LOG.warning("The car could not be given its current back "
"before the add-on stopped: CHARGER_RESTORE.")
async def car_step(self) -> None:
"""One step of Manual. Reads nothing from the world (the cycle's read
did) and writes only through `carmode.ManualWriter`."""
if not self.charger.configured():
return
now = self.car_now()
await self.car_writer.step(
self.charger, self.car.reading, mode=self.car_mode,
want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
clamp=self.car_clamp(), now=now, tracker=self.car,
writing=self.car_writing(), shadow=bool(self.shadow),
status=self.car.status(now, True), clock=self.car_now)
# ------------------------------------------- the car and the peak guard
def car_alarm_w(self):
"""The car's power for the guard's alarm path: Manual only, fresh, not
stuck (`CarTracker.car_w_trusted`), and never above what the read-back
allows. None otherwise, and then the normal alarms stand."""
if not self.car_manual():
return None
return self.car.car_w_trusted(self.car_now())
def _car_quarter(self, proj, w, mono) -> None:
"""The car's energy in the open quarter, for the average the guard's
house leaves out and for the peak line."""
q = self._carq
key = None if proj is None else proj.block_start
last = q["mono"]
if key != q["key"]:
self._car_bank(q)
q["key"], q["ws"] = key, 0.0
if key is not None and w is not None and last is not None:
q["ws"] += float(w) * min(max(mono - last, 0.0), 5.0)
q["mono"] = mono
def _car_bank(self, q) -> None:
"""A closed quarter in which the car drew its share goes on the list."""
key = q["key"]
if key is None:
return
avg = q["ws"] / QUARTER_S
if avg < CAR_PEAK_MIN_W:
return
self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg)
if len(self.car_peak_q) > CAR_PEAK_KEEP:
for k in sorted(self.car_peak_q)[:-CAR_PEAK_KEEP]:
del self.car_peak_q[k]
self.store.set(CAR_PEAK_KEY, dict(self.car_peak_q))
def car_avg_w(self, proj, w) -> float:
"""The car's average over the whole open quarter: what it drew so far
and `w` for the rest."""
if proj is None or w is None:
return 0.0
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
so_far = self._carq["ws"] if self._carq["key"] == proj.block_start \
else 0.0
return (so_far + float(w) * left) / QUARTER_S
def car_exclude(self, proj, w):
"""Decision 1 off: the projection the guard sees without the car
(`house - car_w`). Unchanged without a fresh car reading."""
if proj is None or w is None or proj.block_start is None:
return proj
avg = self.car_avg_w(proj, w)
return dataclasses.replace(
proj, projected_w=max(0.0, float(proj.projected_w) - avg),
held_w=max(0.0, float(proj.held_w) - float(w)))
def car_cycle(self, real_proj, guard, target_w, now_utc) -> None:
"""After the guard has decided: does the car alone explain the excess?
`real_proj` is the projection WITH the car, whatever the guard saw."""
mono = self.car_now()
w = self.car_alarm_w()
self._car_quarter(real_proj, w, mono)
self._car_session_tick(mono)
explains = over = False
if real_proj is not None and target_w is not None \
and real_proj.block_start is not None:
if self.car_cover:
# EV-10: the car explains the ALARM (`_car_explains_alarm`).
explains = self._car_explains_alarm(real_proj, guard,
target_w, w)
over = explains
elif w is not None:
ex = float(real_proj.projected_w) - float(target_w)
over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
self.car_explains = explains
# EV-11: on once the condition has stood for OVER_HOLD_S, a short gap
# in it not starting that count again; off only after it has been gone
# for OVER_OFF_HOLD_S. `car_explains` (the alarm decision) has no hold.
if over:
self._car_over_gone = None
if self._car_over_since is None:
self._car_over_since = mono
if mono - self._car_over_since >= OVER_HOLD_S:
self.car_over = True
else:
if self._car_over_gone is None:
self._car_over_gone = mono
if mono - self._car_over_gone >= OVER_OFF_HOLD_S:
self.car_over, self._car_over_since = False, None
self._car_over_gone = None
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
"""EV-10: is the alarm's own test true with the car and false without
its fresh, corroborated share (`car_exclude`)? The tests are the
alarms': a saturated guard and a floor with other batteries left are
graded by `load_too_high` on where the period lands (SAFETY-81 / 87); a
floor that leaves nothing is graded by `within_aim`, which SAFETY-126
latches for the quarter once the batteries at 0 W would miss the aim.
`_car_needed` is that latch on the period without the car; an
untrusted car figure (`w` None) sets it, so nothing is explained."""
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 not wants:
self._car_needed = False
if batt is not None and prev is not None:
batt = min(float(batt), float(prev))
excl = self.car_exclude(real_proj, w)
if wants:
self._car_needed = self._car_needed or w is None or batt is None \
or peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
if w is None or batt is None or not wants \
or not (guard.saturated or guard.floor_limited):
return False
if guard.saturated:
rating = self.site_rating_w
elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None:
rating = guard.able_w
else:
return bool(not guard.within_aim and not self._car_needed)
def high(p):
return peakguard.load_too_high(
p, batt_w=batt, ceiling_w=guard.ceiling_w,
achievable_w=rating)
return bool(high(real_proj) and not high(excl))
def _car_session_tick(self, mono) -> None:
"""A charging session is a plug-in: the state goes from no car to a
car. The notice is raised once per session."""
s = self.car.status(mono, True)
if s in (chargers.NONE_,) and self._car_prev_state not in (
None, chargers.NONE_):
self._car_over_notified = None
# The session is over: that is a real end, with no hold.
self.car_over = False
self._car_over_since = self._car_over_gone = None
if s not in (chargers.NONE_, None) and self._car_prev_state in (
chargers.NONE_, None):
self._car_session += 1
self._car_prev_state = s
async def check_car_over(self) -> None:
"""One grey notice per charging session: the charge you set takes the
15-minute period over the peak limit. Raised nowhere else."""
if not self.car_over or self._car_over_notified == self._car_session:
return
self._car_over_notified = self._car_session
_LOG.info("The car charge you set takes this 15-minute period over "
"the peak limit: CAR_OVER_PEAK.")
await self.hass.call("persistent_notification", "create",
messages.car_over(f"{self.car_a:.0f}").data())
def car_peak_by_car(self, reading, now):
"""`(True, local time)` when the month's peak quarter was one the car
mostly made (it drew half the peak or more), else `(False, None)`."""
if reading is None or not getattr(reading, "is_observed", False) \
or reading.quarter_start is None or not self.car_peak_q:
return False, None
avg = self.car_peak_q.get(
reading.quarter_start.astimezone(timezone.utc).isoformat())
if avg is None or reading.peak_w is None \
or 2.0 * float(avg) < float(reading.peak_w):
return False, None
return True, reading.quarter_start
+18
View File
@@ -391,6 +391,15 @@ class CycleMixin:
if self._peak_proj is not None and len(self.inverters) > 1:
self._peak_proj = next_quarter(self._peak_proj,
self.p1.averager.max_hold_s)
# EV-04, decision 1: with "Batteries help with the peak while the car
# charges" OFF, the guard's house leaves the car out (`house - car_w`).
# `_peak_proj_real` keeps the quarter as the meter will bill it, for
# the car's own words. Only a fresh, trusted car reading is left out.
self._peak_proj_real = self._peak_proj
if (self._peak_proj is not None and not self.car_cover
and self.car_manual()):
self._peak_proj = self.car_exclude(self._peak_proj,
self.car_alarm_w())
self.peak_guard = None if not self.p1_enabled else peakguard.decide(
self._peak_proj,
# ⚠️ THE SITE SUM. The guard sizes a floor from what the battery is
@@ -440,6 +449,13 @@ class CycleMixin:
self.peak_guard = self._peak_landing(self.peak_guard)
self.peak_guard = peakguard.cap_floor( # SAFETY-128
self.peak_guard, self.answer.peak_cap(site_standing))
# EV-04: does the car alone explain what the guard cannot hold? Fresh
# car readings only; the claim, the floor and the commands above are
# not touched by it.
self.car_cycle(self._peak_proj_real, self.peak_guard,
peakguard.quarter_target_w(
float(self.o.get("peak_cap_w", 3500)),
self.peak_margin_w, _reading), now)
# SITE, and peakguard.claim() says so on the object it builds: the
# quantity is the 15-minute average OFFTAKE AT THE GRID CONNECTION,
# which the capacity tariff bills (one quarter-hour peak per site, not
@@ -1048,6 +1064,8 @@ class CycleMixin:
# and, on a change only, one Home Assistant call.
await self.check_price_gap()
await self.check_charger()
await self.check_car_over()
self.car_kick() # EV-04: Manual, in the background
await self.check_fixed_note()
# SAFETY-31's alarm, and its boundary is the LATCH, not a number: it
+63 -3
View File
@@ -15,8 +15,8 @@ from .freeze import rail_unreachable, rail_w
from .hass import OUTAGE
from .maintenance import IDLE
from .mqtt import (
PAYLOAD_NONE, announced_units, optional_keys, parse_command, unit_slugs,
unit_state_key,
BASE, PAYLOAD_NONE, announced_units, optional_keys, parse_car_command,
parse_command, unit_slugs, unit_state_key,
)
from . import peakguard
from . import pv as pv_read
@@ -35,6 +35,9 @@ class StatusMixin:
already holds the last choice). Never raises: MQTT must not reach
control. (DECISIONS/MAIN-orchestration-archive.md)"""
try:
if isinstance(topic, str) and topic.startswith(f"{BASE}/car/"):
await self._car_mqtt_command(topic, payload, retained)
return
slug, action, value, why = parse_command(
topic, payload, retained, packmode.MODES)
if why is None:
@@ -68,6 +71,29 @@ class StatusMixin:
except Exception: # noqa: BLE001
_LOG.exception("Home Assistant command could not be handled")
async def _car_mqtt_command(self, topic, payload, retained) -> None:
"""EV-04: one command from the car's HA entities, through
handle_action(). A retained command is never applied. Never raises."""
action, value, why = parse_car_command(topic, payload, retained)
result = None
if why is None:
result = await self.handle_action(action, value=value)
if isinstance(result, dict) and "error" not in result:
self.mqtt.publish(self.car_command_values())
return
why = result["error"] if isinstance(result, dict) else "refused"
else:
why = messages.car_refused("topic") if why == "topic" else \
messages.pack_refused(why)
topic_s = "".join(c if c.isprintable() else "?" for c in str(topic)[:128])
_LOG.debug("Home Assistant command %s %s refused: %s", topic_s,
repr(payload)[:48], why)
if (topic_s, why) not in self._mqtt_refused \
and len(self._mqtt_refused) < 32:
self._mqtt_refused.add((topic_s, why))
_LOG.warning("Home Assistant command on %s ignored: %s", topic_s,
why)
@property
def why_words(self) -> str:
"""The page's "Why" line. While control waits for a missing reading
@@ -178,9 +204,33 @@ class StatusMixin:
out.append({"ok": False, "warn": True, "id": "charger",
"text": messages.row_charger_unreach(
f"{brussels(self.car.bad_since_utc):%H:%M}")})
if self.car.other_writer(datetime.now(timezone.utc)):
w = self.car_writer
if self.car_mode == "manual":
# EV-04: in Manual the add-on's own writes are not "another
# writer"; its own detector (a read-back that differs from the
# last write for 30 s) says so, in grey.
if w.other:
out.append({"ok": True, "warn": True, "id": "charger_other",
"text": messages.row_charger_other()})
if w.gave_up:
out.append({"ok": False, "warn": True, "id": "charger_refused",
"text": messages.row_charger_refused()})
if w.phases_gave_up:
out.append({"ok": False, "warn": True, "id": "charger_phases",
"text": messages.row_charger_phases()})
elif self.car.other_writer(datetime.now(timezone.utc)):
out.append({"ok": True, "warn": True, "id": "charger_writer",
"text": messages.row_charger_writer()})
if self.car.stuck(self.car_now()):
out.append({"ok": False, "warn": True, "id": "charger_stuck",
"text": messages.row_charger_stuck()})
r = self.car.reading
if r is not None and r.available and r.error:
out.append({"ok": True, "warn": True, "id": "charger_error",
"text": messages.row_charger_error(r.error)})
if self.car_over:
out.append({"ok": True, "warn": True, "id": "car_over",
"text": messages.row_car_over()})
return out
def car_values(self) -> dict:
@@ -192,6 +242,7 @@ class StatusMixin:
with homeview.in_lang("en"):
word = homeview.car_state_word(state)
return {
**self.car_command_values(),
"car_state": word,
# `ABSENT_AS_UNKNOWN` stays the one PV key (test_pv.py): an absent
# car figure is HA's own "no value" payload, sent by name.
@@ -335,6 +386,13 @@ class StatusMixin:
if _pg is None:
out.append({"ok": True, "warn": True, "id": "peak_guard",
"text": messages.row_peak_guard_waiting()})
elif self.car_explains and (_pg.saturated or _pg.floor_limited):
# EV-04: the car you set is what the batteries cannot hold, so
# no red row. The grey row `car_over` says what is going on.
out.append({"ok": True, "warn": False, "id": "peak_guard",
"text": messages.row_peak_guard_on(
_pg.floor_w or 0.0, _pg.ceiling_w,
shadow=self.shadow)})
elif _pg.saturated and not _pg.within_aim:
out.append({"ok": False, "warn": False, "id": "peak_guard",
"runs": True,
@@ -864,6 +922,8 @@ class StatusMixin:
now = datetime.now(timezone.utc)
if what in ("pack_use", "pack_mode", "pack_sell"):
return self._pack_action(what, unit, value, now)
if what in ("car_mode", "car_current", "car_phases"):
return self._car_action(what, value, now)
if what == "auto_toggle":
self.auto = not self.auto
self.store.set("auto", self.auto)
+77 -6
View File
@@ -19,7 +19,8 @@ section at the bottom and is held to STYLE.md by test_messages.py.
import contextlib
from datetime import datetime, timedelta, timezone
from . import arbitrage, cheaproll, handback, messages, peakguard, priceruns, uitext
from . import (arbitrage, carmode, cheaproll, handback, messages, peakguard,
priceruns, uitext)
from .dayplan import EFF
from .maintenance import CHARGE as M_CHARGE, DRAIN as M_DRAIN, HOLD as M_HOLD
from .maintenance import IDLE as M_IDLE, next_slot_start
@@ -871,8 +872,10 @@ def peak_engaged(c) -> bool:
only), so no battery gives power for it. Nor when the quarter ends on
the aim anyway (SAFETY-126, `within_aim`)."""
pg = getattr(c, "peak_guard", None)
# EV-04: not for a cause the car's own Why explains.
return bool(pg is not None and pg.engaged and (pg.floor_w or 0.0) > 0.0
and not pg.within_aim)
and not pg.within_aim
and not getattr(c, "car_explains", False))
def battery_rows(c, shadow, running, held=False):
@@ -1129,10 +1132,30 @@ def month_peak(c, now):
if pg is not None:
out["period_w"] = pg.projected_w
ceiling = pg.ceiling_w or limit_w
real = getattr(c, "_peak_proj_real", None)
if getattr(c, "car_enabled", False) and c.charger.configured() \
and not c.car_cover and c.car_manual() and real is not None \
and getattr(real, "block_start", None) is not None:
# EV-04, decision 1 off: the guard's own projection leaves the car
# out; the period as the meter will bill it does not.
out["period_w"] = real.projected_w
out["line"] = line_period(out["period_w"], ceiling, c.shadow,
unmeasured=getattr(c, "peak_unmeasured_s", 0.0)
> 0.0,
cut=getattr(c, "room_charge", False))
# EV-04: when a car charge you asked for is in this period, and when one
# set the month's peak. Both empty without a charger in Manual.
out["car_line"] = out["set_by"] = ""
if getattr(c, "car_enabled", False) and c.charger.configured():
w = c.car_alarm_w()
if pg is not None and w is not None and w >= 500.0 \
and out["period_w"] is not None and (pg.engaged or c.car_over):
out["car_line"] = _t("peak.car", kw=_kw(out["period_w"]),
car=_kw(w),
cov=_kw(max(0.0, float(c.site_batt_w or 0))))
by_car, at = c.car_peak_by_car(reading, now)
if by_car:
out["set_by"] = _t("peak.set_by_car", t=f"{brussels(at):%H:%M}")
return out
@@ -1278,6 +1301,35 @@ def _car_why(key, c, good):
return _t("car.why." + (key if key else "wait"))
def _car_manual_why(c, key):
"""The Why of Manual: what you set, and what the peak limit does about it.
Plan lines: two sentences of at most 12 words."""
a = f"{float(c.car_a):.0f}"
w = c.car_writer
pct = _pct(c.o.get("peak_soc_floor", peakguard.PEAK_OPTION_DEFAULTS[
"peak_soc_floor"]))
if c.car_over:
pg = getattr(c, "peak_guard", None)
if not c.car_cover:
return _t("car.why.manual_nocover", a=a)
return _t("car.why.manual_over" if pg is not None and pg.floor_limited
else "car.why.manual_full", a=a, pct=pct)
if c.shadow:
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
return _t("car.why.manual_would", a=f"{float(t):.0f}",
phases=car_phases_word(n))
if not c.auto:
return _t("car.why.manual_stopped")
if key in ("none", "full"):
return _t("car.why.manual_wait", a=a)
if w.blocked:
return _t("car.why.manual_blocked")
if c.car_cover and peak_engaged(c):
giving = max(0.0, float(c.site_batt_w or 0.0))
return _t("car.why.manual_cover", a=a, kw=_kw(giving), pct=pct)
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
def car_block(c, now):
"""The Car card for `/status`, or None when no charger is switched on (the
page then draws nothing, as before)."""
@@ -1292,17 +1344,32 @@ def car_block(c, now):
today = None
if configured and c.car.today_kwh is not None:
today = _t("car.today", kwh=_kwh(c.car.today_kwh))
return {
mode = getattr(c, "car_mode", "off") if configured else "off"
why = _car_why(key, c, good)
if mode == "manual" and key in ("charging", "waiting", "none", "full"):
why = _car_manual_why(c, key)
out = {
"state": key or "wait",
"chip": car_state_word(key),
"kind": _CAR_KIND.get(key, "muted"),
"big": _car_big(key, c, r if fresh else None, good),
"today": today,
"why": _car_why(key, c, good),
"mode": "off",
"why": why,
"mode": mode,
"power_w": (None if not fresh or r is None or r.power_w is None
else round(float(r.power_w), 1)),
}
if configured:
# EV-04: what the page can set. Off and Manual only (Solar and Night
# are later cards, so they are not offered).
clamp = c.car_clamp()
hi = int(clamp) if clamp is not None and clamp >= 6 else 6
out["modes"] = ["off", "manual"]
out["current"] = {"value": round(float(c.car_a)), "min": 6,
"max": hi}
out["phases"] = {"value": c.car_n,
"choices": list(carmode.allowed_phases(c.o))}
return out
# =========================================================================== #
@@ -1815,8 +1882,12 @@ def _samples() -> list:
out += [("title", _t("car.state." + k)) for k in words["car"]["state"]]
out += [("plan", _t("car.big." + k, t="09:12")) for k in
words["car"]["big"]]
out += [("plan", _t("car.why." + k, a="10", brand="Alfen"))
out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW",
pct="20 %", phases=car_phases_word(3)))
for k in words["car"]["why"]]
out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW",
cov="8.6 kW")),
("plan", _t("peak.set_by_car", t="19:45"))]
out += [("plan", _t("car.today", kwh="14.2 kWh")),
("plan", "11.0 kW · 16 A · " + _t("car.phase_many", n=3))]
out += [("plan", line_no_trade(k)) for k in
+29 -3
View File
@@ -42,6 +42,7 @@ from .arbiter import (
P_SAFETY, SET, Claim, Resolution, actuator_for, pre_resolve, resolve,
)
from . import allocator
from . import carmode
from . import chargers
from . import dayplan
from . import modetrade
@@ -83,8 +84,9 @@ from .maintenance import (
CHARGE, DRAIN, HOLD, IDLE, POWER_MOVING, MaintConfig, Maintenance,
FAIL_BACKOFF_DAYS, MaintResult, arbitrate as maint_arbitrate, site_zone,
)
from .mqtt import (MODE_CONFIGS_KEY, MODE_LABELS, USE_OFF, USE_ON,
MqttPublisher, announced_units, mode_configs,
from .mqtt import (CAR_CONFIGS_KEY, MODE_CONFIGS_KEY, MODE_LABELS, USE_OFF,
USE_ON, MqttPublisher, announced_units, car_configs,
mode_configs,
optional_keys, parse_command, unit_slugs, unit_state_key)
from . import peakguard
from . import packshare
@@ -113,6 +115,7 @@ from . import web
# stays importable from `app.main`. DECISIONS/MAIN-orchestration.md.
from .ctl_tasks import TasksMixin
from .ctl_status import StatusMixin
from .ctl_car import CarMixin
from .ctl_alarms import (
AlarmsMixin, HANDBACK_CYCLES, REANNOUNCE_S, ROLLING_BOUND_CYCLES,
ROLLING_S, SHORT_CYCLES, SHORT_SPAN_S,
@@ -183,7 +186,7 @@ def _load_latch(data, now=None):
class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
StatusMixin, TasksMixin):
StatusMixin, TasksMixin, CarMixin):
def __init__(self, opts: dict, hass: HomeAssistant, store, mqtt_pub, *, stop,
peak_db_path: str = "/data/tariff.db",
price_history_path: str = "/data/price_history.json",
@@ -576,6 +579,8 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
self._charger_probed = False
self._car_down_logged = False
self._car_announced = False
# EV-04: Manual mode's state (runtime, in the store) and its writer.
self.car_init(opts, store)
self.house_profile = None
if self.fc_entity is not None:
self.house_profile = dayplan.HouseProfile(
@@ -1036,6 +1041,7 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
_LOG.info(handback.log_shutdown(handback.current())
or "shutting down - commanding 0 W on every inverter")
await self.command_site_release()
await self.car_shutdown() # EV-04: undo a phase change half way
self.mqtt.close()
@@ -1062,6 +1068,23 @@ def mode_announcement(opts, store) -> tuple:
return modes, retract
def car_announcement(opts, store) -> tuple:
"""EV-04: `(car, retract)` for the MQTT publisher at start-up: the three car
entities while a charger is switched on, and the config topics to remove
when it is not (`mqtt.car_configs()`). A site that never had a charger gets
nothing and its store is not written."""
car = None
if chargers.census_entity(opts):
amps = chargers.max_a(opts)
car = (chargers.EV_OPTION_DEFAULTS["ev_max_a"] if amps is None
else amps, carmode.allowed_phases(opts))
stored = store.data.get(CAR_CONFIGS_KEY)
keep, retract = car_configs(car, stored)
if keep and keep != stored:
store.set(CAR_CONFIGS_KEY, keep)
return car, retract
def control_task_done(task: asyncio.Task, *, controller, stop: asyncio.Event,
died: list) -> None:
"""Done-callback on the control task: log its death now and wake amain()
@@ -1231,6 +1254,7 @@ async def amain() -> None:
# OPT-11 P2: each battery's switch and mode list, only while
# battery modes are on (`mode_announcement()`).
_modes, _retract = mode_announcement(opts, store)
_car, _car_retract = car_announcement(opts, store)
broker = await hass.mqtt_service()
pub = MqttPublisher(
broker.get("host") if broker else None,
@@ -1250,6 +1274,8 @@ async def amain() -> None:
units=roster_names(opts),
modes=_modes,
retract=_retract,
car=_car,
car_retract=_car_retract,
)
except Exception as err: # noqa: BLE001
_LOG.warning("MQTT unavailable (%s) - continuing without status entities", err)
+86
View File
@@ -188,6 +188,8 @@ T_METER_FROZEN_NL = "Meter staat mogelijk vast"
TITLE_NL = {T_LOOP_BOUND: T_LOOP_BOUND_NL, T_OUTPUT_CLAMP: T_OUTPUT_CLAMP_NL}
T_CHARGER_UNREACH = "Charger not reachable"
T_CHARGER_UNREACH_NL = "Laadpaal onbereikbaar"
T_CAR_OVER = "Car over the peak limit"
T_CAR_OVER_NL = "Auto boven de piekgrens"
T_NO_PRICES = "No prices"
T_NO_PRICES_NL = "Prijzen ontbreken"
@@ -201,6 +203,7 @@ ID_METER_FROZEN = "goodwe_meter_frozen"
ID_MAINT_FAILED = "goodwe_maint_failed_{slug}"
ID_NO_PRICES = "goodwe_no_prices"
ID_CHARGER_UNREACH = "goodwe_charger_unreachable"
ID_CAR_OVER = "goodwe_car_over"
# PRICE-01: an earlier build raised a card with this id. Nothing raises it now;
# the add-on only dismisses it at start.
OLD_FIXED_CARD_ID = "goodwe_fixed_tariff_unused"
@@ -496,6 +499,61 @@ def row_charger_writer() -> str:
"Iets anders wijzigt de laadpaal en deze add-on leest alleen.")
def car_over(a_text) -> Notice:
"""EV-04: a charge the user set takes the 15-minute period over the peak
limit, and the batteries cannot hold it. Grey, once per charging session.
Not an alarm: the car is never throttled, the user asked for it."""
en = (f"You set {a_text} A, which takes this 15-minute period over the "
"peak limit.")
nl = f"U stelde {a_text} A in, wat dit kwartier boven de piekgrens brengt."
return Notice(ID_CAR_OVER, INFO, T_CAR_OVER, en,
body_nl=f"{T_CAR_OVER_NL}. {nl}")
def row_car_over() -> str:
"""EV-04: the grey row while the car charge you set is over the peak limit."""
return Bi("The car charge you set takes this 15-minute period over the "
"peak limit.",
"De autolading die u instelde brengt dit kwartier boven de "
"piekgrens.")
def row_charger_other() -> str:
"""EV-04: the grey row, in Manual, while something else sets the current."""
return Bi("Something else changes the charger, so the add-on writes "
"nothing until you change it.",
"Iets anders wijzigt de laadpaal, dus de add-on schrijft niets "
"tot u iets wijzigt.")
def row_charger_stuck() -> str:
"""EV-04: the amber row when the charger's reading does not move."""
return Bi("The charger reading may be stuck, so check the charger.",
"De meting van de laadpaal staat mogelijk vast, dus controleer "
"de laadpaal.")
def row_charger_refused() -> str:
"""EV-04: the amber row when the charger does not take the setting."""
return Bi("The charger did not take the setting, so check the charger.",
"De laadpaal nam de instelling niet over, dus controleer de "
"laadpaal.")
def row_charger_phases() -> str:
"""EV-04: the amber row when the charger does not take the phases."""
return Bi("The charger did not take the phases, so check the charger.",
"De laadpaal nam de fasen niet over, dus controleer de "
"laadpaal.")
def row_charger_error(text) -> str:
"""EV-04: the grey row while the charger reports an error. Writes go on."""
t = " ".join(str(text or "").split())[:60]
return Bi(f"The charger reports an error: {t}.",
f"De laadpaal meldt een fout: {t}.")
def row_charger_setup() -> str:
"""EV-03: the amber row when the charger's entities are not found."""
return Bi("The add-on cannot find the charger, so check its entity in "
@@ -1423,6 +1481,9 @@ def why_waiting(missing_s) -> str:
HINTS = {
"control_started": "Control started",
"control_stopped": "Control stopped",
"car_mode": "Car mode set",
"car_current": "Car current set",
"car_phases": "Car phases set",
"settings_saved": "Settings saved, they apply after a restart",
"restart_requested": "Restart requested from the settings page",
"setup_only": "In setup, nothing is sent to any inverter",
@@ -1511,6 +1572,20 @@ def pack_refused(why: str) -> str:
return PACK_REFUSED[why]
# EV-04: why a car mode, current or phases change was refused (the page and
# Home Assistant show it).
CAR_REFUSED = {
"off": "The car charger is not set up.",
"value": "That choice is not possible for the car charger.",
"phases": "The charger limit allows only one number of phases.",
"topic": "That is not a car command.",
}
def car_refused(why: str) -> str:
return CAR_REFUSED[why]
# MAINT-11: why a start or stop of ONE battery's cycle was refused. `{unit}` is
# the battery the sentence is about (for "busy", the one that is cycling). The
# page shows the same sentences in Dutch from app/ui_text, keyed by the code.
@@ -1703,6 +1778,12 @@ def status_samples() -> list:
("row_no_prices", AMBER, row_no_prices()),
("row_charger_unreach", AMBER, row_charger_unreach("09:12")),
("row_charger_writer", GREEN, row_charger_writer()),
("row_car_over", GREEN, row_car_over()),
("row_charger_other", GREEN, row_charger_other()),
("row_charger_error", GREEN, row_charger_error("Socket error")),
("row_charger_stuck", AMBER, row_charger_stuck()),
("row_charger_refused", AMBER, row_charger_refused()),
("row_charger_phases", AMBER, row_charger_phases()),
("row_charger_setup", AMBER, row_charger_setup()),
]
@@ -1740,6 +1821,7 @@ def samples() -> list:
no_prices(*_SINCE_OLDER),
no_prices(),
charger_unreachable("09:12"),
car_over("16"),
]
@@ -1806,6 +1888,8 @@ LABELS = {
"ev_charger": "Charger",
"ev_current_entity": "Current setting entity",
"ev_max_a": "Charger limit",
"ev_batt_cover": "Batteries help with the peak",
"ev_mode_start": "Mode after a restart",
"ev_phases": "Phases",
}
@@ -1890,6 +1974,8 @@ LABELS_NL = {
"ev_charger": "Laadpaal",
"ev_current_entity": "Entiteit van de laadstroom",
"ev_max_a": "Laadpaalgrens",
"ev_batt_cover": "Batterijen helpen met de piek",
"ev_mode_start": "Modus na een herstart",
"ev_phases": "Fasen",
}
# The inverter list shows two of them under a shorter name.
+108 -4
View File
@@ -405,7 +405,7 @@ def _unit_places(names):
yield slug, device, prefix
def discovery_payloads(units=(), omit=(), include=(), modes=()) -> list:
def discovery_payloads(units=(), omit=(), include=(), modes=(), car=None) -> list:
"""Every `(topic, payload)` this add-on announces, in announcement order.
Split out of `_announce()` so that the acceptance criterion can be graded as
@@ -421,6 +421,8 @@ def discovery_payloads(units=(), omit=(), include=(), modes=()) -> list:
re-announces every entity on a live install).
`modes` (OPT-11 P2) is the battery modes offered, empty when they are off.
`car` (EV-04) is None, or `(max_a, phases)`: the car's three command
entities, announced after everything else so no existing row moves.
"""
omit = set(omit)
include = [k for k in include if k not in omit]
@@ -452,6 +454,7 @@ def discovery_payloads(units=(), omit=(), include=(), modes=()) -> list:
DEVICE, unit, dev_class, state_class, icon)))
# OPT-11 P2: last, and only when battery modes are on.
out.extend(mode_payloads(units, modes))
out.extend(car_payloads(car))
return out
@@ -518,6 +521,101 @@ def mode_payloads(units, modes) -> list:
return out
# --- EV-04: the car's mode, current and phases, as HA entities ----------------
# Announced only with a charger switched on, after every other row. A command
# goes through Controller.handle_action(); a retained one is dropped.
CAR_MODE_LABELS = {"off": "Off", "manual": "Manual"} # English, pinned
CAR_MODES = tuple(CAR_MODE_LABELS)
CAR_CONFIGS_KEY = "mqtt_car_configs"
CAR_MIN_A = 6
_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases)/set")
_CAR_CONFIG_RE = re.compile(
rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases)/config")
# (key, component, name, icon)
CAR_ENTITIES = [
("mode", "select", "Car mode", "mdi:car-electric"),
("current", "number", "Car current", "mdi:current-ac"),
("phases", "select", "Car phases", "mdi:sine-wave"),
]
def car_payloads(car) -> list:
"""The `(topic, payload)` for `select.goodwe_car_mode`,
`number.goodwe_car_current` and `select.goodwe_car_phases`. `car` is
`(max_a, phases)`; empty when it is None."""
if not car:
return []
max_a, phases = car
out = []
for key, component, name, icon in CAR_ENTITIES:
unique_id = f"{BASE}_car_{key}"
cfg = {
"name": name,
"object_id": f"goodwe_car_{key}",
"unique_id": unique_id,
"state_topic": f"{BASE}/car_{key}",
"command_topic": f"{BASE}/car/{key}/set",
}
if key == "mode":
cfg["options"] = list(CAR_MODE_LABELS.values())
elif key == "phases":
cfg["options"] = [str(n) for n in phases]
else:
cfg.update({"min": CAR_MIN_A, "max": int(max_a), "step": 1,
"unit_of_measurement": "A", "device_class": "current",
"mode": "box"})
cfg.update({"retain": False, "availability_topic": AVAILABILITY,
"device": DEVICE, "icon": icon})
out.append((f"homeassistant/{component}/{unique_id}/config", cfg))
return out
def car_configs(car, stored) -> tuple:
"""`(keep, retract)` at start-up, as `mode_configs()` does for the battery
modes: turning the charger off removes exactly the entities announced
before, and a site that never had one publishes nothing."""
current = [t for t, _ in car_payloads(car)]
old = [t for t in (stored if isinstance(stored, list) else [])
if isinstance(t, str) and _CAR_CONFIG_RE.fullmatch(t)
and t not in current]
old = list(dict.fromkeys(old))
return current + old, old
def parse_car_command(topic, payload, retained):
"""`(action, value, reject)` for one message on a car command topic.
`action` is `car_mode`, `car_current` or `car_phases`. A value that is
none of the entity's own is None (the action then refuses it)."""
m = _CAR_CMD_RE.fullmatch(topic) if isinstance(topic, str) else None
if m is None:
return None, None, "topic"
key = m.group(1)
action = f"car_{key}"
if bool(retained):
return action, None, "retained"
if not isinstance(payload, (bytes, bytearray)):
return action, None, "size"
if MAX_COMMAND_BYTES < len(payload):
return action, None, "size"
try:
text = bytes(payload).decode(encoding="utf-8").strip()
except ValueError: # UnicodeDecodeError is one
return action, None, "encoding"
value = None
if key == "mode":
value = next((k for k, v in CAR_MODE_LABELS.items() if v == text),
None)
elif key == "phases":
value = {"1": 1, "3": 3}.get(text)
else:
try:
f = float(text)
value = f if f == f and abs(f) < 1000 else None
except ValueError:
value = None
return action, value, None
def mode_retractions(stored, current) -> list:
"""Config topics announced before and not now: each gets an empty
retained config, which removes the entity from HA. Anything in the store
@@ -574,11 +672,13 @@ class MqttPublisher:
# test fixture that builds one with __new__) behaves as before.
modes = ()
retract = ()
car = None # EV-04: `(max_a, phases)` when the charger is on
_loop = None
_handler = None
def __init__(self, host, port, username=None, password=None, omit=(),
units=(), include=(), modes=(), retract=()):
units=(), include=(), modes=(), retract=(), car=None,
car_retract=()):
# `omit` drops sensor keys from discovery entirely. ⚠️ Announcing a
# sensor that nothing will ever publish to is not harmless here:
# p1_sample_age_s is a watchdog input, and an entity that exists but is
@@ -597,7 +697,8 @@ class MqttPublisher:
# OPT-11 P2: the modes offered (empty when battery modes are off), and
# the mode config topics to remove (`mode_retractions()`).
self.modes = tuple(modes)
self.retract = [str(t) for t in retract]
self.retract = [str(t) for t in retract] + [str(t) for t in car_retract]
self.car = tuple(car) if car else None
self.enabled = mqtt is not None and bool(host)
self.client = None
if not self.enabled:
@@ -636,7 +737,8 @@ class MqttPublisher:
# diffing what actually goes on the wire - and a payload built here
# instead would be one this add-on publishes and no check has ever seen.
for topic, cfg in discovery_payloads(self.units, self.omit,
self.include, self.modes):
self.include, self.modes,
self.car):
self.client.publish(topic, json.dumps(cfg), retain=True)
for topic in self.retract:
self.client.publish(topic, "", retain=True)
@@ -647,6 +749,8 @@ class MqttPublisher:
if self.modes:
for key in ("mode", "use"):
self.client.subscribe(f"{BASE}/unit/+/{key}/set")
if self.car:
self.client.subscribe(f"{BASE}/car/+/set")
def bind(self, loop, handler) -> None:
"""OPT-11 P2: hand each command to `handler(topic, payload, retained)`,
+42
View File
@@ -158,6 +158,46 @@
$("#car-today").textContent = c.today || "";
$("#car-today").hidden = !c.today;
$("#car-why").textContent = c.why;
renderCarControls(c);
}
// EV-04: Off and Manual. The mode and the phases send at once; the current
// sends after two seconds of rest. A slider being dragged is left alone.
let carTouch = 0, carTimer = null, carBusy = false;
async function carAct(what, value) {
if (carBusy) return;
carBusy = true;
try {
const r = await fetch("action", { method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ action: what, value: value }) });
const j = await r.json().catch(() => ({}));
if (!r.ok) toast(j.error || t("toast.failed"));
} catch (e) { toast(t("toast.failed")); }
finally { carBusy = false; }
await refresh(true);
}
function renderCarControls(c) {
const modes = c.modes || [];
$("#car-mode").hidden = !modes.length;
$("#car-mode").replaceChildren(...modes.map((m) => h("button", {
type: "button", role: "radio", "aria-checked": String(c.mode === m),
onclick: () => carAct("car_mode", m) }, t("car.mode_" + m))));
$("#car-help").textContent = t("car.help_" + c.mode + ".description") || "";
const on = c.mode === "manual" && !!c.current;
$("#car-manual").hidden = !on;
if (!on) return;
const a = $("#car-a");
if (Date.now() - carTouch > 3000) {
a.min = c.current.min; a.max = c.current.max; a.value = c.current.value;
}
$("#car-a-out").textContent = a.value + " A";
a.oninput = () => {
carTouch = Date.now(); $("#car-a-out").textContent = a.value + " A";
clearTimeout(carTimer);
carTimer = setTimeout(() => carAct("car_current", Number(a.value)), 2000);
};
$("#car-phases").replaceChildren(...c.phases.choices.map((n) => h("button", {
type: "button", role: "radio", "aria-checked": String(c.phases.value === n),
onclick: () => carAct("car_phases", n) }, t("car.phases_" + n))));
}
/* ---------------- Home: today's plan ---------------- */
@@ -288,6 +328,8 @@
bar.className = pct >= 100 ? "bad" : pct >= 80 ? "warn" : "";
$("#peak-meter").setAttribute("aria-label", t("peak.this_month") + " " + (m.pct == null ? "–" : Math.round(m.pct) + " %"));
$("#peak-line").textContent = m.line;
$("#peak-car").textContent = m.car_line || ""; $("#peak-car").hidden = !m.car_line;
$("#peak-setby").textContent = m.set_by || ""; $("#peak-setby").hidden = !m.set_by;
}
function renderAttention() {
const list = S.attention;
+10 -2
View File
@@ -44,8 +44,14 @@
<div class="car-big" id="car-big"></div>
<div class="small muted" id="car-today"></div>
<div class="small car-lab" data-t="car.mode"></div>
<div class="seg" role="radiogroup" id="car-mode" data-t-label="car.mode"><button type="button" role="radio" aria-checked="true" data-t="car.mode_off"></button></div>
<p class="tiny muted" style="margin:6px 0 0" data-t="car.help_off.description"></p>
<div class="seg" role="radiogroup" id="car-mode" data-t-label="car.mode"></div>
<p class="tiny muted" style="margin:6px 0 0" id="car-help"></p>
<div id="car-manual" hidden>
<div class="small car-lab" data-t="car.current"></div>
<div class="slider"><input type="range" id="car-a" min="6" max="16" step="1" data-t-label="car.current"><output class="small" id="car-a-out"></output></div>
<div class="small car-lab" data-t="car.phases"></div>
<div class="seg" role="radiogroup" id="car-phases" data-t-label="car.phases"></div>
</div>
<div class="car-why small"><span class="muted" data-t="car.why"></span><span id="car-why"></span></div>
</div>
@@ -71,6 +77,8 @@
<div class="row spread small" id="peak-figures"><span><span data-t="peak.this_month"></span>: <strong id="peak-now"></strong></span><span class="muted"><span data-t="peak.limit"></span> <span id="peak-limit"></span></span></div>
<div class="meter" id="peak-meter" role="img"><i style="width:0%"></i></div>
<div class="tiny muted" id="peak-line"></div>
<div class="tiny muted" id="peak-car" hidden></div>
<div class="tiny muted" id="peak-setby" hidden></div>
</div>
<div class="card" id="c-attn">
+23 -3
View File
@@ -4,7 +4,7 @@
"inverters": {"name": "Inverters and batteries", "description": "The inverters the add-on controls, and your solar."},
"tariff": {"name": "Tariff and prices", "description": "What you pay and are paid per kWh."},
"safety": {"name": "Safety limits", "description": "The peak limit, starting and stopping, and the safety stops."},
"car": {"name": "Car charger", "description": "Which charger the add-on reads, and its limits."},
"car": {"name": "Car charger", "description": "Which charger the add-on drives, its limits and the mode defaults."},
"maintenance": {"name": "Maintenance", "description": "The monthly battery cycle and the log."},
"tuning": {"name": "Control tuning", "description": "For support only, because these were measured on real hardware."}
},
@@ -36,6 +36,7 @@
"meter_source": {"off": "One grid power entity", "ha_dsmr": "Import and export entities", "mqtt_p1": "Meter over MQTT", "ha_signed": "One net power entity", "homewizard_local": "HomeWizard meter on the network"},
"ev_charger": {"off": "None", "alfen_ha": "Alfen (Home Assistant integration)"},
"ev_phases": {"1": "1 phase", "3": "3 phases", "auto": "1 and 3"},
"ev_mode_start": {"keep": "Keep the last mode", "off": "Off"},
"meter_phases": {"1": "1 phase", "3": "3 phases"},
"shadow_mode": {"auto": "Automatic", "on": "Always on", "off": "Off"},
"price_provider": {"generic_dayahead": "Day-ahead market price", "custom_formula": "Your own price formula", "manual_csv": "A price file", "price_service": "Your own price service"},
@@ -90,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", "help_off": {"description": "The add-on leaves the charger alone."}, "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"},
"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"},
@@ -319,9 +320,22 @@
"limit": "The charger limit is above what the charger allows. Lower it in Settings.",
"name": "The current setting entity does not fit the charger. Check it in Settings.",
"fault": "The charger reports a fault. Check it at the charger itself.",
"wait": "Waiting for the first reading."
"wait": "Waiting for the first reading.",
"manual_set": "You set {a} A, {phases}. The charger keeps it, whatever the peak limit does.",
"manual_cover": "You set {a} A. The batteries give {kw} and help down to {pct}.",
"manual_over": "You set {a} A. The batteries are at {pct}, so this charge sets the peak.",
"manual_full": "You set {a} A. The batteries give all they can, so this charge sets the peak.",
"manual_nocover": "You set {a} A. The guard ignores the car, so this charge can set the peak.",
"manual_wait": "You set {a} A. It is set when a car is connected.",
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
"manual_blocked": "The phases change once per 10 minutes at most. This waits."
}
},
"peak": {
"car": "This 15-minute period is heading for {kw}. The car takes {car} and the batteries cover {cov}.",
"set_by_car": "Set by the car charge you asked for, at {t}."
},
"tile": {
"not_set_up": "Not set up",
"no_reading": "No reading",
@@ -527,6 +541,12 @@
"solar_forecast": "Solar forecast",
"charger": "Charger not reachable",
"charger_writer": "Something else changes the charger",
"charger_other": "Something else changes the charger",
"charger_phases": "Charger did not take phases",
"charger_stuck": "Charger reading may be stuck",
"charger_refused": "Charger did not take it",
"charger_error": "The charger reports an error",
"car_over": "Car over the peak limit",
"charger_setup": "Charger not set up",
"none": "Inverter connection"
},
+23 -3
View File
@@ -4,7 +4,7 @@
"inverters": {"name": "Omvormers en batterijen", "description": "De omvormers die de add-on regelt, en uw zonnepanelen."},
"tariff": {"name": "Tarief en prijzen", "description": "Wat u per kWh betaalt en terugkrijgt."},
"safety": {"name": "Veiligheidsgrenzen", "description": "De piekgrens, starten en stoppen, en de veiligheidsstops."},
"car": {"name": "Laadpaal", "description": "Welke laadpaal de add-on leest, en haar grenzen."},
"car": {"name": "Laadpaal", "description": "Welke laadpaal de add-on stuurt, haar grenzen en de standaardmodus."},
"maintenance": {"name": "Onderhoud", "description": "De maandelijkse batterijcyclus en het logboek."},
"tuning": {"name": "Afstelling van de regeling", "description": "Alleen voor support, want deze zijn gemeten op echte hardware."}
},
@@ -36,6 +36,7 @@
"meter_source": {"off": "Eén entiteit voor netvermogen", "ha_dsmr": "Entiteiten voor afname en injectie", "mqtt_p1": "Meter via MQTT", "ha_signed": "Eén entiteit voor nettovermogen", "homewizard_local": "HomeWizard-meter op het netwerk"},
"ev_charger": {"off": "Geen", "alfen_ha": "Alfen (Home Assistant-integratie)"},
"ev_phases": {"1": "1 fase", "3": "3 fasen", "auto": "1 en 3"},
"ev_mode_start": {"keep": "Laatste modus houden", "off": "Uit"},
"meter_phases": {"1": "1 fase", "3": "3 fasen"},
"shadow_mode": {"auto": "Automatisch", "on": "Altijd aan", "off": "Uit"},
"price_provider": {"generic_dayahead": "Day-aheadprijs van de markt", "custom_formula": "Uw eigen prijsformule", "manual_csv": "Een prijsbestand", "price_service": "Uw eigen prijsdienst"},
@@ -87,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", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "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"},
"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"},
@@ -273,9 +274,22 @@
"limit": "De laadpaalgrens is hoger dan de laadpaal toestaat. Verlaag ze bij Instellingen.",
"name": "De entiteit van de laadstroom past niet bij de laadpaal. Controleer ze bij Instellingen.",
"fault": "De laadpaal meldt een storing. Controleer ze aan de laadpaal zelf.",
"wait": "Wacht op de eerste meting."
"wait": "Wacht op de eerste meting.",
"manual_set": "U stelde {a} A in, {phases}. De laadpaal houdt dit aan, wat de piekgrens ook doet.",
"manual_cover": "U stelde {a} A in. De batterijen leveren {kw} en helpen tot {pct}.",
"manual_over": "U stelde {a} A in. De batterijen staan op {pct}, dus deze lading bepaalt de piek.",
"manual_full": "U stelde {a} A in. De batterijen geven alles, dus deze lading bepaalt de piek.",
"manual_nocover": "U stelde {a} A in. De bewaking negeert de auto, dus deze lading kan de piek bepalen.",
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht."
}
},
"peak": {
"car": "Dit kwartier gaat richting {kw}. De auto neemt {car} en de batterijen dekken {cov}.",
"set_by_car": "Bepaald door de autolading die u vroeg, om {t}."
},
"tile": {"not_set_up": "Niet ingesteld", "no_reading": "Geen meting", "producing": "Produceert", "not_producing": "Produceert niet", "needs_solar": "Zonnemeting nodig", "not_adding_up": "Metingen kloppen niet", "using": "Verbruikt", "taking": "Neemt af van het net", "feeding": "Injecteert", "balanced": "In evenwicht", "giving": "Levert stroom", "charging": "Laadt", "resting": "Rust"},
"now": {
"no_reading": "Geen meting van deze batterij.",
@@ -448,6 +462,12 @@
"solar_forecast": "Zonneprognose",
"charger": "Laadpaal onbereikbaar",
"charger_writer": "Iets anders wijzigt de laadpaal",
"charger_other": "Iets anders wijzigt de laadpaal",
"charger_phases": "Laadpaal nam fasen niet over",
"charger_stuck": "Laadpaalmeting staat mogelijk vast",
"charger_refused": "Laadpaal nam het niet over",
"charger_error": "De laadpaal meldt een fout",
"car_over": "Auto boven de piekgrens",
"charger_setup": "Laadpaal niet ingesteld",
"none": "Verbinding met de omvormer"
},
+4 -2
View File
@@ -223,8 +223,8 @@ GROUPS = (
Field("delivery_hold_s", LOCKED, "s", step=5, show=_SEVERAL),
), collapsed=True),
)),
# EV-03: the car charger, read only. Everything after the choice shows
# only while a charger is switched on.
# EV-03: the car charger. Everything after the choice shows only while a
# charger is switched on. EV-04 adds the battery switch and the restart mode.
Group("car", (
Part("", (
Field("ev_charger", CHOICE, simple=True),
@@ -232,6 +232,8 @@ GROUPS = (
show=_CAR),
Field("ev_max_a", SLIDER, "A", simple=True, show=_CAR),
Field("ev_phases", SEGMENTED, simple=True, show=_CAR),
Field("ev_batt_cover", TOGGLE, simple=True, show=_CAR),
Field("ev_mode_start", SEGMENTED, simple=True, show=_CAR),
)),
)),
Group("maintenance", (
+10
View File
@@ -62,6 +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")
# MAINT-11: start or stop one battery's maintenance cycle (the unit is optional).
MAINT_ACTIONS = ("maint_start", "maint_abort")
@@ -176,6 +177,15 @@ def build_app(controller, selfcfg=None) -> web.Application:
return web.json_response({"ok": False,
"error": result["error"]},
status=400)
elif what in CAR_ACTIONS:
# EV-04: the car's mode, current or phases. Store state, applied by
# the writer's next step; nothing is written to the charger here.
result = await controller.handle_action(
what, value=body.get("value"))
if isinstance(result, dict) and "error" in result:
return web.json_response({"ok": False,
"error": result["error"]},
status=400)
elif what in MAINT_ACTIONS and body.get("unit") is not None:
# MAINT-11: one battery's cycle. No unit = the old bare call below.
result = await controller.handle_action(what, unit=body["unit"])
+10 -4
View File
@@ -873,16 +873,20 @@ options:
shadow_mode: "auto"
# ==========================================================================
# CAR CHARGER - read only (EV-03)
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
# ==========================================================================
# `off` is the shipped value and means NO CHANGE AT ALL: nothing is read,
# shown or announced, and the House tile and the house profile are as before.
# `alfen_ha` reads the charger through its Home Assistant integration. THIS
# VERSION NEVER WRITES TO THE CHARGER; later cards add the modes.
# `alfen_ha` drives the charger through its Home Assistant integration. The
# mode (Off or Manual), the current and the phases are runtime state in the
# store, not options. `ev_batt_cover`: the batteries help with the peak while
# the car charges. `ev_mode_start`: the mode after a restart.
ev_charger: "off"
ev_current_entity: ""
ev_max_a: 16
ev_phases: "auto"
ev_batt_cover: true
ev_mode_start: "keep"
# ==========================================================================
# ADVANCED - the control law and diagnostics
@@ -1262,7 +1266,7 @@ schema:
shadow_mode: list(auto|on|off)
# ==========================================================================
# CAR CHARGER - read only (EV-03)
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
# ==========================================================================
# `ev_current_entity` is the charger's current setpoint; the other entities
# are found from its name. `ev_max_a` may not exceed the charger's own station
@@ -1271,6 +1275,8 @@ schema:
ev_current_entity: str?
ev_max_a: int(6,40)
ev_phases: list(1|3|auto)
ev_batt_cover: bool
ev_mode_start: list(keep|off)
# ==========================================================================
# ADVANCED - the control law and diagnostics
+10 -6
View File
@@ -185,7 +185,9 @@ def callers_of_writes():
out = []
for root, _d, files in os.walk(os.path.join(HERE, "app")):
for f in files:
if not f.endswith(".py") or f == "chargers.py":
# EV-04: carmode.py is the one place that writes, and only in
# Manual (test_ev04.py grades it); chargers.py is the seam.
if not f.endswith(".py") or f in ("chargers.py", "carmode.py"):
continue
tree = ast.parse(io.open(os.path.join(root, f),
encoding="utf-8").read())
@@ -199,15 +201,17 @@ def callers_of_writes():
return out
check(f"nothing in the add-on calls write_current, write_phases or the "
f"charger's release ({callers_of_writes()})", not callers_of_writes())
check(f"nothing in the add-on but carmode.py calls write_current, "
f"write_phases or the charger's release ({callers_of_writes()})",
not callers_of_writes())
check("the seam does define them (the next cards use them)",
all(hasattr(CH.ChargerDriver, m) for m in
("write_current", "write_phases", "release")))
_ha = FakeHa(SimCharger())
asyncio.run(CH.AlfenHaDriver(SET, 16).bind(_ha).write_current(99))
check("the Alfen driver's write (a later card's) is clamped to the charger "
"limit, 16 A and not 99", _ha.sets == [(SET, 16.0)])
_took99 = asyncio.run(CH.AlfenHaDriver(SET, 16).bind(_ha).write_current(99))
check("the Alfen driver never sends 99 A against a 16 A limit (EV-04: a value "
"above the clamp is a software fault, not sent)",
_ha.sets == [] and _took99 is False)
# --------------------------------------------------------------------------- #
print("\n2. THE SEAM")
File diff suppressed because it is too large Load Diff
+522
View File
@@ -0,0 +1,522 @@
"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3).
`python3 -B test_ev10.py`
1. EV-10: the car alone takes the batteries to the peak reserve while the period
is still projected UNDER the aim: no alarm, one grey notice. A stuck car
figure with a house overload, and a house-only drain, still alarm. Mutant:
an uncorroborated car figure in the "period without the car" test.
2. EV-11: the grey row and the Car Why do not flicker while the car keeps the
period over the limit; a real end clears them after OVER_OFF_HOLD_S. The
alarm decision (`car_explains`) has no hold.
3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another
writer"; a real outside change afterwards still shows the row.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import asyncio
import dataclasses
import logging
import os
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import ctl_car, homeview, chargers as CH # noqa: E402
from app.main import Controller # noqa: E402
from app import freshness # noqa: E402
from chargersim import FakeHa, SimCharger # noqa: E402
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
import opt11_identity as rig # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
class _Log(logging.Handler):
def __init__(self):
super().__init__(logging.DEBUG)
self.rec = []
def emit(self, r):
self.rec.append((r.levelname, r.getMessage()))
LOG = _Log()
_lg = logging.getLogger("goodwe")
_lg.addHandler(LOG)
_lg.setLevel(logging.DEBUG)
_lg.propagate = False
# =========================================================================== #
print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)")
# =========================================================================== #
CAP = 4500.0 # the aim is 4450 W (50 W margin)
HOUSE = 1100.0
def at_reserve(plant, c):
"""The batteries reach the peak reserve late in the period, and the house
eases a little: the period is still projected UNDER the aim."""
plant.soc = 19.0
plant.load = lambda at: 780.0 + plant.ch.power_w
def alarms(r):
return P.ids(r, *P.ALARMS)
UNDER = [] # (second, projected W, aim W) while floor-limited
def watch(first, fn):
"""Events for seconds 840 to 894: `fn` at `first`, and a note of every
cycle in which the guard is floor-limited."""
def note(plant, c):
g = c.peak_guard
if g is not None and g.floor_limited:
UNDER.append((plant.t, g.projected_w, g.target_w))
ev = {t: note for t in range(first - 10, 895)}
ev[first] = lambda plant, c: (fn(plant, c), note(plant, c))
return ev
LOG.rec.clear()
r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, at_reserve))
ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")]
check("PRECONDITION: the guard was floor-limited with the projection UNDER "
"the aim (the rig's 5888 W against 6000 W)",
any(p < a for _t, p, a in UNDER))
check("the car alone: no 'Load too high', no 'Battery stopped limiting the "
"peak'", alarms(r10) == [])
rows10 = {x["id"]: x for x in r10["c"].checks()}
check("...no red row; the grey 'Car over the peak limit' row says it",
rows10["peak_guard"]["ok"] is True
and not [x for x in r10["c"].checks()
if x["ok"] is False and not x["warn"]]
and rows10.get("car_over", {}).get("ok") is True)
check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1)
check("...no ERROR (or WARNING) line was logged for it", ERR10 == [])
def house_stuck(plant, c):
at_reserve(plant, c)
plant.ch.freeze() # the reading stops moving
plant.ch.unplug() # the car really goes
plant.load = lambda at: 9000.0 + plant.ch.power_w
asyncio.get_event_loop().create_task(c.handle_action("car_current",
value=10))
r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, house_stuck))
check("a stuck car figure and a house overload at the reserve: the normal "
"alarm still fires",
[n for _t, n in alarms(r10s)]
and all(n in P.ALARMS for _t, n in alarms(r10s)))
def house_drain(plant, c):
plant.soc = 19.0
plant.load = lambda at: 12000.0 + plant.ch.power_w
r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, user_a=6, setpoint=6,
events=watch(600, house_drain))
check("a house-only drain to the reserve with the car charging little: the "
"normal alarm still fires",
alarms(r10h) != [] and not r10h["c"].car_explains)
def plug_late(plant, c):
plant.ch.plug_in()
def house_reserve(plant, c):
plant.soc = 19.0
plant.load = lambda at: 3075.0 + plant.ch.power_w
def swapped_events():
ev = watch(850, house_reserve)
ev[800] = plug_late
return ev
def swapped(mode):
return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode,
plug=False, events=swapped_events())
r10x = swapped("manual")
r10xo = swapped("off")
check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car "
"plugs in late (a small share); the projection is under the aim at the "
"reserve, and Off raises the alarm", alarms(r10xo) != []
and any(p < a for _t, p, a in UNDER))
check("the house drains the batteries and a small car is plugged in: the "
"normal alarm still fires in Manual", alarms(r10x) != [])
r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, mode="off", events=watch(850, at_reserve))
check("PRECONDITION: Off, the same case raises the normal alarm (the false "
"alarm Manual must not make)", alarms(r10off) != [])
# a direct unit of the rule: the car's average, the period without it
class _Car(ctl_car.CarMixin):
def __init__(self, cover=True, w=3700.0):
self.o = {"ev_batt_cover": cover}
self.w = w
self._now = 0.0
self.site_batt_w, self.site_rating_w = 300.0, 5000.0
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
def car_now(self):
return self._now
def car_alarm_w(self):
return self.w
class car: # noqa: N801
@staticmethod
def status(*_a):
return "charging"
@dataclasses.dataclass
class _Proj:
projected_w: float
elapsed_s: float = 850.0
held_w: float = 0.0
block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
def __post_init__(self):
self.held_w = self.projected_w
class _G:
def __init__(self, floor=True, sat=False, within_aim=False):
self.floor_limited, self.saturated = floor, sat
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0
self.engaged, self.blind, self.wanted_w = True, None, 300.0
self.within_aim = within_aim
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None,
within_aim=False):
c = _Car(cover, car_w)
p = _Proj(proj_w)
c._carq = {"key": p.block_start,
"ws": (car_w if car_so_far_w is None else car_so_far_w)
* p.elapsed_s, "mono": 0.0}
c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None)
return c.car_explains
check("rule: the alarm's test is true with the car (4468 W, the batteries "
"at 0 W land 4485 W) and false without it (768 W): the car explains it, "
"with the projection under the aim", explains(4468.0, 3700.0))
check("rule: where the alarm would not fire anyway nothing is explained",
not explains(4300.0, 3700.0, within_aim=True))
check("rule: without the car it is still over the aim: the car does not "
"explain it", not explains(9000.0, 3700.0))
check("rule: no car power, no explanation", not explains(9000.0, 0.0))
check("rule: the guard is not floor-limited or saturated: nothing to explain",
not explains(4300.0, 3700.0, floor=False))
# =========================================================================== #
print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)")
# =========================================================================== #
# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own
# quarter (14.0 kW) was the month peak, so the aim was that quarter's average
# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The
# projection crossed the aim every few seconds, `ex > 0` came and went, and
# `car_over` followed it with no hold on the way off.
def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0,
cover=False):
"""Run `car_cycle` once a second; returns (car_over, car_explains) per second."""
out = []
for k in range(secs):
t = t0 + k
c._now = t
c.w = w_of(t)
p = _Proj(proj_of(t), elapsed_s=300.0 + (t % 400))
c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s,
"mono": t}
c.car_cycle(p, _G(True), target, None)
out.append((c.car_over, c.car_explains))
return out
def noisy(t):
"""The projection straddles the aim: +-40 W, a new value every 7 s."""
return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3))
c11 = _Car(cover=False)
o11 = over_run(c11, 1200, noisy)
flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0])
check("while the car keeps the period at the limit the row stays on: one "
"switch on in 20 minutes, none off", flips == 1 and len(o11) == 1200 and o11[-1][0] is True)
check("it turns on after the existing 10 s hold, not later than the first "
"10 s the condition has stood (a gap does not restart the count)",
next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25)
# the condition on its own, for the PRECONDITION: the same input flips
c11o = _Car(cover=False)
raw = []
for k in range(1200):
c11o._now = float(k)
p = _Proj(noisy(k), elapsed_s=300.0 + (k % 400))
c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k}
ex = p.projected_w - 14000.0
raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex)
raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b)
check("PRECONDITION: the condition itself flips many times in those 20 "
"minutes", raw_flips > 20)
# a real end: the car stops (no trusted power) after 600 s
c11e = _Car(cover=False)
o11e = over_run(c11e, 1000, lambda t: 14500.0,
w_of=lambda t: 11000.0 if t < 600 else None)
off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1)
check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes",
off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S)
and not any(x[0] for x in o11e[off_at:]))
o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0)
check("it comes back after the usual 10 s if the condition returns after "
"it went", len(o11r) == 100 and o11r[9][0] is False and o11r[10][0] is True)
# the alarm decision has no hold: a real house overload is never delayed
c11a = _Car(cover=True)
o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0)
check("decision 1 on: the car explains it at once (no hold)",
len(o11a) == 60 and o11a[0][1] is True)
c11a.w = None # the figure is not trusted
c11a._now = 61.0
c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None)
check("...and the moment the car figure is not trusted it explains nothing, "
"so the normal alarms stand at once (the grey row may stay)",
c11a.car_explains is False)
# the whole thing on the real controller: the Why does not flicker either
def p7_like(plant, c):
plant.load = lambda at: 3000.0 + plant.ch.power_w
r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP,
phases=3, opts={"ev_batt_cover": False})
ov = [s[2] for s in r11["snaps"]]
check("real controller, cover off, an 11 kW car: the flag is steady once on",
sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True)
# =========================================================================== #
print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)")
# =========================================================================== #
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[0]
SET = "number.wallbox_power_connector_max_current_socket_1"
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
"pv_entities": ["sensor.pv"], "ev_charger": "alfen_ha", "ev_max_a": 16,
"ev_phases": "auto", "ev_current_entity": SET}
class _Store:
def __init__(self):
self.data = {}
def set(self, k, v):
self.data[k] = v
def get(self, k, d=None):
return self.data.get(k, d)
def set_time(self, k, v):
self.data[k] = v.isoformat()
def get_time(self, k):
v = self.data.get(k)
return None if v is None else datetime.fromisoformat(v)
class _Pub:
enabled = False
def publish(self, v):
pass
def close(self):
pass
class Site(FakeHa):
def __init__(self, charger):
super().__init__(charger, None)
async def limits(self, _e):
return (-5000.0, 5000.0, 1.0)
def _all(self):
out = super()._all()
for eid, val, unit in (("sensor.grid", 800.0, "W"),
("sensor.soc", 50.0, "%"),
("sensor.batt", 0.0, "W"),
("sensor.pv", 2000.0, "W")):
out[eid] = {"entity_id": eid, "state": str(val),
"attributes": {"unit_of_measurement": unit}}
return out
async def number(self, entity_id, invert=False):
s = self._all().get(entity_id)
try:
v = float(s["state"])
except (TypeError, ValueError, KeyError):
return None
return -v if invert else v
async def set_number(self, entity_id, value):
return await super().set_number(entity_id, float(value))
class World:
"""A real Controller on the charger model. While a write waits for its
read-back, the controller's own reading goes on (as in production, where
the cycle runs while the writer task waits): that is how the read-back of
our own write reaches the tracker BEFORE the write returns."""
def __init__(self, setpoint=10):
self.sim = SimCharger(setpoint_a=setpoint)
self.sim.plug_in()
self.sim.lag_s = 2.0 # the rig's read-back lag
self.sim.phases_allowed = 1
self.t = 1000.0
CLOCK[0] = self.t
self.c = Controller(dict(BASE), Site(self.sim), _Store(), _Pub(),
stop=asyncio.Event())
self.c.auto = True
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
self.drv = self.c.charger
self.drv._sleep = self.sleep
self.drv._clock = lambda: CLOCK[0]
async def sleep(self, s):
self.sim.tick(s)
self.t += s
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t) # the cycle reads on
async def step(self, n=1):
for _ in range(n):
self.sim.tick(1.0)
self.t += 1.0
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t)
await self.c.cycle()
await self.c.car_settle()
def rows(self):
return {r["id"]: r for r in self.c.checks()}
async def own_then_off(wait):
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(wait)
await w.c.handle_action("car_mode", value="off")
await w.step(40)
return w
w12 = asyncio.run(own_then_off(2))
check("PRECONDITION: the add-on wrote 12 A and the charger took it",
w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1)
check("our own write, then Off 2 s later: no 'Something else changes the "
"charger'", "charger_writer" not in w12.rows()
and w12.c.car.writer_at_utc is None)
w12b = asyncio.run(own_then_off(14))
check("...and 14 s later (inside the 15 s)", "charger_writer" not in
w12b.rows() and w12b.c.car.writer_at_utc is None)
async def own_then_outside():
w = await own_then_off(2)
w.sim.set_current(7) # somebody else, afterwards
await w.step(3)
early = "charger_writer" in w.rows()
await w.step(30)
return early, "charger_writer" in w.rows()
early12, late12 = asyncio.run(own_then_outside())
check("an outside change after that still shows the row (within 30 s)",
late12 is True)
async def manual_own():
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(60)
await w.c.handle_action("car_current", value=8)
await w.step(20)
return w
wm = asyncio.run(manual_own())
check("Manual: two writes of ours, never 'another writer' in the tracker",
wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows())
async def failed_write_then_outside(how):
"""A write that RAISES or returns FAILURE must still close the self-mute:
a later outside change shows the row."""
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
async def bad(a):
await w.sleep(1.0)
if how == "raise":
raise RuntimeError("the charger link broke")
return False
w.drv.write_current = bad
await w.c.handle_action("car_current", value=12)
await w.step(3) # the write is tried
await w.c.handle_action("car_mode", value="off")
await w.step(20) # past the 15 s mute
w.sim.set_current(7) # somebody else
await w.step(3)
return w
for how in ("raise", "fail"):
wf = asyncio.run(failed_write_then_outside(how))
check(f"a write that {'raises' if how == 'raise' else 'returns failure'}"
": the mute closes within 15 s, and a later outside change shows "
"the row", wf.c.car.mute_until < wf.t
and "charger_writer" in wf.rows())
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)
+114 -4
View File
@@ -2,6 +2,14 @@
"""EV-03: a model of an Alfen car charger behind Home Assistant, for the unit
tests and, later, for TEST-23.
EV-04 ADDS THE WRITE SIDE: `request_current()` and `request_phases()` are what
the add-on's writes reach. The new state is taken after `lag_s` seconds of
model time (the read-back lag), the power RAMPS to it, and `refuse` makes the
charger ignore a write ("ignore": Home Assistant says yes, the charger does not
change) or Home Assistant refuse it ("error"). `log` records every write with
the model's clock and the power and setpoint at that moment, so a test can
prove the safe phase sequence (0 A first, under 100 W before the phases move).
WHERE IT LIVES, AND WHY. The rig's hardware sims (`hwsim.py`, `plantsim.py`) are
in the infra repo admin/goodwe under `sim/`, pinned by `.gitea/infra-pin`; there
is no `sim/` in this repository. This card may write only to this repository, so
@@ -51,6 +59,18 @@ class SimCharger:
self.unavailable = False
self.login_on = True
self.error = "0: No Error"
# EV-04: the write side
self.t = 0.0 # model seconds
self.lag_s = 0.0 # a write shows in the read-back this late
self.refuse = None # None | "ignore" | "error"
self._snap = None # `freeze()`: the readings stop moving
self._frozen_w = None # `freeze_power()`: only the power does
self.no_energy = False # a charger with no energy entity
self.ramp_w_s = RAMP_W_S # how fast the power follows its target
self.stop_delay_s = 0.0 # mode3 stays C this long after 0 A
self._c_hold = 0.0
self.log = [] # (t, what, value, power_w, setpoint_a)
self._pending = []
# -- the world acts on it -------------------------------------------------
def plug_in(self, car_phases=3):
@@ -76,6 +96,44 @@ class SimCharger:
"""mode3 E or F: the charger's own error states."""
self.state, self.power_w = letter, 0.0
# -- what the add-on's writes reach (EV-04) ----------------------------------
def request_current(self, a):
"""`number.set_value` on the current. False: Home Assistant refused it
(out of the entity's 0-40 A range, or `refuse == "error"`)."""
a = float(a)
if a != a or a < 0.0 or a > 40.0 or self.refuse == "error":
return False
self.log.append((self.t, "current", a, self.power_w, self.setpoint_a))
if self.refuse == "ignore":
return True
self._later("current", a)
return True
def request_phases(self, n):
"""`select.select_option` on the installation's allowed phases."""
if self.refuse == "error" or n not in (1, 3):
return False
self.log.append((self.t, "phases", n, self.power_w, self.setpoint_a))
if self.refuse == "ignore":
return True
self._later("phases", n)
return True
def _later(self, what, v):
if self.lag_s <= 0:
self._apply(what, v)
else:
self._pending.append((self.t + self.lag_s, what, v))
def _apply(self, what, v):
if what == "current":
self.setpoint_a = self.readback_a = max(0.0, min(v, self.station_a))
else:
self.phases_allowed = 3 if v == 3 else 1
def writes(self, what=None):
return [x for x in self.log if what in (None, x[1])]
def go_unavailable(self, on=True):
self.unavailable = bool(on)
@@ -94,13 +152,22 @@ class SimCharger:
def tick(self, seconds=1.0):
for _ in range(int(max(1, round(seconds)))):
self.t += 1.0
for p in [x for x in self._pending if x[0] <= self.t]:
self._pending.remove(p)
self._apply(p[1], p[2])
if self.state in ("E", "F"): # a fault: nothing flows, it stays
self.power_w = 0.0
continue
if self.state != "A":
self.state = "C" if self.target_w() > 0 else "B"
if self.target_w() > 0:
self.state, self._c_hold = "C", 0.0
elif self.state == "C" and self._c_hold < self.stop_delay_s:
self._c_hold += 1.0 # the car has not let go yet
else:
self.state = "B"
tgt = self.target_w()
step = RAMP_W_S
step = self.ramp_w_s
if self.power_w < tgt:
self.power_w = min(tgt, self.power_w + step)
else:
@@ -113,7 +180,20 @@ class SimCharger:
if self.phases_used and self.power_w else 0.0)
return [per if i < self.phases_used else 0.0 for i in range(3)]
def freeze(self, on=True):
"""A stuck sensor: Home Assistant goes on serving the readings of this
moment, whatever the charger does after it."""
self._snap = self._build() if on else None
def freeze_power(self, on=True):
"""Only the power sensor sticks, at what it reads now; the energy meter
and the rest go on telling the truth."""
self._frozen_w = self.power_w if on else None
def states(self) -> dict:
return self._snap if self._snap is not None else self._build()
def _build(self) -> dict:
x = self.x
bad = "unavailable" if self.unavailable else None
@@ -134,7 +214,8 @@ class SimCharger:
{"A": "Available", "B": "EV Connected",
"C": "Charging Normal"}.get(self.state, "Error")),
st(f"sensor.{x}_active_power_total_socket_1",
f"{self.power_w:.0f}", "W"),
f"{self.power_w if self._frozen_w is None else self._frozen_w:.0f}",
"W"),
st(f"sensor.{x}_meter_reading_socket_1", f"{self.kwh:.2f}",
"kWh"),
st(f"sensor.{x}_current_l1_socket_1", f"{amps[0]:.1f}", "A"),
@@ -153,7 +234,10 @@ class SimCharger:
"state": bad or ("on" if self.login_on else "off"),
"attributes": {"device_class": "connectivity"}}),
]
return dict(rows)
out = dict(rows)
if self.no_energy:
out.pop(f"sensor.{x}_meter_reading_socket_1", None)
return out
class FakeHa:
@@ -195,10 +279,20 @@ class FakeHa:
async def set_number(self, entity_id, value):
self.sets.append((entity_id, value))
c = self.charger
if c is not None and entity_id == \
f"number.{c.x}_power_connector_max_current_socket_1":
return c.request_current(value)
return True
async def call(self, domain, service, data=None):
self.calls.append((domain, service, data))
c = self.charger
if c is not None and domain == "select" and service == "select_option" \
and (data or {}).get("entity_id") == \
f"select.{c.x}_installation_max_allowed_phases":
return c.request_phases(
3 if "3" in str((data or {}).get("option")) else 1)
return True
def charger_writes(self):
@@ -251,6 +345,22 @@ def _selftest():
assert c.state == "B" and c.power_w == 0 # under 6 A: paused
c.set_current(10); c.car_full(); c.tick(5)
assert c.state == "B" and c.power_w == 0 and c.readback_a == 10
# EV-04: writes, the read-back lag, a refusal
w = SimCharger(); w.plug_in(); w.tick(1)
assert w.request_current(12) and w.setpoint_a == 12
assert not w.request_current(41) and not w.request_current(-1)
w.lag_s = 3.0
assert w.request_current(8) and w.readback_a == 12
w.tick(2); assert w.readback_a == 12
w.tick(1); assert w.readback_a == 8
w.refuse = "ignore"
assert w.request_current(6) and w.readback_a == 8
w.refuse = "error"
assert not w.request_current(6) and not w.request_phases(3)
w.refuse = None; w.lag_s = 0.0
assert w.request_phases(3) and w.phases_allowed == 3
assert [x[1] for x in w.writes()] == ["current", "current", "current",
"phases"], w.writes()
c.go_unavailable()
assert c.states()[f"sensor.wallbox_active_power_total_socket_1"]["state"] \
== "unavailable"
+153
View File
@@ -0,0 +1,153 @@
#!/usr/bin/env python3
"""EV-04: the real Controller on the SAFETY-81 plant, plus a car charger.
python3 tools/ev04_peak.py # a few runs and what they raised
A 1 s cycle, a 3500 W cap, one battery switched Off (so only the peak guard
makes it give, at most `rating` W), a P1 meter that publishes 0.3 s before each
cycle, and `chargersim.SimCharger` behind the same Home Assistant: its power
is part of the load the meter sees, and the add-on reads and writes it through
the real driver. `events` is `{second: fn(plant, controller)}`, run before that
cycle: unplug, freeze the reading, step the house, change the user's current.
Used by test_ev04.py (sections 9 to 11) and, later, by the rig test."""
import asyncio
import logging
import os
import sys
import tempfile
import time
from datetime import timedelta
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import opt11_identity as rig # noqa: E402
import main_files # noqa: E402
import safety81_sim as s81 # noqa: E402
from app import packmode # noqa: E402
from app.main import Controller # noqa: E402
from app.p1 import make_sample, split_signed # noqa: E402
from app.store import unit_key # noqa: E402
from chargersim import SimCharger # noqa: E402
SET = "number.wallbox_power_connector_max_current_socket_1"
PHASES = "select.wallbox_installation_max_allowed_phases"
ALARMS = ("goodwe_peak_saturated", "goodwe_peak_soc_floor")
OVER = "goodwe_car_over"
class CarPlant(s81._Plant):
"""The SAFETY-81 plant with a charger on the same meter: the grid sees the
house, the car and what the battery does."""
def __init__(self, house, rating, soc, charger):
super().__init__(lambda at: house(at) + charger.power_w, rating, soc)
self.ch = charger
async def state(self, entity_id):
return self.ch.states().get(entity_id)
async def set_number(self, e, v):
if e == SET:
return self.ch.request_current(float(v))
return await super().set_number(e, v)
async def call(self, domain, service, data=None):
if domain == "select" and service == "select_option":
n = 3 if "3" in str((data or {}).get("option")) else 1
return self.ch.request_phases(n)
return await super().call(domain, service, data)
def drive(house, *, dur=300.0, rating=2000.0, soc=60.0, cap=3500.0, margin=50,
opts=None, plug=True, setpoint=16, phases=3, mode="manual",
user_a=16, events=None, sim=None, store=None):
"""Run it. Returns a namespace-like dict: plant, controller, charger, the
notification ids raised with their second, and the controller's rows."""
sim = sim or SimCharger(setpoint_a=setpoint)
if plug:
sim.plug_in()
sim.phases_allowed = phases
o = rig._options(1, dict({
"meter_source": "ha_signed", "p1_net_entity": "sensor.net",
"meter_phases": 1, "peak_cap_w": cap, "peak_margin_w": margin,
"battery_modes_enabled": True, "max_w": rating,
"ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
"ev_current_entity": SET}, **(opts or {})))
store = store or rig._Store()
store.data[unit_key("inverter-a", packmode.USE_KEY)] = False
store.data[packmode.USE_KEY] = False
db = os.path.join(tempfile.mkdtemp(prefix="ev4-"), "tariff.db")
out = {}
async def go():
plant = CarPlant(house, rating, soc, sim)
c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
peak_db_path=db)
for i in c.inverters:
i.dev_min, i.dev_max = -5000.0, 5000.0
c.auto = True
clock = [0.0]
c.car_now = lambda: clock[0]
if hasattr(c.charger, "_sleep"):
async def sleep(s):
sim.tick(s)
clock[0] += s
c.charger._sleep = sleep
c.charger._clock = lambda: clock[0]
real_dt = main_files.live.datetime
class _DT(real_dt):
@classmethod
def now(cls, tz=None):
return rig.BASE + timedelta(seconds=clock[0])
main_files.live.datetime = _DT
c.car_mode, c.car_n, c.car_a = mode, phases, float(user_a)
snaps = []
try:
t = 0.0
while t < dur:
plant.t = clock[0] = t
fn = events_in.get(int(t)) if t == int(t) else None
if fn is not None:
fn(plant, c)
sim.tick(1.0)
ts = t - s81.SAMPLE_LEAD_S
plant.meter = plant.grid(ts)
imp, exp = split_signed(plant.meter)
c.p1.submit(make_sample(
"ha_signed", imp, exp, phases=1,
ingest_ts=rig.BASE + timedelta(seconds=ts),
ingest_mono=time.monotonic()))
await c.read_inputs(now_mono=t)
await c.cycle()
await c.car_settle()
snaps.append((t, c.car_explains, c.car_over,
(c.peak_guard.engaged if c.peak_guard else None),
plant.batt(t), sim.power_w))
t += s81.TICK
finally:
main_files.live.datetime = real_dt
raised = [(at, nid) for at, nid in plant.notes]
out.update(plant=plant, c=c, sim=sim, raised=raised, snaps=snaps,
store=store)
events_in = events or {}
asyncio.run(go())
return out
def ids(out, *wanted):
return [(t, n) for t, n in out["raised"] if n in wanted]
if __name__ == "__main__":
logging.disable(logging.CRITICAL)
for name, kw in (
("car 11 kW, house 1.1 kW, Manual",
dict(house=s81.constant(1100.0))),
("same, Off", dict(house=s81.constant(1100.0), mode="off"))):
r = drive(**kw)
print(f"{name:34s} alarms {ids(r, *ALARMS)} "
f"car notice {ids(r, OVER)}")
+23 -2
View File
@@ -109,7 +109,7 @@ class Hass:
# real `Controller._read_charger()` reads it, so the card is what the add-on
# draws, not a picture.
CAR_STATES = ("car", "car_none", "car_waiting", "car_full", "car_unreach",
"car_setup")
"car_setup", "car_manual_cover", "car_manual_over")
CAR_ENTITY = "number.wallbox_power_connector_max_current_socket_1"
SIM = SimCharger()
@@ -126,7 +126,7 @@ def car_setup(state):
"""Put the model in the state's situation."""
global SIM
SIM = SimCharger(name="other" if state == "car_setup" else "wallbox")
if state in ("car", "car_unreach"):
if state in ("car", "car_unreach", "car_manual_cover", "car_manual_over"):
SIM.plug_in()
SIM.set_phases(3)
SIM.set_current(16)
@@ -332,6 +332,27 @@ def controller(state):
for inv in c.inverters:
inv.batt = 0.0
c.car.stale_s = 15.0
if state in ("car_manual_cover", "car_manual_over"):
# EV-04, Manual at 16 A on 3 phases. First moment: the batteries give
# 5 kW and the period stays on the aim. Second: they are at the peak
# reserve, so the charge you set sets the month's peak.
c.car_mode, c.car_a, c.car_n = "manual", 16.0, 3
if state == "car_manual_cover":
c.pv_w, c.grid = 4100.0, 3450.0
for inv in c.inverters:
inv.batt = 2500.0
c.peak_guard = PeakDecision(
engaged=True, floor_w=3000.0, ceiling_w=3500.0,
ceiling_from="cap", projected_w=3450.0, excess_w=1500.0)
else:
c.pv_w, c.grid = 2400.0, 10200.0
for inv in c.inverters:
inv.soc, inv.batt = 19.0, 0.0
c.peak_guard = PeakDecision(
engaged=True, floor_w=0.0, ceiling_w=3500.0,
ceiling_from="cap", projected_w=10200.0, excess_w=6750.0,
floor_limited=True, soc=19.0, soc_floor=20.0)
c.car_over = c.car_explains = True
if state == "alarm":
c.inverters[0].sign_wd.tripped = True
if state in P3:
+7 -1
View File
@@ -285,7 +285,7 @@ configuration:
description: "The add-on makes every decision but keeps every inverter at 0 W. 'auto' does this while control is stopped, 'on' always, 'off' never."
ev_charger:
name: "Car charger · Charger"
description: "Which car charger the add-on reads. Off leaves everything as it is. This version only reads the charger and never changes it."
description: "Which car charger the add-on drives. Off leaves everything as it is. In Off mode the add-on only reads the charger and never changes it."
ev_current_entity:
name: "Car charger · Current setting entity"
description: "The entity that sets the charger's current. The add-on finds the charger's other entities from its name."
@@ -295,6 +295,12 @@ configuration:
ev_phases:
name: "Car charger · Phases"
description: "How many phases the charger may use: 1, 3, or 1 and 3 (auto)."
ev_batt_cover:
name: "Car charger · Batteries help with the peak"
description: "While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak."
ev_mode_start:
name: "Car charger · Mode after a restart"
description: "Keep the last mode, or start in Off. A restart never changes the charger's current."
auto_start:
name: "Advanced · Start control on boot"
description: "Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart."
+7 -1
View File
@@ -266,7 +266,7 @@ configuration:
description: "De add-on neemt elke beslissing maar houdt elke omvormer op 0 W. 'auto' doet dit zolang de regeling gestopt is, 'on' altijd, 'off' nooit."
ev_charger:
name: "Laadpaal · Laadpaal"
description: "Welke laadpaal de add-on leest. Uit laat alles zoals het is. Deze versie leest de laadpaal alleen en wijzigt niets."
description: "Welke laadpaal de add-on stuurt. Uit laat alles zoals het is. In modus Uit leest de add-on de laadpaal alleen en wijzigt niets."
ev_current_entity:
name: "Laadpaal · Entiteit van de laadstroom"
description: "De entiteit die de stroom van de laadpaal instelt. De add-on vindt de andere entiteiten van de laadpaal via de naam."
@@ -276,6 +276,12 @@ configuration:
ev_phases:
name: "Laadpaal · Fasen"
description: "Hoeveel fasen de laadpaal mag gebruiken: 1, 3, of 1 en 3 (auto)."
ev_batt_cover:
name: "Laadpaal · Batterijen helpen met de piek"
description: "Terwijl de auto laadt. Aan: de batterijen dekken ze tot de piekreserve. Uit: de piekbewaking laat de auto buiten beschouwing, dus de auto alleen kan de piek bepalen."
ev_mode_start:
name: "Laadpaal · Modus na een herstart"
description: "De laatste modus houden, of starten in Uit. Een herstart verandert de stroom van de laadpaal nooit."
auto_start:
name: "Geavanceerd · Regeling starten bij opstarten"
description: "Staat standaard uit. Laat het uit tot de installatie in dienst is, zodat iemand na elke herstart op Start drukt."