Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
29480fda47 | ||
|
|
9fdce023e9 | ||
|
|
7788543e09 | ||
|
|
6d7046fc45 | ||
|
|
07f703d1bc | ||
|
|
2cfbc4aec8 |
@@ -49,10 +49,11 @@ SERIAL="test_loop.py test_freeze.py test_safety87.py"
|
||||
# safety119 704, opt34 515, safety126 402, safety125 388, safety126b 364,
|
||||
# modes_p3 377, safety94 360, modes_p4c 291, modes_p4b 238, tariff24_weather 235,
|
||||
# modes_p4d 196, price_run_fixes 197, safety103 189, safety90 185, safety97 163.
|
||||
# EV-05: ev05_long ~500 and ev05 ~375 alone (the Solar simulations).
|
||||
# CI-18 split test_modes_p4, test_safety126 and test_safety125 so no one file
|
||||
# is much over 400 s; test_opt34 and test_opt36 already fan out inside, and
|
||||
# test_safety119 part 4 is one coupled block, so those three stay whole.
|
||||
HEAVY="test_opt36.py test_safety119.py test_opt34.py test_safety126.py test_safety125.py test_safety126b.py test_modes_p3.py test_safety94.py test_modes_p4c.py test_modes_p4b.py test_tariff24_weather.py test_modes_p4d.py test_safety125b.py test_price_run_fixes.py test_safety103.py test_safety90.py test_safety97.py test_peakguard.py test_opt20.py test_safety81.py"
|
||||
HEAVY="test_opt36.py test_safety119.py test_ev05_long.py test_opt34.py test_ev05.py test_safety126.py test_safety125.py test_safety126b.py test_modes_p3.py test_safety94.py test_modes_p4c.py test_modes_p4b.py test_tariff24_weather.py test_modes_p4d.py test_safety125b.py test_price_run_fixes.py test_safety103.py test_safety90.py test_safety97.py test_peakguard.py test_opt20.py test_safety81.py"
|
||||
#
|
||||
JOBS=${CI_JOBS:-10}
|
||||
cd "${TESTS_DIR:-/w/goodwe-addon/goodwe_controller}"
|
||||
|
||||
@@ -1,5 +1,10 @@
|
||||
# Changelog
|
||||
|
||||
### Not in a release yet
|
||||
|
||||
- When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]).
|
||||
- The car can charge from spare sun only (Solar mode), with the batteries or the car first, and it is cut first when the 15-minute period heads over the peak limit. Three new options with defaults ([[EV-05]]).
|
||||
|
||||
## 0.24.0
|
||||
|
||||
**A minor bump: the add-on can now charge the car (Manual mode), and a car that alone takes the batteries to the peak reserve no longer raises a false peak alarm. Two new options were added, both with defaults, and none needs setting.**
|
||||
|
||||
@@ -120,6 +120,23 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
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 phase change is not a reason to alarm** (EV-15). Rig, twice: at the
|
||||
reserve, with the car covering, the add-on's 3 -> 1 switch set the car to 0 A.
|
||||
A car that is not charging has no corroboration (`CarTracker._corr_note` clears
|
||||
the window, `corroborated` is False), so `car_alarm_w()` was None, the car
|
||||
explained nothing and `_car_need_excl` latched for the quarter: one
|
||||
PEAK_GUARD_FLOOR_LIMITED and one `goodwe_peak_soc_floor`. Now, only for grading
|
||||
(`car_cycle`), `ctl_car._car_own_pause` lets the car's fresh, not stuck figure
|
||||
(`CarTracker.car_w_paused`, 0 W while paused) stand in without corroboration:
|
||||
from the moment our 0 A write is SENT (`zero_sent_at`: the cycle runs beside
|
||||
the writer and the car stops before the write returns), until the current is
|
||||
set again, at most
|
||||
`OWN_PAUSE_MAX_S` (85 s, the sequence's own waits), then at most one
|
||||
corroboration window (60 s). It ends at once on Off, Stop, shadow, unplug,
|
||||
another writer, or a refused select or write (`seq["failed"]`). The energy it
|
||||
drew in the pause is kept apart (`ws_p`), so `car_exclude`, the guard's
|
||||
input, the claim, floor and writes are unchanged. A house overload still fails
|
||||
the test without the car, so it alarms as on Off.
|
||||
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
|
||||
own detector opens before the write and runs 15 s from when it returns, because
|
||||
the read-back reaches the cycle while the write still waits for it.
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
# EV-05 — Solar mode: spare sun to the car
|
||||
|
||||
The design is `reports/EV-01-design-report.md` (sections 2 to 5, decisions 2 and
|
||||
5) and the EV-05 brief v3 (owner answers Q1 and Q4, 2026-11-17). This record
|
||||
keeps what the code had to decide.
|
||||
|
||||
## Where it lives
|
||||
|
||||
`carmode.SolarPlan` decides (pure, monotonic clock): what current, on what
|
||||
phases. `carmode.SolarWriter` makes the charger match it. It is a subclass of
|
||||
`ManualWriter`, so the write, the read-back, the phase sequence and the
|
||||
other-writer watch are Manual's and there is still one `write_current` and one
|
||||
`write_phases` call in `app/` (test_ev04.py's AST check). `ctl_car` builds the
|
||||
inputs (`car_sun_inputs`) and runs the writer in the same background task.
|
||||
|
||||
## The rules the brief left open
|
||||
|
||||
- **Entering Solar starts at 0 A.** Choosing Solar, a restart in Solar, the
|
||||
charger or Home Assistant coming back, a charger error or a stuck reading
|
||||
clearing, and control starting again all reset the plan: 0 A if the charger
|
||||
shows more, then the start rule. Switching from Manual to Solar therefore
|
||||
pauses a Manual charge for the start dwell. Simple and on the safe side.
|
||||
- **The peak cut is what the guard would ask the batteries for.** The excess is
|
||||
taken off the car only when the guard is engaged and wants a discharge
|
||||
(`wanted_w > 0`), and by `min(excess, wanted)`. Batteries that only stop
|
||||
charging in a cloud's first seconds are not "asked", so a cloud does not cut
|
||||
the car. A partial cut caps the car for the rest of that 15-minute period.
|
||||
- **The 4.0 to 4.14 kW band on 3 phases.** 3 phases need 4.14 kW at 6 A, the
|
||||
switch back to 1 phase is under 4.0 kW. Inside that band the car holds 6 A on
|
||||
3 phases with no pause count (the hysteresis the design chose). Under 4.0 kW
|
||||
the down-switch comes after 5 minutes; if the 10-minute gap blocks it, the
|
||||
pause rule does instead.
|
||||
- **A phase switch also waits for the 30 s write rule**, so the current set
|
||||
after a switch is never sooner than 30 s after the one before it.
|
||||
- **The meter's age.** The spare is not computed from a meter reading older
|
||||
than `stale_input_s`, also when `meter_max_age_s` (P1) is longer.
|
||||
- **A stale, stuck or not corroborated charging car makes the spare unknown**:
|
||||
hold, then 0 A after *Pause after*. A paused or idle car with a fresh reading
|
||||
counts 0 W (`car_w_trusted` is None outside mode3 C).
|
||||
- **A stuck reading's 0 A is written whatever the frozen read-back says**, since
|
||||
that read-back means nothing then. Every other exit skips the write when the
|
||||
charger already shows 0 A, and never writes over another writer.
|
||||
- **The guard's alarm path** uses the Solar car like Manual's
|
||||
(`car_alarm_w`), and Solar's own 0 A (pause, cut, phase change) gets EV-15's
|
||||
bounded grace (`_car_solar_pause`). A Solar quarter is never banked as "set
|
||||
by the car", and Solar shows no *Car over the peak limit*.
|
||||
- **Shadow mode** runs the plan without writing, so the card says what it would
|
||||
set; the charger got its one 0 A when shadow mode came on.
|
||||
|
||||
## Solar kWh
|
||||
|
||||
Per cycle in Solar: `min(car power, max(0, spare - room))` Batteries first,
|
||||
`min(car power, max(0, spare))` Car first; never above today's kWh; reset at the
|
||||
day change; kept in the store (`car_sun`).
|
||||
+64
-10
@@ -256,7 +256,10 @@ The label and description each setting shows on the Configuration tab, in tab or
|
||||
| Car charger | Charger limit (A) | `ev_max_a` | The most current the charger may ever be asked for. Never above what the charger reports. Lower it for a weaker fuse or cable. |
|
||||
| Car charger | Phases | `ev_phases` | How many phases the charger may use: 1, 3, or 1 and 3 (auto). |
|
||||
| Car charger | Batteries help with the peak | `ev_batt_cover` | While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak. |
|
||||
| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. A restart never changes the charger's current. |
|
||||
| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current. |
|
||||
| Car charger | Sun kept back (W) | `ev_margin_w` | Solar: this much spare sun is never given to the car. |
|
||||
| Car charger | Start after (minutes) | `ev_start_min` | Solar: the car starts after this long with enough spare sun. |
|
||||
| Car charger | Pause after (minutes) | `ev_pause_min` | Solar: with too little sun the car holds 6 A this long, then pauses. |
|
||||
| Advanced | Start control on boot | `auto_start` | Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart. |
|
||||
| Advanced | Control gain | `gain` | How much of the remaining error control corrects each cycle. Measured on real hardware, do not raise it. |
|
||||
| Advanced | Largest change per cycle (W) | `slew_w` | How far the command may move in one cycle. 0 follows “Inverter rating” and is recommended. |
|
||||
@@ -3278,9 +3281,10 @@ it.
|
||||
### Car charger
|
||||
|
||||
The add-on can drive your car charger and shows it on **Home**, on a *Car* card.
|
||||
The card has two modes in this version: **Off** (the add-on only reads the
|
||||
charger and writes nothing) and **Manual** (the add-on sets the current and the
|
||||
phases you choose). Solar and Night modes come in later versions.
|
||||
The card has three modes in this version: **Off** (the add-on only reads the
|
||||
charger and writes nothing), **Manual** (the add-on sets the current and the
|
||||
phases you choose) and **Solar** (the car charges from spare sun only). Night
|
||||
mode comes in a later version.
|
||||
|
||||
| option | meaning |
|
||||
|---|---|
|
||||
@@ -3290,6 +3294,9 @@ phases you choose). Solar and Night modes come in later versions.
|
||||
| `ev_phases` | `1`, `3` or `auto` (1 and 3). |
|
||||
| `ev_batt_cover` | On (the default): the batteries help cover the car down to the peak reserve. Off: the car is left out of what the peak guard protects. |
|
||||
| `ev_mode_start` | `keep` (the default) or `off`: the mode after a restart. |
|
||||
| `ev_margin_w` | Solar: spare sun never given to the car, 0 to 1000 W (default 100). |
|
||||
| `ev_start_min` | Solar: minutes of enough sun before the car starts, 1 to 30 (default 2). |
|
||||
| `ev_pause_min` | Solar: minutes the car holds 6 A with too little sun before it pauses, 1 to 30 (default 5). |
|
||||
|
||||
**What the Car card shows.** The state (Charging, Connected waiting, No car
|
||||
connected, Car is full, Charger not reachable), the power and current, and the
|
||||
@@ -3320,7 +3327,46 @@ checks within 10 seconds that the charger took it.
|
||||
current again only if the charger shows a different one.
|
||||
- Off writes nothing, ever.
|
||||
|
||||
**The car is never slowed for the peak limit.** A Manual charge goes on whatever
|
||||
**Solar mode.** Choose *Solar* on Home (or `Solar` on `select.goodwe_car_mode`)
|
||||
and where spare sun goes first: **Batteries** or **Car** (`select.goodwe_car_sun_first`).
|
||||
Both apply at once, with no restart.
|
||||
|
||||
- *Spare sun* is solar production less the house, measured without a solar
|
||||
sensor: the car's power, plus what the batteries charge, less what the grid
|
||||
gives. A grid charge of the batteries, or batteries giving more than the house
|
||||
uses, is never spare sun.
|
||||
- *Batteries first*: the car gets what is left after the full rating of every
|
||||
battery that may still charge (switched on, not refusing, not full), less
|
||||
*Sun kept back*. So the car gets sun only when the batteries charge at full
|
||||
power or are full. *Car first*: the car gets the spare sun less *Sun kept
|
||||
back*, and the batteries charge with what it leaves.
|
||||
- The current is whole amps, rounded down, from 6 A to the charger limit. It
|
||||
changes at most once per 30 seconds, and only by 1 A or more.
|
||||
- The car starts after *Start after* (2 minutes) of sun for at least 7 A. With
|
||||
too little sun it holds 6 A for *Pause after* (5 minutes), from the batteries
|
||||
where they can, then pauses at 0 A: the card says *Waiting for sun*.
|
||||
- With `ev_phases` `auto` a start goes on 1 phase. It moves to 3 phases after
|
||||
3 minutes at 4.5 kW or more, and back to 1 phase after 5 minutes under 4 kW,
|
||||
at most once per 10 minutes, always through the safe phase steps above. A car
|
||||
that draws one phase while three are allowed is counted on one phase.
|
||||
- **The car is cut first for the peak limit.** When the 15-minute period heads
|
||||
over the limit and the peak guard would ask the batteries for power, that is
|
||||
taken off the car first, down to 0 A at once. A Solar charge never sets the
|
||||
month's peak.
|
||||
- **Every way out of Solar leaves the charger at 0 A**, written once: a stop or
|
||||
restart of the add-on (before the inverters go to 0 W), stopping control, a
|
||||
safety stop, shadow mode turned on, choosing Off, an unplugged car, a charger
|
||||
error or a stuck reading. After the charger or Home Assistant was away, the
|
||||
add-on first sets 0 A, then starts again by the rules. A meter that stops
|
||||
gives a hold for *Pause after*, then 0 A. Choosing Manual leaves it to Manual.
|
||||
- Another writer stops the add-on's writes after 30 seconds, with an amber row
|
||||
and a warning, until you press the mode again or the charger shows the
|
||||
add-on's value again.
|
||||
- The card shows *{kWh} charged today, {kWh} from the sun*, also as
|
||||
`sensor.goodwe_car_today_solar_kwh`. Only the sun the car could take counts,
|
||||
not the battery or grid share of a hold, and not Manual.
|
||||
|
||||
**The car is never slowed for the peak limit in Manual.** A Manual charge goes on whatever
|
||||
the 15-minute peak does. With the default `ev_batt_cover` on, the batteries help
|
||||
cover it down to the peak reserve; a 3-phase 16 A charge (11 kW) can empty two
|
||||
batteries to the reserve in about 1.5 hours, and the month's peak then rises by
|
||||
@@ -3364,9 +3410,10 @@ charger* shows for an hour after a change. That is expected while you migrate.
|
||||
automation **off** (do not delete it). On the card choose **Manual** with the
|
||||
current your helper held (`input_number.ev_manual_current`). Plug in and check
|
||||
the current on the card and on the charger's display.
|
||||
3. On the next sunny day, choose Solar, with *spare sun goes first to* set as
|
||||
your priority switch was. (Solar comes in a later version; until then keep
|
||||
Manual or Off.)
|
||||
3. On the next sunny day, choose **Solar**, with *Spare sun goes first to* set
|
||||
as your priority switch was (*Batteries* or *Car*), and *Sun kept back* as
|
||||
your automation's margin. Watch the card's *Why* through a cloud: the car
|
||||
holds 6 A for 5 minutes, then waits for the sun.
|
||||
4. Keep your Home Assistant helpers for a week. To go back, set the add-on mode
|
||||
to Off and switch the automation on. After that you can delete the helpers and
|
||||
the automation.
|
||||
@@ -3377,8 +3424,8 @@ off before you choose Manual, and the add-on off (mode Off) before you turn the
|
||||
automation on.
|
||||
|
||||
**Home Assistant entities.** With MQTT the add-on adds the sensors
|
||||
`goodwe_car_power`, `goodwe_car_state` and `goodwe_car_today_kwh`, and the three
|
||||
controls named above. A saved ("retained") command is never applied, so a
|
||||
`goodwe_car_power`, `goodwe_car_state`, `goodwe_car_today_kwh` and
|
||||
`goodwe_car_today_solar_kwh`, and the four controls named above. A saved ("retained") command is never applied, so a
|
||||
restart of Home Assistant cannot change the charger.
|
||||
|
||||
### Site
|
||||
@@ -3516,6 +3563,13 @@ their full power. The add-on never slows the car, so this is information, not an
|
||||
alarm. It is raised once per charging session. To stay under the limit, lower the
|
||||
current.
|
||||
|
||||
### Charger error, car paused
|
||||
|
||||
In Solar mode the charger reports an error, so the add-on set the car to 0 A
|
||||
and writes nothing more until the error clears. Then the car starts again by
|
||||
the Solar rules. Check the charger itself. The notification goes by itself when
|
||||
the error clears.
|
||||
|
||||
### For installers: notifications
|
||||
|
||||
A fixed tariff beside the price service raises no notification: it is the
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
"""EV-04: the car charger's Manual mode, the one place the add-on WRITES to it.
|
||||
"""EV-04 and EV-05: the car charger's Manual and Solar modes, the one place the
|
||||
add-on WRITES to it.
|
||||
|
||||
Pure but for the driver it is handed: no clock of its own (`now` is monotonic
|
||||
seconds from the caller), no Home Assistant, no store. DECISIONS/EV-04-manual-
|
||||
@@ -24,21 +25,38 @@ THE RULES, each tested in test_ev04.py:
|
||||
mode or a value again.
|
||||
* A charger that comes back after being unavailable gets the setting again only
|
||||
if its read-back differs.
|
||||
|
||||
EV-05, SOLAR (`SolarPlan` decides, `SolarWriter` writes; test_ev05.py,
|
||||
DECISIONS/EV-05-solar-mode.md): the car gets the spare sun, `spare = car +
|
||||
battery charge - grid import`, less the batteries' room (Batteries first) and
|
||||
the margin. Whole amps rounded down, at most one write per 30 s and only on a
|
||||
1 A change. Start after `ev_start_min` of enough sun, hold 6 A for
|
||||
`ev_pause_min` below it, then 0 A. The peak guard's excess is taken off the
|
||||
car first, at once. Every way out of Solar leaves the charger at 0 A, written
|
||||
once. Both writers share `ManualWriter._write`, so there is still one
|
||||
`write_current` and one `write_phases` call in the add-on.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import math
|
||||
|
||||
from . import chargers as CH
|
||||
|
||||
_LOG = logging.getLogger("goodwe")
|
||||
|
||||
OFF, MANUAL = "off", "manual"
|
||||
#: the modes this card offers. Solar and Night are later cards (EV-05, EV-02).
|
||||
MODES = (OFF, MANUAL)
|
||||
OFF, MANUAL, SOLAR = "off", "manual", "solar"
|
||||
#: the modes offered. Night is a later card (EV-02).
|
||||
MODES = (OFF, MANUAL, SOLAR)
|
||||
#: Home Assistant's select labels, English and pinned.
|
||||
MODE_LABELS = {OFF: "Off", MANUAL: "Manual"}
|
||||
MODE_LABELS = {OFF: "Off", MANUAL: "Manual", SOLAR: "Solar"}
|
||||
#: EV-05: where the spare sun goes first (`select.goodwe_car_sun_first`).
|
||||
KEY_FIRST = "car_sun_first"
|
||||
FIRST_BATT, FIRST_CAR = "batteries", "car"
|
||||
FIRSTS = (FIRST_BATT, FIRST_CAR)
|
||||
FIRST_LABELS = {FIRST_BATT: "Batteries", FIRST_CAR: "Car"}
|
||||
DEFAULT_FIRST = FIRST_BATT
|
||||
START_KEEP, START_OFF = "keep", "off"
|
||||
|
||||
KEY_MODE, KEY_A, KEY_PHASES = "car_mode", "car_current", "car_phases"
|
||||
@@ -125,6 +143,8 @@ class ManualWriter:
|
||||
self.phase_fails = 0 # phase selects the charger did not take
|
||||
self.phases_gave_up = False
|
||||
self.undone = 0 # sequences undone before the select
|
||||
self.phase_done_at = None # EV-15: our phase change ended well then
|
||||
self.zero_sent_at = None # EV-15: our 0 A write is out, not yet back
|
||||
|
||||
# ------------------------------------------------------------------ user
|
||||
def user_changed(self) -> None:
|
||||
@@ -292,7 +312,14 @@ class ManualWriter:
|
||||
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)
|
||||
self.phase_done_at = None
|
||||
# EV-15: the car stops while the write waits for its read-back, and the
|
||||
# cycle runs beside it: the window opens when the write is SENT.
|
||||
self.zero_sent_at = now
|
||||
try:
|
||||
ok = await self._write(drv, 0.0, cur, now, tracker)
|
||||
finally:
|
||||
self.zero_sent_at = None
|
||||
if not ok:
|
||||
self._failed(now)
|
||||
return
|
||||
@@ -336,6 +363,7 @@ class ManualWriter:
|
||||
self.log.append(("phases", q["n"], now, ok))
|
||||
q["stage"], q["t1"] = "settle", self.last_done # from its return
|
||||
if not ok:
|
||||
q["failed"] = True # EV-15: no grace for the alarm
|
||||
# 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
|
||||
@@ -356,7 +384,10 @@ class ManualWriter:
|
||||
# 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
|
||||
if not q.get("failed"):
|
||||
self.phase_done_at = self.last_done # EV-15
|
||||
return
|
||||
q["failed"] = True # EV-15: a refused write ends it
|
||||
q["tries"] += 1
|
||||
if q["tries"] >= MAX_TRIES:
|
||||
# Left at 0 A is the safe side; the next reading re-applies.
|
||||
@@ -365,3 +396,485 @@ class ManualWriter:
|
||||
self.rev_applied = None
|
||||
return
|
||||
q["t1"] = now - SETTLE_S + 5.0 # again in 5 s
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
# EV-05: Solar. `SolarPlan` decides what the car should get, `SolarWriter`
|
||||
# makes the charger match it through ManualWriter's one write site.
|
||||
# =========================================================================== #
|
||||
MIN_A = CH.MIN_A
|
||||
VOLTS = 230.0 # per phase: the amps a figure in watts is worth
|
||||
SOLAR_WRITE_S = 30.0 # at most one current change per this
|
||||
SOLAR_STEP_A = 1.0 # ... and only on a change of this or more
|
||||
UP_W, UP_S = 4500.0, 180.0 # auto phases: to 3 at this for this long
|
||||
DOWN_W, DOWN_S = 4000.0, 300.0 # ... back to 1 under this for this long
|
||||
ONE_PHASE_S = 10.0 # one phase drawing while 3 are allowed this long
|
||||
ONE_PHASE_MIN_W = 500.0 # ... with the car drawing at least this
|
||||
|
||||
|
||||
def _num(v):
|
||||
try:
|
||||
f = float(v)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
return f if math.isfinite(f) else None
|
||||
|
||||
|
||||
def spare_w(car_w, batt_w, grid_w):
|
||||
"""The spare sun, signed and not clipped: what the car takes, plus what the
|
||||
batteries charge, less what the grid gives. `batt_w` is the add-on's own
|
||||
battery figure (discharge positive) and `grid_w` the meter (import
|
||||
positive), so this is `car - batt - grid` = solar production less the
|
||||
house. A grid charge of the batteries, or batteries giving more than the
|
||||
house uses, is never spare sun. None when a figure is missing or not a
|
||||
number."""
|
||||
c, b, g = _num(car_w), _num(batt_w), _num(grid_w)
|
||||
if c is None or b is None or g is None:
|
||||
return None
|
||||
return c - b - g
|
||||
|
||||
|
||||
def car_target_w(spare, room_w, margin_w, first):
|
||||
"""What the car may take: Batteries first `spare - room - margin`, Car
|
||||
first `spare - margin`. None while the spare is unknown."""
|
||||
s = _num(spare)
|
||||
if s is None:
|
||||
return None
|
||||
room = float(room_w or 0.0) if first == FIRST_BATT else 0.0
|
||||
return s - room - float(margin_w)
|
||||
|
||||
|
||||
def amps_for(car_w, n, clamp=None):
|
||||
"""Whole amps for `car_w` on `n` phases, ROUNDED DOWN, never above the
|
||||
clamp. None for a figure that is not a number."""
|
||||
w = _num(car_w)
|
||||
if w is None or n not in (1, 3):
|
||||
return None
|
||||
a = math.floor(w / (VOLTS * n) + 1e-9)
|
||||
hi = CH.ENTITY_MAX_A if _num(clamp) is None else float(clamp)
|
||||
return float(max(0, min(a, math.floor(hi))))
|
||||
|
||||
|
||||
def solar_option(opts: dict, key: str) -> float:
|
||||
"""`ev_margin_w`, `ev_pause_min` or `ev_start_min` as a number, the shipped
|
||||
default when it is not one (the validator refuses it anyway)."""
|
||||
v = _num((opts or {}).get(key))
|
||||
return float(CH.EV_OPTION_DEFAULTS[key]) if v is None else v
|
||||
|
||||
|
||||
class SunInputs:
|
||||
"""One cycle's inputs for Solar, built by the Controller."""
|
||||
|
||||
def __init__(self, target_w=None, hold=False, cut_w=0.0, car_w=None,
|
||||
key=None, auto=True, fixed_n=1, start_s=120.0,
|
||||
pause_s=300.0, spare_w=None, room_w=0.0, margin_w=100.0,
|
||||
first=DEFAULT_FIRST):
|
||||
self.target_w, self.hold, self.cut_w = target_w, hold, cut_w
|
||||
self.car_w, self.key, self.auto, self.fixed_n = car_w, key, auto, \
|
||||
fixed_n
|
||||
self.start_s, self.pause_s = start_s, pause_s
|
||||
self.spare_w, self.room_w, self.margin_w = spare_w, room_w, margin_w
|
||||
self.first = first
|
||||
|
||||
|
||||
class SolarPlan:
|
||||
"""What Solar wants set, one `step()` per cycle. Pure: monotonic `now` from
|
||||
the caller and no driver, so in shadow mode it runs the same and the card
|
||||
says what it would set. `a` is the current wanted (0: paused), `n` the
|
||||
phases it is meant for."""
|
||||
|
||||
def __init__(self, n=1):
|
||||
self.reset(n)
|
||||
|
||||
def reset(self, n=1, why="paused"):
|
||||
self.a = 0.0
|
||||
self.n = n if n in (1, 3) else 1
|
||||
self.set_at = None # when `a` last changed (the 30 s rule)
|
||||
self.ok_since = None # enough sun to start, since
|
||||
self.low_since = None # under 6 A worth, holding 6 A, since
|
||||
self.unknown_since = None # the spare cannot be measured, since
|
||||
self.up_since = self.down_since = None
|
||||
self.cap_a = self.cap_key = None # the peak cut, for this period
|
||||
self.why = self.pause_why = why
|
||||
self.target_w = None
|
||||
|
||||
def _pause(self, why):
|
||||
self.a, self.set_at = 0.0, None
|
||||
self.ok_since = self.low_since = self.unknown_since = None
|
||||
self.up_since = self.down_since = None
|
||||
self.why = self.pause_why = why
|
||||
|
||||
def _gate(self, now) -> bool:
|
||||
return self.set_at is None or now - self.set_at >= SOLAR_WRITE_S
|
||||
|
||||
def _switch(self, n, target_w, now, clamp):
|
||||
self.n = n
|
||||
a = amps_for(target_w, n, clamp) or 0.0
|
||||
if a >= MIN_A:
|
||||
self.low_since = None
|
||||
elif self.low_since is None:
|
||||
self.low_since = now
|
||||
a = max(a, MIN_A)
|
||||
if self.cap_a is not None:
|
||||
a = max(MIN_A, min(a, self.cap_a))
|
||||
self.a, self.set_at = a, now
|
||||
self.up_since = self.down_since = None
|
||||
self.why = "running"
|
||||
|
||||
def step(self, now, *, target_w, n_calc, auto, fixed_n, clamp,
|
||||
start_s, pause_s, hold=False, cut_w=0.0, car_w=None, key=None,
|
||||
gap_ok=True):
|
||||
if key != self.cap_key:
|
||||
self.cap_a = self.cap_key = None
|
||||
if hold: # readings late, under the stale bound
|
||||
return
|
||||
self.target_w = target_w
|
||||
# The peak guard's excess comes off the car first, at once (no 30 s
|
||||
# rule, no hold). Nothing starts while the period heads over the aim.
|
||||
if cut_w and cut_w > 0.0:
|
||||
self.ok_since = None
|
||||
if self.a > 0.0:
|
||||
base = self.a * VOLTS * n_calc
|
||||
cw = _num(car_w)
|
||||
if cw is not None:
|
||||
base = min(base, cw)
|
||||
new = amps_for(base - float(cut_w), n_calc, clamp)
|
||||
if new is None or new < MIN_A:
|
||||
self._pause("cut")
|
||||
elif new < self.a:
|
||||
self.a, self.set_at, self.why = new, now, "cut"
|
||||
self.cap_a, self.cap_key = new, key
|
||||
return
|
||||
if target_w is None: # the sun cannot be measured: hold, then 0 A
|
||||
self.ok_since = None
|
||||
if self.a > 0.0:
|
||||
if self.unknown_since is None:
|
||||
self.unknown_since = now
|
||||
if now - self.unknown_since >= pause_s:
|
||||
self._pause("unknown")
|
||||
else:
|
||||
self.why = "unknown"
|
||||
return
|
||||
self.unknown_since = None
|
||||
hi = None if _num(clamp) is None else math.floor(float(clamp))
|
||||
if self.a <= 0.0: # paused: the start rule
|
||||
n0 = 1 if auto else fixed_n
|
||||
if target_w >= (MIN_A + 1.0) * VOLTS * n0:
|
||||
if self.ok_since is None:
|
||||
self.ok_since = now
|
||||
self.why = "start"
|
||||
if now - self.ok_since >= start_s:
|
||||
a = amps_for(target_w, n0, clamp)
|
||||
if a is not None and self.cap_a is not None:
|
||||
a = min(a, self.cap_a)
|
||||
if a is not None and a >= MIN_A:
|
||||
self.a, self.n, self.set_at = a, n0, now
|
||||
self.ok_since = self.low_since = None
|
||||
self.up_since = self.down_since = None
|
||||
self.why = "running"
|
||||
else:
|
||||
self.ok_since = None
|
||||
self.why = self.pause_why
|
||||
return
|
||||
if hi is not None and self.a > hi: # the clamp came down
|
||||
if hi < MIN_A:
|
||||
self._pause("paused")
|
||||
return
|
||||
self.a, self.set_at = float(hi), now
|
||||
if auto: # auto phases, by their own dwells
|
||||
if self.n == 1:
|
||||
self.down_since = None
|
||||
if target_w >= UP_W:
|
||||
self.up_since = self.up_since if self.up_since is not None \
|
||||
else now
|
||||
else:
|
||||
self.up_since = None
|
||||
if self.up_since is not None and now - self.up_since >= UP_S \
|
||||
and gap_ok and self._gate(now):
|
||||
self._switch(3, target_w, now, clamp)
|
||||
return
|
||||
else:
|
||||
self.up_since = None
|
||||
if target_w < DOWN_W:
|
||||
self.down_since = self.down_since \
|
||||
if self.down_since is not None else now
|
||||
else:
|
||||
self.down_since = None
|
||||
if self.down_since is not None \
|
||||
and now - self.down_since >= DOWN_S and gap_ok and self._gate(now):
|
||||
self._switch(1, target_w, now, clamp)
|
||||
return
|
||||
want = amps_for(target_w, n_calc, clamp)
|
||||
if want is not None and want >= MIN_A:
|
||||
self.low_since = None
|
||||
if self.cap_a is not None:
|
||||
want = min(want, self.cap_a)
|
||||
self.why = "running"
|
||||
if abs(want - self.a) >= SOLAR_STEP_A and self._gate(now):
|
||||
self.a, self.set_at = want, now
|
||||
return
|
||||
if auto and self.n == 3 and target_w >= DOWN_W:
|
||||
# Inside the phase hysteresis (4.0 kW to 6 A x 690 W): 3 phases at
|
||||
# 6 A stand, as the switch rule says; no pause count.
|
||||
self.low_since = None
|
||||
self.why = "running"
|
||||
if self.a != MIN_A and self._gate(now):
|
||||
self.a, self.set_at = MIN_A, now
|
||||
return
|
||||
if self.low_since is None:
|
||||
self.low_since = now
|
||||
self.why = "hold"
|
||||
if now - self.low_since >= pause_s:
|
||||
self._pause("paused")
|
||||
return
|
||||
if self.a != MIN_A and self._gate(now):
|
||||
self.a, self.set_at = MIN_A, now
|
||||
|
||||
|
||||
class SolarWriter(ManualWriter):
|
||||
"""What Solar does to the charger, one `step()` per cycle. It shares
|
||||
ManualWriter's write, phase sequence and other-writer watch; what differs
|
||||
is that every way out ends at 0 A, written once, and that an interrupted
|
||||
phase change is never undone to the old current."""
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.plan = SolarPlan()
|
||||
self.engaged = False # Solar has run since it was chosen
|
||||
self.reinit = True # start again from 0 A and the start rule
|
||||
self.out = False # not writing: the 0 A has been tried
|
||||
self.stand = False # no car: the standing 0 A has been tried
|
||||
self.fault = None # "error" | "stuck" while it holds
|
||||
self.fault_done = False
|
||||
self.warned = False # the charger error warning, once
|
||||
self.single = False # a one-phase car on a 3-phase allowance
|
||||
self._one_since = None
|
||||
self.zero_at = None # EV-15: our own latest 0 A, sent then
|
||||
self.sent_a = None # the current we last decided to write
|
||||
|
||||
# ------------------------------------------------------------------ help
|
||||
def _mark(self, r, now) -> None:
|
||||
"""A car that draws one phase while 3 are allowed is a one-phase car
|
||||
for the session: the sun arithmetic then uses 1 phase."""
|
||||
if r.state == "A":
|
||||
self.single, self._one_since = False, None
|
||||
return
|
||||
drawing = [x for x in (r.current_a or ()) if x >= CH.IDLE_A]
|
||||
one = (r.phases_allowed == 3 and r.charging is True
|
||||
and r.power_w is not None and r.power_w >= ONE_PHASE_MIN_W
|
||||
and len(r.current_a or ()) >= 3 and len(drawing) == 1)
|
||||
if not one:
|
||||
self._one_since = None
|
||||
return
|
||||
if self._one_since is None:
|
||||
self._one_since = now
|
||||
if now - self._one_since >= ONE_PHASE_S and not self.single:
|
||||
self.single = True
|
||||
_LOG.info("The car draws one phase while three are allowed, so "
|
||||
"the add-on counts one phase for this charge.")
|
||||
|
||||
def _watch(self, cur, now) -> None:
|
||||
"""As Manual's, and in Solar the hold is a warning: the add-on stops
|
||||
writing until you press the mode or the read-back matches again."""
|
||||
was = self.hold
|
||||
super()._watch(cur, now)
|
||||
if self.hold and not was:
|
||||
_LOG.warning("Something else changes the charger, so the add-on "
|
||||
"stops writing to it: CHARGER_OTHER.")
|
||||
|
||||
@property
|
||||
def n_calc(self) -> int:
|
||||
return 1 if self.single else self.plan.n
|
||||
|
||||
def amps_out(self, clamp) -> float:
|
||||
"""The plan's current, never above the clamp; 0 when under 6 A."""
|
||||
a = float(self.plan.a)
|
||||
if _num(clamp) is not None:
|
||||
a = min(a, float(math.floor(float(clamp))))
|
||||
return a if a >= CH.MIN_A else 0.0
|
||||
|
||||
def user_changed(self) -> None:
|
||||
"""As Manual's, and Solar says its current again (another writer's
|
||||
hold is lifted by pressing the mode)."""
|
||||
super().user_changed()
|
||||
self.sent_a = None
|
||||
|
||||
async def _zero_once(self, drv, cur, now, tracker, force=False) -> None:
|
||||
"""One try of 0 A on the way out. Never over another writer, and not
|
||||
when the charger already shows 0 A (unless the reading is stuck, so
|
||||
its 0 A means nothing: `force`)."""
|
||||
if self.hold or (not force and cur is not None and cur <= TOL_A):
|
||||
return
|
||||
self.zero_at, self.sent_a = now, 0.0
|
||||
await self._write(drv, 0.0, cur, now, tracker)
|
||||
|
||||
def _leave(self) -> None:
|
||||
self.engaged, self.seq, self.would = False, None, None
|
||||
self.out = self.stand = False
|
||||
self.fault, self.fault_done = None, False
|
||||
self.reinit = True
|
||||
self.sent_a = None
|
||||
self.plan.reset(self.plan.n)
|
||||
|
||||
def _plan_step(self, sun, now, clamp) -> None:
|
||||
gap = self.last_switch is None or now - self.last_switch >= PHASE_GAP_S
|
||||
self.plan.step(
|
||||
now, target_w=sun.target_w, hold=sun.hold, n_calc=self.n_calc,
|
||||
auto=sun.auto and not self.single,
|
||||
fixed_n=1 if self.single else sun.fixed_n, clamp=clamp,
|
||||
cut_w=sun.cut_w, car_w=sun.car_w, key=sun.key,
|
||||
start_s=sun.start_s, pause_s=sun.pause_s,
|
||||
gap_ok=gap and not self.phases_gave_up)
|
||||
|
||||
# ------------------------------------------------------------------ step
|
||||
async def step(self, drv, r, *, mode, sun, clamp, now, tracker, writing,
|
||||
status, clock=None):
|
||||
"""One cycle. `sun` is `SunInputs`; `writing` is False in shadow mode,
|
||||
while control is stopped, under a safety stop and while stopping."""
|
||||
self._clock = clock or (lambda: now)
|
||||
if r is None or not r.available:
|
||||
self.was_available = False # nothing is tried while it is down
|
||||
return
|
||||
if self.last_done is not None and tracker is not None \
|
||||
and tracker.obs_at is not None \
|
||||
and tracker.obs_at <= self.last_done:
|
||||
return
|
||||
self._mark(r, now)
|
||||
if not self.was_available:
|
||||
self.was_available = True
|
||||
self.reinit = True # back: 0 A first, then the rules
|
||||
cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
|
||||
if mode != SOLAR:
|
||||
self.would = None
|
||||
if not self.engaged:
|
||||
return
|
||||
if mode != MANUAL: # Off: 0 A once, then nothing
|
||||
self.seq = None
|
||||
await self._zero_once(drv, cur, now, tracker)
|
||||
self._leave() # Manual writes its own current
|
||||
return
|
||||
self.engaged = True
|
||||
if sun is None:
|
||||
return
|
||||
if not writing:
|
||||
# Shadow, Stop, a safety stop, stopping: 0 A once, then nothing.
|
||||
# The plan goes on, so the card says what it would set.
|
||||
self.seq = None
|
||||
if not self.out:
|
||||
self.out = True
|
||||
await self._zero_once(drv, cur, now, tracker)
|
||||
self._plan_step(sun, now, clamp)
|
||||
self.would = (self.amps_out(clamp), self.n_calc)
|
||||
self.reinit = True
|
||||
return
|
||||
self.out = False
|
||||
self.would = None
|
||||
fault = ("error" if (r.error or r.state in ("E", "F")) else
|
||||
"stuck" if tracker is not None and tracker.stuck(now)
|
||||
else None)
|
||||
if fault is not None:
|
||||
# 0 A once, then no write until it clears; then the start rule.
|
||||
self.seq = None
|
||||
if self.fault != fault:
|
||||
self.fault, self.fault_done = fault, False
|
||||
if fault == "error" and not self.warned:
|
||||
self.warned = True
|
||||
_LOG.warning("The charger reports an error, so the add-on "
|
||||
"sets the car to 0 A: CHARGER_ERROR.")
|
||||
if not self.fault_done:
|
||||
self.fault_done = True
|
||||
await self._zero_once(drv, cur, now, tracker,
|
||||
force=fault == "stuck")
|
||||
self.plan.reset(self.plan.n, why=fault)
|
||||
self.reinit = True
|
||||
return
|
||||
if self.fault is not None:
|
||||
self.fault, self.fault_done = None, False
|
||||
self.warned = False
|
||||
if r.state == "A" or status == CH.NONE_:
|
||||
# No car: the standing current is 0 A, written once.
|
||||
self.seq = None
|
||||
if not self.stand:
|
||||
self.stand = True
|
||||
await self._zero_once(drv, cur, now, tracker)
|
||||
self.plan.reset(self.plan.n, why="none")
|
||||
self.reinit = False
|
||||
return
|
||||
self.stand = False
|
||||
if self.reinit:
|
||||
self.reinit = False
|
||||
self.seq = None
|
||||
self.mismatch_since = None
|
||||
self.sent_a = None
|
||||
n = r.phases_allowed if r.phases_allowed in (1, 3) else self.plan.n
|
||||
self.plan.reset(n)
|
||||
if status == CH.FULL: # the car is full: nothing written
|
||||
self.plan.why = "full"
|
||||
return
|
||||
if self.seq is None:
|
||||
self._watch(cur, now)
|
||||
if self.hold:
|
||||
return
|
||||
self._plan_step(sun, now, clamp)
|
||||
if self.seq is not None:
|
||||
q = self.seq
|
||||
if self.plan.a < CH.MIN_A:
|
||||
self.seq = None # paused or cut: it stays at 0 A
|
||||
return
|
||||
pf = self.phase_fails
|
||||
await self._advance(drv, r, cur, now, tracker, self.amps_out(clamp)
|
||||
or CH.MIN_A, clamp, None)
|
||||
if self.phase_fails > pf and q.get("from") in (1, 3):
|
||||
self.plan.n = q["from"] # the select was not taken
|
||||
if self.seq is None:
|
||||
self.sent_a = self.last_a
|
||||
return
|
||||
want = self.amps_out(clamp)
|
||||
if want >= CH.MIN_A and not self.single and not self.phases_gave_up \
|
||||
and r.phases_allowed in (1, 3) \
|
||||
and r.phases_allowed != self.plan.n:
|
||||
if self.last_switch is not None \
|
||||
and now - self.last_switch < PHASE_GAP_S:
|
||||
self.blocked = True
|
||||
return
|
||||
self.blocked = False
|
||||
self.zero_at, self.sent_a = now, 0.0
|
||||
await self._begin(drv, r, cur, self.plan.n, now, tracker)
|
||||
if self.seq is not None:
|
||||
self.seq["from"] = r.phases_allowed
|
||||
return
|
||||
if self.sent_a is not None and abs(self.sent_a - want) <= TOL_A \
|
||||
and self.fail_at is None:
|
||||
return # nothing new: a read-back that differs is `_watch`'s
|
||||
if cur is not None and abs(cur - want) <= TOL_A:
|
||||
self.sent_a = want
|
||||
self.fails, self.fail_at = 0, None
|
||||
if self.last_a is None or abs(self.last_a - cur) > TOL_A:
|
||||
self.last_a = cur
|
||||
return
|
||||
if self.gave_up or (self.fail_at is not None
|
||||
and now - self.fail_at < RETRY_S):
|
||||
return
|
||||
if want <= 0.0:
|
||||
self.zero_at = now
|
||||
self.sent_a = want
|
||||
if await self._write(drv, want, cur, now, tracker):
|
||||
self.fails, self.fail_at = 0, None
|
||||
else:
|
||||
self._failed(now)
|
||||
|
||||
async def release(self, drv, r, now, tracker) -> None:
|
||||
"""The add-on stops in Solar: 0 A, once, before the inverters go to
|
||||
0 W. A phase change in the middle is not undone to the old current."""
|
||||
self.seq = None
|
||||
if r is not None and r.available:
|
||||
cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
|
||||
else:
|
||||
cur = None
|
||||
if self.last_done is not None and tracker is not None \
|
||||
and tracker.obs_at is not None \
|
||||
and tracker.obs_at <= self.last_done:
|
||||
cur = self.last_a # the reading predates our own write
|
||||
self._clock = self._clock or (lambda: now)
|
||||
await self._zero_once(drv, cur, now, tracker)
|
||||
self.out = True
|
||||
|
||||
@@ -5,8 +5,8 @@ actuator per site, a census key, a read, a clamped write that says whether the
|
||||
charger took it, and a hand-back. A charger is a modulated actuator with a fail
|
||||
state, not one of DEV-01's on/off loads.
|
||||
|
||||
EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, and only in Manual
|
||||
(`app/carmode.py` is the one caller). `write_current` is clamped to
|
||||
EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, in Manual and (EV-05) in
|
||||
Solar (`app/carmode.py` is the one caller). `write_current` is clamped to
|
||||
`min(ev_max_a, the station limit the charger reports, the entity's own range)`
|
||||
and a value above that is NEVER SENT: it is a software fault, logged in the
|
||||
OUTPUT_CLAMP shape. It says True only when the charger's read-back followed
|
||||
@@ -42,7 +42,13 @@ PHASES_CHOICES = ("1", "3", "auto")
|
||||
# config.yaml's shipped defaults, mirrored (test_defaults_pin.py checks it).
|
||||
EV_OPTION_DEFAULTS = {"ev_charger": "off", "ev_current_entity": "",
|
||||
"ev_max_a": 16, "ev_phases": "auto",
|
||||
"ev_batt_cover": True, "ev_mode_start": "keep"}
|
||||
"ev_batt_cover": True, "ev_mode_start": "keep",
|
||||
# EV-05, Solar: the sun kept back, and the two dwells
|
||||
"ev_margin_w": 100, "ev_pause_min": 5,
|
||||
"ev_start_min": 2}
|
||||
#: EV-05: the ranges config.yaml's schema and the validator both hold.
|
||||
SOLAR_RANGES = {"ev_margin_w": (0, 1000), "ev_pause_min": (1, 30),
|
||||
"ev_start_min": (1, 30)}
|
||||
|
||||
|
||||
def max_a(opts: dict):
|
||||
@@ -553,7 +559,9 @@ class AlfenHaDriver(ChargerDriver):
|
||||
|
||||
async def release(self, mode: str) -> bool:
|
||||
"""The mode's fail state. Manual and Off keep the current (the charger
|
||||
is a stand-alone device and the current is the user's setting)."""
|
||||
is a stand-alone device and the current is the user's setting). Solar's
|
||||
0 A goes through `carmode` (`SolarWriter.release`), the one write
|
||||
site, so nothing is written here."""
|
||||
return True
|
||||
|
||||
|
||||
@@ -800,8 +808,20 @@ class CarTracker:
|
||||
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."""
|
||||
return self._capped_w(now, True)
|
||||
|
||||
def car_w_paused(self, now: float):
|
||||
"""EV-15: the same figure as `car_w_trusted` without the energy-meter
|
||||
corroboration, which a car held at 0 A by the add-on's own phase change
|
||||
cannot give (the meter's window restarts when it stops charging). Fresh,
|
||||
not stuck, and capped by the read-back. Only for grading the alarm
|
||||
during that sequence (`ctl_car._car_own_pause`)."""
|
||||
return self._capped_w(now, False)
|
||||
|
||||
def _capped_w(self, now: float, corroborate: bool):
|
||||
w = self.car_w(now)
|
||||
if w is None or self.stuck(now) or not self.corroborated(now):
|
||||
if w is None or self.stuck(now) \
|
||||
or (corroborate and not self.corroborated(now)):
|
||||
return None
|
||||
r = self.reading
|
||||
a = r.allowed_a if r.allowed_a is not None else r.setpoint_a
|
||||
|
||||
@@ -1,17 +1,21 @@
|
||||
"""EV-04: the Controller's side of the car's Manual mode.
|
||||
"""EV-04 and EV-05: the Controller's side of the car's Manual and Solar modes.
|
||||
|
||||
The writes themselves are `carmode.ManualWriter`'s; this mixin owns the state
|
||||
(mode, current, phases: runtime state in the store, like OPT-11's modes), the
|
||||
actions, the background step that never holds up a control cycle, and what the
|
||||
car means for the peak guard's ALARM PATH. DECISIONS/EV-04-manual-mode.md.
|
||||
EV-05 (DECISIONS/EV-05-solar-mode.md): Solar's inputs (`car_sun_inputs`), the
|
||||
peak guard's excess taken off the car first (`car_cycle`), the 0 A at shutdown
|
||||
before the inverters, and the solar kWh of today.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import logging
|
||||
import math
|
||||
from datetime import timezone
|
||||
|
||||
from . import carmode, chargers, messages, peakguard
|
||||
from . import carmode, chargers, messages, packmode, packshare, peakguard
|
||||
from .tariff import QUARTER_S
|
||||
|
||||
_LOG = logging.getLogger("goodwe")
|
||||
@@ -24,6 +28,17 @@ OVER_HOLD_S = peakguard.ALARM_HOLD_S
|
||||
# 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
|
||||
# EV-15: the longest our own phase change can take (0 A wait, settle, three
|
||||
# tries of a write at 5 s apart and up to 10 s each, the select's own wait);
|
||||
# the grace for the alarm never outlasts it, and after the current is set
|
||||
# again it lasts at most one corroboration window.
|
||||
OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S
|
||||
+ carmode.MAX_TRIES * 15.0 + 10.0)
|
||||
OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S
|
||||
CAR_SUN_KEY = "car_sun" # EV-05: {day, kwh} charged from the sun today
|
||||
# EV-05: at shutdown the charger's 0 A waits at most this long, then the
|
||||
# inverters are released whatever the charger did.
|
||||
RELEASE_WAIT_S = 15.0
|
||||
|
||||
|
||||
class CarMixin:
|
||||
@@ -45,6 +60,25 @@ class CarMixin:
|
||||
self.car_n = n if n in ok else ok[0]
|
||||
self.car_rev = 0
|
||||
self.car_writer = carmode.ManualWriter()
|
||||
self.car_solar = carmode.SolarWriter() # EV-05
|
||||
first = data.get(carmode.KEY_FIRST)
|
||||
self.car_first = first if first in carmode.FIRSTS \
|
||||
else carmode.DEFAULT_FIRST
|
||||
self.car_cut_w = 0.0
|
||||
self._car_key = None
|
||||
self._car_late_s = None
|
||||
self._car_sun_last = None
|
||||
self._car_error_notified = False
|
||||
sun = data.get(CAR_SUN_KEY)
|
||||
self.car_sun = {"day": None, "kwh": 0.0}
|
||||
if isinstance(sun, dict):
|
||||
try:
|
||||
self.car_sun = {"day": sun.get("day"),
|
||||
"kwh": max(0.0, float(sun.get("kwh") or 0.0))}
|
||||
except (TypeError, ValueError):
|
||||
pass
|
||||
self._car_sun_mono = None
|
||||
self._car_sun_saved = round(self.car_sun["kwh"], 2)
|
||||
self._car_task = None
|
||||
self._car_step_failed = False
|
||||
self.car_explains = False # the car alone explains the excess
|
||||
@@ -57,7 +91,7 @@ class CarMixin:
|
||||
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._carq = {"key": None, "ws": 0.0, "ws_p": 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 {}
|
||||
@@ -74,6 +108,12 @@ class CarMixin:
|
||||
return (self.charger.configured()
|
||||
and self.car_mode == carmode.MANUAL)
|
||||
|
||||
def car_solar_mode(self) -> bool:
|
||||
"""EV-05: a charger is set up and the mode is Solar."""
|
||||
ch = getattr(self, "charger", None)
|
||||
return bool(ch is not None and ch.configured()
|
||||
and getattr(self, "car_mode", None) == carmode.SOLAR)
|
||||
|
||||
def car_clamp(self):
|
||||
return carmode.clamp_for(self.o, self.car.reading)
|
||||
|
||||
@@ -97,6 +137,17 @@ class CarMixin:
|
||||
return {"error": messages.car_refused("value")}
|
||||
self.car_mode = value
|
||||
self.store.set(carmode.KEY_MODE, value)
|
||||
elif what == "car_sun_first":
|
||||
# EV-05: arithmetic only, from the next cycle; not a user change of
|
||||
# the writers (the 30 s rule and the other-writer hold stand).
|
||||
if value not in carmode.FIRSTS:
|
||||
return {"error": messages.car_refused("value")}
|
||||
self.car_first = value
|
||||
self.store.set(carmode.KEY_FIRST, value)
|
||||
self.log_event(f"car sun first set to {value} by operator",
|
||||
hint=messages.hint("car_sun_first"))
|
||||
return {"mode": self.car_mode, "current": self.car_a,
|
||||
"phases": self.car_n, "sun_first": self.car_first}
|
||||
elif what == "car_current":
|
||||
clamp = self.car_clamp()
|
||||
if isinstance(value, bool):
|
||||
@@ -119,6 +170,7 @@ class CarMixin:
|
||||
self.store.set(carmode.KEY_PHASES, value)
|
||||
self.car_rev += 1
|
||||
self.car_writer.user_changed()
|
||||
self.car_solar.user_changed()
|
||||
self.log_event(f"car {what[4:]} set to {value} by operator",
|
||||
hint=messages.hint(what))
|
||||
return {"mode": self.car_mode, "current": self.car_a,
|
||||
@@ -128,7 +180,8 @@ class CarMixin:
|
||||
"""The MQTT state of the three car entities."""
|
||||
return {"car_mode": carmode.MODE_LABELS[self.car_mode],
|
||||
"car_current": round(self.car_a),
|
||||
"car_phases": str(self.car_n)}
|
||||
"car_phases": str(self.car_n),
|
||||
"car_sun_first": carmode.FIRST_LABELS[self.car_first]}
|
||||
|
||||
# ------------------------------------------------------------- the writer
|
||||
def car_kick(self) -> None:
|
||||
@@ -142,6 +195,15 @@ class CarMixin:
|
||||
return
|
||||
self._car_task = asyncio.ensure_future(self._car_run())
|
||||
|
||||
def _car_hold_kick(self) -> None:
|
||||
"""EV-05: a cycle that holds for a missing or late reading returns
|
||||
before `car_kick()`. Solar still steps (it holds, counts its dwell from
|
||||
the first missing reading, and an exit still writes its 0 A); Manual is
|
||||
left exactly as it was."""
|
||||
if self.car_solar_engaged():
|
||||
self.car_cut_w = 0.0
|
||||
self.car_kick()
|
||||
|
||||
async def car_settle(self) -> None:
|
||||
"""Wait for the writer step in flight (the checks use it)."""
|
||||
t = self._car_task
|
||||
@@ -164,14 +226,30 @@ class CarMixin:
|
||||
else:
|
||||
self._car_step_failed = False
|
||||
|
||||
def car_solar_engaged(self) -> bool:
|
||||
"""EV-05: Solar is the mode, or its 0 A on the way out is still due."""
|
||||
w = getattr(self, "car_solar", None)
|
||||
return bool(self.charger.configured() and w is not None
|
||||
and (self.car_mode == carmode.SOLAR or w.engaged))
|
||||
|
||||
async def car_shutdown(self) -> None:
|
||||
"""The add-on stops: no new write, and a phase change in the middle is
|
||||
undone by giving the car its current back. The current stands
|
||||
otherwise (Manual's fail state)."""
|
||||
"""The add-on stops: no new write. Manual: a phase change in the middle
|
||||
is undone by giving the car its current back, the current stands
|
||||
otherwise. Solar (EV-05): 0 A, once, waited for at most
|
||||
`RELEASE_WAIT_S` (`Controller.shutdown` calls this first in Solar)."""
|
||||
t, self._car_task = getattr(self, "_car_task", None), None
|
||||
if t is not None and not t.done():
|
||||
t.cancel()
|
||||
await asyncio.gather(t, return_exceptions=True)
|
||||
if self.car_solar_engaged():
|
||||
try:
|
||||
await asyncio.wait_for(self.car_solar.release(
|
||||
self.charger, self.car.reading, self.car_now(), self.car),
|
||||
RELEASE_WAIT_S)
|
||||
except Exception: # noqa: BLE001
|
||||
_LOG.warning("The car charger could not be set to 0 A before "
|
||||
"the add-on stopped: CHARGER_RELEASE.")
|
||||
return
|
||||
if not self.charger.configured() \
|
||||
or getattr(self, "car_writer", None) is None \
|
||||
or self.car_writer.seq is None:
|
||||
@@ -190,33 +268,214 @@ class CarMixin:
|
||||
if not self.charger.configured():
|
||||
return
|
||||
now = self.car_now()
|
||||
await self.car_writer.step(
|
||||
self.charger, self.car.reading, mode=self.car_mode,
|
||||
want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
|
||||
clamp=self.car_clamp(), now=now, tracker=self.car,
|
||||
writing=self.car_writing(), shadow=bool(self.shadow),
|
||||
status=self.car.status(now, True), clock=self.car_now)
|
||||
if self.car_mode != carmode.SOLAR:
|
||||
await self.car_writer.step(
|
||||
self.charger, self.car.reading, mode=self.car_mode,
|
||||
want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
|
||||
clamp=self.car_clamp(), now=now, tracker=self.car,
|
||||
writing=self.car_writing(), shadow=bool(self.shadow),
|
||||
status=self.car.status(now, True), clock=self.car_now)
|
||||
w = self.car_solar
|
||||
if self.car_mode == carmode.SOLAR or w.engaged:
|
||||
await w.step(
|
||||
self.charger, self.car.reading, mode=self.car_mode,
|
||||
sun=(self.car_sun_inputs(now)
|
||||
if self.car_mode == carmode.SOLAR else None),
|
||||
clamp=self.car_clamp(), now=now, tracker=self.car,
|
||||
writing=self.car_writing(), status=self.car.status(now, True),
|
||||
clock=self.car_now)
|
||||
|
||||
# ------------------------------------------------------- EV-05: Solar
|
||||
def car_may_charge(self, inv) -> bool:
|
||||
"""May this battery take the sun? On (battery modes), not refusing a
|
||||
charge, its level read and under full."""
|
||||
if self.modes_on and not self.pack_mode(inv).use:
|
||||
return False
|
||||
if (inv.refused or 0) < 0 or inv.sign_wd.tripped:
|
||||
return False
|
||||
if len(self.inverters) == 1 and (self.batt_refused or 0) < 0:
|
||||
return False
|
||||
return inv.soc is not None and float(inv.soc) < packshare.FULL_PCT
|
||||
|
||||
def car_room_w(self) -> float:
|
||||
"""Batteries first: the RATINGS of the batteries that may charge."""
|
||||
return float(sum(inv.rating_w() for inv in self.inverters
|
||||
if self.car_may_charge(inv)))
|
||||
|
||||
def car_spare_w(self, mono):
|
||||
"""The signed spare sun now, or None when it cannot be measured: a
|
||||
missing meter or battery figure, readings late past the stale bound,
|
||||
or a charging car whose figure is stale, stuck or not corroborated. A
|
||||
paused or idle car with a fresh reading counts as 0 W."""
|
||||
if not self.inputs_ok:
|
||||
return None
|
||||
stale = float(self.o.get("stale_input_s", 15))
|
||||
late = self._car_late_s
|
||||
if late is not None and late >= stale:
|
||||
return None
|
||||
if self.p1_enabled:
|
||||
# The meter's own bound (`meter_max_age_s`) may be longer than
|
||||
# `stale_input_s`; a car write never comes from an older reading.
|
||||
age = self.p1.age_s()
|
||||
if age is None or age > stale:
|
||||
return None
|
||||
r = self.car.reading
|
||||
if r is None or not r.available or not self.car.fresh(mono):
|
||||
return None
|
||||
if r.charging is True:
|
||||
car = self.car.car_w_trusted(mono)
|
||||
else:
|
||||
car = 0.0
|
||||
return carmode.spare_w(car, self.site_batt_w, self.grid)
|
||||
|
||||
def car_sun_inputs(self, mono) -> "carmode.SunInputs":
|
||||
o = self.o
|
||||
spare = self.car_spare_w(mono)
|
||||
late = self._car_late_s
|
||||
hold = late is not None and late < float(o.get("stale_input_s", 15))
|
||||
room = self.car_room_w()
|
||||
margin = carmode.solar_option(o, "ev_margin_w")
|
||||
ph = str(o.get("ev_phases", chargers.EV_OPTION_DEFAULTS["ev_phases"]))
|
||||
self._car_sun_last = carmode.SunInputs(
|
||||
target_w=carmode.car_target_w(spare, room, margin,
|
||||
self.car_first),
|
||||
hold=hold, cut_w=self.car_cut_w,
|
||||
car_w=self.car.car_w(mono), key=self._car_key,
|
||||
auto=ph not in ("1", "3"), fixed_n=3 if ph == "3" else 1,
|
||||
start_s=60.0 * carmode.solar_option(o, "ev_start_min"),
|
||||
pause_s=60.0 * carmode.solar_option(o, "ev_pause_min"),
|
||||
spare_w=spare, room_w=room, margin_w=margin,
|
||||
first=self.car_first)
|
||||
return self._car_sun_last
|
||||
|
||||
def _car_sun_tick(self, mono) -> None:
|
||||
"""Solar kWh: per cycle, in Solar only, the car's power up to the sun
|
||||
it may take (`spare - room` Batteries first, `spare` Car first). The
|
||||
hold's battery or grid share and Manual do not count."""
|
||||
if not self.car_solar_mode():
|
||||
self._car_sun_mono = None
|
||||
return
|
||||
day = self.car.day
|
||||
if day is not None and self.car_sun.get("day") != day:
|
||||
self.car_sun = {"day": day, "kwh": 0.0}
|
||||
self.store.set(CAR_SUN_KEY, dict(self.car_sun))
|
||||
self._car_sun_saved = 0.0
|
||||
last, self._car_sun_mono = self._car_sun_mono, mono
|
||||
if last is None:
|
||||
return
|
||||
dt = min(max(mono - last, 0.0), 5.0)
|
||||
p = self.car.car_w(mono)
|
||||
spare = self.car_spare_w(mono)
|
||||
if p is None or spare is None or dt <= 0.0:
|
||||
return
|
||||
sun = spare - (self.car_room_w() if self.car_first == carmode.FIRST_BATT
|
||||
else 0.0)
|
||||
share = min(float(p), max(0.0, sun))
|
||||
if share <= 0.0:
|
||||
return
|
||||
self.car_sun["kwh"] += share * dt / 3.6e6
|
||||
if round(self.car_sun["kwh"], 2) != self._car_sun_saved:
|
||||
self._car_sun_saved = round(self.car_sun["kwh"], 2)
|
||||
self.store.set(CAR_SUN_KEY, {"day": self.car_sun["day"],
|
||||
"kwh": round(self.car_sun["kwh"], 4)})
|
||||
|
||||
def car_sun_kwh(self):
|
||||
"""Today's kWh from the sun, never above today's kWh; None without a
|
||||
reading of today."""
|
||||
if self.car.today_kwh is None or self.car_sun.get("day") != self.car.day:
|
||||
return None if self.car.today_kwh is None else 0.0
|
||||
return max(0.0, min(float(self.car_sun["kwh"]),
|
||||
float(self.car.today_kwh)))
|
||||
|
||||
async def check_car_error(self) -> None:
|
||||
"""EV-05: in Solar a charger error sets the car to 0 A and raises one
|
||||
warning notification; it is taken down when the error clears."""
|
||||
bad = self.car_solar_mode() and self.car_solar.fault == "error"
|
||||
if bad and not self._car_error_notified:
|
||||
self._car_error_notified = True
|
||||
await self.hass.call("persistent_notification", "create",
|
||||
messages.charger_error().data())
|
||||
elif not bad and self._car_error_notified:
|
||||
self._car_error_notified = False
|
||||
await self.hass.call("persistent_notification", "dismiss",
|
||||
messages.charger_error_gone().data())
|
||||
|
||||
# ------------------------------------------- the car and the peak guard
|
||||
def car_alarm_w(self):
|
||||
"""The car's power for the guard's alarm path: Manual only, fresh, not
|
||||
stuck (`CarTracker.car_w_trusted`), and never above what the read-back
|
||||
allows. None otherwise, and then the normal alarms stand."""
|
||||
if not self.car_manual():
|
||||
"""The car's power for the guard's alarm path: Manual and Solar, fresh,
|
||||
not stuck (`CarTracker.car_w_trusted`), and never above what the
|
||||
read-back allows. None otherwise, and then the normal alarms stand."""
|
||||
if not (self.car_manual() or self.car_solar_mode()):
|
||||
return None
|
||||
return self.car.car_w_trusted(self.car_now())
|
||||
|
||||
def _car_quarter(self, proj, w, mono) -> None:
|
||||
def _car_own_pause(self, mono) -> bool:
|
||||
"""EV-15: is the car held at 0 A by the add-on's OWN phase change? From
|
||||
the moment its 0 A write is SENT (the cycle runs beside the write)
|
||||
until the current is set again, then at most one corroboration window.
|
||||
No when it was aborted (Off, Stop, shadow, unplug, another writer), a
|
||||
write was refused, or it ran past its own maximum."""
|
||||
if self.car_solar_mode():
|
||||
return self._car_solar_pause(mono)
|
||||
wr = getattr(self, "car_writer", None)
|
||||
if wr is None or (wr.seq is None and wr.phase_done_at is None
|
||||
and wr.zero_sent_at is None) or wr.hold:
|
||||
return False
|
||||
r = self.car.reading
|
||||
if not (self.car_manual() and self.car_writing()
|
||||
and r is not None and r.available and r.state != "A"):
|
||||
return False
|
||||
q = wr.seq
|
||||
if q is None and wr.zero_sent_at is not None: # sent, not yet back
|
||||
return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S
|
||||
if q is not None:
|
||||
return not q.get("failed") and 0.0 <= mono - q["t0"] \
|
||||
<= OWN_PAUSE_MAX_S
|
||||
return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
|
||||
|
||||
def _car_solar_pause(self, mono) -> bool:
|
||||
"""EV-05: Solar's own 0 A (a pause, the peak cut, the phase change)
|
||||
gets EV-15's grace, bounded the same way: from the moment it is sent,
|
||||
at most `OWN_PAUSE_MAX_S`; a phase change as in Manual. None for Stop,
|
||||
shadow, an unplugged car or another writer."""
|
||||
wr = getattr(self, "car_solar", None)
|
||||
r = self.car.reading
|
||||
if wr is None or wr.hold or not self.car_writing() or r is None \
|
||||
or not r.available or r.state == "A":
|
||||
return False
|
||||
q = wr.seq
|
||||
if q is not None:
|
||||
return not q.get("failed") and 0.0 <= mono - q["t0"] \
|
||||
<= OWN_PAUSE_MAX_S
|
||||
if wr.zero_sent_at is not None:
|
||||
return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S
|
||||
if wr.zero_at is not None and 0.0 <= mono - wr.zero_at \
|
||||
<= OWN_PAUSE_MAX_S:
|
||||
return True
|
||||
return wr.phase_done_at is not None \
|
||||
and 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
|
||||
|
||||
def _car_quarter(self, proj, w, mono, wg=None) -> None:
|
||||
"""The car's energy in the open quarter, for the average the guard's
|
||||
house leaves out and for the peak line."""
|
||||
house leaves out and for the peak line. `wg` (EV-15) is the figure for
|
||||
grading during our own pause; its energy is kept apart (`ws_p`) so the
|
||||
guard's input is unchanged."""
|
||||
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["key"], q["ws"], q["ws_p"], q["ws_b"] = key, 0.0, 0.0, 0.0
|
||||
if key is not None and last is not None:
|
||||
dt = min(max(mono - last, 0.0), 5.0)
|
||||
if w is not None:
|
||||
q["ws"] += float(w) * dt
|
||||
if not self.car_solar_mode():
|
||||
# EV-05: only a charge you set can be "set by the car";
|
||||
# a Solar charge runs on spare sun and is cut first.
|
||||
q["ws_b"] = q.get("ws_b", 0.0) + float(w) * dt
|
||||
elif wg is not None:
|
||||
q["ws_p"] = q.get("ws_p", 0.0) + float(wg) * dt
|
||||
q["mono"] = mono
|
||||
|
||||
def _car_bank(self, q) -> None:
|
||||
@@ -224,7 +483,7 @@ class CarMixin:
|
||||
key = q["key"]
|
||||
if key is None:
|
||||
return
|
||||
avg = q["ws"] / QUARTER_S
|
||||
avg = q.get("ws_b", q["ws"]) / QUARTER_S
|
||||
if avg < CAR_PEAK_MIN_W:
|
||||
return
|
||||
self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg)
|
||||
@@ -233,14 +492,17 @@ class CarMixin:
|
||||
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:
|
||||
def car_avg_w(self, proj, w, graded=False) -> float:
|
||||
"""The car's average over the whole open quarter: what it drew so far
|
||||
and `w` for the rest."""
|
||||
and `w` for the rest. `graded` (EV-15) adds what it drew during our
|
||||
own pause."""
|
||||
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
|
||||
if graded and self._carq["key"] == proj.block_start:
|
||||
so_far += self._carq.get("ws_p", 0.0)
|
||||
return (so_far + float(w) * left) / QUARTER_S
|
||||
|
||||
def car_exclude(self, proj, w):
|
||||
@@ -264,7 +526,7 @@ class CarMixin:
|
||||
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)
|
||||
avg = self.car_avg_w(proj, w, graded=True)
|
||||
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
|
||||
@@ -279,15 +541,41 @@ class CarMixin:
|
||||
"""After the guard has decided: does the car alone explain the excess?
|
||||
`real_proj` is the projection WITH the car, whatever the guard saw."""
|
||||
mono = self.car_now()
|
||||
# EV-05: the period's own key, and the excess Solar takes off the car
|
||||
# first (the writer step that follows this cycle acts on it at once).
|
||||
self._car_key = None if real_proj is None else real_proj.block_start
|
||||
self.car_cut_w = 0.0
|
||||
# What the guard would ASK the batteries to give (`wanted_w`, its floor
|
||||
# before the rating) is taken off the car instead, up to the excess:
|
||||
# batteries that only stop charging are not asked for anything.
|
||||
if self.car_solar_mode() and real_proj is not None \
|
||||
and target_w is not None and real_proj.block_start is not None \
|
||||
and guard is not None and guard.engaged and guard.blind is None:
|
||||
ex = peakguard.excess_w(real_proj, target_w)
|
||||
want = guard.wanted_w
|
||||
if ex is not None and want is not None and math.isfinite(ex) \
|
||||
and math.isfinite(want) and ex > 0.0 and want > 0.0:
|
||||
self.car_cut_w = float(min(ex, want))
|
||||
self._car_sun_tick(mono)
|
||||
w = self.car_alarm_w()
|
||||
self._car_quarter(real_proj, w, mono)
|
||||
# EV-15: the figure for grading only. Our own phase change holds the
|
||||
# car at 0 A and the energy meter cannot corroborate it then, so for
|
||||
# that bounded time its fresh, not stuck figure stands in.
|
||||
wg = w
|
||||
if w is None and self._car_own_pause(mono):
|
||||
wg = self.car.car_w_paused(mono)
|
||||
self._car_quarter(real_proj, w, mono, wg)
|
||||
self._car_session_tick(mono)
|
||||
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:
|
||||
graded = self._car_explains_alarm(real_proj, guard, target_w, wg)
|
||||
if self.car_solar_mode():
|
||||
# EV-05: Solar is cut first, so it is never "over"; its own
|
||||
# 0 A must not leave the house's alarm graded with the car.
|
||||
explains = graded
|
||||
elif self.car_cover:
|
||||
explains = over = graded
|
||||
elif w is not None:
|
||||
ex = float(real_proj.projected_w) - float(target_w)
|
||||
|
||||
@@ -253,6 +253,7 @@ class CycleMixin:
|
||||
|
||||
stale_after = float(self.o.get("stale_input_s", 15))
|
||||
late_s = self._readings_late(site_standing) # SAFETY-128
|
||||
self._car_late_s = late_s # EV-05: Solar holds, then the stale rule
|
||||
self._late_zero = late_s is not None and late_s >= stale_after
|
||||
# ⚠️ `any`, NOT the sole unit's. The hold exists so a single missed
|
||||
# poll does not become a fault; a LATCHED inverter must still reach the
|
||||
@@ -272,6 +273,7 @@ class CycleMixin:
|
||||
# this cycle's. (DECISIONS/MAIN-orchestration-archive.md)
|
||||
self.why_words = messages.why_waiting(bad_for)
|
||||
self._why_waiting_since = now - timedelta(seconds=bad_for)
|
||||
self._car_hold_kick() # EV-05: Solar counts from now
|
||||
return
|
||||
if late_s is not None and late_s < stale_after and self.inputs_ok \
|
||||
and (self.auto or self.shadow) \
|
||||
@@ -279,6 +281,7 @@ class CycleMixin:
|
||||
and not (n_units > 1 and self.site_sign_wd.tripped):
|
||||
self.reason = f"readings late {late_s:.0f}s" # SAFETY-128: hold
|
||||
self.why_words = messages.why_late()
|
||||
self._car_hold_kick() # EV-05: Solar holds its current
|
||||
return
|
||||
|
||||
claims = []
|
||||
@@ -1065,7 +1068,8 @@ class CycleMixin:
|
||||
await self.check_price_gap()
|
||||
await self.check_charger()
|
||||
await self.check_car_over()
|
||||
self.car_kick() # EV-04: Manual, in the background
|
||||
await self.check_car_error() # EV-05: Solar's charger error
|
||||
self.car_kick() # EV-04/05: in the background
|
||||
await self.check_fixed_note()
|
||||
|
||||
# SAFETY-31's alarm, and its boundary is the LATCH, not a number: it
|
||||
|
||||
@@ -205,7 +205,20 @@ class StatusMixin:
|
||||
"text": messages.row_charger_unreach(
|
||||
f"{brussels(self.car.bad_since_utc):%H:%M}")})
|
||||
w = self.car_writer
|
||||
if self.car_mode == "manual":
|
||||
sw = self.car_solar
|
||||
if self.car_mode == "solar":
|
||||
# EV-05: in Solar another writer stops the add-on's writes: amber,
|
||||
# the same words as in Manual.
|
||||
if sw.other:
|
||||
out.append({"ok": False, "warn": True, "id": "charger_other",
|
||||
"text": messages.row_charger_other()})
|
||||
if sw.gave_up:
|
||||
out.append({"ok": False, "warn": True, "id": "charger_refused",
|
||||
"text": messages.row_charger_refused()})
|
||||
if sw.phases_gave_up:
|
||||
out.append({"ok": False, "warn": True, "id": "charger_phases",
|
||||
"text": messages.row_charger_phases()})
|
||||
elif self.car_mode == "manual":
|
||||
# EV-04: in Manual the add-on's own writes are not "another
|
||||
# writer"; its own detector (a read-back that differs from the
|
||||
# last write for 30 s) says so, in grey.
|
||||
@@ -250,6 +263,8 @@ class StatusMixin:
|
||||
or r.power_w is None else round(r.power_w, 1)),
|
||||
"car_today_kwh": (PAYLOAD_NONE if self.car.today_kwh is None
|
||||
else round(self.car.today_kwh, 3)),
|
||||
"car_today_solar_kwh": (PAYLOAD_NONE if self.car_sun_kwh() is None
|
||||
else round(self.car_sun_kwh(), 3)),
|
||||
}
|
||||
|
||||
# -- UI ------------------------------------------------------------------
|
||||
@@ -922,7 +937,7 @@ class StatusMixin:
|
||||
now = datetime.now(timezone.utc)
|
||||
if what in ("pack_use", "pack_mode", "pack_sell"):
|
||||
return self._pack_action(what, unit, value, now)
|
||||
if what in ("car_mode", "car_current", "car_phases"):
|
||||
if what in ("car_mode", "car_current", "car_phases", "car_sun_first"):
|
||||
return self._car_action(what, value, now)
|
||||
if what == "auto_toggle":
|
||||
self.auto = not self.auto
|
||||
|
||||
@@ -1147,7 +1147,8 @@ def month_peak(c, now):
|
||||
# set the month's peak. Both empty without a charger in Manual.
|
||||
out["car_line"] = out["set_by"] = ""
|
||||
if getattr(c, "car_enabled", False) and c.charger.configured():
|
||||
w = c.car_alarm_w()
|
||||
# EV-05: Manual only. A Solar charge is cut first for the peak.
|
||||
w = c.car_alarm_w() if c.car_manual() else None
|
||||
if pg is not None and w is not None and w >= 500.0 \
|
||||
and out["period_w"] is not None and (pg.engaged or c.car_over):
|
||||
out["car_line"] = _t("peak.car", kw=_kw(out["period_w"]),
|
||||
@@ -1330,6 +1331,64 @@ def _car_manual_why(c, key):
|
||||
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
|
||||
|
||||
|
||||
def _names(invs) -> str:
|
||||
names = [str(i.name) for i in invs]
|
||||
return " " .join(names[:1]) if len(names) == 1 else \
|
||||
", ".join(names[:-1]) + " " + _t("car.and") + " " + names[-1]
|
||||
|
||||
|
||||
def _car_solar_why(c, key):
|
||||
"""EV-05: the Why of Solar, from what the plan did this cycle. Plan
|
||||
lines: two sentences of at most 12 words."""
|
||||
w = c.car_solar
|
||||
p = w.plan
|
||||
o = getattr(c, "o", {}) or {}
|
||||
if w.other:
|
||||
return _t("car.why.solar_other")
|
||||
if c.shadow:
|
||||
a, n = w.would if w.would is not None else (0.0, p.n)
|
||||
if a and a >= 6:
|
||||
return _t("car.why.manual_would", a=f"{float(a):.0f}",
|
||||
phases=car_phases_word(n))
|
||||
return _t("car.why.solar_would")
|
||||
if not c.auto or not c.car_writing():
|
||||
return _t("car.why.solar_stopped")
|
||||
if w.fault in ("error", "stuck"):
|
||||
return _t("car.why.solar_" + w.fault)
|
||||
if key in ("none", "full"):
|
||||
return _t("car.why." + key)
|
||||
why = p.why
|
||||
if why == "running":
|
||||
sun = getattr(c, "_car_sun_last", None)
|
||||
if sun is None or sun.spare_w is None:
|
||||
return _t("car.why.solar_unknown")
|
||||
if sun.first == carmode.FIRST_CAR:
|
||||
return _t("car.why.solar_car",
|
||||
kw=_kw(max(0.0, sun.spare_w - sun.margin_w)),
|
||||
phases=car_phases_word(w.n_calc))
|
||||
room = [i for i in c.inverters if c.car_may_charge(i)]
|
||||
full = [i for i in c.inverters if not c.car_may_charge(i)
|
||||
and i.soc is not None and float(i.soc) >= 100.0]
|
||||
left = _kw(max(0.0, sun.spare_w - sun.room_w))
|
||||
m = watts_text(sun.margin_w)
|
||||
if room and full:
|
||||
return _t("car.why.solar_batt", a=_names(room), b=_names(full),
|
||||
kw=left, m=m)
|
||||
if room:
|
||||
return _t("car.why.solar_batt_room", a=_names(room), kw=left,
|
||||
m=m)
|
||||
return _t("car.why.solar_batt_full", kw=left, m=m)
|
||||
mins = {"hold": "ev_pause_min"}.get(why, "ev_start_min")
|
||||
s = f"{carmode.solar_option(o, mins):.0f}"
|
||||
if why in ("hold", "start", "cut", "unknown"):
|
||||
return _t("car.why.solar_" + why, s=s)
|
||||
return _t("car.why.solar_paused", s=s)
|
||||
|
||||
|
||||
def watts_text(w) -> str:
|
||||
return f"{float(w):.0f} W"
|
||||
|
||||
|
||||
def car_block(c, now):
|
||||
"""The Car card for `/status`, or None when no charger is switched on (the
|
||||
page then draws nothing, as before)."""
|
||||
@@ -1342,12 +1401,22 @@ def car_block(c, now):
|
||||
good = c.car.last_good
|
||||
fresh = configured and c.car.fresh(mono)
|
||||
today = None
|
||||
if configured and c.car.today_kwh is not None:
|
||||
today = _t("car.today", kwh=_kwh(c.car.today_kwh))
|
||||
mode = getattr(c, "car_mode", "off") if configured else "off"
|
||||
if configured and c.car.today_kwh is not None:
|
||||
sun = c.car_sun_kwh() if hasattr(c, "car_sun_kwh") else None
|
||||
today = (_t("car.today_sun", kwh=_kwh(c.car.today_kwh),
|
||||
sun=_kwh(sun))
|
||||
if mode == "solar" and sun is not None
|
||||
else _t("car.today", kwh=_kwh(c.car.today_kwh)))
|
||||
why = _car_why(key, c, good)
|
||||
if mode == "manual" and key in ("charging", "waiting", "none", "full"):
|
||||
why = _car_manual_why(c, key)
|
||||
if mode == "solar" and key in ("charging", "waiting", "none", "full",
|
||||
"fault"):
|
||||
why = _car_solar_why(c, key)
|
||||
# EV-05: a car Solar holds at 0 A is waiting for the sun.
|
||||
if key == "waiting" and c.car_solar.plan.a <= 0.0:
|
||||
key = "paused"
|
||||
out = {
|
||||
"state": key or "wait",
|
||||
"chip": car_state_word(key),
|
||||
@@ -1360,11 +1429,13 @@ def car_block(c, now):
|
||||
else round(float(r.power_w), 1)),
|
||||
}
|
||||
if configured:
|
||||
# EV-04: what the page can set. Off and Manual only (Solar and Night
|
||||
# are later cards, so they are not offered).
|
||||
# EV-04: what the page can set. EV-05 adds Solar and where its spare
|
||||
# sun goes first (Night is a later card, so it is not offered).
|
||||
clamp = c.car_clamp()
|
||||
hi = int(clamp) if clamp is not None and clamp >= 6 else 6
|
||||
out["modes"] = ["off", "manual"]
|
||||
out["modes"] = list(carmode.MODES)
|
||||
out["first"] = {"value": getattr(c, "car_first", carmode.DEFAULT_FIRST),
|
||||
"choices": list(carmode.FIRSTS)}
|
||||
out["current"] = {"value": round(float(c.car_a)), "min": 6,
|
||||
"max": hi}
|
||||
out["phases"] = {"value": c.car_n,
|
||||
@@ -1883,8 +1954,12 @@ def _samples() -> list:
|
||||
out += [("plan", _t("car.big." + k, t="09:12")) for k in
|
||||
words["car"]["big"]]
|
||||
out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW",
|
||||
pct="20 %", phases=car_phases_word(3)))
|
||||
pct="20 %", phases=car_phases_word(3),
|
||||
b="inverter-b", m="100 W", s="5"))
|
||||
for k in words["car"]["why"]]
|
||||
out += [("plan", _t("car.why.solar_batt", a="inverter-a",
|
||||
b="inverter-b", kw="2.0 kW", m="100 W")),
|
||||
("plan", _t("car.today_sun", kwh="14.2 kWh", sun="3.1 kWh"))]
|
||||
out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW",
|
||||
cov="8.6 kW")),
|
||||
("plan", _t("peak.set_by_car", t="19:45"))]
|
||||
|
||||
@@ -1040,8 +1040,14 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
|
||||
self.stopping = True
|
||||
_LOG.info(handback.log_shutdown(handback.current())
|
||||
or "shutting down - commanding 0 W on every inverter")
|
||||
await self.command_site_release()
|
||||
await self.car_shutdown() # EV-04: undo a phase change half way
|
||||
if self.car_solar_engaged():
|
||||
# EV-05: Solar's fail state is 0 A, and it goes out BEFORE the
|
||||
# inverters go to 0 W (bounded by `ctl_car.RELEASE_WAIT_S`).
|
||||
await self.car_shutdown()
|
||||
await self.command_site_release()
|
||||
else:
|
||||
await self.command_site_release()
|
||||
await self.car_shutdown() # EV-04: undo a phase change half way
|
||||
self.mqtt.close()
|
||||
|
||||
|
||||
|
||||
@@ -190,6 +190,8 @@ T_CHARGER_UNREACH = "Charger not reachable"
|
||||
T_CHARGER_UNREACH_NL = "Laadpaal onbereikbaar"
|
||||
T_CAR_OVER = "Car over the peak limit"
|
||||
T_CAR_OVER_NL = "Auto boven de piekgrens"
|
||||
T_CHARGER_ERROR = "Charger error, car paused"
|
||||
T_CHARGER_ERROR_NL = "Laadpaalfout, auto gepauzeerd"
|
||||
T_NO_PRICES = "No prices"
|
||||
T_NO_PRICES_NL = "Prijzen ontbreken"
|
||||
|
||||
@@ -204,6 +206,7 @@ ID_MAINT_FAILED = "goodwe_maint_failed_{slug}"
|
||||
ID_NO_PRICES = "goodwe_no_prices"
|
||||
ID_CHARGER_UNREACH = "goodwe_charger_unreachable"
|
||||
ID_CAR_OVER = "goodwe_car_over"
|
||||
ID_CHARGER_ERROR = "goodwe_charger_error"
|
||||
# PRICE-01: an earlier build raised a card with this id. Nothing raises it now;
|
||||
# the add-on only dismisses it at start.
|
||||
OLD_FIXED_CARD_ID = "goodwe_fixed_tariff_unused"
|
||||
@@ -510,6 +513,22 @@ def car_over(a_text) -> Notice:
|
||||
body_nl=f"{T_CAR_OVER_NL}. {nl}")
|
||||
|
||||
|
||||
def charger_error() -> Notice:
|
||||
"""EV-05: in Solar the charger reports an error, so the add-on set the car
|
||||
to 0 A. Said once per error, taken down when it clears."""
|
||||
en = ("The charger reports an error, so the add-on paused the car until "
|
||||
"it clears.")
|
||||
nl = ("De laadpaal meldt een fout, dus de add-on pauzeert de auto tot die "
|
||||
"verdwijnt.")
|
||||
return Notice(ID_CHARGER_ERROR, WARNING, T_CHARGER_ERROR, en,
|
||||
body_nl=f"{T_CHARGER_ERROR_NL}. {nl}")
|
||||
|
||||
|
||||
def charger_error_gone() -> Dismiss:
|
||||
"""EV-05: takes the 'Charger error, car paused' notification down."""
|
||||
return Dismiss(ID_CHARGER_ERROR)
|
||||
|
||||
|
||||
def row_car_over() -> str:
|
||||
"""EV-04: the grey row while the car charge you set is over the peak limit."""
|
||||
return Bi("The car charge you set takes this 15-minute period over the "
|
||||
@@ -1484,6 +1503,7 @@ HINTS = {
|
||||
"car_mode": "Car mode set",
|
||||
"car_current": "Car current set",
|
||||
"car_phases": "Car phases set",
|
||||
"car_sun_first": "Where spare sun goes first set",
|
||||
"settings_saved": "Settings saved, they apply after a restart",
|
||||
"restart_requested": "Restart requested from the settings page",
|
||||
"setup_only": "In setup, nothing is sent to any inverter",
|
||||
@@ -1822,6 +1842,7 @@ def samples() -> list:
|
||||
no_prices(),
|
||||
charger_unreachable("09:12"),
|
||||
car_over("16"),
|
||||
charger_error(),
|
||||
]
|
||||
|
||||
|
||||
@@ -1891,6 +1912,9 @@ LABELS = {
|
||||
"ev_batt_cover": "Batteries help with the peak",
|
||||
"ev_mode_start": "Mode after a restart",
|
||||
"ev_phases": "Phases",
|
||||
"ev_margin_w": "Sun kept back",
|
||||
"ev_pause_min": "Pause after",
|
||||
"ev_start_min": "Start after",
|
||||
}
|
||||
|
||||
|
||||
@@ -1977,6 +2001,9 @@ LABELS_NL = {
|
||||
"ev_batt_cover": "Batterijen helpen met de piek",
|
||||
"ev_mode_start": "Modus na een herstart",
|
||||
"ev_phases": "Fasen",
|
||||
"ev_margin_w": "Zon achtergehouden",
|
||||
"ev_pause_min": "Pauzeren na",
|
||||
"ev_start_min": "Starten na",
|
||||
}
|
||||
# The inverter list shows two of them under a shorter name.
|
||||
UNIT_LABELS_NL = {"setpoint_entity": "Setpoint-entiteit",
|
||||
|
||||
@@ -144,6 +144,8 @@ OPTIONAL_SENSORS = [
|
||||
("car_power", "goodwe_car_power", "Car power", "W", "power", "measurement", "mdi:car-electric"),
|
||||
("car_state", "goodwe_car_state", "Car state", None, None, None, "mdi:ev-station"),
|
||||
("car_today_kwh", "goodwe_car_today_kwh", "Car energy today", "kWh", "energy", "total_increasing", "mdi:ev-station"),
|
||||
# EV-05: what of today's charge came from the sun (Solar mode only).
|
||||
("car_today_solar_kwh", "goodwe_car_today_solar_kwh", "Car solar energy today", "kWh", "energy", "total_increasing", "mdi:solar-power"),
|
||||
]
|
||||
|
||||
# ⚠️ HA's OWN "this sensor has no value" PAYLOAD, and the one place this add-on
|
||||
@@ -200,7 +202,8 @@ def optional_keys(opts: dict) -> tuple:
|
||||
from . import chargers as _ch # EV-03: same reason
|
||||
out = ("pv",) if _pv.entities(opts) else ()
|
||||
if _ch.census_entity(opts):
|
||||
out += ("car_power", "car_state", "car_today_kwh")
|
||||
out += ("car_power", "car_state", "car_today_kwh",
|
||||
"car_today_solar_kwh")
|
||||
return out
|
||||
|
||||
|
||||
@@ -524,18 +527,24 @@ def mode_payloads(units, modes) -> list:
|
||||
# --- EV-04: the car's mode, current and phases, as HA entities ----------------
|
||||
# Announced only with a charger switched on, after every other row. A command
|
||||
# goes through Controller.handle_action(); a retained one is dropped.
|
||||
CAR_MODE_LABELS = {"off": "Off", "manual": "Manual"} # English, pinned
|
||||
CAR_MODE_LABELS = {"off": "Off", "manual": "Manual", # English, pinned
|
||||
"solar": "Solar"} # EV-05
|
||||
# EV-05: where spare sun goes first; mirrors carmode.FIRST_LABELS (this module
|
||||
# imports nothing from the package, test_ev05.py checks the two agree).
|
||||
CAR_FIRST_LABELS = {"batteries": "Batteries", "car": "Car"}
|
||||
CAR_MODES = tuple(CAR_MODE_LABELS)
|
||||
CAR_CONFIGS_KEY = "mqtt_car_configs"
|
||||
CAR_MIN_A = 6
|
||||
_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases)/set")
|
||||
_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases|sun_first)/set")
|
||||
_CAR_CONFIG_RE = re.compile(
|
||||
rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases)/config")
|
||||
rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases|sun_first)"
|
||||
rf"/config")
|
||||
# (key, component, name, icon)
|
||||
CAR_ENTITIES = [
|
||||
("mode", "select", "Car mode", "mdi:car-electric"),
|
||||
("current", "number", "Car current", "mdi:current-ac"),
|
||||
("phases", "select", "Car phases", "mdi:sine-wave"),
|
||||
("sun_first", "select", "Car spare sun first", "mdi:solar-power"), # EV-05
|
||||
]
|
||||
|
||||
|
||||
@@ -560,6 +569,8 @@ def car_payloads(car) -> list:
|
||||
cfg["options"] = list(CAR_MODE_LABELS.values())
|
||||
elif key == "phases":
|
||||
cfg["options"] = [str(n) for n in phases]
|
||||
elif key == "sun_first":
|
||||
cfg["options"] = list(CAR_FIRST_LABELS.values())
|
||||
else:
|
||||
cfg.update({"min": CAR_MIN_A, "max": int(max_a), "step": 1,
|
||||
"unit_of_measurement": "A", "device_class": "current",
|
||||
@@ -607,6 +618,9 @@ def parse_car_command(topic, payload, retained):
|
||||
None)
|
||||
elif key == "phases":
|
||||
value = {"1": 1, "3": 3}.get(text)
|
||||
elif key == "sun_first":
|
||||
value = next((k for k, v in CAR_FIRST_LABELS.items() if v == text),
|
||||
None)
|
||||
else:
|
||||
try:
|
||||
f = float(text)
|
||||
|
||||
@@ -160,8 +160,9 @@
|
||||
$("#car-why").textContent = c.why;
|
||||
renderCarControls(c);
|
||||
}
|
||||
// EV-04: Off and Manual. The mode and the phases send at once; the current
|
||||
// sends after two seconds of rest. A slider being dragged is left alone.
|
||||
// EV-04: Off and Manual; EV-05: Solar and where its spare sun goes first.
|
||||
// The mode, the phases and the choice send at once; the current sends after
|
||||
// two seconds of rest. A slider being dragged is left alone.
|
||||
let carTouch = 0, carTimer = null, carBusy = false;
|
||||
async function carAct(what, value) {
|
||||
if (carBusy) return;
|
||||
@@ -182,6 +183,13 @@
|
||||
type: "button", role: "radio", "aria-checked": String(c.mode === m),
|
||||
onclick: () => carAct("car_mode", m) }, t("car.mode_" + m))));
|
||||
$("#car-help").textContent = t("car.help_" + c.mode + ".description") || "";
|
||||
const sol = c.mode === "solar" && !!c.first;
|
||||
$("#car-solar").hidden = !sol;
|
||||
if (sol) {
|
||||
$("#car-first").replaceChildren(...c.first.choices.map((f) => h("button", {
|
||||
type: "button", role: "radio", "aria-checked": String(c.first.value === f),
|
||||
onclick: () => carAct("car_sun_first", f) }, t("car.first_" + f))));
|
||||
}
|
||||
const on = c.mode === "manual" && !!c.current;
|
||||
$("#car-manual").hidden = !on;
|
||||
if (!on) return;
|
||||
|
||||
@@ -52,6 +52,11 @@
|
||||
<div class="small car-lab" data-t="car.phases"></div>
|
||||
<div class="seg" role="radiogroup" id="car-phases" data-t-label="car.phases"></div>
|
||||
</div>
|
||||
<div id="car-solar" hidden>
|
||||
<div class="small car-lab" data-t="car.first"></div>
|
||||
<div class="seg" role="radiogroup" id="car-first" data-t-label="car.first"></div>
|
||||
<p class="tiny muted" style="margin:6px 0 0" data-t="car.first_help.description"></p>
|
||||
</div>
|
||||
<div class="car-why small"><span class="muted" data-t="car.why"></span><span id="car-why"></span></div>
|
||||
</div>
|
||||
|
||||
|
||||
@@ -91,7 +91,7 @@
|
||||
"loading": "Loading the forecast."
|
||||
},
|
||||
"peak": {"name": "Peak limit", "this_month": "This month's peak", "limit": "Limit", "none": "None recorded yet", "unreadable": "Cannot be read now"},
|
||||
"car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "mode_manual": "Manual", "help_off": {"description": "The add-on leaves the charger alone."}, "help_manual": {"description": "Charges at the current you set, whatever the sun or the peak limit do."}, "current": "Current", "phases": "Phases", "phases_1": "1 phase", "phases_3": "3 phases", "why": "Why"},
|
||||
"car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "mode_manual": "Manual", "help_off": {"description": "The add-on leaves the charger alone."}, "help_manual": {"description": "Charges at the current you set, whatever the sun or the peak limit do."}, "current": "Current", "phases": "Phases", "phases_1": "1 phase", "phases_3": "3 phases", "why": "Why", "mode_solar": "Solar", "help_solar": {"description": "Charges only from spare sun and pauses when there is too little."}, "first": "Spare sun goes first to", "first_batteries": "Batteries", "first_car": "Car", "first_help": {"description": "Batteries: the car gets sun only when the batteries charge at full power or are full."}},
|
||||
"attention": {"name": "Needs attention", "nothing": "Nothing to look at", "to_look": "to look at", "details": "Details", "alarm": "Alarm", "warning": "Warning", "info": "Info"},
|
||||
"control": {"name": "Control", "stop": "Stop control", "start": "Start control", "maint_start": "Start a battery cycle now", "maint_abort": "Stop the battery cycle", "docs": "Add-on documentation", "more": "More actions"},
|
||||
"details": {"name": "Details for installers", "rows": "Status rows", "checks": "Checks", "event": "Last event"},
|
||||
@@ -302,11 +302,11 @@
|
||||
"warning": "See Needs attention below."
|
||||
},
|
||||
"car": {
|
||||
"state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "fault": "Charger fault", "wait": "No reading yet"},
|
||||
"big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "fault": "The charger reports a fault.", "wait": "No reading yet."},
|
||||
"state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "fault": "Charger fault", "wait": "No reading yet", "paused": "Waiting for sun"},
|
||||
"big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "fault": "The charger reports a fault.", "wait": "No reading yet.", "paused": "Waiting for spare sun."},
|
||||
"phase_one": "1 phase",
|
||||
"phase_many": "{n} phases",
|
||||
"today": "{kwh} charged today.",
|
||||
"today": "{kwh} charged today.", "today_sun": "{kwh} charged today, {sun} from the sun.", "and": "and",
|
||||
"why": {
|
||||
"charging": "The charger is charging the car. The add-on leaves it alone.",
|
||||
"waiting": "The car is connected and not charging. The add-on leaves the charger alone.",
|
||||
@@ -329,7 +329,21 @@
|
||||
"manual_wait": "You set {a} A. It is set when a car is connected.",
|
||||
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
|
||||
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
|
||||
"manual_blocked": "The phases change once per 10 minutes at most. This waits."
|
||||
"manual_blocked": "The phases change once per 10 minutes at most. This waits.",
|
||||
"solar_batt": "Batteries first: {a} at full power, {b} is full. The car gets the {kw} left, less {m} kept back.",
|
||||
"solar_batt_room": "Batteries first: {a} at full power. The car gets the {kw} left, less {m} kept back.",
|
||||
"solar_batt_full": "Batteries first, and the batteries are full. The car gets the {kw} left, less {m} kept back.",
|
||||
"solar_car": "Car first: the car takes {kw} on {phases}. The batteries get the rest of the sun.",
|
||||
"solar_hold": "Too little spare sun, so the car holds 6 A for now. It pauses after {s} minutes like this.",
|
||||
"solar_paused": "Too little spare sun for the car's minimum of 6 A. It starts after {s} minutes of enough sun.",
|
||||
"solar_start": "There is enough spare sun now. The car starts after {s} minutes of it.",
|
||||
"solar_cut": "The car was cut first to stay under the peak limit. It starts again after {s} minutes of enough sun.",
|
||||
"solar_unknown": "The add-on cannot measure the spare sun now. The car pauses if this lasts.",
|
||||
"solar_would": "Shadow mode: the add-on would keep the car paused.",
|
||||
"solar_stopped": "Control is stopped, so the add-on paused the car.",
|
||||
"solar_error": "The charger reports an error, so the add-on paused the car.",
|
||||
"solar_stuck": "The charger reading may be stuck, so the add-on paused the car.",
|
||||
"solar_other": "Something else changes the charger, so the add-on leaves it alone."
|
||||
}
|
||||
},
|
||||
"peak": {
|
||||
|
||||
@@ -88,7 +88,7 @@
|
||||
"loading": "De prognose wordt geladen."
|
||||
},
|
||||
"peak": {"name": "Piekgrens", "this_month": "Piek van deze maand", "limit": "Grens", "none": "Nog niets gemeten", "unreadable": "Nu niet leesbaar"},
|
||||
"car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "mode_manual": "Handmatig", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "help_manual": {"description": "Laadt met de stroom die u instelt, wat de zon of de piekgrens ook doen."}, "current": "Stroom", "phases": "Fasen", "phases_1": "1 fase", "phases_3": "3 fasen", "why": "Waarom"},
|
||||
"car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "mode_manual": "Handmatig", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "help_manual": {"description": "Laadt met de stroom die u instelt, wat de zon of de piekgrens ook doen."}, "current": "Stroom", "phases": "Fasen", "phases_1": "1 fase", "phases_3": "3 fasen", "why": "Waarom", "mode_solar": "Zon", "help_solar": {"description": "Laadt alleen met zonne-overschot en pauzeert als er te weinig is."}, "first": "Zonne-overschot gaat eerst naar", "first_batteries": "Batterijen", "first_car": "Auto", "first_help": {"description": "Batterijen: de auto krijgt pas zon als de batterijen op vol vermogen laden of vol zijn."}},
|
||||
"attention": {"name": "Vraagt aandacht", "nothing": "Niets om na te kijken", "to_look": "na te kijken", "details": "Details", "alarm": "Alarm", "warning": "Waarschuwing", "info": "Info"},
|
||||
"control": {"name": "Regeling", "stop": "Regeling stoppen", "start": "Regeling starten", "maint_start": "Nu een batterijcyclus starten", "maint_abort": "Batterijcyclus stoppen", "docs": "Documentatie van de add-on", "more": "Meer acties"},
|
||||
"details": {"name": "Details voor installateurs", "rows": "Statusregels", "checks": "Controles", "event": "Laatste gebeurtenis"},
|
||||
@@ -256,11 +256,11 @@
|
||||
"pill": {"running": "Actief", "shadow": "Schaduwmodus", "stopped": "Gestopt", "alarm": "Heeft u nu nodig", "waiting": "Wacht op Home Assistant", "warning": "Actief, met een waarschuwing"},
|
||||
"banner_sub": {"running": "De batterijen volgen het plan hieronder.", "shadow": "De plannen hieronder tonen wat de add-on zou doen.", "stopped": "Start de regeling hieronder als u klaar bent.", "alarm": "Zie Vraagt aandacht hieronder voor wat u moet doen.", "waiting": "De regeling gaat vanzelf verder zodra Home Assistant antwoordt.", "warning": "Zie Vraagt aandacht hieronder."},
|
||||
"car": {
|
||||
"state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "fault": "Laadpaalstoring", "wait": "Nog geen meting"},
|
||||
"big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "fault": "De laadpaal meldt een storing.", "wait": "Nog geen meting."},
|
||||
"state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "fault": "Laadpaalstoring", "wait": "Nog geen meting", "paused": "Wacht op zon"},
|
||||
"big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "fault": "De laadpaal meldt een storing.", "wait": "Nog geen meting.", "paused": "Wacht op zonne-overschot."},
|
||||
"phase_one": "1 fase",
|
||||
"phase_many": "{n} fasen",
|
||||
"today": "Vandaag {kwh} geladen.",
|
||||
"today": "Vandaag {kwh} geladen.", "today_sun": "Vandaag {kwh} geladen, {sun} van de zon.", "and": "en",
|
||||
"why": {
|
||||
"charging": "De laadpaal laadt de auto. De add-on laat haar met rust.",
|
||||
"waiting": "De auto is aangesloten en laadt niet. De add-on laat de laadpaal met rust.",
|
||||
@@ -283,7 +283,21 @@
|
||||
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
|
||||
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
|
||||
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
|
||||
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht."
|
||||
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.",
|
||||
"solar_batt": "Eerst de batterijen: {a} op vol vermogen, {b} is vol. De auto krijgt de {kw} die overblijft, min {m} marge.",
|
||||
"solar_batt_room": "Eerst de batterijen: {a} op vol vermogen. De auto krijgt de {kw} die overblijft, min {m} marge.",
|
||||
"solar_batt_full": "Eerst de batterijen, en die zijn vol. De auto krijgt de {kw} die overblijft, min {m} marge.",
|
||||
"solar_car": "Eerst de auto: die neemt {kw} op {phases}. De batterijen krijgen de rest van de zon.",
|
||||
"solar_hold": "Te weinig zonne-overschot, dus de auto houdt nu 6 A. Na {s} minuten zo pauzeert ze.",
|
||||
"solar_paused": "Te weinig zonne-overschot voor het minimum van de auto, 6 A. Ze start na {s} minuten genoeg zon.",
|
||||
"solar_start": "Er is nu genoeg zonne-overschot. De auto start na {s} minuten daarvan.",
|
||||
"solar_cut": "De auto werd eerst teruggeschroefd voor de piekgrens. Ze start weer na {s} minuten genoeg zon.",
|
||||
"solar_unknown": "De add-on kan het zonne-overschot nu niet meten. De auto pauzeert als dit duurt.",
|
||||
"solar_would": "Schaduwmodus: de add-on zou de auto gepauzeerd houden.",
|
||||
"solar_stopped": "De regeling is gestopt, dus de add-on pauzeert de auto.",
|
||||
"solar_error": "De laadpaal meldt een fout, dus de add-on pauzeert de auto.",
|
||||
"solar_stuck": "De laadpaal meet mogelijk niet meer, dus de add-on pauzeert de auto.",
|
||||
"solar_other": "Iets anders wijzigt de laadpaal, dus de add-on laat haar met rust."
|
||||
}
|
||||
},
|
||||
"peak": {
|
||||
|
||||
@@ -234,6 +234,9 @@ GROUPS = (
|
||||
Field("ev_phases", SEGMENTED, simple=True, show=_CAR),
|
||||
Field("ev_batt_cover", TOGGLE, simple=True, show=_CAR),
|
||||
Field("ev_mode_start", SEGMENTED, simple=True, show=_CAR),
|
||||
Field("ev_margin_w", SLIDER, "W", step=10, show=_CAR),
|
||||
Field("ev_start_min", SLIDER, "min", show=_CAR),
|
||||
Field("ev_pause_min", SLIDER, "min", show=_CAR),
|
||||
)),
|
||||
)),
|
||||
Group("maintenance", (
|
||||
|
||||
@@ -688,6 +688,17 @@ def _charger_problems(opts: dict, writers: dict) -> list[str]:
|
||||
out.append(f"{S('ev_max_a')} is {messages.shown(opts.get('ev_max_a'))}"
|
||||
f". Set it from {chargers.MIN_A:.0f} to "
|
||||
f"{chargers.ENTITY_MAX_A:.0f} A.")
|
||||
# EV-05: Solar's sun kept back and its two dwells, each in its range.
|
||||
for key, (lo, hi) in chargers.SOLAR_RANGES.items():
|
||||
raw = opts.get(key, chargers.EV_OPTION_DEFAULTS[key])
|
||||
try:
|
||||
v = float(raw)
|
||||
ok = not isinstance(raw, bool) and v == v and lo <= v <= hi
|
||||
except (TypeError, ValueError):
|
||||
ok = False
|
||||
if not ok:
|
||||
out.append(f"{S(key)} is {messages.shown(raw)}. Set it from {lo} "
|
||||
f"to {hi}.")
|
||||
entity = chargers.census_entity(opts)
|
||||
if entity and drivers.census_key(entity) in writers:
|
||||
out.append(f"{S('ev_current_entity')} is {entity}, which an inverter "
|
||||
|
||||
@@ -62,7 +62,7 @@ _LOG = logging.getLogger("goodwe.web")
|
||||
|
||||
# OPT-11: the per-battery actions, which name a battery and a value.
|
||||
PACK_ACTIONS = ("pack_use", "pack_mode", "pack_sell")
|
||||
CAR_ACTIONS = ("car_mode", "car_current", "car_phases")
|
||||
CAR_ACTIONS = ("car_mode", "car_current", "car_phases", "car_sun_first")
|
||||
# MAINT-11: start or stop one battery's maintenance cycle (the unit is optional).
|
||||
MAINT_ACTIONS = ("maint_start", "maint_abort")
|
||||
|
||||
|
||||
@@ -873,20 +873,25 @@ options:
|
||||
shadow_mode: "auto"
|
||||
|
||||
# ==========================================================================
|
||||
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
|
||||
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar)
|
||||
# ==========================================================================
|
||||
# `off` is the shipped value and means NO CHANGE AT ALL: nothing is read,
|
||||
# shown or announced, and the House tile and the house profile are as before.
|
||||
# `alfen_ha` drives the charger through its Home Assistant integration. The
|
||||
# mode (Off or Manual), the current and the phases are runtime state in the
|
||||
# store, not options. `ev_batt_cover`: the batteries help with the peak while
|
||||
# the car charges. `ev_mode_start`: the mode after a restart.
|
||||
# mode (Off, Manual or Solar), the current, the phases and where spare sun
|
||||
# goes first are runtime state in the store, not options. `ev_batt_cover`:
|
||||
# the batteries help with the peak while the car charges. `ev_mode_start`:
|
||||
# the mode after a restart. Solar: `ev_margin_w` sun kept back, and the car
|
||||
# starts after `ev_start_min` of enough sun and pauses after `ev_pause_min`.
|
||||
ev_charger: "off"
|
||||
ev_current_entity: ""
|
||||
ev_max_a: 16
|
||||
ev_phases: "auto"
|
||||
ev_batt_cover: true
|
||||
ev_mode_start: "keep"
|
||||
ev_margin_w: 100
|
||||
ev_start_min: 2
|
||||
ev_pause_min: 5
|
||||
|
||||
# ==========================================================================
|
||||
# ADVANCED - the control law and diagnostics
|
||||
@@ -1266,7 +1271,7 @@ schema:
|
||||
shadow_mode: list(auto|on|off)
|
||||
|
||||
# ==========================================================================
|
||||
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
|
||||
# CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar)
|
||||
# ==========================================================================
|
||||
# `ev_current_entity` is the charger's current setpoint; the other entities
|
||||
# are found from its name. `ev_max_a` may not exceed the charger's own station
|
||||
@@ -1277,6 +1282,9 @@ schema:
|
||||
ev_phases: list(1|3|auto)
|
||||
ev_batt_cover: bool
|
||||
ev_mode_start: list(keep|off)
|
||||
ev_margin_w: int(0,1000)
|
||||
ev_start_min: int(1,30)
|
||||
ev_pause_min: int(1,30)
|
||||
|
||||
# ==========================================================================
|
||||
# ADVANCED - the control law and diagnostics
|
||||
|
||||
@@ -905,16 +905,18 @@ check("it stays for an hour and then goes",
|
||||
# --------------------------------------------------------------------------- #
|
||||
print("\n9. THE MQTT SENSORS")
|
||||
# --------------------------------------------------------------------------- #
|
||||
check("the three car sensors are announced only with a charger on",
|
||||
check("the car sensors (EV-05: four, with today's solar kWh) are announced "
|
||||
"only with a charger on",
|
||||
mqtt.optional_keys(CAR) == ("pv", "car_power", "car_state",
|
||||
"car_today_kwh")
|
||||
"car_today_kwh", "car_today_solar_kwh")
|
||||
and mqtt.optional_keys(BASE) == ("pv",))
|
||||
pl = dict(mqtt.discovery_payloads(include=mqtt.optional_keys(CAR)))
|
||||
names = sorted(k for k in pl if "_car_" in k)
|
||||
check(f"discovery announces three sensors, goodwe_car_power, "
|
||||
f"goodwe_car_state and goodwe_car_today_kwh ({names})",
|
||||
check(f"discovery announces the sensors goodwe_car_power, goodwe_car_state, "
|
||||
f"goodwe_car_today_kwh and (EV-05) goodwe_car_today_solar_kwh ({names})",
|
||||
[pl[k]["object_id"] for k in names] == [
|
||||
"goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh"]
|
||||
"goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh",
|
||||
"goodwe_car_today_solar_kwh"]
|
||||
and all(k.startswith("homeassistant/sensor/") for k in names))
|
||||
check("...and no command entity (no select, number or switch for the car)",
|
||||
not [k for k in pl if "car" in k and not k.startswith(
|
||||
|
||||
@@ -248,7 +248,7 @@ async def part2():
|
||||
w = World()
|
||||
out = {}
|
||||
out["manual"] = await w.act("car_mode", "manual")
|
||||
out["bad_mode"] = await w.act("car_mode", "solar") # not in this card
|
||||
out["bad_mode"] = await w.act("car_mode", "bogus") # EV-05 accepts Solar
|
||||
out["night"] = await w.act("car_mode", "night")
|
||||
out["a12"] = await w.act("car_current", 12)
|
||||
out["a5"] = await w.act("car_current", 5)
|
||||
@@ -266,7 +266,7 @@ w2, o2 = run(part2())
|
||||
check("Manual is chosen at once, no restart", o2["manual"] == {
|
||||
"mode": "manual", "current": 6.0, "phases": 1} and w2.c.car_mode == "manual"
|
||||
or w2.c.car_mode == "manual")
|
||||
check("Solar and Night are not accepted (EV-05, EV-02)",
|
||||
check("Night (EV-02) and an unknown mode are not accepted",
|
||||
"error" in o2["bad_mode"] and "error" in o2["night"]
|
||||
and w2.c.car_mode == "manual")
|
||||
check("a current between 6 A and the clamp is accepted and stored",
|
||||
@@ -307,7 +307,7 @@ check("ev_phases 1: 3 phases cannot be chosen, 1 can",
|
||||
async def part2c():
|
||||
out = {}
|
||||
for start, stored in (("keep", "manual"), ("off", "manual"),
|
||||
("keep", None), ("keep", "solar")):
|
||||
("keep", None), ("keep", "night")):
|
||||
st = _Store()
|
||||
if stored:
|
||||
st.data["car_mode"] = stored
|
||||
@@ -322,7 +322,7 @@ check("ev_mode_start keep: a restart keeps Manual",
|
||||
check("ev_mode_start off: a restart starts in Off and the store says so",
|
||||
o2c[("off", "manual")] == ("off", "off"))
|
||||
check("no stored mode, or one this build does not know, is Off",
|
||||
o2c[("keep", None)][0] == "off" and o2c[("keep", "solar")][0] == "off")
|
||||
o2c[("keep", None)][0] == "off" and o2c[("keep", "night")][0] == "off")
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n3. MANUAL WRITES THE CURRENT ONCE PER USER CHANGE")
|
||||
@@ -1606,13 +1606,14 @@ pl = dict(mqtt.car_payloads((16, (1, 3))))
|
||||
sel = pl["homeassistant/select/goodwe_ctl_car_mode/config"]
|
||||
num = pl["homeassistant/number/goodwe_ctl_car_current/config"]
|
||||
ph = pl["homeassistant/select/goodwe_ctl_car_phases/config"]
|
||||
check("three entities: select.goodwe_car_mode, number.goodwe_car_current, "
|
||||
"select.goodwe_car_phases", len(pl) == 3
|
||||
check("four entities: select.goodwe_car_mode, number.goodwe_car_current, "
|
||||
"select.goodwe_car_phases and (EV-05) select.goodwe_car_sun_first",
|
||||
len(pl) == 4
|
||||
and sel["object_id"] == "goodwe_car_mode"
|
||||
and num["object_id"] == "goodwe_car_current"
|
||||
and ph["object_id"] == "goodwe_car_phases")
|
||||
check("the mode's labels are English and pinned: Off, Manual (Solar and Night "
|
||||
"are not offered)", sel["options"] == ["Off", "Manual"])
|
||||
check("the mode's labels are English and pinned: Off, Manual, Solar (EV-05; "
|
||||
"Night is not offered)", sel["options"] == ["Off", "Manual", "Solar"])
|
||||
check("the current is 6 A to the clamp, whole amps", num["min"] == 6
|
||||
and num["max"] == 16 and num["step"] == 1
|
||||
and num["unit_of_measurement"] == "A")
|
||||
@@ -1629,7 +1630,7 @@ check("nothing is announced without a charger (and the default announcement "
|
||||
"is as it was)", mqtt.car_payloads(None) == []
|
||||
and mqtt.discovery_payloads() == mqtt.discovery_payloads(car=None))
|
||||
check("the car entities come after every other row",
|
||||
[t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-3:]
|
||||
[t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-4:]
|
||||
== [t for t, _ in mqtt.car_payloads((16, (1, 3)))])
|
||||
cmd = mqtt.parse_car_command
|
||||
check("a command parses: mode, current, phases",
|
||||
@@ -1641,8 +1642,8 @@ check("a command parses: mode, current, phases",
|
||||
== ("car_phases", 3, None))
|
||||
check("a retained command is dropped",
|
||||
cmd("goodwe_ctl/car/mode/set", b"Manual", True)[2] == "retained")
|
||||
check("Solar, Night, junk and a long payload are refused",
|
||||
cmd("goodwe_ctl/car/mode/set", b"Solar", False)[1] is None
|
||||
check("Night, an unknown mode, junk and a long payload are refused",
|
||||
cmd("goodwe_ctl/car/mode/set", b"Bogus", False)[1] is None
|
||||
and cmd("goodwe_ctl/car/mode/set", b"Night", False)[1] is None
|
||||
and cmd("goodwe_ctl/car/current/set", b"abc", False)[1] is None
|
||||
and cmd("goodwe_ctl/car/phases/set", b"2", False)[1] is None
|
||||
@@ -1660,7 +1661,7 @@ async def ha_story():
|
||||
out = {"mode": w.c.car_mode, "a": w.c.car_a, "rb": w.sim.readback_a,
|
||||
"pub": list(w.c.mqtt.values)[-1]}
|
||||
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Off", True) # retained
|
||||
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Solar", False)
|
||||
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Night", False)
|
||||
await w.c.mqtt_command("goodwe_ctl/car/current/set", b"99", False)
|
||||
await w.c.mqtt_command("goodwe_ctl/car/phases/set", b"2", False)
|
||||
await w.step(5)
|
||||
@@ -1678,8 +1679,8 @@ check("HA commands go through handle_action(): Manual and 13 A are applied "
|
||||
"and written, and the new state is published",
|
||||
ha["mode"] == "manual" and ha["a"] == 13.0 and ha["rb"] == 13
|
||||
and ha["pub"] == {"car_mode": "Manual", "car_current": 13,
|
||||
"car_phases": "1"})
|
||||
check("a retained command, Solar, 99 A and 2 phases change nothing",
|
||||
"car_phases": "1", "car_sun_first": "Batteries"})
|
||||
check("a retained command, Night, 99 A and 2 phases change nothing",
|
||||
ha["after"] == ("manual", 13.0, 1))
|
||||
check("the three states are in the published values",
|
||||
ha["state"].get("car_mode") == "Manual"
|
||||
@@ -1700,11 +1701,11 @@ st_ = _S()
|
||||
car_, retract_ = _main.car_announcement(CAR, st_)
|
||||
check("with a charger the entities are announced and their topics kept",
|
||||
car_ == (16.0, (1, 3)) and not retract_ and len(
|
||||
st_.data["mqtt_car_configs"]) == 3)
|
||||
st_.data["mqtt_car_configs"]) == 4)
|
||||
car2, retract2 = _main.car_announcement(BASE, st_)
|
||||
check("turning the charger off removes exactly those entities",
|
||||
car2 is None and sorted(retract2) == sorted(st_.data["mqtt_car_configs"])
|
||||
and len(retract2) == 3)
|
||||
and len(retract2) == 4)
|
||||
st2 = _S()
|
||||
check("a site that never had a charger publishes nothing and its store is "
|
||||
"not written",
|
||||
@@ -1734,7 +1735,7 @@ async def web_story():
|
||||
("manual", {"action": "car_mode", "value": "manual"}),
|
||||
("a", {"action": "car_current", "value": 12}),
|
||||
("n", {"action": "car_phases", "value": 3}),
|
||||
("solar", {"action": "car_mode", "value": "solar"}),
|
||||
("solar", {"action": "car_mode", "value": "night"}),
|
||||
("big", {"action": "car_current", "value": 40})):
|
||||
async with s.post(root + "action", json=body) as r:
|
||||
out[key] = (r.status, await r.json(content_type=None))
|
||||
@@ -1753,21 +1754,22 @@ check("POST /action car_mode, car_current and car_phases store and answer",
|
||||
web["manual"] == (200, {"ok": True, "result": {
|
||||
"mode": "manual", "current": 6.0, "phases": 1}})
|
||||
and web["a"][0] == 200 and web["n"][0] == 200)
|
||||
check("...Solar and 40 A (above the clamp) are a 400 with a plain reason",
|
||||
check("...Night and 40 A (above the clamp) are a 400 with a plain reason",
|
||||
web["solar"][0] == 400 and web["solar"][1]["ok"] is False
|
||||
and web["solar"][1]["error"] == messages.car_refused("value")
|
||||
and web["big"][0] == 400)
|
||||
car_s = web["status_en"]["car"]
|
||||
check("/status gives the page what it needs: the mode, the modes offered (Off "
|
||||
"and Manual only), the current's range, the phases",
|
||||
car_s["mode"] == "manual" and car_s["modes"] == ["off", "manual"]
|
||||
check("/status gives the page what it needs: the mode, the modes offered (Off, "
|
||||
"Manual and, EV-05, Solar), the current's range, the phases",
|
||||
car_s["mode"] == "manual"
|
||||
and car_s["modes"] == ["off", "manual", "solar"]
|
||||
and car_s["current"] == {"value": 12, "min": 6, "max": 16}
|
||||
and car_s["phases"] == {"value": 3, "choices": [1, 3]})
|
||||
check("/status in Dutch has the Dutch Why",
|
||||
web["status_nl"]["car"]["why"].startswith("U stelde 12 A in"))
|
||||
check("the page has the controls and no Solar or Night button",
|
||||
check("the page has the controls and no Night button (EV-05 adds Solar)",
|
||||
'id="car-manual"' in web["page"] and 'id="car-a"' in web["page"]
|
||||
and "mode_solar" not in web["page"] and "mode_night" not in web["page"])
|
||||
and "mode_night" not in web["page"])
|
||||
check("the page names the Manual strings in both languages",
|
||||
"Handmatig" in web["page"] and "Manual" in web["page"])
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,421 @@
|
||||
"""EV-05: the car's Solar mode, the long runs. `python3 -B test_ev05_long.py`
|
||||
|
||||
Split from test_ev05.py so CI's parallel batch stays short: the shadow-mode
|
||||
twin (T39), the acceptance day (T44), the fuzz (T45), and the hour-long
|
||||
"nothing else changes" comparisons (T50, T51). Same harness,
|
||||
`tools/ev05_sun.py`; the rows are named by their test-plan id.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import logging
|
||||
import math
|
||||
import os
|
||||
import random
|
||||
import sys
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
import ev05_sun as S # noqa: E402
|
||||
from chargersim import SimCharger # noqa: E402
|
||||
|
||||
logging.disable(logging.CRITICAL)
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
def const(w):
|
||||
return lambda t: float(w)
|
||||
|
||||
|
||||
def steps(*pairs):
|
||||
def f(t):
|
||||
v = pairs[0][1]
|
||||
for at, w in pairs:
|
||||
if t >= at:
|
||||
v = w
|
||||
return float(v)
|
||||
return f
|
||||
|
||||
|
||||
def cur(r):
|
||||
return S.writes(r, "current")
|
||||
|
||||
|
||||
def ph(r):
|
||||
return S.writes(r, "phases")
|
||||
|
||||
|
||||
FULL = {"a": 100.0, "b": 100.0}
|
||||
ABLE = {"a": 60.0, "b": 60.0}
|
||||
|
||||
|
||||
def quarters(r, aim):
|
||||
"""(start, import average, car average) of each whole quarter."""
|
||||
out = []
|
||||
tr = r["trace"]
|
||||
for q0 in range(0, int(tr[-1]["t"]) + 1 - 900, 900):
|
||||
xs = [x for x in tr if q0 <= x["t"] < q0 + 900]
|
||||
if len(xs) < 890:
|
||||
continue
|
||||
g = sum(max(0.0, x["grid"]) for x in xs) / len(xs)
|
||||
car = sum(x["car"] for x in xs) / len(xs)
|
||||
out.append((q0, g, car))
|
||||
return out
|
||||
|
||||
|
||||
def seq_ok(r):
|
||||
"""Every select: a 0 A write before it, the car under 100 W or out of C or
|
||||
20 s after the 0 A, then 10 s or more to the next current; no other write
|
||||
in between."""
|
||||
log = r["sim"].log
|
||||
state = {x["t"]: x["st"] for x in r["trace"]}
|
||||
bad = []
|
||||
for i, x in enumerate(log):
|
||||
if x[1] != "phases":
|
||||
continue
|
||||
prev = log[i - 1] if i else None
|
||||
nxt = log[i + 1] if i + 1 < len(log) else None
|
||||
if prev is None or prev[1] != "current" or prev[2] != 0.0:
|
||||
bad.append(("no 0 A before", x))
|
||||
continue
|
||||
quiet = (x[3] < 100.0 or state.get(x[0] - 1) != "C"
|
||||
or x[0] - prev[0] >= 20.0)
|
||||
if not quiet or x[4] != 0.0:
|
||||
bad.append(("select under load", x))
|
||||
if nxt is not None and (nxt[1] != "current" or nxt[0] - x[0] < 10.0):
|
||||
bad.append(("current too soon or not next", x, nxt))
|
||||
return bad
|
||||
|
||||
|
||||
def inv_sets(r):
|
||||
return [x for x in r["plant"].sets if x[1].startswith("number.sp_")]
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
print("\nT39. SHADOW MODE: NOTHING WRITTEN, THE CARD SAYS WHAT IT WOULD SET (N10)")
|
||||
# =========================================================================== #
|
||||
|
||||
|
||||
def cloudy(t):
|
||||
k = int(t) // 240
|
||||
return 900.0 + (2600.0 if k % 3 else 400.0) + 300.0 * (k % 5)
|
||||
|
||||
|
||||
twin = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
|
||||
opts={"ev_phases": "1"}, dur=3600)
|
||||
for name, kw in (("on", dict(opts={"ev_phases": "1", "shadow_mode": "on"})),
|
||||
("auto, control stopped",
|
||||
dict(opts={"ev_phases": "1", "shadow_mode": "auto"},
|
||||
events={0: lambda p, c: setattr(c, "auto", False)}))):
|
||||
sh = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
|
||||
dur=3600, **kw)
|
||||
diff = [(a["t"], a["a"], (b["would"] or (None,))[0])
|
||||
for a, b in zip(twin["trace"], sh["trace"])
|
||||
if b["would"] is not None and a["a"] != b["would"][0]]
|
||||
check(f"T39 shadow {name}: the charger log is empty for a cloudy hour, and "
|
||||
f"every second the card's 'would set' is the current of a twin run "
|
||||
f"without shadow mode ({len(diff)} seconds differ: {diff[:3]})",
|
||||
sh["sim"].log == [] and not diff
|
||||
and len({a['a'] for a in twin['trace']}) >= 3)
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
print("\nT50, T51. NOTHING ELSE CHANGES FOR THE GUARD AND THE ZERO-GRID LOOP")
|
||||
# =========================================================================== #
|
||||
h50 = steps((0, 400.0), (600, 2600.0), (900, 800.0), (1800, 4200.0),
|
||||
(2100, 300.0), (3000, 1500.0))
|
||||
r50 = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600)
|
||||
r50o = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600,
|
||||
opts={"ev_charger": "off"})
|
||||
|
||||
|
||||
check(f"T50: Solar with no car for an hour: the guard's floor and every battery "
|
||||
f"command are identical to the run with no charger "
|
||||
f"({len(inv_sets(r50))} commands)", inv_sets(r50) == inv_sets(r50o)
|
||||
and [x["floor"] for x in r50["trace"]]
|
||||
== [x["floor"] for x in r50o["trace"]] and cur(r50) == [])
|
||||
sun51 = steps((0, 3000.0), (700, 5200.0), (1500, 2500.0))
|
||||
r51 = S.drive(house=const(400.0), sun=sun51, first="car", socs=ABLE,
|
||||
dur=2000)
|
||||
carp = {int(x["t"]): x["car"] for x in r51["trace"]}
|
||||
r51o = S.drive(house=lambda t: 400.0 + carp.get(math.ceil(t), 0.0),
|
||||
sun=sun51, socs=ABLE, dur=2000, opts={"ev_charger": "off"})
|
||||
check(f"T51: Car first, the zero-grid loop: the same meter series with the car "
|
||||
f"as a Solar car and as house load gives the same battery commands "
|
||||
f"({len(inv_sets(r51))} commands)", inv_sets(r51) == inv_sets(r51o)
|
||||
and max(carp.values()) > 3000)
|
||||
check("T51: the batteries charge with what the car leaves (Car first)",
|
||||
-300 <= r51["plant"].batt(1999) <= 0)
|
||||
# =========================================================================== #
|
||||
print("\nT44. THE ACCEPTANCE DAY: 08:00-18:00, CLOUDS, HOUSE STEPS (A2)")
|
||||
# =========================================================================== #
|
||||
_rnd44 = random.Random(44)
|
||||
CLOUDS44 = []
|
||||
for _i in range(12):
|
||||
a = _rnd44.randint(600, 34000)
|
||||
CLOUDS44.append((a, a + _rnd44.randint(60, 480)))
|
||||
STEPS44 = [(8000, 8300), (17000, 17300), (26000, 26300)]
|
||||
|
||||
|
||||
def sun44(t):
|
||||
base = max(0.0, 7500.0 * math.sin(math.pi * t / 36000.0))
|
||||
return base * (0.15 if any(a <= t < b for a, b in CLOUDS44) else 1.0)
|
||||
|
||||
|
||||
def house44(t):
|
||||
w = 1450.0 + 1050.0 * math.sin(t / 1700.0)
|
||||
return w + (3000.0 if any(a <= t < b for a, b in STEPS44) else 0.0)
|
||||
|
||||
|
||||
long44 = sum(1 for a, b in CLOUDS44 if b - a > 300)
|
||||
for first, race in (("batteries", False), ("car", True)):
|
||||
# The batteries' levels move with their charge (A 15.36 kWh, B 20.48 kWh),
|
||||
# so with Batteries first the car gets sun once they are full.
|
||||
r44 = S.drive(house=house44, sun=sun44, first=first, socs={"a": 40.0,
|
||||
"b": 60.0},
|
||||
caps={"a": 15.36, "b": 20.48}, dur=36000, race=race)
|
||||
# On the harness clock, as the trace (the model's own clock runs ahead).
|
||||
w44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "current"]
|
||||
p44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "phases"]
|
||||
# A phase change's own 0 A (a select follows within 25 s) is not a pause.
|
||||
seq0 = {t for t, v in w44 if v == 0.0 and any(0 < pt - t <= 25
|
||||
for pt, _n in p44)}
|
||||
starts, pauses, paused, pause_t = 0, 0, True, []
|
||||
for t, v in w44:
|
||||
if v == 0.0 and t not in seq0:
|
||||
paused = True
|
||||
pauses += 1
|
||||
pause_t.append(t)
|
||||
elif v > 0 and paused:
|
||||
starts += 1
|
||||
paused = False
|
||||
why_at = {x["t"]: x["why"] for x in r44["trace"]}
|
||||
cut_t = [t for t in pause_t if why_at.get(t) == "cut"
|
||||
or why_at.get(t - 1) == "cut"]
|
||||
# Car first: no hold pause from a cloud under 300 s. Batteries first: a
|
||||
# battery that gave power in the cloud is under 100 % again, so its
|
||||
# rating is room and the car waits for it (the brief's room rule).
|
||||
short_hit = [t for t in pause_t if t not in cut_t and first == "car"
|
||||
and any(a <= t <= b + 2 for a, b in CLOUDS44 if b - a <= 300)]
|
||||
print(f" pauses (second, why): {[(t, why_at.get(t)) for t in pause_t]}")
|
||||
# N5 on the whole day: a start 120 s or more after its pause, a hold
|
||||
# pause after 300 s of holding, non-zero writes 30 s apart.
|
||||
nz = [t for t, v in w44 if v > 0]
|
||||
n5 = [("30 s", b) for a, b in zip(nz, nz[1:]) if b - a < 30]
|
||||
last_p = None
|
||||
for t, v in w44:
|
||||
if v == 0.0 and t not in seq0:
|
||||
last_p = t
|
||||
elif v > 0 and last_p is not None:
|
||||
if t - last_p < 120:
|
||||
n5.append(("start", t))
|
||||
last_p = None
|
||||
for t in pause_t:
|
||||
if why_at.get(t) == "paused":
|
||||
run = 0
|
||||
while why_at.get(t - 1 - run) == "hold":
|
||||
run += 1
|
||||
if run < 298:
|
||||
n5.append(("pause", t, run))
|
||||
# The loop turns at most `slew_w` per cycle, so for some 15 s after each
|
||||
# current step, cloud edge and house step the grid covers the change:
|
||||
# counted apart (dev report). The rest is the car on grid power while
|
||||
# the loop is settled, outside the holds.
|
||||
edges = [t for t, v in w44] + [e for ab in CLOUDS44 + STEPS44 for e in ab]
|
||||
edges.sort()
|
||||
|
||||
def settling(t):
|
||||
return any(0 <= t - e < 15 for e in edges)
|
||||
grid_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
|
||||
if x["why"] not in ("hold",) and not settling(x["t"])) / 3600.0
|
||||
slew_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
|
||||
if settling(x["t"])) / 3600.0
|
||||
steps44 = edges
|
||||
over44 = [(q, round(g)) for q, g, car in quarters(r44, 3400.0)
|
||||
if g > 3410.0 and g - car <= 3410.0]
|
||||
gaps = [b[0] - a[0] for a, b in zip(p44, p44[1:])]
|
||||
check(f"T44 {first} first ({'race' if race else 'step'}): starts {starts} "
|
||||
f"(<= 1 + {long44} long clouds + {len(cut_t)} peak cuts, Car first)"
|
||||
f"; pauses {pauses}; N5 dwells {n5[:3]}; selects {len(p44)} "
|
||||
f"(gaps >= 600 s: {gaps[:4]}); no pause from a short cloud "
|
||||
f"{short_hit[:3]}; the car's grid energy outside holds {grid_wh:.1f} "
|
||||
f"Wh (and {slew_wh:.1f} Wh in the loop's 15 s after "
|
||||
f"{len(steps44)} steps and edges); quarters over the aim by the car "
|
||||
f"{over44}",
|
||||
starts >= 1 and not n5 and all(g >= 600 for g in gaps)
|
||||
and (first != "car" or starts <= 1 + long44 + len(cut_t))
|
||||
and not seq_ok(r44) and not short_hit and grid_wh <= 10.0
|
||||
and not over44)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\nT45. THE FUZZ: 14 SITES, 16800 STEPS (N1-N10)")
|
||||
# The plan asks 14 x 400 steps; a busy site rarely has the 60 s calm a start
|
||||
# needs, so each site runs 1200 steps to make enough writes to judge.
|
||||
# =========================================================================== #
|
||||
|
||||
|
||||
def fuzz(seed):
|
||||
rnd = random.Random(seed)
|
||||
stations = [10.0, 13.0, 16.0]
|
||||
st = {"sun": rnd.uniform(0, 9000), "house": rnd.uniform(200, 3000),
|
||||
"n": {}, "acts": [], "undo": [], "exits": []}
|
||||
|
||||
def exit_check(p, c):
|
||||
"""N9: Solar to Off with the charger above 0 A, reachable, taking
|
||||
writes and not held by another writer: a 0 A must follow."""
|
||||
ch = p.ch
|
||||
if c.car_mode == "solar" and not c.car_solar.hold \
|
||||
and not ch.unavailable and ch.refuse is None \
|
||||
and ch.readback_a > 0.5 and not p.ha_down:
|
||||
st["exits"].append(p.t)
|
||||
|
||||
def later(p, fn):
|
||||
st["undo"].append((p.t + rnd.randint(10, 40), fn))
|
||||
|
||||
def ev(p, c):
|
||||
for due in [u for u in st["undo"] if u[0] <= p.t]:
|
||||
st["undo"].remove(due)
|
||||
due[1]()
|
||||
if st.get("back") is not None and p.t >= st["back"]:
|
||||
st["back"] = None # the user goes back to Solar
|
||||
st["acts"].append(p.t)
|
||||
return c.handle_action("car_mode", value="solar")
|
||||
if st.get("press") is not None and p.t >= st["press"]:
|
||||
st["press"] = None # the user presses the mode
|
||||
st["acts"].append(p.t)
|
||||
return c.handle_action("car_mode", value=c.car_mode)
|
||||
r = rnd.random()
|
||||
ch = p.ch
|
||||
if r < 0.012:
|
||||
st["sun"] = rnd.choice([0.0, 1000.0, 2500.0, 5000.0, 8000.0,
|
||||
8000.0, 6500.0])
|
||||
elif r < 0.02:
|
||||
st["house"] = rnd.uniform(200, 4000)
|
||||
elif r < 0.08:
|
||||
st["sun"] = max(0.0, st["sun"] + rnd.uniform(-600, 600))
|
||||
elif r < 0.082:
|
||||
if ch.state != "A":
|
||||
ch.unplug()
|
||||
later(p, ch.plug_in)
|
||||
st["n"]["plug"] = st["n"].get("plug", 0) + 1
|
||||
elif r < 0.084:
|
||||
ch.go_unavailable(True)
|
||||
later(p, lambda: ch.go_unavailable(False))
|
||||
st["n"]["down"] = st["n"].get("down", 0) + 1
|
||||
elif r < 0.087:
|
||||
ch.set_current(rnd.randint(0, 16))
|
||||
st["n"]["other"] = st["n"].get("other", 0) + 1
|
||||
st["press"] = p.t + rnd.randint(20, 90)
|
||||
elif r < 0.089:
|
||||
ch.refuse = rnd.choice(["ignore", "error"])
|
||||
later(p, lambda: setattr(ch, "refuse", None))
|
||||
elif r < 0.091:
|
||||
p.meter_on = False
|
||||
later(p, lambda: setattr(p, "meter_on", True))
|
||||
st["n"]["meter"] = st["n"].get("meter", 0) + 1
|
||||
elif r < 0.093:
|
||||
c.o["shadow_mode"] = "on"
|
||||
later(p, lambda: c.o.__setitem__("shadow_mode", "off"))
|
||||
st["n"]["shadow"] = st["n"].get("shadow", 0) + 1
|
||||
elif r < 0.095:
|
||||
c.auto = False
|
||||
later(p, lambda: setattr(c, "auto", True))
|
||||
st["n"]["stop"] = st["n"].get("stop", 0) + 1
|
||||
elif r < 0.098:
|
||||
m = rnd.choice(["solar", "solar", "solar", "off", "manual"])
|
||||
st["n"]["mode"] = st["n"].get("mode", 0) + 1
|
||||
st["acts"].append(p.t)
|
||||
if m == "off":
|
||||
exit_check(p, c)
|
||||
return c.handle_action("car_mode", value=m)
|
||||
elif r < 0.1:
|
||||
ch.station_a = rnd.choice(stations)
|
||||
elif r < 0.103 and c.car_mode == "solar" and p.ch.readback_a > 0.5 \
|
||||
and st.get("back") is None:
|
||||
exit_check(p, c) # leave Solar while it charges
|
||||
st["acts"].append(p.t)
|
||||
st["back"] = p.t + rnd.randint(30, 120)
|
||||
return c.handle_action("car_mode", value="off")
|
||||
elif r < 0.2 and c.car_solar.seq is not None:
|
||||
st["n"]["mid"] = st["n"].get("mid", 0) + 1
|
||||
exit_check(p, c)
|
||||
return c.handle_action("car_mode", value="off")
|
||||
ctx = []
|
||||
|
||||
def note(p, c, t):
|
||||
ctx.append((t, c.car_mode, c.car_writing(), c.car_solar.single,
|
||||
c.car_solar.hold, p.ch.station_a))
|
||||
r = S.drive(house=lambda t: st["house"], sun=lambda t: st["sun"],
|
||||
first="car", opts={"ev_margin_w": 0, "ev_start_min": 1,
|
||||
"ev_pause_min": 1}, socs=FULL, dur=1200,
|
||||
events={t: ev for t in range(1, 1200)}, on_cycle=note,
|
||||
race=seed % 2 == 1, sim=SimCharger(setpoint_a=rnd.choice(
|
||||
[0, 10, 16])))
|
||||
bad = []
|
||||
by_t = {x[0]: x for x in ctx}
|
||||
log = r["plant"].wlog # on the harness clock
|
||||
last_sel, last_nz = None, None
|
||||
for t, what, v, power, sp in log:
|
||||
# A write logged at second t comes after that second's actions.
|
||||
x = by_t.get(t) or by_t.get(t - 1)
|
||||
mode = x[1] if x else "?"
|
||||
if what == "current" and v > min(16.0, x[5] if x else 16.0) + 1e-9:
|
||||
bad.append(("N1 over the clamp", t, v))
|
||||
if what == "phases":
|
||||
if sp != 0.0:
|
||||
bad.append(("N2 select with the setpoint up", t))
|
||||
if last_sel is not None and t - last_sel < 600:
|
||||
bad.append(("N2 two selects in 600 s", t))
|
||||
last_sel = t
|
||||
if what == "current" and mode == "off" and v > 0:
|
||||
bad.append(("N10 a non-zero write in Off", t, v))
|
||||
if what == "current" and x is not None and not x[2] and v > 0 \
|
||||
and mode == "solar":
|
||||
bad.append(("N10 a non-zero Solar write while not writing", t, v))
|
||||
if what == "current" and v > 0 and mode == "solar":
|
||||
near_act = any(abs(t - a) <= 3 for a in st["acts"])
|
||||
if last_nz is not None and t - last_nz < 30 and not near_act:
|
||||
bad.append(("N5 two non-zero writes under 30 s", t, v))
|
||||
last_nz = t
|
||||
for te in st["exits"]:
|
||||
if not any(x[1] == "current" and x[2] == 0.0 and te <= x[0] <= te + 3
|
||||
for x in log):
|
||||
bad.append(("N9 Solar to Off left the current up", te))
|
||||
if r["c"].charger.clamp_faults:
|
||||
bad.append(("N1 clamp fault", r["c"].charger.clamp_faults))
|
||||
st["n"]["exits"] = len(st["exits"])
|
||||
return bad, len(log), st["n"]
|
||||
|
||||
|
||||
fz_bad, fz_n, fz_counts = [], 0, {}
|
||||
for _seed in range(14):
|
||||
_b, _n, _c = fuzz(_seed)
|
||||
fz_bad += _b
|
||||
fz_n += _n
|
||||
for k, v in _c.items():
|
||||
fz_counts[k] = fz_counts.get(k, 0) + v
|
||||
check(f"T45: {fz_n} charger writes over 14 random Solar sites and 16800 steps "
|
||||
f"(outages, unplugs, refusals, other writers, a silent meter, shadow and "
|
||||
f"Stop, mode changes, half racing): none over the clamp, no select with "
|
||||
f"the setpoint up or two in 600 s, every Solar to Off at 0 A (N9), no "
|
||||
f"non-zero write in Off, in shadow "
|
||||
f"or stopped, none under 30 s apart ({fz_bad[:3]})",
|
||||
not fz_bad and fz_n > 100)
|
||||
check(f"T45: each disturbance happened ({fz_counts})",
|
||||
all(fz_counts.get(k, 0) > 2 for k in ("plug", "down", "other", "meter",
|
||||
"shadow", "stop", "mode",
|
||||
"exits")))
|
||||
|
||||
print()
|
||||
if fails:
|
||||
print(f"{len(fails)} FAILED")
|
||||
for f in fails:
|
||||
print(" -", f)
|
||||
sys.exit(1)
|
||||
print("all passed")
|
||||
@@ -0,0 +1,344 @@
|
||||
"""EV-15: the add-on's own phase change at the peak reserve raises no alarm.
|
||||
`python3 -B test_ev15.py`
|
||||
|
||||
The rig (EV-10 and EV-10b, F-2): cover on, the batteries at the reserve, the car
|
||||
charging and explaining the excess. The add-on's own 3 -> 1 phase switch sets
|
||||
the car to 0 A; with the car not charging its figure is no longer corroborated
|
||||
(`CarTracker.corroborated`), so `car_alarm_w()` is None, nothing is explained,
|
||||
and PEAK_GUARD_FLOOR_LIMITED plus `goodwe_peak_soc_floor` fire. The rule: for
|
||||
the add-on's own sequence only (`ctl_car._car_own_pause`, bounded) the car's
|
||||
fresh, not stuck figure stands in for grading.
|
||||
|
||||
1. The rig shapes end to end through the car cycle: 3 -> 1 and 1 -> 3.
|
||||
2. A house overload that starts during the sequence still alarms, as on Off.
|
||||
3. Aborted (Off, Stop, unplug), refused, an outside writer: no grace.
|
||||
4. The bounds, and the figure that stands in (stale, stuck: nothing).
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, carmode, chargers as CH # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
logging.disable(logging.CRITICAL)
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
def at(t, fn):
|
||||
return {"t": t, "fn": fn}
|
||||
|
||||
|
||||
def beside(plant, c):
|
||||
"""The writer runs BESIDE the cycle, as in production (`car_kick`): its 1 s
|
||||
poll for the read-back lands after the cycle's own read, and the cycle does
|
||||
not wait for the writer (`ev04_peak.drive` does)."""
|
||||
gate = asyncio.Event()
|
||||
|
||||
async def sleep(_s):
|
||||
gate.clear()
|
||||
await gate.wait()
|
||||
|
||||
async def settle():
|
||||
gate.set()
|
||||
for _ in range(5):
|
||||
await asyncio.sleep(0)
|
||||
c.charger._sleep = sleep
|
||||
c.car_settle = settle
|
||||
|
||||
|
||||
def run(house, cap, t_res, t_sw, new, *, extra=None, mode="manual",
|
||||
sim_fn=None, dur=895, plug=True, side=False):
|
||||
"""Reserve at `t_res`, our phase change to `new` at `t_sw`. Returns the
|
||||
run, a per-second trace (second, own-pause, explains, red rows) and the
|
||||
alarms."""
|
||||
tr = []
|
||||
|
||||
def note(plant, c):
|
||||
red = [x["id"] for x in c.checks()
|
||||
if x["ok"] is False and not x["warn"]] \
|
||||
if t_sw - 5 <= plant.t <= t_sw + 90 else []
|
||||
g = c.peak_guard
|
||||
lim = bool(g is not None and (g.floor_limited or g.saturated))
|
||||
tr.append((plant.t, getattr(c, "_car_own_pause", lambda _t: False)(c.car_now()), c.car_explains,
|
||||
red, plant.ch.power_w, plant.ch.state, lim))
|
||||
|
||||
def reserve(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda t: house + plant.ch.power_w
|
||||
|
||||
def switch(plant, c):
|
||||
asyncio.get_event_loop().create_task(
|
||||
c.handle_action("car_phases", value=new))
|
||||
|
||||
ev = {t: note for t in range(0, dur)}
|
||||
ev[t_res] = lambda p, c: (reserve(p, c), note(p, c))
|
||||
ev[t_sw] = lambda p, c: (switch(p, c), note(p, c))
|
||||
if side:
|
||||
ev[t_sw - 2] = lambda p, c: (beside(p, c), note(p, c))
|
||||
for t, fn in (extra or {}).items():
|
||||
prev = ev.get(t, note)
|
||||
ev[t] = (lambda p, c, prev=prev, fn=fn: (fn(p, c), prev(p, c)))
|
||||
sim = None
|
||||
if sim_fn is not None or side:
|
||||
from chargersim import SimCharger
|
||||
sim = SimCharger(setpoint_a=16)
|
||||
sim_fn = sim_fn or (lambda s: None)
|
||||
sim_fn(sim)
|
||||
r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0,
|
||||
cap=cap, phases=(3 if new == 1 else 1), user_a=16, setpoint=16,
|
||||
mode=mode, events=ev, sim=sim, plug=plug)
|
||||
return r, tr, P.ids(r, *P.ALARMS)
|
||||
|
||||
|
||||
def reds(tr):
|
||||
return [x for x in tr if x[3]]
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. THE RIG SHAPES THROUGH THE CAR CYCLE")
|
||||
# =========================================================================== #
|
||||
SHAPES = (
|
||||
("EV-10 shape: house 3 kW, car 11 kW, aim 6 kW, 3 -> 1",
|
||||
3000.0, 6050.0, 300, 600, 1),
|
||||
("EV-10b shape: a 9411 W limit, 3 -> 1", 2000.0, 9461.0, 300, 600, 1),
|
||||
("1 -> 3 (the car 3.7 kW, then 11 kW), aim 5 kW", 2500.0, 5050.0,
|
||||
100, 600, 3),
|
||||
)
|
||||
for name, house, cap, t_res, t_sw, new in SHAPES:
|
||||
r, tr, al = run(house, cap, t_res, t_sw, new)
|
||||
c, sim = r["c"], r["sim"]
|
||||
sw = [x for x in sim.writes() if x[1] == "phases"]
|
||||
check(f"{name}: the car at the reserve covers, and the add-on's own "
|
||||
f"sequence ran (0 A, select, the current back)",
|
||||
len(sw) == 1 and [x[2] for x in sim.writes("current")][-2:]
|
||||
== [0.0, 16.0] and sim.phases_allowed == new)
|
||||
pause = [x for x in tr if x[1]]
|
||||
check(f"{name}: the own-pause grace was on during it, and ended",
|
||||
len(pause) >= 10 and not any(x[1] for x in tr[-1:])
|
||||
and (pause[-1][0] - pause[0][0])
|
||||
<= getattr(ctl_car, "OWN_PAUSE_MAX_S", 0)
|
||||
+ getattr(ctl_car, "OWN_PAUSE_TAIL_S", 0))
|
||||
check(f"{name}: no PEAK_GUARD_FLOOR_LIMITED / saturated, no "
|
||||
f"goodwe_peak_soc_floor notification", al == [])
|
||||
check(f"{name}: no red row in any sample around the switch",
|
||||
reds(tr) == [])
|
||||
limited = [x for x in tr if x[1] and x[6]]
|
||||
check(f"{name}: in every cycle of the sequence in which the guard is "
|
||||
f"limited (the cycle of the rig's alarm among them) the car "
|
||||
f"explains it", len(limited) >= 1 and all(x[2] for x in limited)
|
||||
and any(x[2] for x in tr if x[0] == t_sw + 1))
|
||||
check(f"{name}: and in every limited cycle after it, to the quarter's end",
|
||||
all(x[2] for x in tr if x[0] >= t_sw and x[6]))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. A HOUSE OVERLOAD DURING THE SEQUENCE STILL ALARMS")
|
||||
# =========================================================================== #
|
||||
def overload(plant, c):
|
||||
plant.load = lambda t: 25000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload})
|
||||
ro, tro, alo = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload},
|
||||
mode="off", plug=False)
|
||||
rn, trn, aln = run(3000.0, 6050.0, 300, 900, 1, extra={606: overload})
|
||||
check("PRECONDITION: on Off (no car) the same load alarms, and in Manual "
|
||||
"with no phase change", alo != [] and aln != [])
|
||||
check("a 25 kW house overload that starts 6 s into the sequence (the car "
|
||||
"paused): the alarm fires", al != [])
|
||||
print(f" alarm seconds: in the sequence {[t for t, _ in al]}, Off without "
|
||||
f"the car {[t for t, _ in alo]}, Manual with no phase change "
|
||||
f"{[t for t, _ in aln]}")
|
||||
check("...at the same second as on Off and as in Manual with no phase change",
|
||||
bool(al) and bool(alo) and bool(aln)
|
||||
and al[0][0] == alo[0][0] == aln[0][0])
|
||||
check("...and the car does not explain it (during the sequence too)",
|
||||
not any(x[2] for x in tr if 640 <= x[0] <= 660))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n3. ABORTED, REFUSED, OUTSIDE: NO GRACE AFTER IT")
|
||||
# =========================================================================== #
|
||||
def hit(res, t0, secs):
|
||||
return [x for x in res if t0 <= x[0] <= t0 + secs and x[1]]
|
||||
|
||||
|
||||
def off_now(plant, c):
|
||||
asyncio.get_event_loop().create_task(c.handle_action("car_mode",
|
||||
value="off"))
|
||||
|
||||
|
||||
def stop_now(plant, c):
|
||||
c.auto = False
|
||||
|
||||
|
||||
def unplug(plant, c):
|
||||
plant.ch.unplug()
|
||||
|
||||
|
||||
slow = lambda s: setattr(s, "stop_delay_s", 8.0) # noqa: E731
|
||||
for what, fn in (("Off", off_now), ("Stop", stop_now), ("unplug", unplug)):
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={602: fn},
|
||||
sim_fn=slow)
|
||||
check(f"{what} 2 s into the sequence: the grace is off from the next "
|
||||
f"cycle on", not hit(tr, 604, 200)
|
||||
and any(x[1] for x in tr if 600 <= x[0] <= 602))
|
||||
|
||||
def refuse_phases(sim):
|
||||
sim.request_phases = lambda n: False
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, sim_fn=refuse_phases)
|
||||
check("the select is refused: the grace ends at once (no cycle of it after "
|
||||
"the refusal), the current comes back",
|
||||
len([x for x in r["sim"].writes("current")]) >= 2
|
||||
and not hit(tr, 606, 200))
|
||||
|
||||
def outside_zero(plant, c):
|
||||
plant.ch.set_current(0.0)
|
||||
|
||||
|
||||
r2, tr2, al2 = run(3000.0, 6050.0, 300, 900, 1, extra={602: outside_zero})
|
||||
check("an outside writer's 0 A: no grace, and the normal grading (no car "
|
||||
"power: nothing explained) raises the alarm as before",
|
||||
not any(x[1] for x in tr2) and not any(x[2] for x in tr2
|
||||
if 610 <= x[0] <= 700)
|
||||
and al2 != [])
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n4. THE BOUNDS AND THE FIGURE THAT STANDS IN")
|
||||
# =========================================================================== #
|
||||
class _C(ctl_car.CarMixin):
|
||||
"""The mixin with just what `_car_own_pause` reads."""
|
||||
def __init__(self):
|
||||
self.o = {}
|
||||
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
self.car_mode = carmode.MANUAL
|
||||
self.auto, self.shadow = True, False
|
||||
self.inverters, self.site_sign_wd = [], type("W", (), {"tripped": False})()
|
||||
self.circ_wd = type("W", (), {"tripped": False})()
|
||||
self.charger = type("H", (), {"configured": lambda s: True})()
|
||||
self.car = CH.CarTracker()
|
||||
self.car.reading = CH.ChargerReading(available=True, state="B")
|
||||
|
||||
|
||||
c = _C()
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "n": 1, "tries": 0,
|
||||
"prev": 16.0}
|
||||
M = ctl_car.OWN_PAUSE_MAX_S
|
||||
check("bound: the sequence's own maximum is its waits (0 A wait, settle, "
|
||||
"three tries at 15 s, the select) and no more",
|
||||
M == carmode.ZERO_WAIT_S + carmode.SETTLE_S + carmode.MAX_TRIES * 15.0
|
||||
+ 10.0 and ctl_car.OWN_PAUSE_TAIL_S == CH.CORR_WINDOW_S)
|
||||
check("bound: on at the 0 A write and up to the maximum",
|
||||
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M))
|
||||
check("bound: off one second past it", not c._car_own_pause(101.0 + M))
|
||||
c.car_writer.seq = None
|
||||
c.car_writer.phase_done_at = 200.0
|
||||
T = ctl_car.OWN_PAUSE_TAIL_S
|
||||
check("bound: after the current is set again it lasts one corroboration "
|
||||
"window", c._car_own_pause(200.0 + T) and not c._car_own_pause(201.0 + T))
|
||||
c.car_writer.phase_done_at = None
|
||||
check("no sequence and none just done: no grace", not c._car_own_pause(100.0))
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "failed": True}
|
||||
check("a refused write marks the sequence: no grace", not c._car_own_pause(110.0))
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
|
||||
c.car_mode = carmode.OFF
|
||||
check("Off: no grace", not c._car_own_pause(110.0))
|
||||
c.car_mode, c.shadow = carmode.MANUAL, True
|
||||
check("shadow mode: no grace", not c._car_own_pause(110.0))
|
||||
c.shadow, c.auto = False, False
|
||||
check("control stopped: no grace", not c._car_own_pause(110.0))
|
||||
c.auto = True
|
||||
c.car_writer.hold = True
|
||||
check("another writer (hold): no grace", not c._car_own_pause(110.0))
|
||||
c.car_writer.hold = False
|
||||
c.car_writer.seq, c.car_writer.zero_sent_at = None, 100.0
|
||||
check("0 A sent, not yet back: grace from the send, to the maximum, no more",
|
||||
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M)
|
||||
and not c._car_own_pause(101.0 + M))
|
||||
c.car_writer.zero_sent_at = None
|
||||
c.car_writer.phase_done_at = 200.0
|
||||
c.car_writer.hold = True
|
||||
check("another writer in the 60 s after the current is set: no grace",
|
||||
not c._car_own_pause(210.0))
|
||||
c.car_writer.hold, c.car_writer.phase_done_at = False, None
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
|
||||
c.car.reading = CH.ChargerReading(available=True, state="A")
|
||||
check("unplugged: no grace", not c._car_own_pause(110.0))
|
||||
c.car.reading = CH.ChargerReading(available=True, state="B")
|
||||
check("PRECONDITION: the same state is on", c._car_own_pause(110.0))
|
||||
|
||||
tk = CH.CarTracker()
|
||||
tk.reading = CH.ChargerReading(available=True, state="B", power_w=500.0,
|
||||
allowed_a=16.0, phases_allowed=1)
|
||||
tk.last_ok = 0.0
|
||||
check("the stand-in figure is the fresh reading, capped by the read-back",
|
||||
tk.car_w_paused(5.0) == 500.0 and tk.car_w_trusted(5.0) is None)
|
||||
check("a stale reading stands in for nothing", tk.car_w_paused(100.0) is None)
|
||||
tk.stuck_now = True
|
||||
check("a stuck reading stands in for nothing", tk.car_w_paused(5.0) is None)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n5. THE WRITER RUNS BESIDE THE CYCLE (review F-1)")
|
||||
# =========================================================================== #
|
||||
# The car stops (state B) in the same Home Assistant update as the 0 A
|
||||
# read-back; the write has not returned yet, so no sequence exists. The window
|
||||
# opens when the write is SENT (`ManualWriter.zero_sent_at`).
|
||||
def lagged(lag, delay):
|
||||
def f(s):
|
||||
s.lag_s, s.stop_delay_s = lag, delay
|
||||
return f
|
||||
|
||||
|
||||
for lag, delay in ((2, 0), (0, 0), (2, 3), (5, 2)):
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
|
||||
sim_fn=lagged(lag, delay))
|
||||
nm = f"beside the cycle, lag {lag} s, stop delay {delay} s"
|
||||
limited = [x for x in tr if x[0] >= 600 and x[6]]
|
||||
check(f"{nm}: our sequence ran (select once, then 16 A again)",
|
||||
len([x for x in r["sim"].writes("phases")]) == 1
|
||||
and r["sim"].phases_allowed == 1
|
||||
and [x[2] for x in r["sim"].writes("current")][-2:] == [0.0, 16.0])
|
||||
check(f"{nm}: no PEAK_GUARD_FLOOR_LIMITED, no goodwe_peak_soc_floor",
|
||||
al == [])
|
||||
check(f"{nm}: no red row, and the car explains every limited cycle",
|
||||
reds(tr) == [] and all(x[2] for x in limited))
|
||||
|
||||
|
||||
def not_taken(plant, c):
|
||||
plant.ch.refuse = "ignore" # HA accepts, the charger does nothing
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
|
||||
sim_fn=lagged(0, 0), extra={600: not_taken})
|
||||
check("the 0 A write is not taken (read-back never follows): the window was "
|
||||
"open while it waited", any(x[1] for x in tr if 600 <= x[0] <= 606))
|
||||
own = [x[0] for x in tr if x[1]]
|
||||
runs = 1 + len([1 for a, b in zip(own, own[1:]) if b - a > 1])
|
||||
check("...and no grace after the refusal (the retry, RETRY_S later, opens it "
|
||||
"again only while that write waits: at most 3 runs of 11 s), no "
|
||||
"sequence made", not hit(tr, 613, 40) and r["c"].car_writer.seq is None
|
||||
and 1 <= runs <= 3 and len(own) <= 3 * 11)
|
||||
check("...the car went on charging and nothing was written but the 0 A",
|
||||
r["sim"].power_w > 5000.0 and not r["sim"].writes("phases"))
|
||||
|
||||
print()
|
||||
if fails:
|
||||
print(f"FAIL: {len(fails)} check(s)")
|
||||
for f in fails:
|
||||
print(" -", f)
|
||||
sys.exit(1)
|
||||
print("ok: EV-15")
|
||||
@@ -0,0 +1,290 @@
|
||||
#!/usr/bin/env python3
|
||||
"""EV-05: the real Controller on a sunny plant with N batteries and a car.
|
||||
|
||||
python3 tools/ev05_sun.py # mock-up scenario 2, both priorities
|
||||
|
||||
A 1 s cycle, a P1 meter that publishes 0.3 s before each cycle, N batteries
|
||||
each with ITS OWN rating and level (switched On, so the zero-grid loop charges
|
||||
them from the export), and `chargersim.SimCharger` behind the same Home
|
||||
Assistant. The meter sees `house + car - sun - batteries` (battery discharge
|
||||
positive), so the spare sun the add-on computes is `sun - house` whatever it
|
||||
does. A battery at 100 % takes no charge. `events` is `{second: fn(plant, c)}`,
|
||||
run before that cycle. `race=True` uses the production order (read, the writer
|
||||
task settles, then the cycle), as test_ev04.py's `World.step_race`.
|
||||
|
||||
Used by test_ev05.py and, later, by the rig test."""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
from datetime import timedelta
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, HERE)
|
||||
|
||||
import opt11_identity as rig # noqa: E402
|
||||
import main_files # noqa: E402
|
||||
from app import packmode # noqa: E402
|
||||
from app.main import Controller # noqa: E402
|
||||
from app.p1 import make_sample, split_signed # noqa: E402
|
||||
from app.store import unit_key # noqa: E402
|
||||
from chargersim import SimCharger # noqa: E402
|
||||
from app import p1 as _p1 # noqa: E402
|
||||
|
||||
SET = "number.wallbox_power_connector_max_current_socket_1"
|
||||
PHASES = "select.wallbox_installation_max_allowed_phases"
|
||||
ALARMS = ("goodwe_peak_saturated", "goodwe_peak_soc_floor")
|
||||
RESPONSE_S = 0.5 # a battery reaches its new command this much later
|
||||
SAMPLE_LEAD_S = 0.3
|
||||
|
||||
|
||||
class SunPlant:
|
||||
"""The house, the sun, N batteries and the charger on one meter."""
|
||||
|
||||
def __init__(self, house, sun, ratings, socs, charger):
|
||||
self.house, self.sun = house, sun
|
||||
self.ratings, self.socs = dict(ratings), dict(socs)
|
||||
self.ch = charger
|
||||
self.t = 0.0
|
||||
self.hists = {u: [(-1e9, 0.0)] for u in self.ratings}
|
||||
self.notes = [] # (t, notification id) raised
|
||||
self.dismissed = []
|
||||
self.sets = [] # (t, entity, value): every number write
|
||||
# Every charger write the model took, as `SimCharger.log` has it but
|
||||
# on THIS clock (the model's own runs ahead while a write waits).
|
||||
self.wlog = []
|
||||
self.meter = 0.0
|
||||
self.meter_on = True # False: the meter stops publishing
|
||||
self.batt_nan = set() # units whose battery figure reads None
|
||||
self.utc_off = 0.0 # the wall clock jumps, the model clock not
|
||||
self.ha_down = False # Home Assistant answers nothing (SAFETY-112)
|
||||
|
||||
def batt_of(self, u, at):
|
||||
w = 0.0
|
||||
for when, v in self.hists[u]:
|
||||
if when <= at:
|
||||
w = v
|
||||
r = self.ratings[u]
|
||||
w = max(-r, min(r, float(round(w))))
|
||||
if self.socs[u] >= 100.0 and w < 0.0:
|
||||
w = 0.0 # a full battery takes no charge
|
||||
return w
|
||||
|
||||
def batt(self, at):
|
||||
return sum(self.batt_of(u, at) for u in self.ratings)
|
||||
|
||||
def grid(self, at):
|
||||
return self.house(at) + self.ch.power_w - self.sun(at) - self.batt(at)
|
||||
|
||||
# -- Home Assistant -----------------------------------------------------
|
||||
async def limits(self, e):
|
||||
return (-5000.0, 5000.0, 1.0)
|
||||
|
||||
async def state(self, entity_id):
|
||||
if self.ha_down:
|
||||
return None
|
||||
return self.ch.states().get(entity_id)
|
||||
|
||||
async def states(self):
|
||||
if self.ha_down:
|
||||
return []
|
||||
return list(self.ch.states().values())
|
||||
|
||||
async def call(self, domain, service, data=None):
|
||||
if self.ha_down:
|
||||
return False
|
||||
if service == "create":
|
||||
self.notes.append((self.t, (data or {}).get("notification_id")))
|
||||
if service == "dismiss":
|
||||
self.dismissed.append((self.t, (data or {}).get("notification_id")))
|
||||
if domain == "select" and service == "select_option":
|
||||
n = 3 if "3" in str((data or {}).get("option")) else 1
|
||||
return self._logged("phases", n, self.ch.request_phases)
|
||||
return True
|
||||
|
||||
def _logged(self, what, v, fn):
|
||||
n0, row = len(self.ch.log), (self.t, what, v, self.ch.power_w,
|
||||
self.ch.setpoint_a)
|
||||
ok = fn(v)
|
||||
if len(self.ch.log) > n0:
|
||||
self.wlog.append(row)
|
||||
return ok
|
||||
|
||||
async def number(self, e, invert=False):
|
||||
if self.ha_down:
|
||||
return None
|
||||
for u in self.ratings:
|
||||
if e == "sensor.soc_" + u:
|
||||
return self.socs[u]
|
||||
if e == "sensor.batt_" + u:
|
||||
return None if u in self.batt_nan else self.batt_of(u, self.t)
|
||||
if e in ("sensor.grid", "sensor.net"):
|
||||
return self.meter
|
||||
return None
|
||||
|
||||
async def set_number(self, e, v):
|
||||
if self.ha_down:
|
||||
return False
|
||||
self.sets.append((self.t, e, float(v)))
|
||||
if e == SET:
|
||||
return self._logged("current", float(v), self.ch.request_current)
|
||||
if e.startswith("number.sp_"):
|
||||
self.hists[e[-1]].append((self.t + RESPONSE_S, float(v)))
|
||||
return True
|
||||
|
||||
|
||||
def drive(house, sun, *, dur=600.0, ratings=None, socs=None, cap=3500.0,
|
||||
margin=100, opts=None, plug=True, setpoint=0, phases=1, mode="solar",
|
||||
first="batteries", events=None, sim=None, store=None, race=False,
|
||||
on_cycle=None, car_phases=3, t0=0.0, caps=None):
|
||||
"""Run it. Returns a dict: plant, controller, charger, notifications with
|
||||
their second, and a per-second trace. `caps` ({unit: kWh}) lets each
|
||||
battery's level move with what it charges or gives; without it the
|
||||
levels stand still."""
|
||||
ratings = ratings or {"a": 5000.0, "b": 4600.0}
|
||||
socs = socs or {u: 50.0 for u in ratings}
|
||||
sim = sim or SimCharger(setpoint_a=setpoint)
|
||||
if plug:
|
||||
sim.plug_in(car_phases=car_phases)
|
||||
sim.phases_allowed = phases
|
||||
units = sorted(ratings)
|
||||
o = rig._options(len(units), dict({
|
||||
"meter_source": "ha_signed", "p1_net_entity": "sensor.net",
|
||||
"meter_phases": 1, "peak_cap_w": cap, "peak_margin_w": margin,
|
||||
"battery_modes_enabled": True,
|
||||
"ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
|
||||
"ev_current_entity": SET}, **(opts or {})))
|
||||
if len(units) == 1:
|
||||
o["max_w"] = ratings[units[0]]
|
||||
else:
|
||||
o["inverters"] = [dict(x, max_w=ratings[x["name"][-1]])
|
||||
for x in o["inverters"]]
|
||||
store = store or rig._Store()
|
||||
store.data["car_mode"] = mode
|
||||
store.data["car_sun_first"] = first
|
||||
for u in units:
|
||||
store.data[unit_key("inverter-" + u, packmode.USE_KEY)] = True
|
||||
db = os.path.join(tempfile.mkdtemp(prefix="ev5-"), "tariff.db")
|
||||
out = {}
|
||||
events_in = events or {}
|
||||
|
||||
async def go():
|
||||
plant = SunPlant(house, sun, ratings, socs, sim)
|
||||
c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
|
||||
peak_db_path=db)
|
||||
for i in c.inverters:
|
||||
r = ratings[i.name[-1]] if len(units) > 1 else ratings[units[0]]
|
||||
i.dev_min, i.dev_max = -r, r
|
||||
c.auto = True
|
||||
clock = [t0]
|
||||
c.car_now = lambda: clock[0]
|
||||
real_time = _p1.time
|
||||
|
||||
class _Time:
|
||||
"""The meter's age on the model clock, so a silent meter goes
|
||||
stale in model seconds."""
|
||||
def __getattr__(self, k):
|
||||
return getattr(real_time, k)
|
||||
|
||||
@staticmethod
|
||||
def monotonic():
|
||||
return clock[0]
|
||||
_p1.time = _Time()
|
||||
if hasattr(c.charger, "_sleep"):
|
||||
async def sleep(s):
|
||||
sim.tick(s)
|
||||
clock[0] += s
|
||||
c.charger._sleep = sleep
|
||||
c.charger._clock = lambda: clock[0]
|
||||
real_dt = main_files.live.datetime
|
||||
|
||||
class _DT(real_dt):
|
||||
@classmethod
|
||||
def now(cls, tz=None):
|
||||
return rig.BASE + timedelta(seconds=clock[0] + plant.utc_off)
|
||||
main_files.live.datetime = _DT
|
||||
trace = []
|
||||
try:
|
||||
t = t0
|
||||
while t < t0 + dur:
|
||||
plant.t = clock[0] = t
|
||||
fn = events_in.get(int(t)) if t == int(t) else None
|
||||
if fn is not None:
|
||||
r = fn(plant, c)
|
||||
if asyncio.iscoroutine(r):
|
||||
await r
|
||||
sim.tick(1.0)
|
||||
ts = t - SAMPLE_LEAD_S
|
||||
if plant.meter_on and not plant.ha_down:
|
||||
plant.meter = plant.grid(ts)
|
||||
imp, exp = split_signed(plant.meter)
|
||||
c.p1.submit(make_sample(
|
||||
"ha_signed", imp, exp, phases=1,
|
||||
ingest_ts=rig.BASE + timedelta(seconds=ts),
|
||||
ingest_mono=ts))
|
||||
await c.read_inputs(now_mono=t)
|
||||
if race:
|
||||
await c.car_settle()
|
||||
await c.cycle()
|
||||
else:
|
||||
await c.cycle()
|
||||
await c.car_settle()
|
||||
w = c.car_solar
|
||||
g = c.peak_guard
|
||||
trace.append(dict(
|
||||
t=t, a=w.plan.a, why=w.plan.why, n=w.plan.n,
|
||||
sp=sim.setpoint_a, rb=sim.readback_a,
|
||||
ph=sim.phases_allowed, car=sim.power_w, st=sim.state,
|
||||
grid=plant.grid(t), batt=plant.batt(t),
|
||||
house=plant.house(t), sun=plant.sun(t),
|
||||
cut=c.car_cut_w, explains=c.car_explains,
|
||||
lim=bool(g is not None and (g.floor_limited
|
||||
or g.saturated)),
|
||||
floor=(None if g is None else g.floor_w),
|
||||
excess=(None if g is None else g.excess_w),
|
||||
proj=(None if g is None else g.projected_w),
|
||||
target=(None if g is None else g.target_w),
|
||||
would=w.would, single=w.single,
|
||||
spare=c.car_spare_w(t), ok=w.plan.ok_since,
|
||||
red=[x["id"] for x in c.checks()
|
||||
if x["ok"] is False and not x["warn"]]
|
||||
if on_cycle == "rows" else []))
|
||||
if callable(on_cycle):
|
||||
on_cycle(plant, c, t)
|
||||
for u, kwh in (caps or {}).items():
|
||||
lv = plant.socs[u] - plant.batt_of(u, t) / 36.0 / kwh
|
||||
plant.socs[u] = max(0.0, min(100.0, lv))
|
||||
t += 1.0
|
||||
await c.car_settle()
|
||||
finally:
|
||||
main_files.live.datetime = real_dt
|
||||
_p1.time = real_time
|
||||
out.update(plant=plant, c=c, sim=sim, trace=trace, store=store,
|
||||
raised=list(plant.notes))
|
||||
asyncio.run(go())
|
||||
return out
|
||||
|
||||
|
||||
def ids(out, *wanted):
|
||||
return [(t, n) for t, n in out["raised"] if n in wanted]
|
||||
|
||||
|
||||
def writes(out, what="current"):
|
||||
"""(t, value) of every charger write of that kind, in model seconds."""
|
||||
return [(x[0], x[2]) for x in out["sim"].writes(what)]
|
||||
|
||||
|
||||
def const(w):
|
||||
return lambda t: float(w)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
logging.disable(logging.CRITICAL)
|
||||
for first in ("batteries", "car"):
|
||||
r = drive(const(900.0), const(7900.0), dur=600, first=first,
|
||||
socs={"a": 71.0, "b": 100.0})
|
||||
print(f"scenario 2, {first} first: writes {writes(r)} phases "
|
||||
f"{writes(r, 'phases')} batteries {r['plant'].batt(599):.0f} W "
|
||||
f"grid {r['plant'].grid(599):.0f} W")
|
||||
@@ -300,7 +300,16 @@ configuration:
|
||||
description: "While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak."
|
||||
ev_mode_start:
|
||||
name: "Car charger · Mode after a restart"
|
||||
description: "Keep the last mode, or start in Off. A restart never changes the charger's current."
|
||||
description: "Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current."
|
||||
ev_margin_w:
|
||||
name: "Car charger · Sun kept back (W)"
|
||||
description: "Solar: this much spare sun is never given to the car."
|
||||
ev_start_min:
|
||||
name: "Car charger · Start after (minutes)"
|
||||
description: "Solar: the car starts after this long with enough spare sun."
|
||||
ev_pause_min:
|
||||
name: "Car charger · Pause after (minutes)"
|
||||
description: "Solar: with too little sun the car holds 6 A this long, then pauses."
|
||||
auto_start:
|
||||
name: "Advanced · Start control on boot"
|
||||
description: "Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart."
|
||||
|
||||
@@ -281,7 +281,16 @@ configuration:
|
||||
description: "Terwijl de auto laadt. Aan: de batterijen dekken ze tot de piekreserve. Uit: de piekbewaking laat de auto buiten beschouwing, dus de auto alleen kan de piek bepalen."
|
||||
ev_mode_start:
|
||||
name: "Laadpaal · Modus na een herstart"
|
||||
description: "De laatste modus houden, of starten in Uit. Een herstart verandert de stroom van de laadpaal nooit."
|
||||
description: "De laatste modus houden, of starten in Uit. In Zon zet een herstart de laadpaal eerst op 0 A, andere modi laten haar stroom."
|
||||
ev_margin_w:
|
||||
name: "Laadpaal · Zon achtergehouden (W)"
|
||||
description: "Zon: zoveel zonne-overschot krijgt de auto nooit."
|
||||
ev_start_min:
|
||||
name: "Laadpaal · Starten na (minuten)"
|
||||
description: "Zon: de auto start na zo lang genoeg zonne-overschot."
|
||||
ev_pause_min:
|
||||
name: "Laadpaal · Pauzeren na (minuten)"
|
||||
description: "Zon: met te weinig zon houdt de auto zo lang 6 A en pauzeert dan."
|
||||
auto_start:
|
||||
name: "Geavanceerd · Regeling starten bij opstarten"
|
||||
description: "Staat standaard uit. Laat het uit tot de installatie in dienst is, zodat iemand na elke herstart op Start drukt."
|
||||
|
||||
Reference in New Issue
Block a user