Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b12776c705 | ||
|
|
b86c0153cf | ||
|
|
269b89d6b0 | ||
|
|
646f61e730 | ||
|
|
a60342e4e8 | ||
|
|
50d5ae90d2 | ||
|
|
8efc385956 | ||
|
|
75ebe22a4d | ||
|
|
6e6344eb02 | ||
|
|
f31dcb62b6 | ||
|
|
661a3b009a | ||
|
|
0c92239a63 |
@@ -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,161 @@
|
||||
# EV-04 — Manual mode: the first write to a car charger
|
||||
|
||||
The design is `reports/EV-01-design-report.md` (sections 2 to 5), accepted on
|
||||
2026-11-15 with all eight decisions as recommended. This record keeps what the
|
||||
code had to decide that the design left open.
|
||||
|
||||
## What writes, and who may
|
||||
|
||||
`app/carmode.py` `ManualWriter` is the only caller of `write_current` and
|
||||
`write_phases` (test_ev03.py greps for any other). It runs in a background task
|
||||
(`ctl_car.CarMixin.car_kick`), never in the control cycle: a write waits up to
|
||||
10 s for the charger's read-back, and the cycle must never wait for a charger.
|
||||
|
||||
- **Off writes nothing.** The mode is runtime state in the store (`car_mode`,
|
||||
`car_current`, `car_phases`), changed on Home or from Home Assistant with no
|
||||
restart. Solar and Night are not accepted (EV-05, EV-02).
|
||||
- **Once per user change.** A user change sets a flag the writer clears when the
|
||||
charger has what was asked. A difference nobody asked for is the other-writer
|
||||
detector's business, not a reason to write.
|
||||
- **No car or a full car: nothing is written**, and the setting waits for a car.
|
||||
- **Shadow mode and a stopped control write nothing**; the card says what the add-on
|
||||
would set.
|
||||
- **The clamp is the driver's too.** The writer asks for at most the clamp, and
|
||||
`AlfenHaDriver.write_current` refuses anything above
|
||||
`min(ev_max_a, station limit read now, entity range max)`: it sends nothing,
|
||||
logs `CHARGER_CLAMP` at ERROR (the OUTPUT_CLAMP shape) and answers False.
|
||||
- **"Taken"** means the read-back followed within 10 s. A write that was not
|
||||
taken is tried again after a minute, three times, then it waits for the user
|
||||
(an amber row). A late read-back is adopted, never called another writer.
|
||||
|
||||
## The phase sequence
|
||||
|
||||
0 A, wait until the charger reports under 100 W or mode3 leaves C (20 s at most),
|
||||
select the phases, wait 10 s, write the current. One switch per 10 minutes. A
|
||||
charger that does not take the 0 A never gets the phases select. A sequence that
|
||||
has begun is finished whatever the mode, because it leaves the car at 0 A
|
||||
otherwise; a stop of the add-on in the middle gives the car its current back
|
||||
(`car_shutdown`).
|
||||
|
||||
## Another writer
|
||||
|
||||
A read-back that differs from what the add-on last wrote (or tried to write, or
|
||||
saw before a refused write) for 30 s is another writer: a grey row, and no write
|
||||
until the user changes the mode or a value. EV-03's detector still serves Off;
|
||||
the tracker mutes its own detector for 15 s after each of our writes, so Manual
|
||||
back to Off does not show the add-on as a second writer.
|
||||
|
||||
## The peak guard's alarm path
|
||||
|
||||
`Controller` passes the car's power to the guard's alarm path (`car_cycle`).
|
||||
**The car explains the excess when the house alone would land the period under
|
||||
the aim**: the car's average over the whole period (what it drew so far, and its
|
||||
power now for the rest, `car_avg_w`) is at least how far the projected period is
|
||||
over the aim. With decision 1 on it also needs the guard to be unable to hold
|
||||
it (saturated or at the peak reserve). Then "Load too high" and "Battery stopped
|
||||
limiting the peak" are not raised, the rows are not red, and one grey notice per
|
||||
charging session says so. The claim, the floor and the commands are unchanged.
|
||||
|
||||
The brief's wording is `car_w >= projected excess over the aim`. The
|
||||
instantaneous form (`car_w >= excess_w`, the watts to come off the meter now)
|
||||
stops holding late in a period that the car already pushed over, because
|
||||
`excess_w` grows as the seconds run out; the average form does not, and it is the
|
||||
same test for a steady car.
|
||||
|
||||
**A stale, stuck or frozen car figure must never hide a real overload.** Only
|
||||
`CarTracker.car_w_trusted` is used: fresh (the EV-03 rules, which also make an
|
||||
unavailable reading None at once), not stuck after a write (SAFETY-37's shape),
|
||||
never above what the read-back allows, and CORROBORATED by the charger's energy
|
||||
meter (round 2). The rule (`CarTracker.corroborated`, constants `CORR_*` in
|
||||
`chargers.py`): the charger reports charging (mode3 C) and has an energy entity,
|
||||
and, looking back over unbroken charging readings to the shortest stretch that
|
||||
is at least 55 s long and over which the reported power adds up to at least
|
||||
40 Wh, the meter has gained at least 50 % of that, less 15 Wh (the meter shows
|
||||
10 Wh steps, so at 40 Wh it must show one step; an honest car can fall one step
|
||||
short and still passes). Readings are kept 180 s. A gap, a state other than C or
|
||||
a meter that goes back starts the history again. With no such stretch yet (a
|
||||
session just began, or the add-on just started) the figure is believed, so a
|
||||
charge does not raise false alarms for its first minute; a frozen figure is
|
||||
believed for that long only. No energy entity: never corroborated, so the normal
|
||||
alarms stand. **Bound:** a frozen figure of P watts on a car that has really
|
||||
stopped is caught within max(60 s, 40 Wh / P): 60 s from 2.4 kW up, 104 s at
|
||||
1.38 kW (6 A, 1 phase, the lowest charge), plus the alarms' own 10 s hold. Below
|
||||
about 0.8 kW (40 Wh over the 180 s kept) the figure is believed; it cannot hide
|
||||
an overload that matters. (Round 2 had a 15 Wh slack that cancelled the 50 % rule
|
||||
up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
|
||||
## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3)
|
||||
|
||||
- **The car is the cause when the alarm's own test says so, on the same
|
||||
landing** (EV-10). `car_cycle` (`_car_explains_alarm`) runs the alarm's test on
|
||||
the period as it is and on the period without the car's fresh, corroborated
|
||||
average (`car_exclude_alarm`, EV-10b below): the car explains the alarm only if it is true with the
|
||||
car and false without it. A saturated guard, and a floor with other batteries
|
||||
left, use `load_too_high` on the landing (the batteries give only what they
|
||||
still can). A floor that leaves nothing uses SAFETY-126's `misses_aim` (the
|
||||
batteries at 0 W from now on), which is latched for the quarter; the add-on keeps
|
||||
that latch twice, with and without the car, from the same readings. Both reset
|
||||
at a new quarter and when the guard stops wanting power, and they run every
|
||||
cycle, so the cover option does not touch them. This holds with the projection
|
||||
still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the
|
||||
same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`,
|
||||
sets the latch without the car, and the normal alarms stand. There is no minimum
|
||||
car power: the comparison itself is what separates car from house.
|
||||
- **The period without the car is not clipped at 0 W** (EV-10b). The rig showed
|
||||
EV-10 failing: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
|
||||
give more than the house uses, so the house alone is an export; `car_exclude`
|
||||
clipped it at 0 W, `misses_aim` added the batteries' full 8.1 kW back, the
|
||||
"house needs the batteries" latch set early in the quarter, and the floor alarm
|
||||
could never be explained. `car_exclude_alarm` (alarm grading only) builds the
|
||||
house alone as: rest of the period `held - car_w`, keeping its sign, so
|
||||
`misses_aim` adds the batteries back to `held - car_w + batt` = the house; done
|
||||
part `max(0, done - car so far)` in Ws (no export is credited that only the
|
||||
car caused); landing `(done + max(held, 0) * left) / 900`. Without a fresh
|
||||
car reading it is the period as it is. `car_exclude` (the projection the guard
|
||||
sees with the cover off) is unchanged, with its clip.
|
||||
- **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
@@ -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
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -0,0 +1,402 @@
|
||||
"""EV-04: the Controller's side of the car's Manual mode.
|
||||
|
||||
The writes themselves are `carmode.ManualWriter`'s; this mixin owns the state
|
||||
(mode, current, phases: runtime state in the store, like OPT-11's modes), the
|
||||
actions, the background step that never holds up a control cycle, and what the
|
||||
car means for the peak guard's ALARM PATH. DECISIONS/EV-04-manual-mode.md.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import logging
|
||||
from datetime import timezone
|
||||
|
||||
from . import carmode, chargers, messages, peakguard
|
||||
from .tariff import QUARTER_S
|
||||
|
||||
_LOG = logging.getLogger("goodwe")
|
||||
|
||||
CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W}
|
||||
CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept
|
||||
CAR_PEAK_KEEP = 3200 # about a month of quarters
|
||||
OVER_HOLD_S = peakguard.ALARM_HOLD_S
|
||||
# EV-11: the card, the row and Why stay on this long after the car stops being
|
||||
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
|
||||
# sampling) and shorter than a quarter, or until the session really ends.
|
||||
OVER_OFF_HOLD_S = 180.0
|
||||
|
||||
|
||||
class CarMixin:
|
||||
# ------------------------------------------------------------------ state
|
||||
def car_init(self, opts, store) -> None:
|
||||
"""Mode, current and phases from the store; `ev_mode_start` says what a
|
||||
restart does with the mode. A site with no charger keeps defaults and
|
||||
writes nothing."""
|
||||
data = getattr(store, "data", None) or {}
|
||||
self.car_mode = carmode.start_mode(opts, data.get(carmode.KEY_MODE))
|
||||
if carmode.start_mode(opts, carmode.MANUAL) == carmode.OFF \
|
||||
and data.get(carmode.KEY_MODE) not in (None, carmode.OFF):
|
||||
store.set(carmode.KEY_MODE, carmode.OFF)
|
||||
clamp = carmode.clamp_for(opts, None)
|
||||
a = carmode.value_a(data.get(carmode.KEY_A, carmode.DEFAULT_A), clamp)
|
||||
self.car_a = carmode.DEFAULT_A if a is None else a
|
||||
n = data.get(carmode.KEY_PHASES, carmode.DEFAULT_PHASES)
|
||||
ok = carmode.allowed_phases(opts)
|
||||
self.car_n = n if n in ok else ok[0]
|
||||
self.car_rev = 0
|
||||
self.car_writer = carmode.ManualWriter()
|
||||
self._car_task = None
|
||||
self._car_step_failed = False
|
||||
self.car_explains = False # the car alone explains the excess
|
||||
self.car_over = False # ... held: the card and row say so
|
||||
self._car_over_since = None
|
||||
self._car_over_gone = None
|
||||
self._car_batt_prev = None
|
||||
self._car_need_real = self._car_need_excl = False # EV-10 latches
|
||||
self._car_latch_block = None
|
||||
self._car_over_notified = None # the session a notice was raised for
|
||||
self._car_session = 0
|
||||
self._car_prev_state = None
|
||||
self._carq = {"key": None, "ws": 0.0, "mono": None}
|
||||
self._peak_proj_real = None
|
||||
saved = data.get(CAR_PEAK_KEY)
|
||||
self.car_peak_q = dict(saved) if isinstance(saved, dict) else {}
|
||||
|
||||
@property
|
||||
def car_cover(self) -> bool:
|
||||
"""Decision 1: do the batteries help cover the car down to the peak
|
||||
reserve? Default yes."""
|
||||
v = self.o.get("ev_batt_cover")
|
||||
return bool(chargers.EV_OPTION_DEFAULTS["ev_batt_cover"]
|
||||
if v is None else v)
|
||||
|
||||
def car_manual(self) -> bool:
|
||||
return (self.charger.configured()
|
||||
and self.car_mode == carmode.MANUAL)
|
||||
|
||||
def car_clamp(self):
|
||||
return carmode.clamp_for(self.o, self.car.reading)
|
||||
|
||||
def car_writing(self) -> bool:
|
||||
"""May the add-on write to the charger now? Control runs, shadow mode is
|
||||
off, no safety stop is latched and the add-on is not shutting down. Shadow mode gates charger
|
||||
writes exactly as it gates inverter writes."""
|
||||
latched = (any(i.sign_wd.tripped for i in self.inverters)
|
||||
or self.site_sign_wd.tripped or self.circ_wd.tripped)
|
||||
return bool(self.auto and not self.shadow and not latched
|
||||
and not getattr(self, "stopping", False))
|
||||
|
||||
# ---------------------------------------------------------------- actions
|
||||
def _car_action(self, what, value, now) -> dict:
|
||||
"""The mode, the current or the phases, from the page or from Home
|
||||
Assistant. Store state, applied by the next step with no restart."""
|
||||
if not self.charger.configured():
|
||||
return {"error": messages.car_refused("off")}
|
||||
if what == "car_mode":
|
||||
if value not in carmode.MODES:
|
||||
return {"error": messages.car_refused("value")}
|
||||
self.car_mode = value
|
||||
self.store.set(carmode.KEY_MODE, value)
|
||||
elif what == "car_current":
|
||||
clamp = self.car_clamp()
|
||||
if isinstance(value, bool):
|
||||
return {"error": messages.car_refused("value")}
|
||||
a = carmode.value_a(value, clamp)
|
||||
try:
|
||||
inside = a is not None and abs(float(value) - a) < 0.5
|
||||
except (TypeError, ValueError):
|
||||
inside = False
|
||||
if not inside:
|
||||
return {"error": messages.car_refused("value")}
|
||||
self.car_a = a
|
||||
self.store.set(carmode.KEY_A, a)
|
||||
else:
|
||||
if value not in (1, 3) or isinstance(value, bool):
|
||||
return {"error": messages.car_refused("value")}
|
||||
if value not in carmode.allowed_phases(self.o):
|
||||
return {"error": messages.car_refused("phases")}
|
||||
self.car_n = value
|
||||
self.store.set(carmode.KEY_PHASES, value)
|
||||
self.car_rev += 1
|
||||
self.car_writer.user_changed()
|
||||
self.log_event(f"car {what[4:]} set to {value} by operator",
|
||||
hint=messages.hint(what))
|
||||
return {"mode": self.car_mode, "current": self.car_a,
|
||||
"phases": self.car_n}
|
||||
|
||||
def car_command_values(self) -> dict:
|
||||
"""The MQTT state of the three car entities."""
|
||||
return {"car_mode": carmode.MODE_LABELS[self.car_mode],
|
||||
"car_current": round(self.car_a),
|
||||
"car_phases": str(self.car_n)}
|
||||
|
||||
# ------------------------------------------------------------- the writer
|
||||
def car_kick(self) -> None:
|
||||
"""Start one writer step in the background, unless one is running. A
|
||||
write waits up to 10 s for the charger's read-back, and a control cycle
|
||||
never waits for the charger."""
|
||||
if not self.charger.configured():
|
||||
return
|
||||
t = self._car_task
|
||||
if t is not None and not t.done():
|
||||
return
|
||||
self._car_task = asyncio.ensure_future(self._car_run())
|
||||
|
||||
async def car_settle(self) -> None:
|
||||
"""Wait for the writer step in flight (the checks use it)."""
|
||||
t = self._car_task
|
||||
if t is not None:
|
||||
await asyncio.gather(t, return_exceptions=True)
|
||||
|
||||
async def _car_run(self) -> None:
|
||||
try:
|
||||
await self.car_step()
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception: # noqa: BLE001
|
||||
# Once at WARNING-and-above, then quietly: a step that fails
|
||||
# fails every second.
|
||||
if not self._car_step_failed:
|
||||
self._car_step_failed = True
|
||||
_LOG.exception("The car charger step failed")
|
||||
else:
|
||||
_LOG.debug("The car charger step failed again", exc_info=True)
|
||||
else:
|
||||
self._car_step_failed = False
|
||||
|
||||
async def car_shutdown(self) -> None:
|
||||
"""The add-on stops: no new write, and a phase change in the middle is
|
||||
undone by giving the car its current back. The current stands
|
||||
otherwise (Manual's fail state)."""
|
||||
t, self._car_task = getattr(self, "_car_task", None), None
|
||||
if t is not None and not t.done():
|
||||
t.cancel()
|
||||
await asyncio.gather(t, return_exceptions=True)
|
||||
if not self.charger.configured() \
|
||||
or getattr(self, "car_writer", None) is None \
|
||||
or self.car_writer.seq is None:
|
||||
return
|
||||
try:
|
||||
await asyncio.wait_for(self.car_writer.abandon(
|
||||
self.charger, self.car_now(), self.car, self.car_clamp()),
|
||||
15.0)
|
||||
except Exception: # noqa: BLE001
|
||||
_LOG.warning("The car could not be given its current back "
|
||||
"before the add-on stopped: CHARGER_RESTORE.")
|
||||
|
||||
async def car_step(self) -> None:
|
||||
"""One step of Manual. Reads nothing from the world (the cycle's read
|
||||
did) and writes only through `carmode.ManualWriter`."""
|
||||
if not self.charger.configured():
|
||||
return
|
||||
now = self.car_now()
|
||||
await self.car_writer.step(
|
||||
self.charger, self.car.reading, mode=self.car_mode,
|
||||
want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
|
||||
clamp=self.car_clamp(), now=now, tracker=self.car,
|
||||
writing=self.car_writing(), shadow=bool(self.shadow),
|
||||
status=self.car.status(now, True), clock=self.car_now)
|
||||
|
||||
# ------------------------------------------- the car and the peak guard
|
||||
def car_alarm_w(self):
|
||||
"""The car's power for the guard's alarm path: Manual only, fresh, not
|
||||
stuck (`CarTracker.car_w_trusted`), and never above what the read-back
|
||||
allows. None otherwise, and then the normal alarms stand."""
|
||||
if not self.car_manual():
|
||||
return None
|
||||
return self.car.car_w_trusted(self.car_now())
|
||||
|
||||
def _car_quarter(self, proj, w, mono) -> None:
|
||||
"""The car's energy in the open quarter, for the average the guard's
|
||||
house leaves out and for the peak line."""
|
||||
q = self._carq
|
||||
key = None if proj is None else proj.block_start
|
||||
last = q["mono"]
|
||||
if key != q["key"]:
|
||||
self._car_bank(q)
|
||||
q["key"], q["ws"] = key, 0.0
|
||||
if key is not None and w is not None and last is not None:
|
||||
q["ws"] += float(w) * min(max(mono - last, 0.0), 5.0)
|
||||
q["mono"] = mono
|
||||
|
||||
def _car_bank(self, q) -> None:
|
||||
"""A closed quarter in which the car drew its share goes on the list."""
|
||||
key = q["key"]
|
||||
if key is None:
|
||||
return
|
||||
avg = q["ws"] / QUARTER_S
|
||||
if avg < CAR_PEAK_MIN_W:
|
||||
return
|
||||
self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg)
|
||||
if len(self.car_peak_q) > CAR_PEAK_KEEP:
|
||||
for k in sorted(self.car_peak_q)[:-CAR_PEAK_KEEP]:
|
||||
del self.car_peak_q[k]
|
||||
self.store.set(CAR_PEAK_KEY, dict(self.car_peak_q))
|
||||
|
||||
def car_avg_w(self, proj, w) -> float:
|
||||
"""The car's average over the whole open quarter: what it drew so far
|
||||
and `w` for the rest."""
|
||||
if proj is None or w is None:
|
||||
return 0.0
|
||||
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
||||
so_far = self._carq["ws"] if self._carq["key"] == proj.block_start \
|
||||
else 0.0
|
||||
return (so_far + float(w) * left) / QUARTER_S
|
||||
|
||||
def car_exclude(self, proj, w):
|
||||
"""Decision 1 off: the projection the guard sees without the car
|
||||
(`house - car_w`). Unchanged without a fresh car reading."""
|
||||
if proj is None or w is None or proj.block_start is None:
|
||||
return proj
|
||||
avg = self.car_avg_w(proj, w)
|
||||
return dataclasses.replace(
|
||||
proj, projected_w=max(0.0, float(proj.projected_w) - avg),
|
||||
held_w=max(0.0, float(proj.held_w) - float(w)))
|
||||
|
||||
def car_exclude_alarm(self, proj, w):
|
||||
"""EV-10b: the period as it would be without the car, for grading the
|
||||
alarm. The house alone, the batteries giving only what the house
|
||||
would draw from them: the car's share of their power is not charged to
|
||||
the house. The rest of the period keeps its sign (`held - car`, an
|
||||
export while the batteries give more than the house uses), so
|
||||
`misses_aim` adds the batteries back to exactly the house. What is
|
||||
already done is clipped at 0 Ws: no export is credited for power only
|
||||
the car asked for. 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)
|
||||
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
||||
held = float(proj.held_w)
|
||||
done_ws = QUARTER_S * float(proj.projected_w) - max(held, 0.0) * left
|
||||
car_ws = avg * QUARTER_S - float(w) * left # the car so far
|
||||
held_x = held - float(w)
|
||||
return dataclasses.replace(
|
||||
proj, held_w=held_x,
|
||||
projected_w=(max(0.0, done_ws - car_ws)
|
||||
+ max(held_x, 0.0) * left) / QUARTER_S)
|
||||
|
||||
def car_cycle(self, real_proj, guard, target_w, now_utc) -> None:
|
||||
"""After the guard has decided: does the car alone explain the excess?
|
||||
`real_proj` is the projection WITH the car, whatever the guard saw."""
|
||||
mono = self.car_now()
|
||||
w = self.car_alarm_w()
|
||||
self._car_quarter(real_proj, w, mono)
|
||||
self._car_session_tick(mono)
|
||||
explains = over = False
|
||||
if real_proj is not None and target_w is not None \
|
||||
and real_proj.block_start is not None:
|
||||
# EV-10: every cycle, so the latches do not depend on the option.
|
||||
graded = self._car_explains_alarm(real_proj, guard, target_w, w)
|
||||
if self.car_cover:
|
||||
explains = over = graded
|
||||
elif w is not None:
|
||||
ex = float(real_proj.projected_w) - float(target_w)
|
||||
over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
|
||||
self.car_explains = explains
|
||||
# EV-11: on once the condition has stood for OVER_HOLD_S, a short gap
|
||||
# in it not starting that count again; off only after it has been gone
|
||||
# for OVER_OFF_HOLD_S. `car_explains` (the alarm decision) has no hold.
|
||||
if over:
|
||||
self._car_over_gone = None
|
||||
if self._car_over_since is None:
|
||||
self._car_over_since = mono
|
||||
if mono - self._car_over_since >= OVER_HOLD_S:
|
||||
self.car_over = True
|
||||
else:
|
||||
if self._car_over_gone is None:
|
||||
self._car_over_gone = mono
|
||||
if mono - self._car_over_gone >= OVER_OFF_HOLD_S:
|
||||
self.car_over, self._car_over_since = False, None
|
||||
self._car_over_gone = None
|
||||
|
||||
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
|
||||
"""EV-10: is the alarm's own test true with the car and false without
|
||||
its fresh, corroborated share (`car_exclude_alarm`), on the same landing? The
|
||||
tests are the alarms': a saturated guard and a floor with other
|
||||
batteries left are graded by `load_too_high` on where the period lands
|
||||
(SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's
|
||||
`misses_aim` (the batteries at 0 W from now on), latched for the
|
||||
quarter. That latch is kept here twice, on the period as it is
|
||||
(`_car_need_real`) and without the car (`_car_need_excl`), from the
|
||||
same `misses_aim` and the same batteries reading. Both reset at a new
|
||||
quarter and when the guard no longer wants power, whatever the cover
|
||||
option says (this runs every cycle). A car that is 0 W, or untrusted
|
||||
(`w` None sets the second latch), makes the two equal and explains
|
||||
nothing."""
|
||||
batt, prev = self.site_batt_w, self._car_batt_prev
|
||||
self._car_batt_prev = batt
|
||||
wants = bool(guard is not None and guard.engaged
|
||||
and guard.blind is None
|
||||
and (guard.wanted_w or 0.0) > 0.0)
|
||||
if real_proj.block_start != self._car_latch_block:
|
||||
self._car_latch_block = real_proj.block_start
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
if not wants:
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
if batt is not None and prev is not None:
|
||||
batt = min(float(batt), float(prev))
|
||||
excl = self.car_exclude_alarm(real_proj, w)
|
||||
if wants:
|
||||
if batt is None:
|
||||
self._car_need_real = self._car_need_excl = True
|
||||
else:
|
||||
self._car_need_real = self._car_need_real or \
|
||||
peakguard.misses_aim(real_proj, batt_w=batt,
|
||||
target_w=target_w)
|
||||
self._car_need_excl = self._car_need_excl or w is None or \
|
||||
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
|
||||
if w is None or batt is None or not wants \
|
||||
or not (guard.saturated or guard.floor_limited):
|
||||
return False
|
||||
if guard.saturated:
|
||||
rating = self.site_rating_w
|
||||
elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None:
|
||||
rating = guard.able_w
|
||||
else:
|
||||
return bool(not guard.within_aim and self._car_need_real
|
||||
and not self._car_need_excl)
|
||||
|
||||
def high(p):
|
||||
return peakguard.load_too_high(
|
||||
p, batt_w=batt, ceiling_w=guard.ceiling_w,
|
||||
achievable_w=rating)
|
||||
return bool(high(real_proj) and not high(excl))
|
||||
|
||||
def _car_session_tick(self, mono) -> None:
|
||||
"""A charging session is a plug-in: the state goes from no car to a
|
||||
car. The notice is raised once per session."""
|
||||
s = self.car.status(mono, True)
|
||||
if s in (chargers.NONE_,) and self._car_prev_state not in (
|
||||
None, chargers.NONE_):
|
||||
self._car_over_notified = None
|
||||
# The session is over: that is a real end, with no hold.
|
||||
self.car_over = False
|
||||
self._car_over_since = self._car_over_gone = None
|
||||
if s not in (chargers.NONE_, None) and self._car_prev_state in (
|
||||
chargers.NONE_, None):
|
||||
self._car_session += 1
|
||||
self._car_prev_state = s
|
||||
|
||||
async def check_car_over(self) -> None:
|
||||
"""One grey notice per charging session: the charge you set takes the
|
||||
15-minute period over the peak limit. Raised nowhere else."""
|
||||
if not self.car_over or self._car_over_notified == self._car_session:
|
||||
return
|
||||
self._car_over_notified = self._car_session
|
||||
_LOG.info("The car charge you set takes this 15-minute period over "
|
||||
"the peak limit: CAR_OVER_PEAK.")
|
||||
await self.hass.call("persistent_notification", "create",
|
||||
messages.car_over(f"{self.car_a:.0f}").data())
|
||||
|
||||
def car_peak_by_car(self, reading, now):
|
||||
"""`(True, local time)` when the month's peak quarter was one the car
|
||||
mostly made (it drew half the peak or more), else `(False, None)`."""
|
||||
if reading is None or not getattr(reading, "is_observed", False) \
|
||||
or reading.quarter_start is None or not self.car_peak_q:
|
||||
return False, None
|
||||
avg = self.car_peak_q.get(
|
||||
reading.quarter_start.astimezone(timezone.utc).isoformat())
|
||||
if avg is None or reading.peak_w is None \
|
||||
or 2.0 * float(avg) < float(reading.peak_w):
|
||||
return False, None
|
||||
return True, reading.quarter_start
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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)`,
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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">
|
||||
|
||||
@@ -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"
|
||||
},
|
||||
|
||||
@@ -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"
|
||||
},
|
||||
|
||||
@@ -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", (
|
||||
|
||||
@@ -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"])
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -0,0 +1,562 @@
|
||||
"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3).
|
||||
`python3 -B test_ev10.py`
|
||||
|
||||
1. EV-10: the car alone takes the batteries to the peak reserve while the period
|
||||
is still projected UNDER the aim: no alarm, one grey notice. A stuck car
|
||||
figure with a house overload, and a house-only drain, still alarm. Mutant:
|
||||
an uncorroborated car figure in the "period without the car" test.
|
||||
2. EV-11: the grey row and the Car Why do not flicker while the car keeps the
|
||||
period over the limit; a real end clears them after OVER_OFF_HOLD_S. The
|
||||
alarm decision (`car_explains`) has no hold.
|
||||
3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another
|
||||
writer"; a real outside change afterwards still shows the row.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, homeview, chargers as CH # noqa: E402
|
||||
from app.main import Controller # noqa: E402
|
||||
from app import freshness # noqa: E402
|
||||
from chargersim import FakeHa, SimCharger # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
import opt11_identity as rig # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
class _Log(logging.Handler):
|
||||
def __init__(self):
|
||||
super().__init__(logging.DEBUG)
|
||||
self.rec = []
|
||||
|
||||
def emit(self, r):
|
||||
self.rec.append((r.levelname, r.getMessage()))
|
||||
|
||||
|
||||
LOG = _Log()
|
||||
_lg = logging.getLogger("goodwe")
|
||||
_lg.addHandler(LOG)
|
||||
_lg.setLevel(logging.DEBUG)
|
||||
_lg.propagate = False
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)")
|
||||
# =========================================================================== #
|
||||
CAP = 4500.0 # the aim is 4450 W (50 W margin)
|
||||
HOUSE = 1100.0
|
||||
|
||||
|
||||
def at_reserve(plant, c):
|
||||
"""The batteries reach the peak reserve late in the period, and the house
|
||||
eases a little: the period is still projected UNDER the aim."""
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 780.0 + plant.ch.power_w
|
||||
|
||||
|
||||
def alarms(r):
|
||||
return P.ids(r, *P.ALARMS)
|
||||
|
||||
|
||||
UNDER = [] # (second, projected W, aim W) while floor-limited
|
||||
|
||||
|
||||
def watch(first, fn):
|
||||
"""Events for seconds 840 to 894: `fn` at `first`, and a note of every
|
||||
cycle in which the guard is floor-limited."""
|
||||
def note(plant, c):
|
||||
g = c.peak_guard
|
||||
if g is not None and g.floor_limited:
|
||||
UNDER.append((plant.t, g.projected_w, g.target_w))
|
||||
ev = {t: note for t in range(first - 10, 895)}
|
||||
ev[first] = lambda plant, c: (fn(plant, c), note(plant, c))
|
||||
return ev
|
||||
|
||||
|
||||
LOG.rec.clear()
|
||||
r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, events=watch(850, at_reserve))
|
||||
ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")]
|
||||
check("PRECONDITION: the guard was floor-limited with the projection UNDER "
|
||||
"the aim (the rig's 5888 W against 6000 W)",
|
||||
any(p < a for _t, p, a in UNDER))
|
||||
check("the car alone: no 'Load too high', no 'Battery stopped limiting the "
|
||||
"peak'", alarms(r10) == [])
|
||||
rows10 = {x["id"]: x for x in r10["c"].checks()}
|
||||
check("...no red row; the grey 'Car over the peak limit' row says it",
|
||||
rows10["peak_guard"]["ok"] is True
|
||||
and not [x for x in r10["c"].checks()
|
||||
if x["ok"] is False and not x["warn"]]
|
||||
and rows10.get("car_over", {}).get("ok") is True)
|
||||
check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1)
|
||||
check("...no ERROR (or WARNING) line was logged for it", ERR10 == [])
|
||||
|
||||
|
||||
def house_stuck(plant, c):
|
||||
at_reserve(plant, c)
|
||||
plant.ch.freeze() # the reading stops moving
|
||||
plant.ch.unplug() # the car really goes
|
||||
plant.load = lambda at: 9000.0 + plant.ch.power_w
|
||||
asyncio.get_event_loop().create_task(c.handle_action("car_current",
|
||||
value=10))
|
||||
|
||||
|
||||
r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, events=watch(850, house_stuck))
|
||||
check("a stuck car figure and a house overload at the reserve: the normal "
|
||||
"alarm still fires",
|
||||
[n for _t, n in alarms(r10s)]
|
||||
and all(n in P.ALARMS for _t, n in alarms(r10s)))
|
||||
|
||||
|
||||
def house_drain(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 12000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, user_a=6, setpoint=6,
|
||||
events=watch(600, house_drain))
|
||||
check("a house-only drain to the reserve with the car charging little: the "
|
||||
"normal alarm still fires",
|
||||
alarms(r10h) != [] and not r10h["c"].car_explains)
|
||||
|
||||
|
||||
|
||||
def plug_late(plant, c):
|
||||
plant.ch.plug_in()
|
||||
|
||||
|
||||
def house_reserve(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda at: 3075.0 + plant.ch.power_w
|
||||
|
||||
|
||||
def swapped_events():
|
||||
ev = watch(850, house_reserve)
|
||||
ev[800] = plug_late
|
||||
return ev
|
||||
|
||||
|
||||
def swapped(mode):
|
||||
return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode,
|
||||
plug=False, events=swapped_events())
|
||||
|
||||
|
||||
r10x = swapped("manual")
|
||||
r10xo = swapped("off")
|
||||
check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car "
|
||||
"plugs in late (a small share); the projection is under the aim at the "
|
||||
"reserve, and Off raises the alarm", alarms(r10xo) != []
|
||||
and any(p < a for _t, p, a in UNDER))
|
||||
check("the house drains the batteries and a small car is plugged in: the "
|
||||
"normal alarm still fires in Manual", alarms(r10x) != [])
|
||||
|
||||
r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
|
||||
cap=CAP, phases=1, mode="off", events=watch(850, at_reserve))
|
||||
check("PRECONDITION: Off, the same case raises the normal alarm (the false "
|
||||
"alarm Manual must not make)", alarms(r10off) != [])
|
||||
|
||||
|
||||
# a direct unit of the rule: the car's average, the period without it
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self, cover=True, w=3700.0):
|
||||
self.o = {"ev_batt_cover": cover}
|
||||
self.w = w
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 300.0, 5000.0
|
||||
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
class car: # noqa: N801
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class _Proj:
|
||||
projected_w: float
|
||||
elapsed_s: float = 850.0
|
||||
held_w: float = 0.0
|
||||
block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
||||
|
||||
def __post_init__(self):
|
||||
self.held_w = self.projected_w
|
||||
|
||||
|
||||
class _G:
|
||||
def __init__(self, floor=True, sat=False, within_aim=False):
|
||||
self.floor_limited, self.saturated = floor, sat
|
||||
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0
|
||||
self.engaged, self.blind, self.wanted_w = True, None, 300.0
|
||||
self.within_aim = within_aim
|
||||
|
||||
|
||||
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None,
|
||||
within_aim=False, earlier=(), block=0, c=None, at=0.0):
|
||||
"""One cycle of `car_cycle` on a stub; `earlier` are projections of
|
||||
cycles before it in the same quarter (they latch SAFETY-126's test)."""
|
||||
c = c or _Car(cover, car_w)
|
||||
c.w = car_w
|
||||
for k, e in enumerate(tuple(earlier) + (proj_w,)):
|
||||
p = _Proj(e)
|
||||
p.block_start = p.block_start + timedelta(minutes=15 * block)
|
||||
c._now = at - len(earlier) + k
|
||||
c._carq = {"key": p.block_start,
|
||||
"ws": ((car_w or 0.0) if car_so_far_w is None else car_so_far_w)
|
||||
* p.elapsed_s, "mono": c._now}
|
||||
c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None)
|
||||
return c.car_explains
|
||||
|
||||
|
||||
check("rule: the alarm's test is true with the car (4468 W, the batteries "
|
||||
"at 0 W land 4485 W) and false without it (768 W): the car explains it, "
|
||||
"with the projection under the aim", explains(4468.0, 3700.0))
|
||||
check("rule: under the aim, the quarter's test latched by the car's share "
|
||||
"(4600 W earlier), the car explains the alarm (the positive under-aim "
|
||||
"case; a single 4300 W cycle has no landing miss to explain, so it "
|
||||
"needs the earlier cycle)", explains(4300.0, 3700.0, earlier=(4600.0,)))
|
||||
check("rule: where the alarm would not fire anyway nothing is explained",
|
||||
not explains(4300.0, 3700.0, within_aim=True))
|
||||
check("rule: without the car it is still over the aim: the car does not "
|
||||
"explain it", not explains(9000.0, 3700.0))
|
||||
check("rule: no car power, no explanation", not explains(4300.0, 0.0))
|
||||
check("rule: ...also when the test was latched earlier in the quarter",
|
||||
not explains(4300.0, 0.0, earlier=(4600.0,))
|
||||
and not explains(9000.0, 0.0))
|
||||
check("rule: an untrusted car figure (None) explains nothing",
|
||||
not explains(4300.0, None, earlier=(4600.0,)))
|
||||
# the latches: per quarter, and independent of the cover option
|
||||
c4 = _Car(True, 3700.0)
|
||||
explains(9000.0, 3700.0, c=c4, block=0) # the house needs it: latched
|
||||
check("latch: in the same quarter the house need stays latched, so the car "
|
||||
"does not explain", not explains(4300.0, 3700.0, c=c4, block=0, at=10.0))
|
||||
check("latch: a new quarter starts clean: the car alone explains it again",
|
||||
explains(4300.0, 3700.0, c=c4, block=1, at=1000.0,
|
||||
earlier=(4600.0,)))
|
||||
c5 = _Car(False, 3700.0) # cover OFF
|
||||
explains(9000.0, 3700.0, c=c5, block=0) # the house needs it
|
||||
c5.o["ev_batt_cover"] = True # ... and the option flips
|
||||
check("latch: the option flipping to ON does not lose a house need seen "
|
||||
"while it was off", not explains(4300.0, 3700.0, c=c5, block=0, at=10.0))
|
||||
c6 = _Car(True, 3700.0)
|
||||
explains(9000.0, 3700.0, c=c6, block=0)
|
||||
c6.o["ev_batt_cover"] = False
|
||||
explains(4300.0, 3700.0, c=c6, block=0, at=10.0)
|
||||
c6.o["ev_batt_cover"] = True
|
||||
check("latch: ... nor does flipping it off and on again",
|
||||
not explains(4300.0, 3700.0, c=c6, block=0, at=20.0))
|
||||
|
||||
check("rule: the guard is not floor-limited or saturated: nothing to explain",
|
||||
not explains(4300.0, 3700.0, floor=False))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)")
|
||||
# =========================================================================== #
|
||||
# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own
|
||||
# quarter (14.0 kW) was the month peak, so the aim was that quarter's average
|
||||
# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The
|
||||
# projection crossed the aim every few seconds, `ex > 0` came and went, and
|
||||
# `car_over` followed it with no hold on the way off.
|
||||
|
||||
|
||||
def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0,
|
||||
cover=False):
|
||||
"""Run `car_cycle` once a second; returns (car_over, car_explains) per second."""
|
||||
out = []
|
||||
for k in range(secs):
|
||||
t = t0 + k
|
||||
c._now = t
|
||||
c.w = w_of(t)
|
||||
p = _Proj(proj_of(t), elapsed_s=300.0 + (t % 400))
|
||||
c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s,
|
||||
"mono": t}
|
||||
c.car_cycle(p, _G(True), target, None)
|
||||
out.append((c.car_over, c.car_explains))
|
||||
return out
|
||||
|
||||
|
||||
def noisy(t):
|
||||
"""The projection straddles the aim: +-40 W, a new value every 7 s."""
|
||||
return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3))
|
||||
|
||||
|
||||
c11 = _Car(cover=False)
|
||||
o11 = over_run(c11, 1200, noisy)
|
||||
flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0])
|
||||
check("while the car keeps the period at the limit the row stays on: one "
|
||||
"switch on in 20 minutes, none off", flips == 1 and len(o11) == 1200 and o11[-1][0] is True)
|
||||
check("it turns on after the existing 10 s hold, not later than the first "
|
||||
"10 s the condition has stood (a gap does not restart the count)",
|
||||
next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25)
|
||||
|
||||
# the condition on its own, for the PRECONDITION: the same input flips
|
||||
c11o = _Car(cover=False)
|
||||
raw = []
|
||||
for k in range(1200):
|
||||
c11o._now = float(k)
|
||||
p = _Proj(noisy(k), elapsed_s=300.0 + (k % 400))
|
||||
c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k}
|
||||
ex = p.projected_w - 14000.0
|
||||
raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex)
|
||||
raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b)
|
||||
check("PRECONDITION: the condition itself flips many times in those 20 "
|
||||
"minutes", raw_flips > 20)
|
||||
|
||||
# a real end: the car stops (no trusted power) after 600 s
|
||||
c11e = _Car(cover=False)
|
||||
o11e = over_run(c11e, 1000, lambda t: 14500.0,
|
||||
w_of=lambda t: 11000.0 if t < 600 else None)
|
||||
off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1)
|
||||
check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes",
|
||||
off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S)
|
||||
and not any(x[0] for x in o11e[off_at:]))
|
||||
o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0)
|
||||
check("it comes back after the usual 10 s if the condition returns after "
|
||||
"it went", len(o11r) == 100 and o11r[9][0] is False and o11r[10][0] is True)
|
||||
|
||||
# the alarm decision has no hold: a real house overload is never delayed
|
||||
c11a = _Car(cover=True)
|
||||
o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0)
|
||||
check("decision 1 on: the car explains it at once (no hold)",
|
||||
len(o11a) == 60 and o11a[0][1] is True)
|
||||
c11a.w = None # the figure is not trusted
|
||||
c11a._now = 61.0
|
||||
c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None)
|
||||
check("...and the moment the car figure is not trusted it explains nothing, "
|
||||
"so the normal alarms stand at once (the grey row may stay)",
|
||||
c11a.car_explains is False)
|
||||
|
||||
# the whole thing on the real controller: the Why does not flicker either
|
||||
def p7_like(plant, c):
|
||||
plant.load = lambda at: 3000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP,
|
||||
phases=3, opts={"ev_batt_cover": False})
|
||||
ov = [s[2] for s in r11["snaps"]]
|
||||
check("real controller, cover off, an 11 kW car: the flag is steady once on",
|
||||
sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)")
|
||||
# =========================================================================== #
|
||||
CLOCK = [1000.0]
|
||||
freshness.monotonic = lambda: CLOCK[0]
|
||||
SET = "number.wallbox_power_connector_max_current_socket_1"
|
||||
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
|
||||
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
|
||||
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
|
||||
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
|
||||
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
|
||||
"pv_entities": ["sensor.pv"], "ev_charger": "alfen_ha", "ev_max_a": 16,
|
||||
"ev_phases": "auto", "ev_current_entity": SET}
|
||||
|
||||
|
||||
class _Store:
|
||||
def __init__(self):
|
||||
self.data = {}
|
||||
|
||||
def set(self, k, v):
|
||||
self.data[k] = v
|
||||
|
||||
def get(self, k, d=None):
|
||||
return self.data.get(k, d)
|
||||
|
||||
def set_time(self, k, v):
|
||||
self.data[k] = v.isoformat()
|
||||
|
||||
def get_time(self, k):
|
||||
v = self.data.get(k)
|
||||
return None if v is None else datetime.fromisoformat(v)
|
||||
|
||||
|
||||
class _Pub:
|
||||
enabled = False
|
||||
|
||||
def publish(self, v):
|
||||
pass
|
||||
|
||||
def close(self):
|
||||
pass
|
||||
|
||||
|
||||
class Site(FakeHa):
|
||||
def __init__(self, charger):
|
||||
super().__init__(charger, None)
|
||||
|
||||
async def limits(self, _e):
|
||||
return (-5000.0, 5000.0, 1.0)
|
||||
|
||||
def _all(self):
|
||||
out = super()._all()
|
||||
for eid, val, unit in (("sensor.grid", 800.0, "W"),
|
||||
("sensor.soc", 50.0, "%"),
|
||||
("sensor.batt", 0.0, "W"),
|
||||
("sensor.pv", 2000.0, "W")):
|
||||
out[eid] = {"entity_id": eid, "state": str(val),
|
||||
"attributes": {"unit_of_measurement": unit}}
|
||||
return out
|
||||
|
||||
async def number(self, entity_id, invert=False):
|
||||
s = self._all().get(entity_id)
|
||||
try:
|
||||
v = float(s["state"])
|
||||
except (TypeError, ValueError, KeyError):
|
||||
return None
|
||||
return -v if invert else v
|
||||
|
||||
async def set_number(self, entity_id, value):
|
||||
return await super().set_number(entity_id, float(value))
|
||||
|
||||
|
||||
class World:
|
||||
"""A real Controller on the charger model. While a write waits for its
|
||||
read-back, the controller's own reading goes on (as in production, where
|
||||
the cycle runs while the writer task waits): that is how the read-back of
|
||||
our own write reaches the tracker BEFORE the write returns."""
|
||||
|
||||
def __init__(self, setpoint=10):
|
||||
self.sim = SimCharger(setpoint_a=setpoint)
|
||||
self.sim.plug_in()
|
||||
self.sim.lag_s = 2.0 # the rig's read-back lag
|
||||
self.sim.phases_allowed = 1
|
||||
self.t = 1000.0
|
||||
CLOCK[0] = self.t
|
||||
self.c = Controller(dict(BASE), Site(self.sim), _Store(), _Pub(),
|
||||
stop=asyncio.Event())
|
||||
self.c.auto = True
|
||||
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
|
||||
self.drv = self.c.charger
|
||||
self.drv._sleep = self.sleep
|
||||
self.drv._clock = lambda: CLOCK[0]
|
||||
|
||||
async def sleep(self, s):
|
||||
self.sim.tick(s)
|
||||
self.t += s
|
||||
CLOCK[0] = self.t
|
||||
await self.c.read_inputs(now_mono=self.t) # the cycle reads on
|
||||
|
||||
async def step(self, n=1):
|
||||
for _ in range(n):
|
||||
self.sim.tick(1.0)
|
||||
self.t += 1.0
|
||||
CLOCK[0] = self.t
|
||||
await self.c.read_inputs(now_mono=self.t)
|
||||
await self.c.cycle()
|
||||
await self.c.car_settle()
|
||||
|
||||
def rows(self):
|
||||
return {r["id"]: r for r in self.c.checks()}
|
||||
|
||||
|
||||
async def own_then_off(wait):
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(wait)
|
||||
await w.c.handle_action("car_mode", value="off")
|
||||
await w.step(40)
|
||||
return w
|
||||
|
||||
|
||||
w12 = asyncio.run(own_then_off(2))
|
||||
check("PRECONDITION: the add-on wrote 12 A and the charger took it",
|
||||
w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1)
|
||||
check("our own write, then Off 2 s later: no 'Something else changes the "
|
||||
"charger'", "charger_writer" not in w12.rows()
|
||||
and w12.c.car.writer_at_utc is None)
|
||||
w12b = asyncio.run(own_then_off(14))
|
||||
check("...and 14 s later (inside the 15 s)", "charger_writer" not in
|
||||
w12b.rows() and w12b.c.car.writer_at_utc is None)
|
||||
|
||||
|
||||
async def own_then_outside():
|
||||
w = await own_then_off(2)
|
||||
w.sim.set_current(7) # somebody else, afterwards
|
||||
await w.step(3)
|
||||
early = "charger_writer" in w.rows()
|
||||
await w.step(30)
|
||||
return early, "charger_writer" in w.rows()
|
||||
|
||||
|
||||
early12, late12 = asyncio.run(own_then_outside())
|
||||
check("an outside change after that still shows the row (within 30 s)",
|
||||
late12 is True)
|
||||
|
||||
|
||||
async def manual_own():
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(60)
|
||||
await w.c.handle_action("car_current", value=8)
|
||||
await w.step(20)
|
||||
return w
|
||||
|
||||
|
||||
wm = asyncio.run(manual_own())
|
||||
check("Manual: two writes of ours, never 'another writer' in the tracker",
|
||||
wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows())
|
||||
|
||||
|
||||
async def failed_write_then_outside(how):
|
||||
"""A write that RAISES or returns FAILURE must still close the self-mute:
|
||||
it ends 15 s after the write returned, and a later outside change shows
|
||||
the row."""
|
||||
w = World()
|
||||
await w.step(3)
|
||||
await w.c.handle_action("car_mode", value="manual")
|
||||
ret = []
|
||||
|
||||
async def bad(a):
|
||||
await w.sleep(1.0)
|
||||
ret.append(w.t) # when the write came back
|
||||
if how == "raise":
|
||||
raise RuntimeError("the charger link broke")
|
||||
return False
|
||||
w.drv.write_current = bad
|
||||
await w.c.handle_action("car_current", value=12)
|
||||
await w.step(3) # the write is tried
|
||||
closed = (bool(ret) and w.c.car.mute_until <= ret[-1] + 15.0 + 1e-6)
|
||||
await w.c.handle_action("car_mode", value="off")
|
||||
await w.step(20) # past the 15 s mute
|
||||
w.sim.set_current(7) # somebody else
|
||||
await w.step(3)
|
||||
return w, closed
|
||||
|
||||
|
||||
for how in ("raise", "fail"):
|
||||
wf, closed = asyncio.run(failed_write_then_outside(how))
|
||||
check(f"a write that {'raises' if how == 'raise' else 'returns failure'}"
|
||||
": the mute ends within 15 s of the write's return, and a later "
|
||||
"outside change shows the row",
|
||||
closed and "charger_writer" in wf.rows())
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,158 @@
|
||||
"""EV-10b: the period without the car is not clipped at 0 W (rig F-1 again).
|
||||
`python3 -B test_ev10b.py`
|
||||
|
||||
The rig shape: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
|
||||
give more than the house uses, so the house alone is an export; clipping it at
|
||||
0 W charged the car's battery share to the house, latched "the house needs the
|
||||
batteries" for the quarter, and the floor alarm fired once both batteries
|
||||
reached the reserve. Mutating a module this file grades? Read MUTATION.md first.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
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, peakguard, tariff # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
CAP = 6050.0 # aim 6000 W
|
||||
OPTS = {"inverters": [
|
||||
{"name": f"inverter-{u}", "setpoint_entity": f"number.sp_{u}",
|
||||
"soc_entity": f"sensor.soc_{u}", "batt_entity": f"sensor.batt_{u}",
|
||||
"max_w": 4050, "bms_soc_floor": 10} for u in "ab"]}
|
||||
|
||||
|
||||
def rig_run(house_w, soc_events, dur=895):
|
||||
"""A whole quarter from its start, N=2 (4.05 kW each = 8.1 kW), the car at
|
||||
11 kW; `soc_events` is {second: {"a": soc, "b": soc}}."""
|
||||
def setter(socs):
|
||||
return lambda plant, c: plant.socs.update(socs)
|
||||
return P.drive(s81.constant(house_w), dur=dur, rating=4050.0,
|
||||
soc={"a": 60.0, "b": 60.0}, cap=CAP, phases=3, n=2,
|
||||
plant_cls=P.CarPlantN, opts=OPTS, dev_w=4050.0,
|
||||
events={t: setter(s) for t, s in soc_events.items()})
|
||||
|
||||
|
||||
def summary(r):
|
||||
rows = r["c"].checks()
|
||||
red = [x["id"] for x in rows if x["ok"] is False and not x["warn"]]
|
||||
return (P.ids(r, *P.ALARMS), red, P.ids(r, P.OVER),
|
||||
max(abs(r["plant"].batt(t)) for t in range(0, 30)) if r else 0)
|
||||
|
||||
|
||||
print("1. THE RIG SHAPE, A WHOLE QUARTER (house 3 kW, car 11 kW, batteries 8.1 kW)")
|
||||
r = rig_run(3000.0, {30: {"a": 19.0, "b": 19.0}})
|
||||
al, red, over, _ = summary(r)
|
||||
peak_batt = max(r["plant"].batt(t) for t in range(5, 30))
|
||||
check("PRECONDITION: the batteries gave more than the house uses (8.1 kW "
|
||||
"against 3 kW) before the reserve", peak_batt > 7500.0)
|
||||
check("both batteries reach the reserve early in the quarter: no 'Battery "
|
||||
"stopped limiting the peak', no 'Load too high'", al == [])
|
||||
check("...no red row, and no goodwe_peak_soc_floor", red == [])
|
||||
check("...one car-over notice", len(over) == 1)
|
||||
check("...the car-over row is on at the end", any(
|
||||
x["id"] == "car_over" and x["ok"] is True for x in r["c"].checks()))
|
||||
|
||||
r2 = rig_run(3000.0, {30: {"a": 19.0}, 200: {"b": 19.0}})
|
||||
al2, red2, over2, _ = summary(r2)
|
||||
check("N=2, one battery reaches the reserve first, the other later: no "
|
||||
"alarm, no red row, one car-over notice",
|
||||
al2 == [] and red2 == [] and len(over2) == 1)
|
||||
|
||||
print("\n2. BATTERIES ABOVE THE HOUSE AND THE HOUSE ALONE OVER THE AIM")
|
||||
r3 = rig_run(7000.0, {30: {"a": 19.0, "b": 19.0}})
|
||||
check("house 7 kW, car 11 kW, aim 6 kW, batteries to the reserve: the alarm "
|
||||
"fires (the house alone misses the aim)", summary(r3)[0] != []
|
||||
and not r3["c"].car_explains)
|
||||
|
||||
|
||||
print("\n3. THE COUNTERFACTUAL ITSELF")
|
||||
BS = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self, cover=True):
|
||||
self.o = {"ev_batt_cover": cover}
|
||||
self._carq = {"key": BS, "ws": 0.0, "mono": 0.0}
|
||||
|
||||
|
||||
def proj(grid, elapsed, held=None):
|
||||
return tariff.Projection(
|
||||
projected_w=grid, elapsed_w=grid, elapsed_s=elapsed,
|
||||
covered_frac=1.0, complete=False, block_start=BS,
|
||||
held_w=grid if held is None else held)
|
||||
|
||||
|
||||
def lands(p, batt, aim=5950.0):
|
||||
return peakguard.misses_aim(p, batt_w=batt, target_w=aim)
|
||||
|
||||
|
||||
c = _Car()
|
||||
for el in (10.0, 30.0, 120.0, 300.0, 600.0):
|
||||
c._carq["ws"] = 11040.0 * el
|
||||
p = proj(3000 + 11040 - 8100, el)
|
||||
x = c.car_exclude_alarm(p, 11040.0)
|
||||
check(f"rig numbers at {el:.0f} s: the house alone does not miss the aim "
|
||||
"(no 0 W clip)", not lands(x, 8100.0))
|
||||
check(f"...and the guard-side `car_exclude` is unchanged (still clipped)",
|
||||
c.car_exclude(p, 11040.0).held_w == 0.0)
|
||||
c._carq["ws"] = 11040.0 * 30
|
||||
x = c.car_exclude_alarm(proj(5940.0, 30.0), 11040.0)
|
||||
check("the rest of the period keeps its sign: held = grid - car = -5100 W",
|
||||
abs(x.held_w - (5940.0 - 11040.0)) < 1e-6)
|
||||
check("a fresh car reading is needed: None gives the period back as it is",
|
||||
c.car_exclude_alarm(proj(5940.0, 30.0), None).held_w == 5940.0)
|
||||
# the house alone over the aim still misses
|
||||
c._carq["ws"] = 11040.0 * 30
|
||||
check("house 7 kW alone (batteries 8.1 kW, car 11 kW): the house misses the aim",
|
||||
lands(c.car_exclude_alarm(proj(7000 + 11040 - 8100, 30.0), 11040.0),
|
||||
8100.0))
|
||||
# with the batteries giving less than the house the two agree where the old
|
||||
# clip did not bite
|
||||
p = proj(3000 + 3700 - 300, 300.0)
|
||||
c._carq["ws"] = 3700.0 * 300.0
|
||||
old, new = c.car_exclude(p, 3700.0), c.car_exclude_alarm(p, 3700.0)
|
||||
check("batteries under the house: the same landing as before (no clip bit)",
|
||||
abs(old.projected_w - new.projected_w) < 1e-6
|
||||
and abs(old.held_w - new.held_w) < 1e-6)
|
||||
|
||||
# cover OFF: the projection the guard sees is `car_exclude`, bit for bit what
|
||||
# b86c015 built (a frozen copy of its formula), over a grid of periods
|
||||
def frozen(c, p, w):
|
||||
avg = c.car_avg_w(p, w)
|
||||
return (max(0.0, float(p.projected_w) - avg),
|
||||
max(0.0, float(p.held_w) - float(w)))
|
||||
|
||||
|
||||
same = True
|
||||
for grid in (-3000.0, 0.0, 800.0, 5900.0, 14000.0):
|
||||
for held in (-4000.0, 0.0, 6000.0, 15000.0):
|
||||
for el in (0.0, 30.0, 450.0, 899.0):
|
||||
for w in (1380.0, 3700.0, 11040.0):
|
||||
c._carq["ws"] = w * el * 0.9
|
||||
p = proj(grid, el, held)
|
||||
x = c.car_exclude(p, w)
|
||||
same = same and (x.projected_w, x.held_w) == frozen(c, p, w)
|
||||
check("cover off: the projection the guard sees (`car_exclude`) is bit for "
|
||||
"bit the old formula over 240 periods", same)
|
||||
check("...and `car_exclude` still hands back the period when the car figure "
|
||||
"is None", c.car_exclude(proj(5000.0, 30.0), None).projected_w == 5000.0)
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -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"
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
#!/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)
|
||||
|
||||
|
||||
class CarPlantN(CarPlant):
|
||||
"""EV-10b: N batteries, each its own setpoint, power and SoC (`soc` is a
|
||||
dict {"a": %, "b": %}); `rating` is per battery. The grid sees them all."""
|
||||
|
||||
def __init__(self, house, rating, soc, charger):
|
||||
super().__init__(house, rating, 0.0, charger)
|
||||
self.socs = dict(soc)
|
||||
self.hists = {u: [(-1e9, 0.0)] for u in self.socs}
|
||||
|
||||
def batt_of(self, u, at):
|
||||
w = 0.0
|
||||
for when, v in self.hists[u]:
|
||||
if when <= at:
|
||||
w = v
|
||||
return max(-self.rating, min(self.rating, float(round(w))))
|
||||
|
||||
def batt(self, at):
|
||||
return sum(self.batt_of(u, at) for u in self.socs)
|
||||
|
||||
async def number(self, e, invert=False):
|
||||
for u in self.socs:
|
||||
if e == "sensor.soc_" + u:
|
||||
return self.socs[u]
|
||||
if e == "sensor.batt_" + u:
|
||||
return self.batt_of(u, self.t)
|
||||
return await super().number(e, invert)
|
||||
|
||||
async def set_number(self, e, v):
|
||||
if e.startswith("number.sp_"):
|
||||
self.hists[e[-1]].append((self.t + s81.RESPONSE_S, float(v)))
|
||||
return True
|
||||
return await super().set_number(e, v)
|
||||
|
||||
|
||||
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, n=1, plant_cls=None,
|
||||
dev_w=5000.0):
|
||||
"""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(n, 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()
|
||||
for u in "ab"[:n]:
|
||||
store.data[unit_key("inverter-" + u, 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 = (plant_cls or 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 = -dev_w, dev_w
|
||||
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)}")
|
||||
@@ -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:
|
||||
|
||||
@@ -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."
|
||||
|
||||
@@ -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."
|
||||
|
||||
Reference in New Issue
Block a user