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