Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4950a2374f | ||
|
|
43b0db73d2 | ||
|
|
ef8c5dcf62 | ||
|
|
93c6628eca | ||
|
|
5db56b5f28 | ||
|
|
12c97b56f4 | ||
|
|
9fdce023e9 | ||
|
|
7788543e09 | ||
|
|
6d7046fc45 | ||
|
|
07f703d1bc | ||
|
|
2cfbc4aec8 | ||
|
|
f66048b287 | ||
|
|
69a1ccce1f | ||
|
|
9a355144fc | ||
|
|
628bde8013 | ||
|
|
ff2eebe28b | ||
|
|
b12776c705 | ||
|
|
b86c0153cf |
@@ -2,8 +2,127 @@
|
||||
|
||||
### Not in a release yet
|
||||
|
||||
- The *Car* card can now charge: choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. The car is never slowed for the peak limit, the add-on says so instead of raising false peak alarms, and the batteries help cover it unless you switch that off. Off still writes nothing ([[EV-04]]).
|
||||
- Car charger fixes: when the car alone takes the batteries to the peak reserve, the add-on no longer raises "Battery stopped limiting the peak" (the grey "Car over the peak limit" note says it instead); that note and the Car card's reason stay steady instead of flickering; and switching to Off right after the add-on's own change no longer shows "Something else changes the charger".
|
||||
- When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]).
|
||||
|
||||
## 0.24.0
|
||||
|
||||
**A minor bump: the add-on can now charge the car (Manual mode), and a car that alone takes the batteries to the peak reserve no longer raises a false peak alarm. Two new options were added, both with defaults, and none needs setting.**
|
||||
Two options were added (`ev_batt_cover` and `ev_mode_start`), none was removed or renamed, and no default changed (92 options, 90 before). **Existing installs need no option change:** the new options have defaults, and `ev_charger` is still off, so an install that does not use the car charger runs as 0.23.0 did. It is a minor bump because it adds a feature and new options; every saved setting still starts.
|
||||
|
||||
**The add-on can now charge the car.** This is the first version that writes to the car charger. On the *Car* card, choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home, or from Home Assistant when MQTT is on. **Off writes nothing.** The car is never slowed for the peak limit; the batteries help cover it unless you switch *Batteries help with the peak* off. **If your own automation in Home Assistant writes the same charger, switch it off before you choose Manual:** two writers fight over one setting. See "Car charger" in DOCS ([[EV-04]]).
|
||||
|
||||
**Car charger fixes.** When the car alone takes the batteries to the peak reserve, the add-on no longer says "Battery stopped limiting the peak"; a grey "Car over the peak limit" note says it instead, and the note stays steady instead of flickering. A change the add-on makes itself is no longer shown as "Something else changes the charger". A real overload of the house still raises the normal alarm ([[EV-10]], [[EV-11]], [[EV-12]]).
|
||||
|
||||
Contents of this release, in merge order since 0.23.0 (`b656091`):
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| `75ebe22` | The add-on can charge the car: choose Manual on the *Car* card and set the current (6 A up to the charger limit) and 1 or 3 phases. Off writes nothing, the car is never slowed for the peak limit, and the batteries help cover it unless you switch that off. This is the first version that writes to the charger, so switch off any other automation that writes it ([[EV-04]], #257) |
|
||||
| `b86c015` | When the car alone takes the batteries to the peak reserve, there is no false "Battery stopped limiting the peak". The "Car over the peak limit" note stays steady, and the add-on's own change is not shown as "Something else changes the charger" ([[EV-10]], [[EV-11]], [[EV-12]], #258) |
|
||||
| `628bde8` | The false "Battery stopped limiting the peak" is now gone also when the batteries cover the car down to the reserve: the check counts the house alone. A real overload of the house still raises the alarm ([[EV-10]], #259, called EV-10b) |
|
||||
|
||||
|
||||
### Known issues
|
||||
|
||||
- A false "Battery is not keeping up" can still show when the peak guard pauses a maintenance charge ([[SAFETY-92]]).
|
||||
- A battery capped at a low limit with a perfectly flat reading can still trip the stale check ([[SAFETY-74]]).
|
||||
- A battery whose reading at rest is beyond about ±175 W is still not caught when it refuses ([[SAFETY-97]]).
|
||||
- The peak guard can still back off near the end of a 15-minute period when a meter reading is late, by less than 30 s. This is about the guard's discharge only; a grid charge is cut back since 0.19.2 ([[SAFETY-99]]).
|
||||
- Two inverters: the maintenance charge can switch on and off while the house is above the peak aim ([[SAFETY-88]]).
|
||||
- Two inverters: the "circulating" figure counts a battery's reading at rest ([[SAFETY-98]]).
|
||||
- Two inverters: a drain that starts during a big step in house use can send the other battery to full power, and about 1 kW goes to the grid for about 10 s ([[SAFETY-104]]).
|
||||
- Two inverters: when a battery comes back during a maintenance charge, the grid can step by several kW at once ([[SAFETY-101]]).
|
||||
- Two inverters: when a battery drops out during a solar surplus, the others can swing by up to 1.5 kW in a simulation ([[SAFETY-105]]).
|
||||
- Two inverters: after a drain ends, a change in house use can go unanswered for about 9 s, because some readings are old ([[SAFETY-106]]).
|
||||
- Two inverters: when one battery's level is missing, both batteries are held at 0 W, and for about 15 s the last command stays on ([[SAFETY-108]]).
|
||||
- Two inverters: if one battery's level stays missing for 12 h, the other battery's cycle can be marked failed, with a 7-day wait and a notice, though it is healthy. This comes from reading the code; it has not been seen on a site ([[MAINT-17]]).
|
||||
- When the 15-minute demand forecast sensor counts the battery's own charge, the maintenance charge runs at about half the power the peak limit leaves, so it takes about twice as long (seen on a site: about 1.2 kW instead of 2.5 kW; the peak limit was kept). At the start of a month, before a peak above the limit, that is about 2 kWh a night in a rig test: the cycle can reach its 36 h limit after about 4 nights and fail, and since 0.22.0 the other battery gets no grid charge on those nights ([[SAFETY-111]]).
|
||||
- One inverter: after a link drop, the battery's own safety stop to 0 W can be taken as a refusal, and the site stays at 0 W for up to 15 min ([[SAFETY-102]]).
|
||||
- After a Home Assistant restart, control still waits until Home Assistant has finished starting, which can take several minutes, though the readings are already there ([[SAFETY-115]]).
|
||||
- While Home Assistant is not answering, the page can list inverters as refusing commands and sensors as missing, and send you to Developer Tools, though they are fine ([[UX-37]]).
|
||||
- If Home Assistant hangs or stops, the page keeps saying "Waiting for Home Assistant" and never turns into an alarm ([[SAFETY-113]]).
|
||||
- Right after Home Assistant has started, the page can say for about 4 s that an inverter cannot be controlled, and the first command can come late ([[SAFETY-114]]).
|
||||
- After a Home Assistant restart, the controller status sensor can still say "running" while the add-on cannot control. It was seen once, and the cause is not known ([[SAFETY-116]]).
|
||||
- Battery modes on: after a planned top-up from the grid, the Batteries screen can say "Enough sun is forecast" ([[UX-32]]).
|
||||
- Battery modes on: the forecast line "we count on" can show more sun than the plan counts, because the plan takes house use off first ([[UX-33]]).
|
||||
- Battery modes on: before a planned top-up, the Today list shows a smaller "gives" amount than the plan will use; it grows as the charge happens ([[UX-34]]).
|
||||
- Two inverters, battery modes on: while the other battery is in its maintenance charge, a battery's card can say it charges from the grid while it stays at 0 W ([[OPT-18]]).
|
||||
- Two inverters, battery modes on: while a battery refuses to charge in a cheap run, the action log on the page gets about 8 lines an hour for its retries, and the page hint says "waiting for a better price" ([[UX-38]]).
|
||||
- A battery in a safety stop, or one the add-on cannot reach, can still be started for a cycle, and its drain then waits about 12 h and ends in a failed-cycle notice. This comes from reading the code; it has not been seen on a site ([[MAINT-19]]).
|
||||
- On the Settings page, the rows of the solar forecast lists are labelled "Phase 1", "Phase 2" instead of "Sensor 1", "Sensor 2" ([[UX-27]]).
|
||||
- In the solar forecast list, a blank or repeated row makes "source 2 of 2" count differently from the rows on the Settings page ([[UX-28]]).
|
||||
- The solar forecast message says "has no reading" also when the sensor shows a number that is too old or in the wrong unit ([[UX-29]]).
|
||||
- If you use only the forecast lists, two Settings notes sit on the single-sensor field, and one of them tells you to set that field ([[UX-30]]).
|
||||
- After a restart during a price outage, the "No prices" message can say "yet" when prices did come in earlier ([[UX-39]]).
|
||||
- On the new settings page, you cannot see whether a price service token is set. Check the Configuration tab ([[UX-41]]).
|
||||
- On the classic settings page, the first click on Save after editing a field can do nothing. Click again ([[UX-42]]).
|
||||
- A steady overload on a 1 s meter can warn, and send the Home Assistant notification, 2 or 3 times at the start of each 15-minute period instead of once. The peak limit is still kept ([[SAFETY-122]]).
|
||||
- A fixed tariff is priced once per hour, so a price window that starts or ends at :15, :30 or :45 gets the wrong price for part of that hour. Windows that start and end on the hour are right ([[TARIFF-23]]).
|
||||
- Step 6 of the setup wizard stays empty because of an error in the page, in English and in Dutch ([[UX-51]]).
|
||||
- On Dutch pages, refusal texts, the last-event line under the Home buttons, the installer details and the trading status sentences are still English, and a few Dutch texts read badly, such as "1 metingen geweigerd" ([[UX-52]]).
|
||||
- Some price texts say "hour" where the add-on acts on a 15-minute period, such as "cheapest hour" ([[UX-47]]).
|
||||
- After the add-on restarts, the Home price chart shows no price for the earlier part of today, and the setup check can say "12 of 24 hours", though the prices are known ([[UX-48]]).
|
||||
- With battery modes on and only batteries on "Leftover solar", the Home price chart can mark a cheap period where no battery charges ([[UX-49]]).
|
||||
- On a phone, the bars of the Home price chart are too thin to tap one 15-minute period. The arrow keys work ([[UX-50]]).
|
||||
- In the last second of a 15-minute period, being a few watts over the aim can make the peak guard ask a battery for full power for one second. When a charge ends on a period edge, the last-second give can fade out over about 10 s, and a rig test exported up to 7.4 kW for about 8 s ([[SAFETY-124]]).
|
||||
- During the night grid charge, a 15-minute period can end 6 to 14 W over the peak aim, because the battery charges harder than asked. This was seen in simulation; a rig test saw 2 to 8 W ([[OPT-35]]).
|
||||
- The test rig could not bring back the false peak alarm that [[SAFETY-126]] fixes, so that fix is shown in simulation only. Watch the notifications for a few nights ([[TEST-35]]).
|
||||
- The night cheap run is sized for the batteries' full charging power, not for what the peak limit leaves. Under a tight limit the run can end before the batteries reach their level, and Home can show a level they do not reach (79.9 % against a shown 95 % in a rig test) ([[OPT-25]]).
|
||||
- By day, a Leftover solar plan that has only a daily forecast figure counts the sun from now, not from when the figure was read. It counts about 22 % too much for a figure one hour old; the night plan is not affected ([[OPT-30]]).
|
||||
- The night charge can buy too much in a house that uses more at night than by day, such as one with a heat pump or a car charger that is not set up in the add-on, and on a sunny day, because spare sun in one expensive hour does not count for the later ones ([[OPT-31]]).
|
||||
- A cheap run that has already started can overlap a new give run after a re-plan, so a battery can charge from the grid at the dearest price for part of an hour. This was seen in a test case, not on a site. Also in 0.19.2 ([[OPT-32]]).
|
||||
- If the solar forecast sensors stop updating before 17:00, as in winter or further north, there is no forecast from three hours after their last update until 20:00 ([[OPT-33]]).
|
||||
- With a forecast that gives only a daily total, the sun is spread an hour off on the two clock-change days after the change. The day's total is right ([[OPT-24]]).
|
||||
- The add-on learns the house's use only once a solar forecast is set, so a site that adds a forecast later waits one more day for its first plan ([[OPT-26]]).
|
||||
- Home says "No trading on price yet: no prices have arrived" when every battery is on Solar first, though the prices are shown ([[UX-55]]).
|
||||
- The Home plan header can say "Charges in the cheapest hour, gives power in the dearest" when Home draws no charge, and it says "hour" for 15-minute prices ([[UX-56]]).
|
||||
- While the peak guard holds back charging, Home hides the rest of the cheap run and gives no reason. The charge starts again when the guard lets go ([[UX-57]]).
|
||||
- With battery modes on and selling on, Home can draw a "Sells up to" block when the add-on judges the trade not worth it, and then it will not sell ([[UX-58]]).
|
||||
- Home, the plan and the Forecast tab stop drawing a battery's give at the trading floor, though control goes on giving down to the battery's cut-out ([[UX-59]]).
|
||||
- During a price outage, the Batteries screen says "Prices differ too little" and Home says "The price gap is too small" ([[UX-60]]).
|
||||
- With battery modes on and no meter, or a meter that is a Home Assistant entity, a grid charge is not possible and nothing says so ([[UX-61]]).
|
||||
- On the Batteries screen, a charge the add-on refused in a cheap run reads as "Saves its power for ...", for up to 15 minutes ([[UX-62]]).
|
||||
- A Leftover solar battery with no capacity set never charges from the grid when a solar forecast is set, and nothing warns about it ([[UX-63]]).
|
||||
- The "How the modes work" box on the Batteries screen does not describe Cheap hours only ([[UX-64]]).
|
||||
- With battery modes on, Settings still shows "Trade on the price spread", which the modes ignore. A site with modes on and no price source starts, and the Batteries screen says "No prices, so it follows the house" without pointing to Settings ([[UX-65]]).
|
||||
- With battery modes off and several equal prices in a row, Home and the Forecast tab draw one price quarter, while the add-on trades every quarter of the run ([[UX-67]]).
|
||||
- Late in the day, the Forecast tab's "now" line and last bars sit over the axis labels at the right edge ([[UX-68]]).
|
||||
- The Forecast tab's level curve charges at each battery's full rating. Under a peak limit the levels it draws are too high and a charge block can end early (54.6 % shown against 39.7 % in a rig test) ([[UX-70]]).
|
||||
- The peak forecast check says maintenance charging is not kept under the peak limit when no peak forecast is set, but since 0.19.2 it is ([[UX-73]]).
|
||||
- The peak guard row can show the same figure twice, such as "at this rate 3 500 W, over 3 500 W". Also in 0.19.2 ([[UX-74]]).
|
||||
- If the inverter's setpoint entity appears in Home Assistant after the add-on has started, the page keeps saying "Inverter control: not found in Home Assistant" and the batteries say "An alarm stopped control" until a restart, though control runs ([[UX-75]]).
|
||||
- In the last minute of a 15-minute period, with Home Assistant readings 30 s late, the period can end about 80 W over the peak aim and over the limit: 3 530 W against a 3 450 W aim and a 3 500 W limit in a rig test with a 2 kW load added 45 s before the end. The peak guard sees the load too late to hold it back ([[SAFETY-133]]).
|
||||
- With Home Assistant readings 10 s late, the grid charge in a cheap run can swing by several kW. In a test the add-on asked for an 8.7 kW charge (9.6 kW on 0.20.0) ([[SAFETY-132]]).
|
||||
- A plan rebuilt while the battery levels are missing for a moment can drop a cheap run that has not started yet, so the battery does not charge that day. Seen in a replay of real prices, where it cost about EUR 0.40 of extra grid use; the Leftover solar change in 0.20.1 no longer triggers it in those replays, but the cause stays ([[OPT-37]]).
|
||||
- On a 5 s meter, Home Assistant readings 10 s late are still not caught, and readings 15 s late only after about 4 minutes. Control now follows the meter more gently, so less goes to the grid: in a simulation with a changing load, 340 Wh became 189 Wh at 10 s late and 363 Wh became 296 Wh at 15 s late. In a rig test, 15 s late exported 13 to 19 % more than before ([[SAFETY-136]], [[SAFETY-134]]).
|
||||
- With readings 10 to 15 s late, the hold can end in the middle of the delay and the swing can come back. Seen in rig tests with a 2 s and a 5 s meter ([[SAFETY-134]]).
|
||||
- With readings 10 s late on a 1 s meter, the grid can still move between -422 and +340 W while the batteries are held. With a very long delay (30 to 90 s) the request can swing by about 900 W every few seconds. Seen in review tests ([[SAFETY-130]]).
|
||||
- A battery that answers very slowly (10 s or more) can be taken for late Home Assistant readings and held, and the page then blames Home Assistant. A GoodWe battery settles in about 6 s and this has not been seen on one ([[SAFETY-131]]).
|
||||
- The page row for late readings reads awkwardly in English ("Home Assistant readings show requests about N seconds late, so control holds the batteries"), and the Dutch text misses a word ([[UX-78]]).
|
||||
- When the add-on stops, a write that takes more than 2 s can still land after the 0 W, and the 30 s safety timer on the ESPHome board then sets 0 W. After the Stop button, a cycle that had already decided can send its share (560 to 670 W) just after the 0 W; the next cycle sends 0 W again ([[SAFETY-138]]).
|
||||
- In the last hour of a cheap run, Home can draw a battery's grid charge up to an hour past the time control stops charging it. It only draws too much, never too little ([[UX-79]]).
|
||||
- A tomorrow solar forecast sensor that reports just after midnight with yesterday's value can be used as the new day's forecast for up to 12 hours. This has not been seen on a site ([[OPT-39]]).
|
||||
- During a cheap-hours charge, at some 15-minute boundaries the add-on sends 0 W for one tick ("no trade (headroom)") and then goes on. Seen in a rig test, in 5 of 8 cases; once, with a frozen battery reading, it left a battery at 0 W until 23:45 ([[OPT-40]]).
|
||||
- While one battery's monthly cycle charges, the other battery's card on Home says "Saves its power for higher prices", and the plan still shows its grid charge in the cheap hours, though it will not charge ([[UX-80]]).
|
||||
- After a failed monthly cycle, the plan line shows the day the wait ends, such as 18 November, not when the cycle tries again, such as 19 November at 19:00 ([[MAINT-26]]).
|
||||
- At the start of a cheap window the peak guard can step once although the period is under the aim, and the step can land on a battery in its monthly charge. In a rig test it gave 1.7 to 2.3 kW for 6 s ([[SAFETY-140]]).
|
||||
- A grid charge at full power in the last seconds of a 15-minute period can run into the next period, where the peak guard cuts it back ([[SAFETY-139]]).
|
||||
- In a long real peak, the peak guard can end a 15-minute period up to 10 W over its aim, as 0.22.0 does (up to 31 W there). In a rig test the month's highest peak did not rise ([[SAFETY-141]]).
|
||||
- The peak reserve notification can be created again and again, 24 to 47 times in 2 hours in a rig test, while the guard holds a battery at its reserve. 0.22.0 does the same ([[MAINT-29]]).
|
||||
- When you switch the car charger off, its three sensors stay in Home Assistant with their last values. From reading the code, the PV power sensor does the same when it is switched off ([[TEL-19]]).
|
||||
- In Settings, the choice for no car charger says "None", while its help says "Off" ([[UX-81]]).
|
||||
- DOCS names the car's energy sensor `goodwe_car_today_kwh`, but Home Assistant creates it as `sensor.goodwe_car_energy_today` ([[TEL-20]]).
|
||||
- When the charger refuses a current, the Car card can show two amber rows: "Charger did not take it" and "Charger reading may be stuck" ([[EV-13]]).
|
||||
- In shadow mode, and after a phase change was given up, the Car card's *Why* line says what you set, not what the charger does ([[EV-14]]).
|
||||
- When the add-on changes the car's phases while the batteries are at the peak reserve, "Battery stopped limiting the peak" can show for a moment, with one notification ([[EV-15]]).
|
||||
- With *Batteries help with the peak* on, the Car card's *Why* line can switch between two wordings while the car is over the peak limit ([[EV-16]]).
|
||||
|
||||
### If you are crossing from a version older than 0.10.0
|
||||
|
||||
`## 0.10.0` below can refuse an old config: `slew_w` above its limit, and the
|
||||
withdrawn `price_provider` ids `engie_dynamic`, `totalenergies_dynamic` and
|
||||
`eneco_eddy`. Read it before you update. Run `tools/predeploy_check.py` with the
|
||||
bare options (`jq '.data.options'`) first.
|
||||
|
||||
## 0.23.0
|
||||
|
||||
|
||||
@@ -89,7 +89,7 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
- **The car is the cause when the alarm's own test says so, on the same
|
||||
landing** (EV-10). `car_cycle` (`_car_explains_alarm`) runs the alarm's test on
|
||||
the period as it is and on the period without the car's fresh, corroborated
|
||||
average (`car_exclude`): the car explains the alarm only if it is true with the
|
||||
average (`car_exclude_alarm`, EV-10b below): the car explains the alarm only if it is true with the
|
||||
car and false without it. A saturated guard, and a floor with other batteries
|
||||
left, use `load_too_high` on the landing (the batteries give only what they
|
||||
still can). A floor that leaves nothing uses SAFETY-126's `misses_aim` (the
|
||||
@@ -97,10 +97,22 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
that latch twice, with and without the car, from the same readings. Both reset
|
||||
at a new quarter and when the guard stops wanting power, and they run every
|
||||
cycle, so the cover option does not touch them. This holds with the projection
|
||||
still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the
|
||||
same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`,
|
||||
sets the latch without the car, and the normal alarms stand. There is no minimum
|
||||
car power: the comparison itself is what separates car from house.
|
||||
still under the aim (rig: 5888 W against 6000 W). A car of 0 W explains
|
||||
nothing; a stale, stuck or uncorroborated figure is `None` and the normal
|
||||
alarms stand while it is (EV-18 below). There is no minimum car power: the
|
||||
comparison itself is what separates car from house.
|
||||
- **The period without the car is not clipped at 0 W** (EV-10b). The rig showed
|
||||
EV-10 failing: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
|
||||
give more than the house uses, so the house alone is an export; `car_exclude`
|
||||
clipped it at 0 W, `misses_aim` added the batteries' full 8.1 kW back, the
|
||||
"house needs the batteries" latch set early in the quarter, and the floor alarm
|
||||
could never be explained. `car_exclude_alarm` (alarm grading only) builds the
|
||||
house alone as: rest of the period `held - car_w`, keeping its sign, so
|
||||
`misses_aim` adds the batteries back to `held - car_w + batt` = the house; done
|
||||
part `max(0, done - car so far)` in Ws (no export is credited that only the
|
||||
car caused); landing `(done + max(held, 0) * left) / 900`. Without a fresh
|
||||
car reading it is the period as it is. `car_exclude` (the projection the guard
|
||||
sees with the cover off) is unchanged, with its clip.
|
||||
- **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter
|
||||
became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so
|
||||
the test crossed the aim every few seconds. `car_over` (row, card, notice) now
|
||||
@@ -108,6 +120,45 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a
|
||||
quarter) and a gap does not restart the 10 s
|
||||
on-count. `car_explains`, which the alarms read, has no hold.
|
||||
- **Our own phase change is not a reason to alarm** (EV-15). Rig, twice: at the
|
||||
reserve, with the car covering, the add-on's 3 -> 1 switch set the car to 0 A.
|
||||
A car that is not charging has no corroboration (`CarTracker._corr_note` clears
|
||||
the window, `corroborated` is False), so `car_alarm_w()` was None, the car
|
||||
explained nothing and `_car_need_excl` latched for the quarter: one
|
||||
PEAK_GUARD_FLOOR_LIMITED and one `goodwe_peak_soc_floor`. Now, only for grading
|
||||
(`car_cycle`), `ctl_car._car_own_pause` lets the car's fresh, not stuck figure
|
||||
(`CarTracker.car_w_paused`, 0 W while paused) stand in without corroboration:
|
||||
from the moment our 0 A write is SENT (`zero_sent_at`: the cycle runs beside
|
||||
the writer and the car stops before the write returns), until the current is
|
||||
set again, at most
|
||||
`OWN_PAUSE_MAX_S` (85 s, the sequence's own waits), then at most one
|
||||
corroboration window (60 s). It ends at once on Off, Stop, shadow, unplug,
|
||||
another writer, or a refused select or write (`seq["failed"]`). The energy it
|
||||
drew in the pause is kept apart (`ws_p`), so `car_exclude`, the guard's
|
||||
input, the claim, floor and writes are unchanged. A house overload still fails
|
||||
the test without the car, so it alarms as on Off.
|
||||
- **The batteries as they give now, and no latch from an unknown** (EV-18, EV-15
|
||||
rig F-A). At the reserve the loop still gives some battery power; "without the
|
||||
car, batteries at 0 W" counted it as house, `_car_need_excl` latched at the
|
||||
quarter's start and the floor alarm stood for the quarter with the excess
|
||||
smaller than the car. Owner 2026-11-19: without the car the batteries keep
|
||||
giving what they give now (the lower of two readings, every cycle); a miss so
|
||||
(`_car_need_house`) seen with a trusted car figure stays latched to the
|
||||
quarter's end. The car explains where the period with it misses on the same
|
||||
batteries (`_car_over_now`), or by the EV-10 test above. A `None` car figure
|
||||
or battery reading explains nothing in that cycle and latches nothing; a car
|
||||
known to draw nothing (fresh, not charging) still grades the house's need.
|
||||
Owner 2026-11-19: a figure the energy meter contradicted (it answered over a
|
||||
whole window and fell short; an unknown reading is no contradiction) grades
|
||||
no alarm to the quarter's end; the guard's input keeps it. After a restart
|
||||
or a gap the car's earlier energy is not known, so it counts as house.
|
||||
- **A battery rise is house only once a second reading shows it** (EV-19, EV-15
|
||||
rig F-B). At the reserve inverter-b goes on following the house, so its
|
||||
output rises; the reading shows it one cycle before P1 does, and the house
|
||||
figure (meter + battery) counted that power as house. `_car_need_house`
|
||||
latched and the alarm stood. For the house figure, a reading above both
|
||||
earlier ones counts only up to the higher of them; the credit stays the lower
|
||||
of the last two readings.
|
||||
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
|
||||
own detector opens before the write and runs 15 s from when it returns, because
|
||||
the read-back reaches the cycle while the write still waits for it.
|
||||
|
||||
@@ -125,6 +125,8 @@ class ManualWriter:
|
||||
self.phase_fails = 0 # phase selects the charger did not take
|
||||
self.phases_gave_up = False
|
||||
self.undone = 0 # sequences undone before the select
|
||||
self.phase_done_at = None # EV-15: our phase change ended well then
|
||||
self.zero_sent_at = None # EV-15: our 0 A write is out, not yet back
|
||||
|
||||
# ------------------------------------------------------------------ user
|
||||
def user_changed(self) -> None:
|
||||
@@ -292,7 +294,14 @@ class ManualWriter:
|
||||
async def _begin(self, drv, r, cur, n, now, tracker) -> None:
|
||||
"""Step 1 of the safe sequence: 0 A. A charger that does not take it
|
||||
stops the sequence before the phases are touched."""
|
||||
ok = await self._write(drv, 0.0, cur, now, tracker)
|
||||
self.phase_done_at = None
|
||||
# EV-15: the car stops while the write waits for its read-back, and the
|
||||
# cycle runs beside it: the window opens when the write is SENT.
|
||||
self.zero_sent_at = now
|
||||
try:
|
||||
ok = await self._write(drv, 0.0, cur, now, tracker)
|
||||
finally:
|
||||
self.zero_sent_at = None
|
||||
if not ok:
|
||||
self._failed(now)
|
||||
return
|
||||
@@ -336,6 +345,7 @@ class ManualWriter:
|
||||
self.log.append(("phases", q["n"], now, ok))
|
||||
q["stage"], q["t1"] = "settle", self.last_done # from its return
|
||||
if not ok:
|
||||
q["failed"] = True # EV-15: no grace for the alarm
|
||||
# The charger did not take it: the car gets its current back
|
||||
# on the old phases after the same SETTLE_S as a taken select
|
||||
# (HA may have taken it and only the read-back be late), and
|
||||
@@ -356,7 +366,10 @@ class ManualWriter:
|
||||
# still wanted, and one that is in place is adopted.
|
||||
self.seq, self.rev_applied, self.reapply = None, None, False
|
||||
self.fails, self.blocked = 0, False
|
||||
if not q.get("failed"):
|
||||
self.phase_done_at = self.last_done # EV-15
|
||||
return
|
||||
q["failed"] = True # EV-15: a refused write ends it
|
||||
q["tries"] += 1
|
||||
if q["tries"] >= MAX_TRIES:
|
||||
# Left at 0 A is the safe side; the next reading re-applies.
|
||||
|
||||
@@ -790,6 +790,17 @@ class CarTracker:
|
||||
return got_wh >= CORR_RATIO * exp_wh - CORR_SLACK_WH
|
||||
return True
|
||||
|
||||
def contradicted(self, now: float) -> bool:
|
||||
"""EV-18: did the energy meter answer over a whole window and fall
|
||||
short (`corroborated` compared and failed)? Not when the energy
|
||||
reading is unknown, the window is empty or still short, or the car is
|
||||
not charging: those are unknown, not contradicted."""
|
||||
r = self.reading
|
||||
if r is None or not r.available or r.charging is not True \
|
||||
or r.energy_kwh is None or not self._hist:
|
||||
return False
|
||||
return not self.corroborated(now)
|
||||
|
||||
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."""
|
||||
@@ -800,8 +811,20 @@ class CarTracker:
|
||||
EV-03 rules), not stuck after a write, corroborated by the energy meter
|
||||
(`corroborated`), and never above what the read-back allows the car to
|
||||
draw: an old or frozen figure must not hide a house overload."""
|
||||
return self._capped_w(now, True)
|
||||
|
||||
def car_w_paused(self, now: float):
|
||||
"""EV-15: the same figure as `car_w_trusted` without the energy-meter
|
||||
corroboration, which a car held at 0 A by the add-on's own phase change
|
||||
cannot give (the meter's window restarts when it stops charging). Fresh,
|
||||
not stuck, and capped by the read-back. Only for grading the alarm
|
||||
during that sequence (`ctl_car._car_own_pause`)."""
|
||||
return self._capped_w(now, False)
|
||||
|
||||
def _capped_w(self, now: float, corroborate: bool):
|
||||
w = self.car_w(now)
|
||||
if w is None or self.stuck(now) or not self.corroborated(now):
|
||||
if w is None or self.stuck(now) \
|
||||
or (corroborate and not self.corroborated(now)):
|
||||
return None
|
||||
r = self.reading
|
||||
a = r.allowed_a if r.allowed_a is not None else r.setpoint_a
|
||||
|
||||
@@ -24,6 +24,13 @@ OVER_HOLD_S = peakguard.ALARM_HOLD_S
|
||||
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
|
||||
# sampling) and shorter than a quarter, or until the session really ends.
|
||||
OVER_OFF_HOLD_S = 180.0
|
||||
# EV-15: the longest our own phase change can take (0 A wait, settle, three
|
||||
# tries of a write at 5 s apart and up to 10 s each, the select's own wait);
|
||||
# the grace for the alarm never outlasts it, and after the current is set
|
||||
# again it lasts at most one corroboration window.
|
||||
OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S
|
||||
+ carmode.MAX_TRIES * 15.0 + 10.0)
|
||||
OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S
|
||||
|
||||
|
||||
class CarMixin:
|
||||
@@ -51,13 +58,15 @@ class CarMixin:
|
||||
self.car_over = False # ... held: the card and row say so
|
||||
self._car_over_since = None
|
||||
self._car_over_gone = None
|
||||
self._car_batt_prev = None
|
||||
self._car_batt_prev = self._car_batt_prev2 = None
|
||||
self._car_need_real = self._car_need_excl = False # EV-10 latches
|
||||
self._car_need_house = self._car_over_now = False # EV-18 latches
|
||||
self._car_latch_block = None
|
||||
self._car_contra_block = None # EV-18: the quarter it was contradicted
|
||||
self._car_over_notified = None # the session a notice was raised for
|
||||
self._car_session = 0
|
||||
self._car_prev_state = None
|
||||
self._carq = {"key": None, "ws": 0.0, "mono": None}
|
||||
self._carq = {"key": None, "ws": 0.0, "ws_p": 0.0, "mono": None}
|
||||
self._peak_proj_real = None
|
||||
saved = data.get(CAR_PEAK_KEY)
|
||||
self.car_peak_q = dict(saved) if isinstance(saved, dict) else {}
|
||||
@@ -206,17 +215,68 @@ class CarMixin:
|
||||
return None
|
||||
return self.car.car_w_trusted(self.car_now())
|
||||
|
||||
def _car_quarter(self, proj, w, mono) -> None:
|
||||
def _car_own_pause(self, mono) -> bool:
|
||||
"""EV-15: is the car held at 0 A by the add-on's OWN phase change? From
|
||||
the moment its 0 A write is SENT (the cycle runs beside the write)
|
||||
until the current is set again, then at most one corroboration window.
|
||||
No when it was aborted (Off, Stop, shadow, unplug, another writer), a
|
||||
write was refused, or it ran past its own maximum."""
|
||||
wr = getattr(self, "car_writer", None)
|
||||
if wr is None or (wr.seq is None and wr.phase_done_at is None
|
||||
and wr.zero_sent_at is None) or wr.hold:
|
||||
return False
|
||||
r = self.car.reading
|
||||
if not (self.car_manual() and self.car_writing()
|
||||
and r is not None and r.available and r.state != "A"):
|
||||
return False
|
||||
q = wr.seq
|
||||
if q is None and wr.zero_sent_at is not None: # sent, not yet back
|
||||
return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S
|
||||
if q is not None:
|
||||
return not q.get("failed") and 0.0 <= mono - q["t0"] \
|
||||
<= OWN_PAUSE_MAX_S
|
||||
return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
|
||||
|
||||
def _car_contradicted(self, mono) -> bool:
|
||||
"""EV-18 (owner 2026-11-19): did the charger's energy meter answer
|
||||
and fall short of a fresh, not stuck figure of a charging car
|
||||
(`CarTracker.contradicted`)? Then that figure stays untrusted for the
|
||||
alarm to the quarter's end (`car_cycle`). An unknown energy reading
|
||||
contradicts nothing."""
|
||||
r = getattr(self.car, "reading", None)
|
||||
if r is None or not r.available or r.charging is not True \
|
||||
or not self.car_manual():
|
||||
return False
|
||||
return (self.car.car_w(mono) is not None and not self.car.stuck(mono)
|
||||
and self.car.contradicted(mono))
|
||||
|
||||
def _car_idle(self, mono) -> bool:
|
||||
"""EV-18: is the car known to draw nothing? A fresh reading that says
|
||||
it is not charging (mode3 A or B) at under `CAR_PEAK_MIN_W`. Not an
|
||||
unknown figure: the house's own need is graded in such a cycle."""
|
||||
r = getattr(self.car, "reading", None)
|
||||
if r is None or not r.available or r.charging is not False:
|
||||
return False
|
||||
p = self.car.car_w(mono)
|
||||
return p is not None and p < CAR_PEAK_MIN_W
|
||||
|
||||
def _car_quarter(self, proj, w, mono, wg=None) -> None:
|
||||
"""The car's energy in the open quarter, for the average the guard's
|
||||
house leaves out and for the peak line."""
|
||||
house leaves out and for the peak line. `wg` (EV-15) is the figure for
|
||||
grading during our own pause; its energy is kept apart (`ws_p`) so the
|
||||
guard's input is unchanged."""
|
||||
q = self._carq
|
||||
key = None if proj is None else proj.block_start
|
||||
last = q["mono"]
|
||||
if key != q["key"]:
|
||||
self._car_bank(q)
|
||||
q["key"], q["ws"] = key, 0.0
|
||||
if key is not None and w is not None and last is not None:
|
||||
q["ws"] += float(w) * min(max(mono - last, 0.0), 5.0)
|
||||
q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0
|
||||
if key is not None and last is not None:
|
||||
dt = min(max(mono - last, 0.0), 5.0)
|
||||
if w is not None:
|
||||
q["ws"] += float(w) * dt
|
||||
elif wg is not None:
|
||||
q["ws_p"] = q.get("ws_p", 0.0) + float(wg) * dt
|
||||
q["mono"] = mono
|
||||
|
||||
def _car_bank(self, q) -> None:
|
||||
@@ -233,14 +293,17 @@ class CarMixin:
|
||||
del self.car_peak_q[k]
|
||||
self.store.set(CAR_PEAK_KEY, dict(self.car_peak_q))
|
||||
|
||||
def car_avg_w(self, proj, w) -> float:
|
||||
def car_avg_w(self, proj, w, graded=False) -> float:
|
||||
"""The car's average over the whole open quarter: what it drew so far
|
||||
and `w` for the rest."""
|
||||
and `w` for the rest. `graded` (EV-15) adds what it drew during our
|
||||
own pause."""
|
||||
if proj is None or w is None:
|
||||
return 0.0
|
||||
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
||||
so_far = self._carq["ws"] if self._carq["key"] == proj.block_start \
|
||||
else 0.0
|
||||
if graded and self._carq["key"] == proj.block_start:
|
||||
so_far += self._carq.get("ws_p", 0.0)
|
||||
return (so_far + float(w) * left) / QUARTER_S
|
||||
|
||||
def car_exclude(self, proj, w):
|
||||
@@ -253,18 +316,64 @@ class CarMixin:
|
||||
proj, projected_w=max(0.0, float(proj.projected_w) - avg),
|
||||
held_w=max(0.0, float(proj.held_w) - float(w)))
|
||||
|
||||
def car_exclude_alarm(self, proj, w):
|
||||
"""EV-10b: the period as it would be without the car, for grading the
|
||||
alarm. The house alone, the batteries giving only what the house
|
||||
would draw from them: the car's share of their power is not charged to
|
||||
the house. The rest of the period keeps its sign (`held - car`, an
|
||||
export while the batteries give more than the house uses), so
|
||||
`misses_aim` adds the batteries back to exactly the house. What is
|
||||
already done is clipped at 0 Ws: no export is credited for power only
|
||||
the car asked for. Unchanged without a fresh car reading."""
|
||||
if proj is None or w is None or proj.block_start is None:
|
||||
return proj
|
||||
avg = self.car_avg_w(proj, w, graded=True)
|
||||
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
||||
held = float(proj.held_w)
|
||||
done_ws = QUARTER_S * float(proj.projected_w) - max(held, 0.0) * left
|
||||
car_ws = avg * QUARTER_S - float(w) * left # the car so far
|
||||
held_x = held - float(w)
|
||||
return dataclasses.replace(
|
||||
proj, held_w=held_x,
|
||||
projected_w=(max(0.0, done_ws - car_ws)
|
||||
+ max(held_x, 0.0) * left) / QUARTER_S)
|
||||
|
||||
def car_cycle(self, real_proj, guard, target_w, now_utc) -> None:
|
||||
"""After the guard has decided: does the car alone explain the excess?
|
||||
`real_proj` is the projection WITH the car, whatever the guard saw."""
|
||||
mono = self.car_now()
|
||||
w = self.car_alarm_w()
|
||||
self._car_quarter(real_proj, w, mono)
|
||||
# EV-15: the figure for grading only. Our own phase change holds the
|
||||
# car at 0 A and the energy meter cannot corroborate it then, so for
|
||||
# that bounded time its fresh, not stuck figure stands in.
|
||||
own = (w is None or float(w) <= 0.0) and self._car_own_pause(mono)
|
||||
wg = w
|
||||
if w is None and own:
|
||||
wg = self.car.car_w_paused(mono)
|
||||
self._car_quarter(real_proj, w, mono, wg)
|
||||
self._car_session_tick(mono)
|
||||
# EV-18 (owner 2026-11-19): a figure the meter contradicted grades no
|
||||
# alarm again in that quarter, not even as our own pause's stand-in.
|
||||
# The alarm decision only: the car's energy count, the guard's input
|
||||
# (`car_exclude`) and, with the cover off, the car-over row keep it.
|
||||
key = None if real_proj is None else real_proj.block_start
|
||||
if key is not None and not own and self._car_contradicted(mono):
|
||||
self._car_contra_block = key
|
||||
contra = key is not None and key == self._car_contra_block
|
||||
explains = over = False
|
||||
if real_proj is not None and target_w is not None \
|
||||
and real_proj.block_start is not None:
|
||||
# EV-10: every cycle, so the latches do not depend on the option.
|
||||
graded = self._car_explains_alarm(real_proj, guard, target_w, w)
|
||||
# EV-18: a car known to draw nothing counts as 0 W for the latches
|
||||
# (the house's own need); it and a 0 W figure explain nothing,
|
||||
# but in our own pause (EV-15).
|
||||
idle = wg is None and self._car_idle(mono)
|
||||
graded = self._car_explains_alarm(
|
||||
real_proj, guard, target_w,
|
||||
None if contra else 0.0 if idle else wg)
|
||||
if contra or idle or (w is not None and float(w) <= 0.0
|
||||
and not own):
|
||||
graded = False
|
||||
if self.car_cover:
|
||||
explains = over = graded
|
||||
elif w is not None:
|
||||
@@ -289,40 +398,52 @@ class CarMixin:
|
||||
|
||||
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
|
||||
"""EV-10: is the alarm's own test true with the car and false without
|
||||
its fresh, corroborated share (`car_exclude`), on the same landing? The
|
||||
its fresh, corroborated share (`car_exclude_alarm`), on the same landing? The
|
||||
tests are the alarms': a saturated guard and a floor with other
|
||||
batteries left are graded by `load_too_high` on where the period lands
|
||||
(SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's
|
||||
`misses_aim` (the batteries at 0 W from now on), latched for the
|
||||
quarter. That latch is kept here twice, on the period as it is
|
||||
(`_car_need_real`) and without the car (`_car_need_excl`), from the
|
||||
same `misses_aim` and the same batteries reading. Both reset at a new
|
||||
quarter and when the guard no longer wants power, whatever the cover
|
||||
option says (this runs every cycle). A car that is 0 W, or untrusted
|
||||
(`w` None sets the second latch), makes the two equal and explains
|
||||
nothing."""
|
||||
batt, prev = self.site_batt_w, self._car_batt_prev
|
||||
self._car_batt_prev = batt
|
||||
quarter (`_car_need_real`, and `_car_need_excl` without the car).
|
||||
EV-18 (owner 2026-11-19): without the car, the batteries keep giving
|
||||
what they give now (the lower of two readings), re-checked every cycle;
|
||||
a miss seen so (`_car_need_house`) never lets the car explain for the
|
||||
rest of the quarter. The car also explains where the period with it,
|
||||
on the same batteries, misses (`_car_over_now`). Only a trusted figure
|
||||
latches: an untrusted car (`w` None) or an unknown battery reading
|
||||
explains nothing in that cycle only. All reset at a new quarter and
|
||||
when the guard no longer wants power, whatever the cover option says
|
||||
(this runs every cycle). DECISIONS/EV-04-manual-mode.md (EV-18)."""
|
||||
now, prev = self.site_batt_w, self._car_batt_prev
|
||||
prev2, self._car_batt_prev2 = self._car_batt_prev2, prev
|
||||
self._car_batt_prev = now
|
||||
# EV-19: the reading can show a rise one cycle before the meter does
|
||||
# (the batteries pick up the house at the reserve), so a reading above
|
||||
# both earlier ones is not yet counted as house.
|
||||
seen = now
|
||||
if now is not None and prev is not None and prev2 is not None:
|
||||
seen = min(float(now), max(float(prev), float(prev2)))
|
||||
wants = bool(guard is not None and guard.engaged
|
||||
and guard.blind is None
|
||||
and (guard.wanted_w or 0.0) > 0.0)
|
||||
if real_proj.block_start != self._car_latch_block:
|
||||
if real_proj.block_start != self._car_latch_block or not wants:
|
||||
self._car_latch_block = real_proj.block_start
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
if not wants:
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
self._car_need_house = self._car_over_now = False
|
||||
batt = now
|
||||
if batt is not None and prev is not None:
|
||||
batt = min(float(batt), float(prev))
|
||||
excl = self.car_exclude(real_proj, w)
|
||||
if wants:
|
||||
if batt is None:
|
||||
self._car_need_real = self._car_need_excl = True
|
||||
else:
|
||||
self._car_need_real = self._car_need_real or \
|
||||
peakguard.misses_aim(real_proj, batt_w=batt,
|
||||
target_w=target_w)
|
||||
self._car_need_excl = self._car_need_excl or w is None or \
|
||||
excl = self.car_exclude_alarm(real_proj, w)
|
||||
if wants and batt is not None:
|
||||
self._car_need_real = self._car_need_real or \
|
||||
peakguard.misses_aim(real_proj, batt_w=batt,
|
||||
target_w=target_w)
|
||||
self._car_over_now = self._car_over_now or \
|
||||
self._car_lands_over(real_proj, now, batt, target_w)
|
||||
if w is not None:
|
||||
self._car_need_excl = self._car_need_excl or \
|
||||
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
|
||||
self._car_need_house = self._car_need_house or \
|
||||
self._car_lands_over(excl, seen, batt, target_w)
|
||||
if w is None or batt is None or not wants \
|
||||
or not (guard.saturated or guard.floor_limited):
|
||||
return False
|
||||
@@ -332,7 +453,8 @@ class CarMixin:
|
||||
rating = guard.able_w
|
||||
else:
|
||||
return bool(not guard.within_aim and self._car_need_real
|
||||
and not self._car_need_excl)
|
||||
and not self._car_need_house
|
||||
and (self._car_over_now or not self._car_need_excl))
|
||||
|
||||
def high(p):
|
||||
return peakguard.load_too_high(
|
||||
@@ -340,6 +462,16 @@ class CarMixin:
|
||||
achievable_w=rating)
|
||||
return bool(high(real_proj) and not high(excl))
|
||||
|
||||
@staticmethod
|
||||
def _car_lands_over(p, now, gives, target_w) -> bool:
|
||||
"""EV-18: does the period end more than `ALARM_MISS_W` over the aim
|
||||
with the batteries giving `gives` W from now on (`now`: what they gave
|
||||
in the meter's figure)? Of what is done, only the car's energy counted
|
||||
since the add-on started is the car's (a restart or a gap leaves the
|
||||
rest with the house)."""
|
||||
return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w,
|
||||
achievable_w=gives)
|
||||
|
||||
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."""
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
name: GoodWe RS485 Controller
|
||||
version: "0.23.0"
|
||||
version: "0.24.0"
|
||||
slug: goodwe_controller
|
||||
description: >-
|
||||
Drives a GoodWe ES/BP battery inverter over its RS485 EMS port by sending it a
|
||||
|
||||
@@ -0,0 +1,176 @@
|
||||
"""EV-10b: the period without the car is not clipped at 0 W (rig F-1 again).
|
||||
`python3 -B test_ev10b.py`
|
||||
|
||||
The rig shape: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
|
||||
give more than the house uses, so the house alone is an export; clipping it at
|
||||
0 W charged the car's battery share to the house, latched "the house needs the
|
||||
batteries" for the quarter, and the floor alarm fired once both batteries
|
||||
reached the reserve. Mutating a module this file grades? Read MUTATION.md first.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import dataclasses
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, peakguard, tariff # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
CAP = 6050.0 # aim 6000 W
|
||||
OPTS = {"inverters": [
|
||||
{"name": f"inverter-{u}", "setpoint_entity": f"number.sp_{u}",
|
||||
"soc_entity": f"sensor.soc_{u}", "batt_entity": f"sensor.batt_{u}",
|
||||
"max_w": 4050, "bms_soc_floor": 10} for u in "ab"]}
|
||||
|
||||
|
||||
def rig_run(house_w, soc_events, dur=895):
|
||||
"""A whole quarter from its start, N=2 (4.05 kW each = 8.1 kW), the car at
|
||||
11 kW; `soc_events` is {second: {"a": soc, "b": soc}}."""
|
||||
def setter(socs):
|
||||
return lambda plant, c: plant.socs.update(socs)
|
||||
return P.drive(s81.constant(house_w), dur=dur, rating=4050.0,
|
||||
soc={"a": 60.0, "b": 60.0}, cap=CAP, phases=3, n=2,
|
||||
plant_cls=P.CarPlantN, opts=OPTS, dev_w=4050.0,
|
||||
events={t: setter(s) for t, s in soc_events.items()})
|
||||
|
||||
|
||||
def summary(r):
|
||||
rows = r["c"].checks()
|
||||
red = [x["id"] for x in rows if x["ok"] is False and not x["warn"]]
|
||||
return (P.ids(r, *P.ALARMS), red, P.ids(r, P.OVER),
|
||||
max(abs(r["plant"].batt(t)) for t in range(0, 30)) if r else 0)
|
||||
|
||||
|
||||
print("1. THE RIG SHAPE, A WHOLE QUARTER (house 3 kW, car 11 kW, batteries 8.1 kW)")
|
||||
r = rig_run(3000.0, {30: {"a": 19.0, "b": 19.0}})
|
||||
al, red, over, _ = summary(r)
|
||||
peak_batt = max(r["plant"].batt(t) for t in range(5, 30))
|
||||
check("PRECONDITION: the batteries gave more than the house uses (8.1 kW "
|
||||
"against 3 kW) before the reserve", peak_batt > 7500.0)
|
||||
check("both batteries reach the reserve early in the quarter: no 'Battery "
|
||||
"stopped limiting the peak', no 'Load too high'", al == [])
|
||||
check("...no red row, and no goodwe_peak_soc_floor", red == [])
|
||||
check("...one car-over notice", len(over) == 1)
|
||||
check("...the car-over row is on at the end", any(
|
||||
x["id"] == "car_over" and x["ok"] is True for x in r["c"].checks()))
|
||||
|
||||
r2 = rig_run(3000.0, {30: {"a": 19.0}, 200: {"b": 19.0}})
|
||||
al2, red2, over2, _ = summary(r2)
|
||||
check("N=2, one battery reaches the reserve first, the other later: no "
|
||||
"alarm, no red row, one car-over notice",
|
||||
al2 == [] and red2 == [] and len(over2) == 1)
|
||||
|
||||
print("\n2. BATTERIES ABOVE THE HOUSE AND THE HOUSE ALONE OVER THE AIM")
|
||||
r3 = rig_run(7000.0, {30: {"a": 19.0, "b": 19.0}})
|
||||
check("house 7 kW, car 11 kW, aim 6 kW, batteries to the reserve: the alarm "
|
||||
"fires (the house alone misses the aim)", summary(r3)[0] != []
|
||||
and not r3["c"].car_explains)
|
||||
|
||||
|
||||
print("\n3. THE COUNTERFACTUAL ITSELF")
|
||||
BS = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self, cover=True):
|
||||
self.o = {"ev_batt_cover": cover}
|
||||
self._carq = {"key": BS, "ws": 0.0, "mono": 0.0}
|
||||
|
||||
|
||||
def proj(grid, elapsed, held=None):
|
||||
return tariff.Projection(
|
||||
projected_w=grid, elapsed_w=grid, elapsed_s=elapsed,
|
||||
covered_frac=1.0, complete=False, block_start=BS,
|
||||
held_w=grid if held is None else held)
|
||||
|
||||
|
||||
def lands(p, batt, aim=5950.0):
|
||||
return peakguard.misses_aim(p, batt_w=batt, target_w=aim)
|
||||
|
||||
|
||||
c = _Car()
|
||||
for el in (10.0, 30.0, 120.0, 300.0, 600.0):
|
||||
c._carq["ws"] = 11040.0 * el
|
||||
p = proj(3000 + 11040 - 8100, el)
|
||||
x = c.car_exclude_alarm(p, 11040.0)
|
||||
check(f"rig numbers at {el:.0f} s: the house alone does not miss the aim "
|
||||
"(no 0 W clip)", not lands(x, 8100.0))
|
||||
check(f"...and the guard-side `car_exclude` is unchanged (still clipped)",
|
||||
c.car_exclude(p, 11040.0).held_w == 0.0)
|
||||
c._carq["ws"] = 11040.0 * 30
|
||||
x = c.car_exclude_alarm(proj(5940.0, 30.0), 11040.0)
|
||||
check("the rest of the period keeps its sign: held = grid - car = -5100 W",
|
||||
abs(x.held_w - (5940.0 - 11040.0)) < 1e-6)
|
||||
check("a fresh car reading is needed: None gives the period back as it is",
|
||||
c.car_exclude_alarm(proj(5940.0, 30.0), None).held_w == 5940.0)
|
||||
# the house alone over the aim still misses
|
||||
c._carq["ws"] = 11040.0 * 30
|
||||
check("house 7 kW alone (batteries 8.1 kW, car 11 kW): the house misses the aim",
|
||||
lands(c.car_exclude_alarm(proj(7000 + 11040 - 8100, 30.0), 11040.0),
|
||||
8100.0))
|
||||
# review: the done part is clipped at 0 Ws. Rig shape for 400 s (grid 5940 W),
|
||||
# then the batteries at the reserve and the house at 12 kW: the house alone
|
||||
# lands 6667 W. Crediting the car-made export (-5100 W x 400 s) would hide it.
|
||||
c._carq["ws"] = 11040.0 * 400
|
||||
held = 12000.0 + 11040.0
|
||||
check("the car's battery share earlier is not credited against a later house "
|
||||
"overload (done part clipped at 0 Ws)",
|
||||
lands(c.car_exclude_alarm(
|
||||
proj((5940.0 * 400 + held * 500) / 900, 400.0, held), 11040.0), 0.0))
|
||||
# review: the rest of the period takes off the car's power NOW, not its
|
||||
# quarter average. Car 11 kW for 500 s, then 1.4 kW; house 7 kW, no batteries.
|
||||
c._carq["ws"] = 11040.0 * 500 + 1380.0 * 100
|
||||
held = 7000.0 + 1380.0
|
||||
check("a car turned down mid-quarter: the rest takes off its power now, so "
|
||||
"the house alone (7 kW) still misses the aim",
|
||||
lands(c.car_exclude_alarm(
|
||||
proj(((7000 + 11040) * 500 + held * 100 + held * 300) / 900, 600.0,
|
||||
held), 1380.0), 0.0))
|
||||
# with the batteries giving less than the house the two agree where the old
|
||||
# clip did not bite
|
||||
p = proj(3000 + 3700 - 300, 300.0)
|
||||
c._carq["ws"] = 3700.0 * 300.0
|
||||
old, new = c.car_exclude(p, 3700.0), c.car_exclude_alarm(p, 3700.0)
|
||||
check("batteries under the house: the same landing as before (no clip bit)",
|
||||
abs(old.projected_w - new.projected_w) < 1e-6
|
||||
and abs(old.held_w - new.held_w) < 1e-6)
|
||||
|
||||
# cover OFF: the projection the guard sees is `car_exclude`, bit for bit what
|
||||
# b86c015 built (a frozen copy of its formula), over a grid of periods
|
||||
def frozen(c, p, w):
|
||||
avg = c.car_avg_w(p, w)
|
||||
return (max(0.0, float(p.projected_w) - avg),
|
||||
max(0.0, float(p.held_w) - float(w)))
|
||||
|
||||
|
||||
same = True
|
||||
for grid in (-3000.0, 0.0, 800.0, 5900.0, 14000.0):
|
||||
for held in (-4000.0, 0.0, 6000.0, 15000.0):
|
||||
for el in (0.0, 30.0, 450.0, 899.0):
|
||||
for w in (1380.0, 3700.0, 11040.0):
|
||||
c._carq["ws"] = w * el * 0.9
|
||||
p = proj(grid, el, held)
|
||||
x = c.car_exclude(p, w)
|
||||
same = same and (x.projected_w, x.held_w) == frozen(c, p, w)
|
||||
check("cover off: the projection the guard sees (`car_exclude`) is bit for "
|
||||
"bit the old formula over 240 periods", same)
|
||||
check("...and `car_exclude` still hands back the period when the car figure "
|
||||
"is None", c.car_exclude(proj(5000.0, 30.0), None).projected_w == 5000.0)
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,344 @@
|
||||
"""EV-15: the add-on's own phase change at the peak reserve raises no alarm.
|
||||
`python3 -B test_ev15.py`
|
||||
|
||||
The rig (EV-10 and EV-10b, F-2): cover on, the batteries at the reserve, the car
|
||||
charging and explaining the excess. The add-on's own 3 -> 1 phase switch sets
|
||||
the car to 0 A; with the car not charging its figure is no longer corroborated
|
||||
(`CarTracker.corroborated`), so `car_alarm_w()` is None, nothing is explained,
|
||||
and PEAK_GUARD_FLOOR_LIMITED plus `goodwe_peak_soc_floor` fire. The rule: for
|
||||
the add-on's own sequence only (`ctl_car._car_own_pause`, bounded) the car's
|
||||
fresh, not stuck figure stands in for grading.
|
||||
|
||||
1. The rig shapes end to end through the car cycle: 3 -> 1 and 1 -> 3.
|
||||
2. A house overload that starts during the sequence still alarms, as on Off.
|
||||
3. Aborted (Off, Stop, unplug), refused, an outside writer: no grace.
|
||||
4. The bounds, and the figure that stands in (stale, stuck: nothing).
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, carmode, chargers as CH # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
logging.disable(logging.CRITICAL)
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
def at(t, fn):
|
||||
return {"t": t, "fn": fn}
|
||||
|
||||
|
||||
def beside(plant, c):
|
||||
"""The writer runs BESIDE the cycle, as in production (`car_kick`): its 1 s
|
||||
poll for the read-back lands after the cycle's own read, and the cycle does
|
||||
not wait for the writer (`ev04_peak.drive` does)."""
|
||||
gate = asyncio.Event()
|
||||
|
||||
async def sleep(_s):
|
||||
gate.clear()
|
||||
await gate.wait()
|
||||
|
||||
async def settle():
|
||||
gate.set()
|
||||
for _ in range(5):
|
||||
await asyncio.sleep(0)
|
||||
c.charger._sleep = sleep
|
||||
c.car_settle = settle
|
||||
|
||||
|
||||
def run(house, cap, t_res, t_sw, new, *, extra=None, mode="manual",
|
||||
sim_fn=None, dur=895, plug=True, side=False):
|
||||
"""Reserve at `t_res`, our phase change to `new` at `t_sw`. Returns the
|
||||
run, a per-second trace (second, own-pause, explains, red rows) and the
|
||||
alarms."""
|
||||
tr = []
|
||||
|
||||
def note(plant, c):
|
||||
red = [x["id"] for x in c.checks()
|
||||
if x["ok"] is False and not x["warn"]] \
|
||||
if t_sw - 5 <= plant.t <= t_sw + 90 else []
|
||||
g = c.peak_guard
|
||||
lim = bool(g is not None and (g.floor_limited or g.saturated))
|
||||
tr.append((plant.t, getattr(c, "_car_own_pause", lambda _t: False)(c.car_now()), c.car_explains,
|
||||
red, plant.ch.power_w, plant.ch.state, lim))
|
||||
|
||||
def reserve(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda t: house + plant.ch.power_w
|
||||
|
||||
def switch(plant, c):
|
||||
asyncio.get_event_loop().create_task(
|
||||
c.handle_action("car_phases", value=new))
|
||||
|
||||
ev = {t: note for t in range(0, dur)}
|
||||
ev[t_res] = lambda p, c: (reserve(p, c), note(p, c))
|
||||
ev[t_sw] = lambda p, c: (switch(p, c), note(p, c))
|
||||
if side:
|
||||
ev[t_sw - 2] = lambda p, c: (beside(p, c), note(p, c))
|
||||
for t, fn in (extra or {}).items():
|
||||
prev = ev.get(t, note)
|
||||
ev[t] = (lambda p, c, prev=prev, fn=fn: (fn(p, c), prev(p, c)))
|
||||
sim = None
|
||||
if sim_fn is not None or side:
|
||||
from chargersim import SimCharger
|
||||
sim = SimCharger(setpoint_a=16)
|
||||
sim_fn = sim_fn or (lambda s: None)
|
||||
sim_fn(sim)
|
||||
r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0,
|
||||
cap=cap, phases=(3 if new == 1 else 1), user_a=16, setpoint=16,
|
||||
mode=mode, events=ev, sim=sim, plug=plug)
|
||||
return r, tr, P.ids(r, *P.ALARMS)
|
||||
|
||||
|
||||
def reds(tr):
|
||||
return [x for x in tr if x[3]]
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. THE RIG SHAPES THROUGH THE CAR CYCLE")
|
||||
# =========================================================================== #
|
||||
SHAPES = (
|
||||
("EV-10 shape: house 3 kW, car 11 kW, aim 6 kW, 3 -> 1",
|
||||
3000.0, 6050.0, 300, 600, 1),
|
||||
("EV-10b shape: a 9411 W limit, 3 -> 1", 2000.0, 9461.0, 300, 600, 1),
|
||||
("1 -> 3 (the car 3.7 kW, then 11 kW), aim 5 kW", 2500.0, 5050.0,
|
||||
100, 600, 3),
|
||||
)
|
||||
for name, house, cap, t_res, t_sw, new in SHAPES:
|
||||
r, tr, al = run(house, cap, t_res, t_sw, new)
|
||||
c, sim = r["c"], r["sim"]
|
||||
sw = [x for x in sim.writes() if x[1] == "phases"]
|
||||
check(f"{name}: the car at the reserve covers, and the add-on's own "
|
||||
f"sequence ran (0 A, select, the current back)",
|
||||
len(sw) == 1 and [x[2] for x in sim.writes("current")][-2:]
|
||||
== [0.0, 16.0] and sim.phases_allowed == new)
|
||||
pause = [x for x in tr if x[1]]
|
||||
check(f"{name}: the own-pause grace was on during it, and ended",
|
||||
len(pause) >= 10 and not any(x[1] for x in tr[-1:])
|
||||
and (pause[-1][0] - pause[0][0])
|
||||
<= getattr(ctl_car, "OWN_PAUSE_MAX_S", 0)
|
||||
+ getattr(ctl_car, "OWN_PAUSE_TAIL_S", 0))
|
||||
check(f"{name}: no PEAK_GUARD_FLOOR_LIMITED / saturated, no "
|
||||
f"goodwe_peak_soc_floor notification", al == [])
|
||||
check(f"{name}: no red row in any sample around the switch",
|
||||
reds(tr) == [])
|
||||
limited = [x for x in tr if x[1] and x[6]]
|
||||
check(f"{name}: in every cycle of the sequence in which the guard is "
|
||||
f"limited (the cycle of the rig's alarm among them) the car "
|
||||
f"explains it", len(limited) >= 1 and all(x[2] for x in limited)
|
||||
and any(x[2] for x in tr if x[0] == t_sw + 1))
|
||||
check(f"{name}: and in every limited cycle after it, to the quarter's end",
|
||||
all(x[2] for x in tr if x[0] >= t_sw and x[6]))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. A HOUSE OVERLOAD DURING THE SEQUENCE STILL ALARMS")
|
||||
# =========================================================================== #
|
||||
def overload(plant, c):
|
||||
plant.load = lambda t: 25000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload})
|
||||
ro, tro, alo = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload},
|
||||
mode="off", plug=False)
|
||||
rn, trn, aln = run(3000.0, 6050.0, 300, 900, 1, extra={606: overload})
|
||||
check("PRECONDITION: on Off (no car) the same load alarms, and in Manual "
|
||||
"with no phase change", alo != [] and aln != [])
|
||||
check("a 25 kW house overload that starts 6 s into the sequence (the car "
|
||||
"paused): the alarm fires", al != [])
|
||||
print(f" alarm seconds: in the sequence {[t for t, _ in al]}, Off without "
|
||||
f"the car {[t for t, _ in alo]}, Manual with no phase change "
|
||||
f"{[t for t, _ in aln]}")
|
||||
check("...at the same second as on Off and as in Manual with no phase change",
|
||||
bool(al) and bool(alo) and bool(aln)
|
||||
and al[0][0] == alo[0][0] == aln[0][0])
|
||||
check("...and the car does not explain it (during the sequence too)",
|
||||
not any(x[2] for x in tr if 640 <= x[0] <= 660))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n3. ABORTED, REFUSED, OUTSIDE: NO GRACE AFTER IT")
|
||||
# =========================================================================== #
|
||||
def hit(res, t0, secs):
|
||||
return [x for x in res if t0 <= x[0] <= t0 + secs and x[1]]
|
||||
|
||||
|
||||
def off_now(plant, c):
|
||||
asyncio.get_event_loop().create_task(c.handle_action("car_mode",
|
||||
value="off"))
|
||||
|
||||
|
||||
def stop_now(plant, c):
|
||||
c.auto = False
|
||||
|
||||
|
||||
def unplug(plant, c):
|
||||
plant.ch.unplug()
|
||||
|
||||
|
||||
slow = lambda s: setattr(s, "stop_delay_s", 8.0) # noqa: E731
|
||||
for what, fn in (("Off", off_now), ("Stop", stop_now), ("unplug", unplug)):
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={602: fn},
|
||||
sim_fn=slow)
|
||||
check(f"{what} 2 s into the sequence: the grace is off from the next "
|
||||
f"cycle on", not hit(tr, 604, 200)
|
||||
and any(x[1] for x in tr if 600 <= x[0] <= 602))
|
||||
|
||||
def refuse_phases(sim):
|
||||
sim.request_phases = lambda n: False
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, sim_fn=refuse_phases)
|
||||
check("the select is refused: the grace ends at once (no cycle of it after "
|
||||
"the refusal), the current comes back",
|
||||
len([x for x in r["sim"].writes("current")]) >= 2
|
||||
and not hit(tr, 606, 200))
|
||||
|
||||
def outside_zero(plant, c):
|
||||
plant.ch.set_current(0.0)
|
||||
|
||||
|
||||
r2, tr2, al2 = run(3000.0, 6050.0, 300, 900, 1, extra={602: outside_zero})
|
||||
check("an outside writer's 0 A: no grace, and the normal grading (no car "
|
||||
"power: nothing explained) raises the alarm as before",
|
||||
not any(x[1] for x in tr2) and not any(x[2] for x in tr2
|
||||
if 610 <= x[0] <= 700)
|
||||
and al2 != [])
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n4. THE BOUNDS AND THE FIGURE THAT STANDS IN")
|
||||
# =========================================================================== #
|
||||
class _C(ctl_car.CarMixin):
|
||||
"""The mixin with just what `_car_own_pause` reads."""
|
||||
def __init__(self):
|
||||
self.o = {}
|
||||
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
self.car_mode = carmode.MANUAL
|
||||
self.auto, self.shadow = True, False
|
||||
self.inverters, self.site_sign_wd = [], type("W", (), {"tripped": False})()
|
||||
self.circ_wd = type("W", (), {"tripped": False})()
|
||||
self.charger = type("H", (), {"configured": lambda s: True})()
|
||||
self.car = CH.CarTracker()
|
||||
self.car.reading = CH.ChargerReading(available=True, state="B")
|
||||
|
||||
|
||||
c = _C()
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "n": 1, "tries": 0,
|
||||
"prev": 16.0}
|
||||
M = ctl_car.OWN_PAUSE_MAX_S
|
||||
check("bound: the sequence's own maximum is its waits (0 A wait, settle, "
|
||||
"three tries at 15 s, the select) and no more",
|
||||
M == carmode.ZERO_WAIT_S + carmode.SETTLE_S + carmode.MAX_TRIES * 15.0
|
||||
+ 10.0 and ctl_car.OWN_PAUSE_TAIL_S == CH.CORR_WINDOW_S)
|
||||
check("bound: on at the 0 A write and up to the maximum",
|
||||
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M))
|
||||
check("bound: off one second past it", not c._car_own_pause(101.0 + M))
|
||||
c.car_writer.seq = None
|
||||
c.car_writer.phase_done_at = 200.0
|
||||
T = ctl_car.OWN_PAUSE_TAIL_S
|
||||
check("bound: after the current is set again it lasts one corroboration "
|
||||
"window", c._car_own_pause(200.0 + T) and not c._car_own_pause(201.0 + T))
|
||||
c.car_writer.phase_done_at = None
|
||||
check("no sequence and none just done: no grace", not c._car_own_pause(100.0))
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "failed": True}
|
||||
check("a refused write marks the sequence: no grace", not c._car_own_pause(110.0))
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
|
||||
c.car_mode = carmode.OFF
|
||||
check("Off: no grace", not c._car_own_pause(110.0))
|
||||
c.car_mode, c.shadow = carmode.MANUAL, True
|
||||
check("shadow mode: no grace", not c._car_own_pause(110.0))
|
||||
c.shadow, c.auto = False, False
|
||||
check("control stopped: no grace", not c._car_own_pause(110.0))
|
||||
c.auto = True
|
||||
c.car_writer.hold = True
|
||||
check("another writer (hold): no grace", not c._car_own_pause(110.0))
|
||||
c.car_writer.hold = False
|
||||
c.car_writer.seq, c.car_writer.zero_sent_at = None, 100.0
|
||||
check("0 A sent, not yet back: grace from the send, to the maximum, no more",
|
||||
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M)
|
||||
and not c._car_own_pause(101.0 + M))
|
||||
c.car_writer.zero_sent_at = None
|
||||
c.car_writer.phase_done_at = 200.0
|
||||
c.car_writer.hold = True
|
||||
check("another writer in the 60 s after the current is set: no grace",
|
||||
not c._car_own_pause(210.0))
|
||||
c.car_writer.hold, c.car_writer.phase_done_at = False, None
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
|
||||
c.car.reading = CH.ChargerReading(available=True, state="A")
|
||||
check("unplugged: no grace", not c._car_own_pause(110.0))
|
||||
c.car.reading = CH.ChargerReading(available=True, state="B")
|
||||
check("PRECONDITION: the same state is on", c._car_own_pause(110.0))
|
||||
|
||||
tk = CH.CarTracker()
|
||||
tk.reading = CH.ChargerReading(available=True, state="B", power_w=500.0,
|
||||
allowed_a=16.0, phases_allowed=1)
|
||||
tk.last_ok = 0.0
|
||||
check("the stand-in figure is the fresh reading, capped by the read-back",
|
||||
tk.car_w_paused(5.0) == 500.0 and tk.car_w_trusted(5.0) is None)
|
||||
check("a stale reading stands in for nothing", tk.car_w_paused(100.0) is None)
|
||||
tk.stuck_now = True
|
||||
check("a stuck reading stands in for nothing", tk.car_w_paused(5.0) is None)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n5. THE WRITER RUNS BESIDE THE CYCLE (review F-1)")
|
||||
# =========================================================================== #
|
||||
# The car stops (state B) in the same Home Assistant update as the 0 A
|
||||
# read-back; the write has not returned yet, so no sequence exists. The window
|
||||
# opens when the write is SENT (`ManualWriter.zero_sent_at`).
|
||||
def lagged(lag, delay):
|
||||
def f(s):
|
||||
s.lag_s, s.stop_delay_s = lag, delay
|
||||
return f
|
||||
|
||||
|
||||
for lag, delay in ((2, 0), (0, 0), (2, 3), (5, 2)):
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
|
||||
sim_fn=lagged(lag, delay))
|
||||
nm = f"beside the cycle, lag {lag} s, stop delay {delay} s"
|
||||
limited = [x for x in tr if x[0] >= 600 and x[6]]
|
||||
check(f"{nm}: our sequence ran (select once, then 16 A again)",
|
||||
len([x for x in r["sim"].writes("phases")]) == 1
|
||||
and r["sim"].phases_allowed == 1
|
||||
and [x[2] for x in r["sim"].writes("current")][-2:] == [0.0, 16.0])
|
||||
check(f"{nm}: no PEAK_GUARD_FLOOR_LIMITED, no goodwe_peak_soc_floor",
|
||||
al == [])
|
||||
check(f"{nm}: no red row, and the car explains every limited cycle",
|
||||
reds(tr) == [] and all(x[2] for x in limited))
|
||||
|
||||
|
||||
def not_taken(plant, c):
|
||||
plant.ch.refuse = "ignore" # HA accepts, the charger does nothing
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
|
||||
sim_fn=lagged(0, 0), extra={600: not_taken})
|
||||
check("the 0 A write is not taken (read-back never follows): the window was "
|
||||
"open while it waited", any(x[1] for x in tr if 600 <= x[0] <= 606))
|
||||
own = [x[0] for x in tr if x[1]]
|
||||
runs = 1 + len([1 for a, b in zip(own, own[1:]) if b - a > 1])
|
||||
check("...and no grace after the refusal (the retry, RETRY_S later, opens it "
|
||||
"again only while that write waits: at most 3 runs of 11 s), no "
|
||||
"sequence made", not hit(tr, 613, 40) and r["c"].car_writer.seq is None
|
||||
and 1 <= runs <= 3 and len(own) <= 3 * 11)
|
||||
check("...the car went on charging and nothing was written but the 0 A",
|
||||
r["sim"].power_w > 5000.0 and not r["sim"].writes("phases"))
|
||||
|
||||
print()
|
||||
if fails:
|
||||
print(f"FAIL: {len(fails)} check(s)")
|
||||
for f in fails:
|
||||
print(" -", f)
|
||||
sys.exit(1)
|
||||
print("ok: EV-15")
|
||||
@@ -0,0 +1,832 @@
|
||||
"""EV-18: no floor alarm at a quarter's start while the car explains the excess
|
||||
(EV-15 rig F-A). `python3 -B test_ev18.py`
|
||||
|
||||
The rig: both batteries at the peak reserve, the car charging, and
|
||||
PEAK_GUARD_FLOOR_LIMITED + `goodwe_peak_soc_floor` at a quarter's start, red
|
||||
for most of the quarter, while the grid excess was smaller than the car. Two
|
||||
causes, both latched for the quarter by `_car_need_excl`:
|
||||
C1 one cycle with no trusted car figure set the latch (T1);
|
||||
C2 "without the car" assumed the batteries give 0 W from now on, so what
|
||||
the loop still gives below the reserve counted as house (T2).
|
||||
The rule now (owner 2026-11-19, Q1-Q3): without the car the batteries keep
|
||||
giving what they give now (the lower of the last two readings, re-checked
|
||||
every cycle); a house need seen with a trusted car figure stays latched to the
|
||||
quarter's end; an unknown car figure keeps the alarm only while it is unknown.
|
||||
|
||||
T-ids are the test plan's (reports/EV-18-test-plan.md). "base" is 9fdce02.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import chargers as CH, ctl_car, tariff # noqa: E402
|
||||
from chargersim import SimCharger # noqa: E402
|
||||
from named_absence import first, nth, present # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import ev18_peak as H # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
AIM = H.AIM
|
||||
CAR = 1380.0
|
||||
E = H.E
|
||||
# Measured on base 9fdce02 with this file's own runs: the seconds of
|
||||
# goodwe_peak_soc_floor in the honest shapes, which must not come later now. An
|
||||
# honest shape steps the house at E, and the meter shows it at E+1.
|
||||
T5_BASE = [E + 1] # also T6 (T5 shape), T8, T9(a), T10(b) T5
|
||||
T7_BASE = E + 72
|
||||
T9B_BASE = [] # 400 W real: never uncorroborated (Findings)
|
||||
T9C_BASE = E + 1 # 100 W real: never trusted at the edge
|
||||
T10A_T5_BASE = [E + 2] # the guard disengages at E+1 (no battery reading)
|
||||
T11_BASE = [E + 13] # SAFETY-87: ALARM_HOLD_S after the step
|
||||
T13_BASE = [E + 301]
|
||||
T15_T5_BASE = [E + 10] # x10: one cycle
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. UNIT: car_cycle ACROSS A QUARTER EDGE (a real `_carq`, not preset)")
|
||||
# =========================================================================== #
|
||||
BS = datetime(2026, 11, 17, 21, 15, tzinfo=timezone.utc) # the edge E
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self):
|
||||
self.o = {"ev_batt_cover": True}
|
||||
self.w = CAR
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
|
||||
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
|
||||
self.car_init({}, self.store)
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
class car: # noqa: N801
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class _G:
|
||||
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
|
||||
def __init__(self, wants=True, within_aim=False):
|
||||
self.floor_limited, self.saturated = True, False
|
||||
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, AIM + 50.0
|
||||
self.engaged, self.blind = True, None
|
||||
self.wanted_w = 300.0 if wants else 0.0
|
||||
self.within_aim = within_aim
|
||||
|
||||
|
||||
def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None):
|
||||
"""`car_cycle` once per entry of `secs` (seconds from the edge E, `x` fake
|
||||
seconds apart). `grid(t)` is the meter (house + car - batteries),
|
||||
`batt(t)` the site battery reading, `w(t)` the trusted car figure. Returns
|
||||
(car, {t: car_explains})."""
|
||||
c = c or _Car()
|
||||
mono_x = x if mono_x is None else mono_x
|
||||
done, out = {}, {}
|
||||
t0 = nth(list(secs), 0)
|
||||
if c._carq["key"] is None and present(t0) and t0 % 900:
|
||||
# started mid-quarter: the car was counted since its start (no restart)
|
||||
c._carq.update(key=BS + timedelta(seconds=900 * (t0 // 900)),
|
||||
ws=float(w(t0) or 0.0) * (t0 % 900), ws_p=0.0)
|
||||
for t in secs:
|
||||
q = t // 900
|
||||
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
|
||||
g = float(grid(t))
|
||||
d = done.get(bs, g * el)
|
||||
p = tariff.Projection(
|
||||
projected_w=(d + g * (900 - el)) / 900.0,
|
||||
elapsed_w=(d / el if el else g), elapsed_s=float(el),
|
||||
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
|
||||
done[bs] = d + g * x
|
||||
c._now = 10000.0 + t * mono_x / x
|
||||
c.w, c.site_batt_w = w(t), batt(t)
|
||||
c.car_cycle(p, guard(t) if guard else _G(), AIM, None)
|
||||
out[t] = c.car_explains
|
||||
return c, out
|
||||
|
||||
|
||||
def const(v):
|
||||
return lambda t: v
|
||||
|
||||
|
||||
def run_of(d, t0, t1):
|
||||
return [d[t] for t in sorted(d) if t0 <= t <= t1]
|
||||
|
||||
|
||||
# --- T1: the car figure untrusted for the edge's first cycles --------------- #
|
||||
def t1(x=1, mono_x=None):
|
||||
_c, ex = urun(range(-30, 121, x), const(13000.0 + CAR), const(0.0),
|
||||
lambda t: None if 0 <= t <= 2 * x else CAR, x=x,
|
||||
mono_x=mono_x)
|
||||
return ex
|
||||
|
||||
|
||||
ex = t1()
|
||||
print(f" T1 explains E-1..E+5: {run_of(ex, -1, 5)}")
|
||||
check("T1 PRECONDITION: before the edge the car (trusted) explains the "
|
||||
"excess (house 13 000 W, car 1 380 W, grid 14 380 W)",
|
||||
all(run_of(ex, -30, -1)) and len(run_of(ex, -30, -1)) == 30)
|
||||
check("T1 (Expected 5): while the car figure is unknown (E+0..E+2) it "
|
||||
"explains nothing, so the alarm stands", not any(run_of(ex, 0, 2)))
|
||||
_c1b, ex1b = urun(range(-30, 121), const(12500.0 + CAR - 800.0), const(800.0),
|
||||
lambda t: None if 0 <= t <= 2 else CAR)
|
||||
check("T1b (the EV-10 path: the grid lands under the aim, the batteries at "
|
||||
"0 W would miss; house 12 500 W, b 800 W): unknown E+0..E+2, released "
|
||||
"at E+3 and explained to E+120",
|
||||
not any(run_of(ex1b, 0, 2)) and all(run_of(ex1b, 3, 120))
|
||||
and len(run_of(ex1b, 3, 120)) == 118)
|
||||
check("T1 (Expected 3): released at the first trusted cycle (E+3) and "
|
||||
"explained to E+120 (base: latched False to E+120)",
|
||||
all(run_of(ex, 3, 120)) and len(run_of(ex, 3, 120)) == 118)
|
||||
|
||||
# --- T2c: the battery W boundary, graded on the lower of two readings ------- #
|
||||
def t2c(b_of):
|
||||
_c, ex = urun(range(0, 6), lambda t: 14000.0 + CAR - b_of(t), b_of,
|
||||
const(CAR))
|
||||
return run_of(ex, 0, 5)
|
||||
|
||||
|
||||
e391, e389 = t2c(const(391.0)), t2c(const(389.0))
|
||||
e395 = t2c(lambda t: 395.0 if t == 0 else 385.0)
|
||||
print(f" T2c 391 W {e391}, 389 W {e389}, 395 then 385 W {e395}")
|
||||
check("T2c: b steady at 391 W (house alone with the real batteries lands "
|
||||
"13 609 W, aim + 9 W): the car explains from E+0", all(e391)
|
||||
and len(e391) == 6)
|
||||
check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0",
|
||||
not any(e389) and len(e389) == 6)
|
||||
check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from "
|
||||
"the second cycle on", not any(e395[1:]) and len(e395) == 6)
|
||||
# review round 1 (MD): the meter shows the higher output while the readings
|
||||
# are 389 W then 800 W. b gives 800 W; one reading of 389 W at E+3, the meter
|
||||
# still at 800 W. House 14 005 W: at E+4 the house latch grades on the lower
|
||||
# reading (389 W), rest 13 616 W, landing 13 614 W > aim + 10 W; on the
|
||||
# current one (800 W) it would be 13 205 W.
|
||||
_cl, elag = urun(range(0, 12), const(14005.0 + CAR - 800.0),
|
||||
lambda t: 389.0 if t == 3 else 800.0, const(CAR))
|
||||
print(f" T2c lagging meter E+0..E+11: {run_of(elag, 0, 11)}")
|
||||
check("T2c (meter lags, readings 389 then 800 W): explained before, the "
|
||||
"house latch sets on the lower reading at E+4 and holds to E+11",
|
||||
all(run_of(elag, 0, 3)) and not any(run_of(elag, 4, 11))
|
||||
and len(run_of(elag, 4, 11)) == 8)
|
||||
|
||||
# --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- #
|
||||
e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0),
|
||||
const(CAR))[1], 0, 5)
|
||||
e11 = run_of(urun(range(0, 6), const(13611.0 + CAR), const(0.0),
|
||||
const(CAR))[1], 0, 5)
|
||||
check("T4 unit: the house alone at aim + 9 W: the car explains from E+0; at "
|
||||
"aim + 11 W it does not", all(e09) and len(e09) == 6 and not any(e11))
|
||||
|
||||
# --- T8 / N2: 0 W and tiny cars ---------------------------------------------- #
|
||||
e0 = run_of(urun(range(-5, 30), const(14000.0 - 800.0), const(800.0),
|
||||
const(0.0))[1], -5, 29)
|
||||
e50 = run_of(urun(range(-5, 30), const(14090.0 + 50.0), const(0.0),
|
||||
const(50.0))[1], -5, 29)
|
||||
check("T8 unit: a 0 W car never explains, whatever the batteries give (T2 "
|
||||
"shape, b 800 W)", not any(e0) and len(e0) == 35)
|
||||
check("T8 unit: a 50 W car with the house at 14 090 W never explains",
|
||||
not any(e50) and len(e50) == 35)
|
||||
# N2: a car that drew 11 kW earlier in the quarter and now reports 0 W
|
||||
c0, ex0 = urun(range(0, 400), lambda t: 2600.0 + (11040.0 if t < 300 else 0.0),
|
||||
const(0.0), lambda t: 11040.0 if t < 300 else 0.0)
|
||||
check("N2: a trusted 0 W figure explains nothing, also after the car drew "
|
||||
"earlier in the quarter", not any(run_of(ex0, 300, 399)))
|
||||
|
||||
# --- T8 unit: a car known to draw nothing is not an unknown car ------------- #
|
||||
class _Tracker:
|
||||
"""The two things `_car_idle` reads: the reading, and its fresh power."""
|
||||
def __init__(self, available):
|
||||
self.reading = CH.ChargerReading(available=available, state="B",
|
||||
charging=False, power_w=0.0)
|
||||
|
||||
def car_w(self, _now):
|
||||
return 0.0 if self.reading.available else None
|
||||
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
def idle_then_charging(available):
|
||||
c = _Car()
|
||||
c.car = _Tracker(available)
|
||||
_c, ex = urun(range(0, 900),
|
||||
lambda t: 14090.0 if t < 60 else 13000.0 + CAR, const(0.0),
|
||||
lambda t: None if t < 60 else CAR, c=c)
|
||||
return ex
|
||||
|
||||
|
||||
exi, exu = idle_then_charging(True), idle_then_charging(False)
|
||||
check("T8 unit: a car known idle (mode3 B, 0 W, fresh) while the house alone "
|
||||
"misses (14 090 W): that house need is latched, so the car charging "
|
||||
"from E+60 does not explain the quarter (test_ev10's `swapped` case)",
|
||||
not any(run_of(exi, 0, 899)))
|
||||
check("T8 unit: the same with the charger unavailable (unknown car): the "
|
||||
"alarm stands while unknown and is released at E+60 (Expected 5)",
|
||||
not any(run_of(exu, 0, 59)) and all(run_of(exu, 60, 899)))
|
||||
|
||||
# --- the contradiction latch (owner 2026-11-19), unit ----------------------- #
|
||||
class _TrackerC:
|
||||
"""A charging car whose energy meter contradicts it when `contra(t)`."""
|
||||
def __init__(self, contra):
|
||||
self.contra = contra
|
||||
self.reading = CH.ChargerReading(available=True, state="C",
|
||||
charging=True, power_w=CAR)
|
||||
|
||||
def car_w(self, _now):
|
||||
return CAR
|
||||
|
||||
def stuck(self, _now):
|
||||
return False
|
||||
|
||||
def contradicted(self, now):
|
||||
return self.contra(now - 10000.0)
|
||||
|
||||
def car_w_paused(self, _now):
|
||||
return CAR
|
||||
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class _CarC(_Car):
|
||||
def __init__(self, contra, own):
|
||||
super().__init__()
|
||||
self.car, self.own = _TrackerC(contra), own
|
||||
|
||||
def car_manual(self):
|
||||
return True
|
||||
|
||||
def _car_own_pause(self, mono):
|
||||
return self.own(mono - 10000.0)
|
||||
|
||||
|
||||
def contra_run(contra, own, secs):
|
||||
c = _CarC(contra, own)
|
||||
_c, ex = urun(secs, const(13000.0 + CAR), const(0.0),
|
||||
lambda t: None if contra(t) or own(t) else CAR, c=c)
|
||||
return ex
|
||||
|
||||
|
||||
never = lambda t: False # noqa: E731
|
||||
exg = contra_run(lambda t: 300 <= t < 306, never, range(0, 1100))
|
||||
check("contradiction (T3 shape): the meter contradicts the figure at E+300: "
|
||||
"not explained from E+300 to the quarter's end, though trusted again "
|
||||
"from E+306", all(run_of(exg, 0, 299)) and not any(run_of(exg, 300, 899))
|
||||
and len(run_of(exg, 300, 899)) == 600)
|
||||
check("contradiction: released by the next quarter (review MG): explained "
|
||||
"again from E+900", all(run_of(exg, 900, 1099))
|
||||
and len(run_of(exg, 900, 1099)) == 200)
|
||||
exf = contra_run(lambda t: 100 <= t < 130, lambda t: 100 <= t < 130,
|
||||
range(0, 400))
|
||||
check("contradiction during our own pause (EV-15) latches nothing (review "
|
||||
"MF): the stand-in explains in it, the trusted figure after it",
|
||||
all(run_of(exf, 0, 399)) and len(run_of(exf, 0, 399)) == 400)
|
||||
|
||||
# --- T10(a) unit: the battery reading lost for one cycle --------------------- #
|
||||
cA, eA = urun(range(-3, 10), const(14000.0 + CAR - 800.0),
|
||||
lambda t: None if t == 1 else 800.0, const(CAR))
|
||||
check("T10(a) unit, T2 shape: the cycle with no battery reading explains "
|
||||
"nothing (no last-known W credited); the next ones do",
|
||||
eA.get(1) is False and eA.get(0) is True and all(run_of(eA, 2, 9))
|
||||
and len(run_of(eA, 2, 9)) == 8)
|
||||
|
||||
# --- T13 unit: a house need seen with a trusted car stays latched ----------- #
|
||||
c13, e13 = urun(range(-5, 1000),
|
||||
lambda t: (15500.0 if 300 <= t < 360 else 13000.0) + CAR,
|
||||
const(0.0), const(CAR))
|
||||
check("T13 unit: the house steps to 15 500 W at E+300 for 60 s (landing "
|
||||
"without the car 14 667 W): not explained from E+300 to the quarter's "
|
||||
"end, though the house is back at 13 000 W from E+360",
|
||||
all(run_of(e13, 0, 299)) and not any(run_of(e13, 300, 899))
|
||||
and len(run_of(e13, 300, 899)) == 600)
|
||||
check("T13 unit: ...and released by the new quarter", all(run_of(e13, 900, 999)))
|
||||
c13g, e13g = urun(range(0, 400),
|
||||
lambda t: (15500.0 if 100 <= t < 160 else 13000.0) + CAR,
|
||||
const(0.0), const(CAR),
|
||||
guard=lambda t: _G(wants=not (t == 250)))
|
||||
check("T13 unit: ...or by the guard no longer wanting power (EV-10)",
|
||||
not any(run_of(e13g, 100, 249)) and all(run_of(e13g, 251, 399)))
|
||||
|
||||
# --- T14: no flicker --------------------------------------------------------- #
|
||||
def floor_edges(ex):
|
||||
"""Per quarter, False -> True edges of the floor alarm the stub implies
|
||||
(floor-limited, within_aim False, not explained)."""
|
||||
out, was = {}, False
|
||||
for t in sorted(ex):
|
||||
al = not ex[t]
|
||||
if al and not was:
|
||||
out[t // 900] = out.get(t // 900, 0) + 1
|
||||
was = al
|
||||
return out
|
||||
|
||||
|
||||
_ca, eta = urun(range(0, 1200),
|
||||
lambda t: 13610.0 + (40.0 if int(t // 7) % 2 else -40.0) + CAR,
|
||||
const(0.0), const(CAR))
|
||||
_cb, etb = urun(range(0, 1200),
|
||||
lambda t: 14000.0 + CAR - (400.0 if int(t // 7) % 2 else 800.0),
|
||||
lambda t: 400.0 if int(t // 7) % 2 else 800.0, const(CAR))
|
||||
fa, fb = floor_edges(eta), floor_edges(etb)
|
||||
print(f" T14 alarm edges per quarter: (a) {fa} (b) {fb}")
|
||||
check("T14(a): the house alone straddles aim + 10 W by 40 W every 7 s: at "
|
||||
"most one alarm edge per quarter", all(v <= 1 for v in fa.values()))
|
||||
check("T14(b): T2 shape with b alternating 400 / 800 W every 7 s: no alarm "
|
||||
"edge at all (base: one per quarter)", fb == {})
|
||||
|
||||
# --- T15 unit: x10 ------------------------------------------------------------ #
|
||||
ex10 = t1(x=10)
|
||||
check("T15 unit x10 (wall and mono 10 s a cycle): T1 the same; released "
|
||||
"within 1 cycle (E+30, the first trusted cycle)",
|
||||
not any(run_of(ex10, 0, 20)) and all(run_of(ex10, 30, 120))
|
||||
and all(run_of(ex10, -30, -10)))
|
||||
ex10m = t1(x=10, mono_x=1)
|
||||
check("T15 unit, mono x1 and wall x10: the same verdicts (the edge comes from "
|
||||
"the projection's block_start, not from mono)",
|
||||
not any(run_of(ex10m, 0, 20)) and all(run_of(ex10m, 30, 120)))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. THE REAL CONTROLLER ACROSS THE EDGE (N=2, both at the reserve)")
|
||||
# =========================================================================== #
|
||||
|
||||
|
||||
RUNS = [] # (name, alarm edges) of every run, for N5
|
||||
|
||||
|
||||
def summary(name, r, tr):
|
||||
RUNS.append((name, H.edges(tr)))
|
||||
w = H.window(tr, E - 120, E + 900)
|
||||
lim = [x for x in w if x["lim"]]
|
||||
print(f" {name}: alarms {[t - E for t in H.alarms(r)]} edges "
|
||||
f"{[t - E for t in H.edges(tr)]} red {len(H.red_secs(tr))} s "
|
||||
f"(first {[t - E for t in H.red_secs(tr)[:1]]}) errors "
|
||||
f"{len(H.errors(tr))} limited {len(lim)} explained "
|
||||
f"{sum(1 for x in lim if x['explains'])} cmd {H.commands(r, tr)}")
|
||||
return w, lim
|
||||
|
||||
|
||||
def quiet(r, tr):
|
||||
"""No floor notification, no ERROR, no red peak_guard row, E-120..E+900."""
|
||||
return H.alarms(r) == [] and H.red_secs(tr) == [] and H.errors(tr) == []
|
||||
|
||||
|
||||
def all_explained(lim, t0=E - 120):
|
||||
return bool(lim) and all(x["explains"] for x in lim if x["t"] >= t0)
|
||||
|
||||
|
||||
ZERO = const(0.0)
|
||||
|
||||
|
||||
def honest(w):
|
||||
"""An honest shape steps at the edge, so Off has no alarm before it."""
|
||||
return H.shape(w, at=E)
|
||||
|
||||
# --- T2: the rig F-A shape ---------------------------------------------------- #
|
||||
r2, tr2 = H.run(H.shape(14000.0), a=ZERO, b=const(800.0))
|
||||
w2, lim2 = summary("T2", r2, tr2)
|
||||
check("T2 PRECONDITION: limited at the reserve from the edge, the car trusted, "
|
||||
"b 800 W, grid excess 980 W < car",
|
||||
present(first(x for x in w2 if x["t"] == E and x["lim"]))
|
||||
and all(x["w"] == CAR and x["batt"] == 800.0 for x in lim2))
|
||||
check("T2: no goodwe_peak_soc_floor, no PEAK_GUARD_FLOOR_LIMITED ERROR, no "
|
||||
"red peak_guard row in E-120..E+900 (base: alarm at E+0, red to E+900)",
|
||||
quiet(r2, tr2))
|
||||
check("T2: the car explains every floor-limited cycle, E+0..E+10 among them",
|
||||
all_explained(lim2) and len([x for x in lim2 if x["t"] <= E + 10]) == 11)
|
||||
|
||||
# --- T2b: the batteries give less later --------------------------------------- #
|
||||
r2i, tr2i = H.run(H.shape(14000.0), a=ZERO,
|
||||
b=lambda t: 800.0 if t < E + 300 else 0.0)
|
||||
summary("T2b(i)", r2i, tr2i)
|
||||
a2i = H.alarms(r2i)
|
||||
check("T2b(i): b drops to 0 W at E+300 (landing without the car 13 733 W): "
|
||||
"the alarm fires within 1 cycle of E+300",
|
||||
len(a2i) == 1 and E + 300 <= nth(a2i, 0) <= E + 301)
|
||||
check("T2b(i): ...and stays to the quarter's end (a house need with a "
|
||||
"trusted car is latched)", all(x["alarm"] and x["red"] for x in
|
||||
H.window(tr2i, E + 302, E + 899)))
|
||||
r2ii, tr2ii = H.run(H.shape(14000.0), a=ZERO,
|
||||
b=lambda t: 800.0 if t < E + 300 else 400.0)
|
||||
summary("T2b(ii)", r2ii, tr2ii)
|
||||
check("T2b(ii): b drops to 400 W (landing 13 467 W): no alarm to E+900",
|
||||
quiet(r2ii, tr2ii))
|
||||
|
||||
# --- T3: batteries at 0 W, and the 11 kW car ---------------------------------- #
|
||||
r3, tr3 = H.run(H.shape(13000.0), a=ZERO, b=ZERO)
|
||||
w3, lim3 = summary("T3", r3, tr3)
|
||||
check("T3: batteries 0 W, house 13 000 W, car 1 380 W: no alarm, no red row, "
|
||||
"the car explains every limited cycle incl. E+0..E+10, one car notice",
|
||||
quiet(r3, tr3) and all_explained(lim3)
|
||||
and len(P.ids(r3, P.OVER)) == 1
|
||||
and all(x["explains"] for x in lim3 if x["t"] <= E + 10))
|
||||
|
||||
|
||||
def plug_at(t0):
|
||||
return {t0: lambda p, c: p.ch.plug_in()}
|
||||
|
||||
|
||||
r3k, tr3k = H.run(H.shape(2600.0, before=2600.0), a=ZERO, b=ZERO, car_a=16,
|
||||
phases=3, aim=6344.0, plug=False, extra=plug_at(E - 120))
|
||||
w3k, lim3k = summary("T3 11 kW", r3k, tr3k)
|
||||
check("T3 11 kW: house 2 600 W, car 11 kW, aim 6 344 W (base P 21:30): no "
|
||||
"alarm, the car explains every limited cycle",
|
||||
quiet(r3k, tr3k) and all_explained(lim3k)
|
||||
and len(P.ids(r3k, P.OVER)) == 1)
|
||||
|
||||
# --- T4 controller ------------------------------------------------------------ #
|
||||
r409, tr409 = H.run(H.shape(13609.0), a=ZERO, b=ZERO)
|
||||
summary("T4 13 609", r409, tr409)
|
||||
check("T4: the house alone at aim + 9 W: no alarm", quiet(r409, tr409))
|
||||
r411, tr411 = H.run(H.shape(13611.0), a=ZERO, b=ZERO)
|
||||
r411o, tr411o = H.run(H.shape(13611.0), a=ZERO, b=ZERO, mode="off")
|
||||
summary("T4 13 611", r411, tr411)
|
||||
summary("T4 13 611 Off", r411o, tr411o)
|
||||
check("T4: at aim + 11 W the alarm at the same cycle as Off (and as base, "
|
||||
"E+0)", H.alarms(r411) == H.alarms(r411o) == [E])
|
||||
|
||||
# --- T5: an honest alarm ------------------------------------------------------ #
|
||||
r5, tr5 = H.run(honest(14090.0), a=ZERO, b=ZERO)
|
||||
r5o, tr5o = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off")
|
||||
summary("T5", r5, tr5)
|
||||
summary("T5 Off", r5o, tr5o)
|
||||
check("T5: grid excess 1 870 W > car 1 380 W: the alarm and the ERROR at the "
|
||||
"same second as Off and as base (E+1, the step's first sample)",
|
||||
H.alarms(r5) == H.alarms(r5o) == T5_BASE
|
||||
and nth(H.errors(tr5), 0) == nth(H.errors(tr5o), 0) == E + 1)
|
||||
check("T5: the car explains no cycle", not any(x["explains"] for x in tr5))
|
||||
|
||||
|
||||
# --- T6: the car figure unknown across the edge ------------------------------- #
|
||||
def unavailable(t0, t1):
|
||||
return {t0: lambda p, c: p.ch.go_unavailable(True),
|
||||
t1: lambda p, c: p.ch.go_unavailable(False)}
|
||||
|
||||
|
||||
r6, tr6 = H.run(H.shape(13000.0), a=ZERO, b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60))
|
||||
summary("T6 T3 shape", r6, tr6)
|
||||
back = first(x["t"] for x in tr6 if x["t"] >= E + 60 and x["w"] is not None)
|
||||
check("T6 T3 shape: while unknown the car explains nothing and the alarm "
|
||||
"stands from E+0, as base",
|
||||
H.alarms(r6) == [E] and not any(
|
||||
x["explains"] for x in H.window(tr6, E - 5, E + 59))
|
||||
and all(x["alarm"] for x in H.window(tr6, E, E + 59)))
|
||||
check("T6 T3 shape: released within 1 cycle of the first trusted cycle after "
|
||||
"E+60, no new alarm edge to E+900 (base: red to E+900)",
|
||||
present(back) and all(not x["alarm"] and x["explains"] for x in
|
||||
H.window(tr6, back + 1, E + 899))
|
||||
and H.edges(tr6) == [E])
|
||||
r6h, tr6h = H.run(honest(14090.0), a=ZERO, b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60))
|
||||
summary("T6 T5 shape", r6h, tr6h)
|
||||
check("T6 T5 shape: the alarm at the base second and it stands throughout",
|
||||
H.alarms(r6h) == T5_BASE and all(x["alarm"] for x in
|
||||
H.window(tr6h, E + 1, E + 899)))
|
||||
|
||||
|
||||
# --- T7: a frozen car figure, the car really stops ---------------------------- #
|
||||
def frozen_stop(p, c):
|
||||
p.ch.freeze()
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
r7, tr7 = H.run(honest(14090.0), a=ZERO, b=ZERO, extra={E - 30: frozen_stop})
|
||||
summary("T7", r7, tr7)
|
||||
first7 = nth(H.alarms(r7), 0)
|
||||
untr = first(x["t"] for x in tr7 if x["t"] >= E - 30 and x["w"] is None)
|
||||
check("T7: the alarm within 114 s of the stop (max(60, 40 Wh / 1.38 kW) "
|
||||
"+ 10), no later than base",
|
||||
present(first7) and first7 <= E - 30 + 114 and first7 <= T7_BASE)
|
||||
check("T7: never explained after the figure goes untrusted",
|
||||
present(untr) and not any(x["explains"] for x in tr7 if x["t"] >= untr))
|
||||
|
||||
|
||||
# --- T8: a car at 0 W, and a 50 W car ----------------------------------------- #
|
||||
class Draw(SimCharger):
|
||||
"""A charger that draws `real_w` while charging and reports `say_w`."""
|
||||
def __init__(self, real_w, say_w, **kw):
|
||||
super().__init__(**kw)
|
||||
self.real_w, self.say_w = real_w, say_w
|
||||
|
||||
def target_w(self):
|
||||
return 0.0 if super().target_w() <= 0.0 else self.real_w
|
||||
|
||||
def _build(self):
|
||||
keep, self._frozen_w = self._frozen_w, self.say_w
|
||||
try:
|
||||
return super()._build()
|
||||
finally:
|
||||
self._frozen_w = keep
|
||||
|
||||
|
||||
def full(p, c):
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
for nm, kw in (("house 14 090 W", dict(house=honest(14090.0), b=ZERO)),
|
||||
("T2 shape", dict(house=honest(14000.0), b=const(800.0)))):
|
||||
r8, tr8 = H.run(a=ZERO, extra={1: full}, **kw)
|
||||
r8o, tr8o = H.run(a=ZERO, extra={1: full}, mode="off", **kw)
|
||||
summary(f"T8 0 W, {nm}", r8, tr8)
|
||||
summary(f"T8 0 W, {nm}, Off", r8o, tr8o)
|
||||
check(f"T8: a car plugged at 0 W, {nm}: the alarm at the same second as "
|
||||
f"Off, nothing explained", H.alarms(r8) == H.alarms(r8o)
|
||||
and H.alarms(r8) != [] and not any(x["explains"] for x in tr8))
|
||||
r8s, tr8s = H.run(honest(14090.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(50.0, 50.0, setpoint_a=6))
|
||||
r8so, tr8so = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off",
|
||||
sim=Draw(50.0, 50.0, setpoint_a=6))
|
||||
summary("T8 50 W", r8s, tr8s)
|
||||
check("T8: a 50 W car, house 14 090 W: the alarm at the same second as Off, "
|
||||
"nothing explained", H.alarms(r8s) == H.alarms(r8so) == T5_BASE
|
||||
and not any(x["explains"] for x in tr8s))
|
||||
|
||||
# --- T9: a wrong charger reply ------------------------------------------------ #
|
||||
r9a, tr9a = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(1380.0, 11000.0, setpoint_a=6))
|
||||
summary("T9(a)", r9a, tr9a)
|
||||
check("T9(a): reports 11 kW, read-back 6 A 1-ph (cap 1 518 W): the house "
|
||||
"alone misses, the alarm at the base second",
|
||||
H.alarms(r9a) == T5_BASE and all(x["w"] is None or x["w"] <= 1518.0
|
||||
for x in tr9a))
|
||||
r9b, tr9b = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(400.0, 1380.0, setpoint_a=6))
|
||||
summary("T9(b)", r9b, tr9b)
|
||||
check("T9(b): reports 1 380 W, draws 400 W: the same alarms as base (none: "
|
||||
"400 W corroborates a 1 380 W figure, CORR_RATIO 0.5; see the dev "
|
||||
"report's Findings)", H.alarms(r9b) == T9B_BASE)
|
||||
r9c, tr9c = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(100.0, 1380.0, setpoint_a=6))
|
||||
summary("T9(c)", r9c, tr9c)
|
||||
a9c = nth(H.alarms(r9c), 0)
|
||||
check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure "
|
||||
"is uncorroborated, at most 104 s + 10 s after the edge, no later than "
|
||||
"base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE)
|
||||
check("T9(c) (owner 2026-11-19): the meter contradicted the figure, so it "
|
||||
"stays untrusted to the quarter's end: one alarm edge, red and never "
|
||||
"explained to E+899 (the meter's 10 Wh step re-corroborates it every "
|
||||
"360 s)", H.edges(tr9c) == [a9c] and all(
|
||||
x["alarm"] and x["red"] and not x["explains"]
|
||||
for x in H.window(tr9c, a9c, E + 899)))
|
||||
|
||||
# --- T10: a lost battery reading, an unavailable charger ---------------------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
r10, tr10 = H.run(a=ZERO, lost={"b": {E + 1}}, **kw)
|
||||
summary(f"T10(a) {nm}", r10, tr10)
|
||||
gap = first(x for x in tr10 if x["t"] == E + 1)
|
||||
nxt = first(x for x in tr10 if x["t"] == E + 2)
|
||||
check(f"T10(a) {nm}: inverter-b's reading lost at E+1: that cycle grades "
|
||||
f"nothing (P_SAFETY owns a missing input), the next one grades on "
|
||||
f"what is measured", present(gap, nxt) and gap["batt"] is None
|
||||
and nxt["batt"] == (800.0 if nm == "T2" else 0.0))
|
||||
if nm == "T2":
|
||||
check("T10(a) T2: no alarm edge (base: E+0)", quiet(r10, tr10))
|
||||
else:
|
||||
check("T10(a) T5: the same alarm seconds as base",
|
||||
H.alarms(r10) == T10A_T5_BASE)
|
||||
r10b, tr10b = H.run(a=ZERO, extra=unavailable(E + 1, E + 2), **kw)
|
||||
summary(f"T10(b) {nm}", r10b, tr10b)
|
||||
if nm == "T2":
|
||||
check("T10(b) T2: the charger unavailable for one cycle (E+1): the "
|
||||
"alarm stands for that cycle only (Expected 5)",
|
||||
H.edges(tr10b) == [E + 1]
|
||||
and all(not x["alarm"] for x in H.window(tr10b, E + 2, E + 899))
|
||||
and all(x["explains"] for x in H.window(tr10b, E + 2, E + 899)
|
||||
if x["lim"]))
|
||||
else:
|
||||
check("T10(b) T5: the alarm at the base second and it stands",
|
||||
H.alarms(r10b) == T5_BASE and all(
|
||||
x["alarm"] for x in H.window(tr10b, E + 1, E + 899)))
|
||||
|
||||
# --- R1 (review round 2): the energy reading unknown for one cycle ----------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO))):
|
||||
rg, trg = H.run(a=ZERO, extra=H.energy_gap(E + 200), **kw)
|
||||
summary(f"R1 {nm} energy gap at E+200", rg, trg)
|
||||
check(f"R1 {nm}: the charger's energy entity unknown for one cycle "
|
||||
f"(E+200) on a correct car: unknown, not contradicted, so red for "
|
||||
f"that cycle only and explained from the next (Expected 5)",
|
||||
H.red_secs(trg) == [E + 200] and H.edges(trg) == [E + 200]
|
||||
and all(x["explains"] for x in H.window(trg, E + 201, E + 899)
|
||||
if x["lim"]))
|
||||
|
||||
# --- T11: one battery first (SAFETY-87) --------------------------------------- #
|
||||
for nm, house in (("(i) 17 500 W", 17500.0), ("(ii) 19 000 W", 19000.0)):
|
||||
r11, tr11 = H.run(honest(house), soc={"a": 19.0, "b": 35.0})
|
||||
summary(f"T11{nm}", r11, tr11)
|
||||
if house < 18000.0:
|
||||
check("T11(i): b able, house 17 500 W, car 1 380 W: no alarm across E",
|
||||
H.alarms(r11) == [] and P.ids(r11, *P.ALARMS) == [])
|
||||
else:
|
||||
check("T11(ii): house 19 000 W: the alarm at the base second",
|
||||
[t for t, _n in P.ids(r11, *P.ALARMS)] == T11_BASE)
|
||||
|
||||
# --- T12 (record only): plug-in at E+0, the reserve at E+180 ------------------ #
|
||||
def reserve_at(p, c):
|
||||
p.socs.update({"a": 19.0, "b": 19.0})
|
||||
|
||||
|
||||
r12, tr12 = H.run(H.shape(13000.0), soc={"a": 40.0, "b": 40.0}, plug=False,
|
||||
extra={E: lambda p, c: p.ch.plug_in(), E + 180: reserve_at})
|
||||
summary("T12 (record, F-B)", r12, tr12)
|
||||
|
||||
# --- T13 controller: the latch is kept ---------------------------------------- #
|
||||
r13, tr13 = H.run(H.shape(lambda t: 15500.0 if E + 300 <= t < E + 360
|
||||
else 13000.0), a=ZERO, b=ZERO)
|
||||
summary("T13", r13, tr13)
|
||||
check("T13: the house steps to 15 500 W at E+300 for 60 s: the alarm at "
|
||||
"the base second (E+301, the step's first sample), and red to the "
|
||||
"quarter's end", H.alarms(r13) == T13_BASE and all(
|
||||
x["alarm"] and x["red"] for x in H.window(tr13, E + 301, E + 899)))
|
||||
|
||||
# --- T16: the edge paths ------------------------------------------------------ #
|
||||
for nm, kw in (("(a)(b)(c) SAFETY-91 roll, modes on", {}),
|
||||
("(d) the guard not wanting at the edge",
|
||||
dict(lost={"b": {E}}))):
|
||||
r16, tr16 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, **kw)
|
||||
w16, lim16 = summary(f"T16{nm}", r16, tr16)
|
||||
f16 = first(x for x in tr16 if x["t"] >= E and x["lim"])
|
||||
pre = first(x for x in tr16 if x["t"] == E - 1)
|
||||
check(f"T16{nm}: the car explains from the first limited cycle of the "
|
||||
f"new block, no alarm, no red row, `_carq` key = block_start",
|
||||
present(f16) and quiet(r16, tr16) and all(
|
||||
x["explains"] and x["key"] == x["block"]
|
||||
for x in tr16 if x["t"] >= f16["t"] and x["lim"]))
|
||||
if not kw:
|
||||
print(f" T16(c): within_aim at E-1 {pre['within_aim'] if present(pre) else pre}"
|
||||
" (SAFETY-126's latch carried; not asserted)")
|
||||
else:
|
||||
g0 = first(x for x in tr16 if x["t"] == E)
|
||||
check("T16(d) PRECONDITION: the guard did not want power at E+0",
|
||||
present(g0) and not g0["wants"])
|
||||
|
||||
|
||||
# --- T17: a restart ----------------------------------------------------------- #
|
||||
def restart_at(t0):
|
||||
return {t0: lambda p, c: H.restart(c)}
|
||||
|
||||
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO)),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
rr0, tr0 = H.run(a=ZERO, **kw)
|
||||
for at in (E + 2, E + 300):
|
||||
rr, trr = H.run(a=ZERO, extra=restart_at(at), **kw)
|
||||
summary(f"T17 {nm} restart at E+{at - E}", rr, trr)
|
||||
if nm == "T5":
|
||||
check(f"T17 T5, restart at E+{at - E}: the alarm at the base "
|
||||
f"second and again on the first cycle after the restart, "
|
||||
f"as base; red throughout",
|
||||
H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr))
|
||||
== len(H.red_secs(tr0)))
|
||||
elif nm == "T2" and at == E + 300:
|
||||
# review round 1: the car's energy before a restart is not known,
|
||||
# so it counts as house (never credited to the car). Here that
|
||||
# tips the house alone over the aim: the alarm stands from the
|
||||
# restart, the conservative side (base: red from E+0).
|
||||
check("T17 T2, restart at E+300: quiet before the restart; after "
|
||||
"it the car's unknown earlier share counts as house, so at "
|
||||
"most one alarm edge, at the restart",
|
||||
quiet(rr0, tr0) and H.red_secs(trr, t1=at - 1) == []
|
||||
and H.edges(trr) in ([], [at]))
|
||||
else:
|
||||
check(f"T17 {nm}, restart at E+{at - E}: the same as without "
|
||||
f"(no floor notice, no ERROR, no red row)",
|
||||
quiet(rr, trr) and quiet(rr0, tr0))
|
||||
print(f" T17 {nm} car-over notices: twin "
|
||||
f"{[t - E for t, _n in P.ids(rr0, P.OVER)]}, restarted "
|
||||
f"{[t - E for t, _n in P.ids(rr, P.OVER)]} (EV-11's "
|
||||
f"once-per-session state does not survive a restart, as on "
|
||||
f"base)")
|
||||
|
||||
# --- T17b (review round 1): a house need only the done part shows ----------- #
|
||||
def heavy_then_light(t):
|
||||
"""House 18 000 W for E..E+300, then 12 000 W: alone it lands 14 000 W."""
|
||||
if t < E:
|
||||
return H.PRE_W if t < E - 120 else 12000.0
|
||||
return 18000.0 if t < E + 300 else 12000.0
|
||||
|
||||
|
||||
r17b0, tr17b0 = H.run(heavy_then_light, a=ZERO, b=ZERO)
|
||||
r17b, tr17b = H.run(heavy_then_light, a=ZERO, b=ZERO,
|
||||
extra=restart_at(E + 310))
|
||||
summary("T17b no restart", r17b0, tr17b0)
|
||||
summary("T17b restart at E+310", r17b, tr17b)
|
||||
check("T17b: the house heavy before a restart at E+310 (alone it lands "
|
||||
"14 000 W, excess 1 780 W > car): red to the quarter's end and never "
|
||||
"explained, as without the restart (and as base and Off)",
|
||||
len(H.red_secs(tr17b, E, E + 899)) == len(H.red_secs(tr17b0, E, E + 899))
|
||||
== 899 and not any(x["explains"] for x in H.window(tr17b, E, E + 899)))
|
||||
|
||||
# --- T15 controller: x10 ------------------------------------------------------ #
|
||||
# F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at
|
||||
# 10 s a cycle half the car's energy is counted, and late in the quarter the
|
||||
# house alone seems to miss the aim (T2 from about E+540, T3 E+820, as on base
|
||||
# for T3). The x10 verdicts are graded to E+500; what comes after is printed.
|
||||
F2_FROM = E + 500
|
||||
for nm, kw, want in (
|
||||
("T2", dict(house=H.shape(14000.0), b=const(800.0)), "quiet"),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO), "quiet"),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO), "alarm"),
|
||||
("T6", dict(house=H.shape(13000.0), b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60)), "release")):
|
||||
rx, trx = H.run(a=ZERO, x=10, **kw)
|
||||
summary(f"T15 x10 {nm}", rx, trx)
|
||||
early = [x for x in trx if x["t"] < F2_FROM]
|
||||
print(f" T15 x10 {nm}: alarms after E+500 (F2) "
|
||||
f"{[t - E for t in H.alarms(rx) if t >= F2_FROM]}")
|
||||
if want == "quiet":
|
||||
check(f"T15 x10 {nm}: no alarm, no red row, every limited cycle "
|
||||
f"explained, E-120..E+500",
|
||||
not [t for t in H.alarms(rx) if t < F2_FROM]
|
||||
and H.red_secs(trx, t1=F2_FROM - 1) == []
|
||||
and all_explained([x for x in early if x["lim"]]))
|
||||
elif want == "alarm":
|
||||
check("T15 x10 T5: the alarm at the base second (E+10, one cycle)",
|
||||
H.alarms(rx) == T15_T5_BASE)
|
||||
else:
|
||||
bk = first(x["t"] for x in trx if x["t"] >= E + 60
|
||||
and x["w"] is not None)
|
||||
check("T15 x10 T6: the alarm while unknown, released within 1 cycle "
|
||||
"(10 fake s) of the first trusted one, no new edge to E+500",
|
||||
present(bk) and bk <= E + 70
|
||||
and all(not x["alarm"] for x in H.window(trx, bk, F2_FROM - 1))
|
||||
and [t for t in H.edges(trx) if t < F2_FROM] == [E])
|
||||
|
||||
# --- N4: the alarm decision changes no command -------------------------------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
ra, tra = H.run(a=ZERO, **kw)
|
||||
rb, trb = H.run(a=ZERO, explain_off=True, **kw)
|
||||
check(f"N4 {nm}: the claim, the floor, the battery setpoints and the "
|
||||
f"charger writes are identical whether the car explains or not",
|
||||
H.commands(ra, tra) == H.commands(rb, trb))
|
||||
|
||||
# N4 with "Batteries help with the peak" off (review round 2): the guard's
|
||||
# input is `car_exclude`, which reads the car's energy count. The
|
||||
# contradiction latch must not touch it: the same commands with the latch off.
|
||||
for nm, kw in (
|
||||
("SoC 60 %, energy gap at E+200",
|
||||
dict(house=H.shape(13000.0), soc={"a": 60.0, "b": 60.0},
|
||||
extra=H.energy_gap(E + 200))),
|
||||
("at the reserve, energy gap at E+200",
|
||||
dict(house=H.shape(13000.0), a=ZERO, b=ZERO,
|
||||
extra=H.energy_gap(E + 200))),
|
||||
("SoC 60 %, the T9(c) liar",
|
||||
dict(house=honest(13900.0), soc={"a": 60.0, "b": 60.0},
|
||||
sim=Draw(100.0, 1380.0, setpoint_a=6))),
|
||||
("at the reserve, the T9(c) liar",
|
||||
dict(house=honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(100.0, 1380.0, setpoint_a=6)))):
|
||||
ra, tra = H.run(cover=False, **kw)
|
||||
if "sim" in kw:
|
||||
kw = dict(kw, sim=Draw(100.0, 1380.0, setpoint_a=6))
|
||||
rb, trb = H.run(cover=False, latch_off=True, **kw)
|
||||
summary(f"N4 cover off, {nm}", ra, tra)
|
||||
check(f"N4 cover off, {nm}: the claim, the floor, the setpoints and the "
|
||||
f"charger writes are those of the same run without the "
|
||||
f"contradiction latch", H.commands(ra, tra) == H.commands(rb, trb))
|
||||
|
||||
# --- N5: at most one floor-alarm edge per quarter ---------------------------- #
|
||||
def per_quarter(ts):
|
||||
out = {}
|
||||
for t in ts:
|
||||
out[(t - E) // 900] = out.get((t - E) // 900, 0) + 1
|
||||
return out
|
||||
|
||||
|
||||
# Cover off, the T9(c) liar at the reserve: the guard's own engagement flips
|
||||
# as the liar's figure is corroborated now and then (its input is
|
||||
# `car_exclude`), pre-existing (base: 4 edges). Printed, not graded here.
|
||||
LIAR_OFF = "N4 cover off, at the reserve, the T9(c) liar"
|
||||
print(f" {LIAR_OFF}: alarm edges "
|
||||
f"{[[t - E for t in ts] for nm, ts in RUNS if nm == LIAR_OFF]}")
|
||||
many = [(nm, ts) for nm, ts in RUNS
|
||||
if nm != LIAR_OFF and any(v > 1 for v in per_quarter(
|
||||
[t for t in ts if not nm.startswith("T15 x10") or t < F2_FROM])
|
||||
.values())]
|
||||
check(f"N5: at most one floor-alarm edge per quarter in every run "
|
||||
f"({len(RUNS)} runs; x10 to E+500; the cover-off liar apart): "
|
||||
f"{many}", many == [])
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,564 @@
|
||||
"""EV-19: no floor alarm when the batteries first reach the peak reserve early
|
||||
in a Manual car session (EV-15 rig F-B). `python3 -B test_ev19.py`
|
||||
|
||||
The rig: one PEAK_GUARD_FLOOR_LIMITED ERROR, one `goodwe_peak_soc_floor` and
|
||||
one red sample the moment the batteries reached the reserve, while the excess
|
||||
was smaller than the car. Reproduced (T1): at the reserve inverter-b goes on
|
||||
following the house, so its output RISES in that cycle. The battery reading
|
||||
shows the rise one cycle before the P1 sample does, and EV-18's "house"
|
||||
(meter + what the batteries give now) counted the new battery power as house
|
||||
load. That latched `_car_need_house` for the quarter: the alarm stood until
|
||||
the guard stopped wanting power. Now a rise the reading shows above both
|
||||
earlier readings is not counted as house until a second reading confirms it.
|
||||
The credit stays the lower of the last two readings.
|
||||
|
||||
T-ids are the test plan's (reports/EV-19-test-plan.md). "base" is 43b0db7.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, tariff # noqa: E402
|
||||
from named_absence import first, nth, present # noqa: E402
|
||||
import ev19_reserve as V # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
AIM = V.AIM
|
||||
CAR = V.CAR
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. UNIT: car_cycle in the reserve cycle (a real `_carq`)")
|
||||
# =========================================================================== #
|
||||
BS = datetime(2026, 11, 20, 20, 30, tzinfo=timezone.utc) # a quarter edge
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self):
|
||||
self.o = {"ev_batt_cover": True}
|
||||
self.w = CAR
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
|
||||
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
|
||||
self.car_init({}, self.store)
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
class car: # noqa: N801
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class _G:
|
||||
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
|
||||
floor_limited, saturated = True, False
|
||||
floor_w, able_w, ceiling_w = 0.0, None, AIM + 50.0
|
||||
engaged, blind, wanted_w, within_aim = True, None, 300.0, False
|
||||
|
||||
|
||||
def urun(secs, grid, batt, w=lambda t: CAR):
|
||||
"""`car_cycle` once per second of `secs` (seconds from the edge). `grid(t)`
|
||||
is the meter, `batt(t)` the site battery reading. {t: car_explains}."""
|
||||
c = _Car()
|
||||
done, out = {}, {}
|
||||
for t in secs:
|
||||
q = t // 900
|
||||
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
|
||||
g = float(grid(t))
|
||||
d = done.get(bs, g * el)
|
||||
p = tariff.Projection(
|
||||
projected_w=(d + g * (900 - el)) / 900.0,
|
||||
elapsed_w=(d / el if el else g), elapsed_s=float(el),
|
||||
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
|
||||
done[bs] = d + g
|
||||
c._now = 10000.0 + t
|
||||
c.w, c.site_batt_w = w(t), batt(t)
|
||||
c.car_cycle(p, _G(), AIM, None)
|
||||
out[t] = c.car_explains
|
||||
return out
|
||||
|
||||
|
||||
def run_of(d, t0, t1):
|
||||
return [d[t] for t in sorted(d) if t0 <= t <= t1]
|
||||
|
||||
|
||||
def rise(at, lo, hi):
|
||||
"""A battery reading that steps from `lo` to `hi` at `at`."""
|
||||
return lambda t: lo if t < at else hi
|
||||
|
||||
|
||||
def meter(house, b, lag=1):
|
||||
"""The P1 figure: house + car - what the batteries gave `lag` cycles ago
|
||||
(the reading leads the meter by that much)."""
|
||||
return lambda t: house + CAR - b(t - lag)
|
||||
|
||||
|
||||
HB = AIM + 520.0 - CAR # F-B: house + car at batteries 0 W = aim + 520
|
||||
b2 = rise(1, 0.0, 4600.0)
|
||||
u2 = urun(range(-5, 61), meter(HB, b2), b2)
|
||||
print(f" T2 unit E-1..E+3: {run_of(u2, -1, 3)}")
|
||||
check("T2 unit: b starts following the house at the reserve (0 -> 4 600 W) "
|
||||
"and the reading shows it one cycle before the meter: the car explains "
|
||||
"every cycle, the rise cycle E+1 among them (base: not from E+1)",
|
||||
all(run_of(u2, 0, 60)) and len(run_of(u2, 0, 60)) == 61)
|
||||
u2s = urun(range(-5, 61), meter(HB, b2, lag=0), b2)
|
||||
check("T2 unit: the same rise with the meter in step: explained every cycle",
|
||||
all(run_of(u2s, 0, 60)) and len(run_of(u2s, 0, 60)) == 61)
|
||||
|
||||
# T4: the landing without the car at aim + 9 / + 11 W in the rise cycle. The
|
||||
# rise is at the edge, so with the lower reading credited (0 W) the house
|
||||
# alone lands at exactly `house`.
|
||||
b4 = rise(0, 0.0, 800.0)
|
||||
u409 = urun(range(-3, 10), meter(AIM + 9.0, b4), b4)
|
||||
u411 = urun(range(-3, 10), meter(AIM + 11.0, b4), b4)
|
||||
print(f" T4 unit +9 {run_of(u409, 0, 3)} +11 {run_of(u411, 0, 3)}")
|
||||
check("T4 unit: the house alone at aim + 9 W in the rise cycle: the car "
|
||||
"explains from E+0 (base: no)", all(run_of(u409, 0, 9))
|
||||
and len(run_of(u409, 0, 9)) == 10)
|
||||
check("T4 unit: at aim + 11 W it does not, from E+0 (as base)",
|
||||
not any(run_of(u411, 0, 9)) and len(run_of(u411, 0, 9)) == 10)
|
||||
|
||||
# N6 / T7(a): an unknown reading credits nothing; the lower reading is
|
||||
# credited, not the higher or the last known one.
|
||||
b7 = lambda t: None if t == 1 else b2(t) # noqa: E731
|
||||
u7 = urun(range(-5, 30), meter(HB, b2), b7)
|
||||
check("T7(a) unit: the battery reading unknown in the rise cycle: nothing "
|
||||
"explained in that cycle (no last-known W), explained from the next",
|
||||
u7.get(1) is False and u7.get(0) is True and all(run_of(u7, 2, 29)))
|
||||
u6 = urun(range(-5, 30), meter(AIM + 11.0 + 400.0, lambda t: 400.0, lag=0),
|
||||
lambda t: 800.0 if t == 3 else 400.0)
|
||||
check("N6 unit: b at 400 W, the house alone with it at aim + 11 W, one "
|
||||
"reading of 800 W at E+3: not explained in any cycle",
|
||||
not any(run_of(u6, 0, 29)))
|
||||
# The rise counts as house once a second reading confirms it: b steps to
|
||||
# 800 W and the meter, one cycle late, shows a house of aim + 811 W (the
|
||||
# house steps with it), so with b's 800 W the house alone misses by 11 W.
|
||||
b8 = rise(5, 0.0, 800.0)
|
||||
u8 = urun(range(0, 30), lambda t: (AIM - 500.0 if t < 5 else AIM + 811.0)
|
||||
+ CAR - b8(t - 1), b8)
|
||||
print(f" N6 unit house step with a rise E+4..E+8: {run_of(u8, 4, 8)}")
|
||||
check("N6 unit: a house step that comes with a battery rise is latched at "
|
||||
"most one cycle after the rise (E+6), and stays latched",
|
||||
all(run_of(u8, 0, 4)) and not any(run_of(u8, 6, 29)))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. THE REAL CONTROLLER AT THE RESERVE (N=2, tools/ev19_reserve.py)")
|
||||
# =========================================================================== #
|
||||
JOBS = V.jobs()
|
||||
RES = V.run_many(JOBS)
|
||||
|
||||
|
||||
def res(name):
|
||||
return RES[name]
|
||||
|
||||
|
||||
def trusted(x):
|
||||
return x["w"] is not None and x["w"] > 0.0 and not x["contra"]
|
||||
|
||||
|
||||
def bad(x):
|
||||
return bool(x["alarm"] or x["red"] or x["err"])
|
||||
|
||||
|
||||
def hits(r, t0=-10, t1=60):
|
||||
"""T1's reproduction: an alarm, red sample or ERROR in R-10..R+60 in a
|
||||
cycle where the car figure is trusted (every T1 shape lands under the aim
|
||||
without the car, so the car explains there)."""
|
||||
return [int(x["t"] - r.R) for x in r.win(t0, t1) if bad(x) and trusted(x)]
|
||||
|
||||
|
||||
def show(name):
|
||||
r = res(name)
|
||||
print(f" {name}: alarms {r.rel_alarms()} edges {r.edges()} errors "
|
||||
f"{r.errors()} red {len(r.red())} s cmd {r.cmd}")
|
||||
|
||||
|
||||
# Measured on base 43b0db7 with this file's own runs: the seconds from R of
|
||||
# goodwe_peak_soc_floor in the honest shapes, which must not come later now.
|
||||
BASE_ALARMS = {
|
||||
"T4 +11 manual": [0, 857], "T5 t1 manual": [2], "T5 t4 manual": [11],
|
||||
"T5 tau5 manual": [2], "T6 step R+0 manual": [2],
|
||||
"T6 step R+1 manual": [2], "T6 step R+5 manual": [6],
|
||||
"T7(a) T5": [2], "T7(b) T5": [2], "T8(c) frozen, the car stops": [2],
|
||||
"T9(a) T5 b lost at R": [2], "T9(a) T5 b lost at R-1": [2],
|
||||
"T9(b) T5 P1 5 s late at R": [5], "T10 T5 twin": [2],
|
||||
"T10 T5 restart R-2": [2], "T10 T5 restart R+2": [2],
|
||||
"T11 T5 R=E-1": [2], "T11 T5 R=E+0": [0, 2], "T11 T5 R=E+1": [0, 2],
|
||||
"T11 T5 R=E+43": [2], "T12 T5 1->3 at R-15": [2],
|
||||
"T12 T5 1->3 at R+5": [2], "T13(a) draws 100 W manual": [0, 857],
|
||||
"T14(c) N=1 T5": [2], "T15 honest manual": [13],
|
||||
"T16 x10 T5 manual": [20], "T16 x10 T6 manual": [20],
|
||||
"T16 mono1 T5 manual": [20], "T16 mono1 T6 manual": [20],
|
||||
"T16 x10 T11 T5 R=E-10": [20], "T16 x10 T11 T5 R=E+0": [0, 20],
|
||||
"T16 x10 T11 T5 R=E+10": [0, 20], "T16 x10 T11 T5 R=E+40": [20],
|
||||
"T16 mono1 T11 T5 R=E-10": [20], "T16 mono1 T11 T5 R=E+0": [0, 20],
|
||||
"T16 mono1 T11 T5 R=E+10": [0, 20], "T16 mono1 T11 T5 R=E+40": [20],
|
||||
"T16 mono1 T3 t1 bw=0": [600], "T16 mono1 T3 t1 bw=2000": [700],
|
||||
"T16 mono1 T3 t1 bw=4250": [800], "T16 mono1 T3 t4 bw=0": [600],
|
||||
"T16 mono1 T3 t4 bw=2000": [700], "T16 mono1 T3 t4 bw=4250": [800],
|
||||
}
|
||||
# The T1 cells that reproduce F-B on base (G0): b following the house from R.
|
||||
BASE_REPRO = [f"T1 core bw={bw} t2 rp={rp}" for bw in (0, 400, 800)
|
||||
for rp in (30, 100, 110, 180, 600)] + [
|
||||
"T1 d: x10 wall+mono t2 bw=1200", "T1 d: x10 wall, mono x1 t2 bw=1200"]
|
||||
|
||||
|
||||
def as_base(k):
|
||||
"""The same alarm seconds as base."""
|
||||
return res(k).rel_alarms() == BASE_ALARMS[k]
|
||||
|
||||
# --- T1: the reproduction grid ------------------------------------------------ #
|
||||
T1 = sorted(k for k in JOBS if k.startswith("T1 "))
|
||||
C5 = [k for k in T1 if k.startswith("T1 b: energy")]
|
||||
rep = {k: hits(res(k)) for k in T1}
|
||||
print(f" T1 cells {len(T1)}; reproducing on this tree: "
|
||||
f"{sorted(k for k in T1 if rep[k])}")
|
||||
check("T1: no grid cell reproduces F-B: no notice, ERROR or red sample in "
|
||||
"R-10..R+60 while the car figure is trusted (base: the "
|
||||
f"{len(BASE_REPRO)} tau2 cells with b at 0-800 W at R)",
|
||||
not [k for k in T1 if rep[k]])
|
||||
for k in C5:
|
||||
show(k)
|
||||
check("T1 C5 cells (the energy meter late or never stepping): the figure is "
|
||||
"untrusted (contradicted or unknown) wherever the alarm stands, as EV-18 "
|
||||
"Expected 5 wants", all(not trusted(x) for k in C5
|
||||
for x in res(k).win(-10, 60) if bad(x)))
|
||||
|
||||
# --- T2: THE red-before test -------------------------------------------------- #
|
||||
T2 = BASE_REPRO
|
||||
for k in T2:
|
||||
r = res(k)
|
||||
lim = [x for x in r.win(0, 60) if x["floor_lim"]]
|
||||
check(f"T2 {k[3:]}: no notice, no ERROR, no red sample R-60..R+900; the "
|
||||
f"car explains every floor-limited cycle of R..R+60",
|
||||
r.quiet(-60, 900) and bool(lim) and all(x["explains"] for x in lim))
|
||||
check("T2 PRECONDITION: every reproducing cell is in the grid (b at 0, 400, "
|
||||
"800 W x 5 plug-in times; x10 and mono x1 with b at 1 200 W)",
|
||||
len(T2) == 17 and all(k in RES for k in T2))
|
||||
r2 = res("T1 core bw=0 t2 rp=180")
|
||||
x1 = r2.at(1)
|
||||
check("T2 PRECONDITION: in the rise cycle the reading shows b's 4 600 W, the "
|
||||
"guard is floor-limited and wants power",
|
||||
present(x1) and x1["batt"] == 4600.0 and x1["floor_lim"]
|
||||
and x1["wants"])
|
||||
|
||||
# --- T3: the battery W sweep --------------------------------------------------- #
|
||||
T3 = sorted(k for k in JOBS if k.startswith("T3 "))
|
||||
loud = [k for k in T3 if not res(k).quiet(-60, 900)]
|
||||
print(f" T3 cells {len(T3)}, with an alarm or red sample: {loud}")
|
||||
check("T3: tau1 and tau2, b at R 0..4 600 W in 200 W steps and 9 600 W "
|
||||
"(tau5): no alarm and no red sample in any cell", loud == [])
|
||||
|
||||
# --- T4 controller ------------------------------------------------------------- #
|
||||
for k in ("T4 +9 manual", "T4 +11 manual", "T4 +11 off"):
|
||||
show(k)
|
||||
check("T4: the house alone at aim + 9 W, b following the house from R: no "
|
||||
"alarm (base: R+1)", res("T4 +9 manual").quiet(-60, 900))
|
||||
check("T4: at aim + 11 W the alarm in the same cycle as base and as Off "
|
||||
"(R+0)", as_base("T4 +11 manual")
|
||||
and res("T4 +11 manual").rel_alarms()[:1]
|
||||
== res("T4 +11 off").rel_alarms()[:1] == [0])
|
||||
|
||||
|
||||
# --- T5 / T6: honest alarms ---------------------------------------------------- #
|
||||
def same_as_off(k):
|
||||
on, off = res(f"{k} manual"), res(f"{k} off")
|
||||
show(f"{k} manual")
|
||||
show(f"{k} off")
|
||||
a = on.rel_alarms()
|
||||
return (bool(a) and a == off.rel_alarms()
|
||||
and on.errors() == off.errors())
|
||||
|
||||
|
||||
for k in ("T5 t1", "T5 t4", "T5 tau5"):
|
||||
check(f"{k}: the excess is more than the car: PEAK_GUARD_FLOOR_LIMITED, "
|
||||
f"the ERROR and the notice at the same second as Off and as base",
|
||||
same_as_off(k) and as_base(f"{k} manual"))
|
||||
check(f"{k}: the car explains no cycle",
|
||||
not any(x["explains"] for x in res(f"{k} manual").tr))
|
||||
for n in (0, 1, 5):
|
||||
k = f"T6 step R+{n}"
|
||||
show(f"{k} manual")
|
||||
check(f"{k}: the house steps to aim + 1 900 W at R+{n}: the alarm and "
|
||||
f"the ERROR at the same second as base, R+{BASE_ALARMS[k + ' manual'][0]}"
|
||||
f" (no grace, no hold; Off alarms from R+0, where the car explains)",
|
||||
as_base(f"{k} manual") and res(f"{k} manual").errors()
|
||||
== BASE_ALARMS[f"{k} manual"])
|
||||
|
||||
|
||||
# --- T7: unknown values -------------------------------------------------------- #
|
||||
def only_while_unknown(r, t0=-60, t1=900):
|
||||
"""Every alarm / red cycle has an untrusted car figure in it or in the
|
||||
cycle before (the alarm clears within 1 cycle of the first trusted one)."""
|
||||
prev = None
|
||||
for x in r.win(t0, t1):
|
||||
if bad(x) and trusted(x) and (prev is None or trusted(prev)):
|
||||
return False
|
||||
prev = x
|
||||
return True
|
||||
|
||||
|
||||
show("T7(a) T2")
|
||||
check("T7(a) T2: inverter-a's reading unknown at R and R+1: no alarm",
|
||||
res("T7(a) T2").quiet(-60, 900))
|
||||
check("T7(a) T5: the alarm at the same second as base and as Off (the "
|
||||
"guard grades nothing without the reading)", as_base("T7(a) T5")
|
||||
and res("T7(a) T5").rel_alarms() == res("T7(a) T5 off").rel_alarms())
|
||||
show("T7(b) T2")
|
||||
check("T7(b) T2: the charger unavailable at R: an alarm only while the "
|
||||
"figure is unknown, cleared within 1 cycle of the first trusted one",
|
||||
only_while_unknown(res("T7(b) T2")))
|
||||
check("T7(b) T5: the alarm at the same second as base and as Off",
|
||||
as_base("T7(b) T5")
|
||||
and res("T7(b) T5").rel_alarms() == res("T7(b) T5 off").rel_alarms())
|
||||
|
||||
# --- T8: a stale car figure ---------------------------------------------------- #
|
||||
r8a = res("T8(a) Off 120 s, Manual R-5")
|
||||
show("T8(a) Off 120 s, Manual R-5")
|
||||
check("T8(a): nothing before Manual is trusted (car_alarm_w None)",
|
||||
all(x["w"] is None for x in r8a.tr if x["t"] < r8a.R - 5))
|
||||
check("T8(a): after Manual, as T2: no alarm R-60..R+900",
|
||||
r8a.quiet(-60, 900))
|
||||
r8b = res("T8(b) stale R-5..R+20")
|
||||
show("T8(b) stale R-5..R+20")
|
||||
check("T8(b) PRECONDITION: the figure goes untrusted (older than 15 s)",
|
||||
any(x["w"] is None for x in r8b.win(0, 25)))
|
||||
check("T8(b): the alarm only while the figure is stale, cleared within 1 "
|
||||
"cycle of the first fresh one", only_while_unknown(r8b))
|
||||
r8c, r8co = res("T8(c) frozen, the car stops"), res("T8(c) off")
|
||||
show("T8(c) frozen, the car stops")
|
||||
a8 = nth(r8c.rel_alarms(), 0)
|
||||
untr = first(int(x["t"] - r8c.R) for x in r8c.tr
|
||||
if x["t"] >= r8c.R - 30 and not trusted(x))
|
||||
check("T8(c): the alarm at base's second, as Off, within 114 s of the stop",
|
||||
present(a8) and a8 <= -30 + 114
|
||||
and as_base("T8(c) frozen, the car stops")
|
||||
and r8c.rel_alarms() == r8co.rel_alarms())
|
||||
check("T8(c): never explained after the figure goes untrusted",
|
||||
present(untr) and not any(x["explains"] for x in r8c.tr
|
||||
if x["t"] >= r8c.R + untr))
|
||||
|
||||
# --- T9: comms ------------------------------------------------------------------ #
|
||||
for nm in ("T2", "T5"):
|
||||
for k in (f"T9(a) {nm} b lost at R", f"T9(a) {nm} b lost at R-1",
|
||||
f"T9(b) {nm} P1 5 s late at R"):
|
||||
show(k)
|
||||
r = res(k)
|
||||
if nm == "T2":
|
||||
check(f"{k}: no alarm edge", r.edges() == [])
|
||||
else:
|
||||
check(f"{k}: the alarm at the base second "
|
||||
f"(R+{BASE_ALARMS[k][0]})", as_base(k))
|
||||
|
||||
# --- T10: a restart ------------------------------------------------------------ #
|
||||
for nm in ("T2", "T5"):
|
||||
tw = res(f"T10 {nm} twin")
|
||||
for k in (-2, 2):
|
||||
r = res(f"T10 {nm} restart R{k:+d}")
|
||||
show(f"T10 {nm} restart R{k:+d}")
|
||||
if nm == "T2":
|
||||
check(f"T10 T2 restart at R{k:+d}: no notice, no red sample, as "
|
||||
f"the unrestarted twin", r.quiet(-60, 900)
|
||||
and tw.quiet(-60, 900))
|
||||
else:
|
||||
check(f"T10 T5 restart at R{k:+d}: the alarm at the base second "
|
||||
f"and the twin's, red as the twin",
|
||||
as_base(f"T10 T5 restart R{k:+d}") and as_base("T10 T5 twin")
|
||||
and len(r.red()) == len(tw.red()))
|
||||
|
||||
# --- T11: the quarter edge ------------------------------------------------------ #
|
||||
for rr in (-1, 0, 1, 43):
|
||||
r = res(f"T11 T2 R=E{rr:+d}")
|
||||
show(f"T11 T2 R=E{rr:+d}")
|
||||
wa = [(int(x["t"] - r.E), x["within_aim"]) for x in r.tr
|
||||
if r.E - 1 <= x["t"] <= r.E]
|
||||
print(f" T11 T2 R=E{rr:+d}: within_aim at E-1/E+0 {wa} (F1, not "
|
||||
f"asserted)")
|
||||
check(f"T11 T2 R=E{rr:+d}: no alarm across the edge", r.quiet(-60, 900))
|
||||
check(f"T11 T5 R=E{rr:+d}: the alarm at the same seconds as base and "
|
||||
f"as Off", as_base(f"T11 T5 R=E{rr:+d}")
|
||||
and res(f"T11 T5 R=E{rr:+d}").rel_alarms()
|
||||
== res(f"T11 T5 R=E{rr:+d} off").rel_alarms())
|
||||
pre = res("T11 C4 T2 R=E+1")
|
||||
show("T11 C4 T2 R=E+1")
|
||||
wa = [(int(x["t"] - pre.E), x["within_aim"]) for x in pre.tr
|
||||
if pre.E - 1 <= x["t"] <= pre.E]
|
||||
print(f" T11 C4: within_aim at E-1/E+0 {wa} (F1, not asserted)")
|
||||
check("T11 C4 PRECONDITION: the guard wants power in the last 60 s of the "
|
||||
"old quarter (house 13 350 W all along, car 1 380 W)",
|
||||
all(x["wants"] for x in pre.tr if pre.E - 60 <= x["t"] < pre.E))
|
||||
sat = [x for x in pre.win(-60, -1) if x["red"]]
|
||||
print(f" T11 C4: red before R {[int(x['t'] - pre.R) for x in sat]} (near "
|
||||
f"the old quarter's end, the guard saturated: SAFETY-81's row)")
|
||||
check("T11 C4: SAFETY-126's latch carried over the edge, the reserve at "
|
||||
"E+1: no floor notice or ERROR R-60..R+900, no red sample from R; "
|
||||
"before R red only where the guard is saturated (not the floor alarm)",
|
||||
pre.quiet(0, 900) and not [t for t in pre.rel_alarms() if t >= -60]
|
||||
and all(x["lim"] and not x["floor_lim"] and not x["alarm"]
|
||||
for x in sat))
|
||||
|
||||
# --- T12: our own phase change -------------------------------------------------- #
|
||||
for k in (-15, 5):
|
||||
r = res(f"T12 T2 1->3 at R{k:+d}")
|
||||
show(f"T12 T2 1->3 at R{k:+d}")
|
||||
check(f"T12 T2, 1->3 at R{k:+d}: no alarm during our own pause or after",
|
||||
r.quiet(-60, 900))
|
||||
on, off = res(f"T12 T5 1->3 at R{k:+d}"), res(f"T12 T5 1->3 at R{k:+d} off")
|
||||
show(f"T12 T5 1->3 at R{k:+d}")
|
||||
a, ao = nth(on.rel_alarms(), 0), nth(off.rel_alarms(), 0)
|
||||
check(f"T12 T5, 1->3 at R{k:+d}: the alarm at base's second, no later "
|
||||
f"than Off's and within OWN_PAUSE_MAX_S "
|
||||
f"({ctl_car.OWN_PAUSE_MAX_S:.0f} s) of the request",
|
||||
present(a, ao) and a <= ao and as_base(f"T12 T5 1->3 at R{k:+d}")
|
||||
and a <= max(k, 0) + ctl_car.OWN_PAUSE_MAX_S)
|
||||
|
||||
# --- T13: a wrong charger reply ------------------------------------------------- #
|
||||
r13 = res("T13(a) draws 400 W manual")
|
||||
show("T13(a) draws 400 W manual")
|
||||
check("T13(a) 400 W: the energy meter never contradicts a 1 380 W figure "
|
||||
"when 400 W is drawn (CORR_RATIO 0.5 and its slack; EV-18 T9(b)), so "
|
||||
"nothing is uncorroborated and the figure explains; base's R+1 alarm "
|
||||
"was F-B", not any(x["contra"] for x in r13.tr)
|
||||
and all(x["w"] == CAR for x in r13.win(-60, 60)))
|
||||
r13c = res("T13(a) draws 100 W manual")
|
||||
show("T13(a) draws 100 W manual")
|
||||
show("T13(a) draws 100 W off")
|
||||
c0 = first(x["t"] for x in r13c.tr if x["contra"])
|
||||
a13 = nth(r13c.rel_alarms(), 0)
|
||||
check("T13(a) 100 W PRECONDITION: the energy meter contradicts the figure "
|
||||
"within 104 + 10 s of the plug-in (R-180)",
|
||||
present(c0) and c0 <= r13c.R - 180 + 114)
|
||||
check("T13(a) 100 W: the alarm at base's second and Off's, and never "
|
||||
"explained after the contradiction in that quarter",
|
||||
present(a13) and as_base("T13(a) draws 100 W manual")
|
||||
and r13c.rel_alarms() == res("T13(a) draws 100 W off").rel_alarms()
|
||||
and not any(x["explains"] for x in r13c.tr
|
||||
if present(c0) and x["t"] >= c0
|
||||
and x["block"] == r13c.at(0)["block"]))
|
||||
for k in ("T13(b) the write ignored, 0 A", "T14(a) 0 W in C",
|
||||
"T14(a) idle B"):
|
||||
show(f"{k} manual")
|
||||
check(f"{k}: the car at 0 W explains nothing: the alarm as Off",
|
||||
same_as_off(k) and not any(
|
||||
x["explains"] for x in res(f"{k} manual").tr))
|
||||
|
||||
# --- T14: configuration -------------------------------------------------------- #
|
||||
show("T14(b) ev_charger off")
|
||||
check("T14(b) ev_charger off: no explanation, the alarm as Off",
|
||||
res("T14(b) ev_charger off").rel_alarms()
|
||||
== res("T14(b) off").rel_alarms() != []
|
||||
and not any(x["explains"] for x in res("T14(b) ev_charger off").tr))
|
||||
for tj in ("t1", "t4"):
|
||||
show(f"T14(c) N=1 anchor {tj}")
|
||||
check(f"T14(c) N=1 anchor {tj}: no alarm",
|
||||
res(f"T14(c) N=1 anchor {tj}").quiet(-60, 900))
|
||||
check("T14(c) N=1 T5: the alarm at the same second as base and as Off",
|
||||
as_base("T14(c) N=1 T5") and res("T14(c) N=1 T5").rel_alarms()
|
||||
== res("T14(c) N=1 T5 off").rel_alarms())
|
||||
|
||||
# --- T15: one battery first ----------------------------------------------------- #
|
||||
for k in ("T15 anchor manual", "T15 honest manual", "T15 honest off"):
|
||||
show(k)
|
||||
check("T15 anchor: a at the reserve at R, b at R+360: no alarm",
|
||||
res("T15 anchor manual").quiet(-60, 900))
|
||||
check("T15 honest (house 19 000 W): the alarm after ALARM_HOLD_S at the "
|
||||
"base second (R+13; Off R+11, as base)", as_base("T15 honest manual"))
|
||||
|
||||
# --- T16: x10 -------------------------------------------------------------------- #
|
||||
for xn in ("x10", "mono1"):
|
||||
r = res(f"T16 {xn} T2")
|
||||
show(f"T16 {xn} T2")
|
||||
check(f"T16 {xn} T2 PRECONDITION: the rise cycle reads b's 4 600 W",
|
||||
present(r.at(10)) and r.at(10)["batt"] == 4600.0)
|
||||
check(f"T16 {xn} T2: no alarm (base: R+10, 10 red cycles)",
|
||||
r.quiet(-60, 900))
|
||||
t3 = sorted(k for k in JOBS if k.startswith(f"T16 {xn} T3 "))
|
||||
print(f" T16 {xn} T3 alarms "
|
||||
f"{[(k[10:], res(k).rel_alarms()) for k in t3]}")
|
||||
check(f"T16 {xn} T3 ({len(t3)} cells): no alarm R-60..R+300",
|
||||
all(res(k).quiet(-60, 300) for k in t3))
|
||||
# mono x1 / wall x10: the car's energy is counted on the monotonic clock,
|
||||
# a tenth of the wall's, so its share of the quarter is short and the
|
||||
# house latch sets late in the quarter (EV-18 F2, out of scope), as base.
|
||||
check(f"T16 {xn} T3: any later alarm at base's second (EV-18 F2)",
|
||||
all(as_base(k) if k in BASE_ALARMS else res(k).quiet(-60, 900)
|
||||
for k in t3))
|
||||
for k in ("T5", "T6"):
|
||||
show(f"T16 {xn} {k} manual")
|
||||
check(f"T16 {xn} {k}: the alarm at the base second",
|
||||
as_base(f"T16 {xn} {k} manual"))
|
||||
check(f"T16 {xn} T7(b) T2: an alarm only while the figure is unknown",
|
||||
only_while_unknown(res(f"T16 {xn} T7(b) T2")))
|
||||
for rr in (-10, 0, 10, 40):
|
||||
check(f"T16 {xn} T11 T2 R=E{rr:+d}: no alarm",
|
||||
res(f"T16 {xn} T11 T2 R=E{rr:+d}").quiet(-60, 900))
|
||||
check(f"T16 {xn} T11 T5 R=E{rr:+d}: the alarm at the base seconds",
|
||||
as_base(f"T16 {xn} T11 T5 R=E{rr:+d}"))
|
||||
|
||||
# --- T17: no flicker -------------------------------------------------------------- #
|
||||
r17 = res("T17 flicker")
|
||||
print(f" T17 alarm edges per quarter {r17.edges_per_quarter()}")
|
||||
check("T17: the house alone straddles aim + 10 W, the batteries cross the "
|
||||
"reserve 3 times: at most one alarm edge per quarter",
|
||||
all(v <= 1 for v in r17.edges_per_quarter().values()))
|
||||
|
||||
# --- N2: the car explains only with a trusted, non-zero figure ----------------- #
|
||||
bad2 = sorted(k for k, r in RES.items()
|
||||
if any(x["explains"] and not trusted(x) for x in r.tr))
|
||||
check(f"N2: car_explains never True with car_alarm_w None, 0 W or "
|
||||
f"contradicted, in any of the {len(RES)} runs: {bad2}", bad2 == [])
|
||||
|
||||
for k in ("N2 no energy entity", "N2 reports 11 kW at 6 A"):
|
||||
show(f"{k} manual")
|
||||
check(f"{k}: the figure is not trusted for the alarm (no corroboration, "
|
||||
f"or capped by the read-back): nothing explained, the alarm as Off",
|
||||
same_as_off(k) and not any(
|
||||
x["explains"] for x in res(f"{k} manual").tr))
|
||||
check("N2 PRECONDITION: the charger without an energy entity reports a "
|
||||
"fresh 1 380 W", all(x["car_raw"] == CAR for x in
|
||||
res("N2 no energy entity manual").win(-60, 60)))
|
||||
|
||||
# --- N4 / T20: no control change --------------------------------------------- #
|
||||
for nm in ("T2", "T5"):
|
||||
a = res("T1 core bw=0 t2 rp=180") if nm == "T2" else res("T10 T5 twin")
|
||||
check(f"N4 {nm}: the claim, the floor, the setpoints and the charger "
|
||||
f"writes are those of the same run with the car never explaining",
|
||||
a.cmd == res(f"N4 {nm} explain off").cmd)
|
||||
|
||||
# --- N5: at most one floor-alarm edge per quarter ------------------------------ #
|
||||
# Base 43b0db7 has 2 edges in the first quarter of these runs: the guard lets
|
||||
# go for one cycle at R+1 (the battery reads 0 W, the meter does not show it
|
||||
# yet), in Off and in the C5 cells too. Not EV-19's; head must not add one.
|
||||
BASE_TWO = ["T1 b: energy first step late", "T1 b: energy never steps",
|
||||
"T11 T5 R=E+0", "T11 T5 R=E+0 off", "T11 T5 R=E+1",
|
||||
"T11 T5 R=E+1 off", "T16 mono1 T11 T5 R=E+0",
|
||||
"T16 mono1 T11 T5 R=E+10", "T16 mono1 T6 off",
|
||||
"T16 x10 T11 T5 R=E+0", "T16 x10 T11 T5 R=E+10", "T16 x10 T6 off",
|
||||
"T6 step R+0 off", "T6 step R+1 off", "T6 step R+5 off"]
|
||||
many = sorted(k for k, r in RES.items()
|
||||
if any(v > (2 if k in BASE_TWO and q == 0 else 1)
|
||||
for q, v in r.edges_per_quarter().items()))
|
||||
check(f"N5: at most one floor-alarm edge per quarter in every run, and no "
|
||||
f"more than base where base has two ({len(RES)} runs): {many}",
|
||||
many == [])
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -61,33 +61,69 @@ class CarPlant(s81._Plant):
|
||||
return await super().call(domain, service, data)
|
||||
|
||||
|
||||
class CarPlantN(CarPlant):
|
||||
"""EV-10b: N batteries, each its own setpoint, power and SoC (`soc` is a
|
||||
dict {"a": %, "b": %}); `rating` is per battery. The grid sees them all."""
|
||||
|
||||
def __init__(self, house, rating, soc, charger):
|
||||
super().__init__(house, rating, 0.0, charger)
|
||||
self.socs = dict(soc)
|
||||
self.hists = {u: [(-1e9, 0.0)] for u in self.socs}
|
||||
|
||||
def batt_of(self, u, at):
|
||||
w = 0.0
|
||||
for when, v in self.hists[u]:
|
||||
if when <= at:
|
||||
w = v
|
||||
return max(-self.rating, min(self.rating, float(round(w))))
|
||||
|
||||
def batt(self, at):
|
||||
return sum(self.batt_of(u, at) for u in self.socs)
|
||||
|
||||
async def number(self, e, invert=False):
|
||||
for u in self.socs:
|
||||
if e == "sensor.soc_" + u:
|
||||
return self.socs[u]
|
||||
if e == "sensor.batt_" + u:
|
||||
return self.batt_of(u, self.t)
|
||||
return await super().number(e, invert)
|
||||
|
||||
async def set_number(self, e, v):
|
||||
if e.startswith("number.sp_"):
|
||||
self.hists[e[-1]].append((self.t + s81.RESPONSE_S, float(v)))
|
||||
return True
|
||||
return await super().set_number(e, v)
|
||||
|
||||
|
||||
def drive(house, *, dur=300.0, rating=2000.0, soc=60.0, cap=3500.0, margin=50,
|
||||
opts=None, plug=True, setpoint=16, phases=3, mode="manual",
|
||||
user_a=16, events=None, sim=None, store=None):
|
||||
user_a=16, events=None, sim=None, store=None, n=1, plant_cls=None,
|
||||
dev_w=5000.0):
|
||||
"""Run it. Returns a namespace-like dict: plant, controller, charger, the
|
||||
notification ids raised with their second, and the controller's rows."""
|
||||
sim = sim or SimCharger(setpoint_a=setpoint)
|
||||
if plug:
|
||||
sim.plug_in()
|
||||
sim.phases_allowed = phases
|
||||
o = rig._options(1, dict({
|
||||
o = rig._options(n, dict({
|
||||
"meter_source": "ha_signed", "p1_net_entity": "sensor.net",
|
||||
"meter_phases": 1, "peak_cap_w": cap, "peak_margin_w": margin,
|
||||
"battery_modes_enabled": True, "max_w": rating,
|
||||
"ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
|
||||
"ev_current_entity": SET}, **(opts or {})))
|
||||
store = store or rig._Store()
|
||||
store.data[unit_key("inverter-a", packmode.USE_KEY)] = False
|
||||
for u in "ab"[:n]:
|
||||
store.data[unit_key("inverter-" + u, packmode.USE_KEY)] = False
|
||||
store.data[packmode.USE_KEY] = False
|
||||
db = os.path.join(tempfile.mkdtemp(prefix="ev4-"), "tariff.db")
|
||||
out = {}
|
||||
|
||||
async def go():
|
||||
plant = CarPlant(house, rating, soc, sim)
|
||||
plant = (plant_cls or CarPlant)(house, rating, soc, sim)
|
||||
c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
|
||||
peak_db_path=db)
|
||||
for i in c.inverters:
|
||||
i.dev_min, i.dev_max = -5000.0, 5000.0
|
||||
i.dev_min, i.dev_max = -dev_w, dev_w
|
||||
c.auto = True
|
||||
clock = [0.0]
|
||||
c.car_now = lambda: clock[0]
|
||||
|
||||
@@ -0,0 +1,223 @@
|
||||
"""EV-18: the real Controller across one quarter edge `E`, N=2, both units at
|
||||
the peak reserve and the car charging (`ev04_peak.drive`). Used by test_ev18.py.
|
||||
|
||||
The run starts `E` s before an edge (rig.BASE is moved back for the run), with
|
||||
a light house so the first quarter does not raise the month's peak (the aim
|
||||
stays `AIM`). At `E - 120` the house steps to the shape, so the guard first
|
||||
wants power at the edge, as on the rig (EV-15 F-A). `force` makes a unit give
|
||||
what the loop gives below the reserve whatever it is told; `lost` drops its
|
||||
reading for some seconds (the grid still sees it). The trace is one dict per
|
||||
cycle, taken after it.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, HERE)
|
||||
|
||||
import ev04_peak as P # noqa: E402
|
||||
import opt11_identity as rig # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
from app import peakguard # noqa: E402
|
||||
|
||||
E = 150 # the edge, in run seconds
|
||||
AIM = 13600.0
|
||||
MARGIN = 50.0
|
||||
PRE_W = 5000.0 # the first quarter's house: under the cap
|
||||
FLOOR = "goodwe_peak_soc_floor"
|
||||
OPTS = {"peak_soc_floor": 20, "inverters": [
|
||||
{"name": "inverter-a", "setpoint_entity": "number.sp_a",
|
||||
"soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a",
|
||||
"max_w": 5000, "bms_soc_floor": 10},
|
||||
{"name": "inverter-b", "setpoint_entity": "number.sp_b",
|
||||
"soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b",
|
||||
"max_w": 4600, "bms_soc_floor": 10}]}
|
||||
|
||||
|
||||
class _Errors(logging.Handler):
|
||||
def __init__(self):
|
||||
super().__init__(logging.ERROR)
|
||||
self.rec = []
|
||||
|
||||
def emit(self, r):
|
||||
self.rec.append(r.getMessage())
|
||||
|
||||
|
||||
ERR = _Errors()
|
||||
_lg = logging.getLogger("goodwe")
|
||||
_lg.addHandler(ERR)
|
||||
_lg.setLevel(logging.ERROR)
|
||||
_lg.propagate = False
|
||||
|
||||
|
||||
class Plant(P.CarPlantN):
|
||||
force = {}
|
||||
lost = {}
|
||||
|
||||
def batt_of(self, u, at):
|
||||
f = self.force.get(u)
|
||||
if f is not None:
|
||||
return float(f(at))
|
||||
return super().batt_of(u, at)
|
||||
|
||||
async def number(self, e, invert=False):
|
||||
for u, secs in self.lost.items():
|
||||
if e == "sensor.batt_" + u and int(self.t) in secs:
|
||||
return None
|
||||
return await super().number(e, invert)
|
||||
|
||||
|
||||
def shape(after, before=PRE_W, at=None):
|
||||
"""The house: `before` until `at` (E - 120), then `after` (W or fn(t))."""
|
||||
at = E - 120 if at is None else at
|
||||
return lambda t: before if t < at else (after(t) if callable(after)
|
||||
else after)
|
||||
|
||||
|
||||
def run(house, *, a=None, b=None, lost=None, car_a=6, phases=1, aim=AIM,
|
||||
mode="manual", dur=None, extra=None, sim=None, soc=None, plug=True,
|
||||
x=1, mono_x=None, explain_off=False, latch_off=False,
|
||||
cover=True):
|
||||
"""One run; returns (run, trace). `x`: fake seconds per cycle (wall and
|
||||
monotonic both; `mono_x` sets the monotonic rate apart). `explain_off`:
|
||||
the car never explains, `latch_off`: no contradiction latch (both for the
|
||||
control-identity check). `cover`: the option `ev_batt_cover`."""
|
||||
force = {}
|
||||
if a is not None:
|
||||
force["a"] = a
|
||||
if b is not None:
|
||||
force["b"] = b
|
||||
cls = type("Plant", (Plant,), {"force": force, "lost": lost or {}})
|
||||
tr = []
|
||||
n_err = [len(ERR.rec)]
|
||||
dur = E + 900 if dur is None else dur
|
||||
|
||||
def hook(plant, c):
|
||||
orig = c.car_settle
|
||||
if explain_off:
|
||||
c._car_explains_alarm = lambda *a_, **k_: False
|
||||
if latch_off:
|
||||
c._car_contradicted = lambda *a_, **k_: False
|
||||
if not cover:
|
||||
c.o["ev_batt_cover"] = False
|
||||
if mono_x is not None and mono_x != x:
|
||||
c.car_now = (lambda f=c.car_now: f() * mono_x / x)
|
||||
|
||||
async def settle():
|
||||
await orig()
|
||||
g = c.peak_guard
|
||||
red = []
|
||||
if plant.t >= E - 130:
|
||||
red = [r_["id"] for r_ in c.checks()
|
||||
if r_["ok"] is False and not r_["warn"]
|
||||
and r_["id"] == "peak_guard"]
|
||||
errs = [m for m in ERR.rec[n_err[0]:]
|
||||
if "may not draw the battery lower" in m]
|
||||
n_err[0] = len(ERR.rec)
|
||||
cl = peakguard.claim(g) if g is not None else None
|
||||
tr.append({
|
||||
"t": plant.t, "explains": c.car_explains,
|
||||
"lim": bool(g is not None and (g.floor_limited
|
||||
or g.saturated)),
|
||||
"within_aim": bool(g is not None and g.within_aim),
|
||||
"wants": bool(g is not None and g.engaged
|
||||
and (g.wanted_w or 0.0) > 0.0),
|
||||
"alarm": c._peak_floor_limited, "red": red, "err": errs,
|
||||
"w": c.car_alarm_w(), "batt": c.site_batt_w,
|
||||
"key": c._carq["key"],
|
||||
"block": (c._peak_proj_real.block_start
|
||||
if c._peak_proj_real is not None else None),
|
||||
"floor_w": g.floor_w if g is not None else None,
|
||||
"lo": getattr(cl, "lo", None),
|
||||
"sp": tuple(i.last_write for i in c.inverters)})
|
||||
c.car_settle = settle
|
||||
|
||||
ev = {0: hook}
|
||||
for t, fn in (extra or {}).items():
|
||||
if t == 0:
|
||||
ev[0] = (lambda p, c, fn=fn: (hook(p, c), fn(p, c)))
|
||||
else:
|
||||
ev[t] = fn
|
||||
socs = soc or {"a": 19.0, "b": 19.0}
|
||||
s = sim
|
||||
if s is None:
|
||||
from chargersim import SimCharger
|
||||
s = SimCharger(setpoint_a=car_a)
|
||||
if x != 1:
|
||||
tick = s.tick
|
||||
s.tick = lambda secs=1.0: tick(secs * x)
|
||||
base, step = rig.BASE, s81.TICK
|
||||
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
|
||||
try:
|
||||
r = P.drive(house, dur=dur, rating=5000.0, soc=socs,
|
||||
cap=aim + MARGIN, phases=phases, n=2, plant_cls=cls,
|
||||
opts=OPTS, dev_w=5000.0, setpoint=car_a, user_a=car_a,
|
||||
mode=mode, events=ev, sim=s, plug=plug)
|
||||
finally:
|
||||
rig.BASE, s81.TICK = base, step
|
||||
return r, tr
|
||||
|
||||
|
||||
def alarms(r):
|
||||
"""Seconds of each goodwe_peak_soc_floor notification."""
|
||||
return [t for t, n in r["raised"] if n == FLOOR]
|
||||
|
||||
|
||||
def window(tr, t0, t1):
|
||||
return [x for x in tr if t0 <= x["t"] <= t1]
|
||||
|
||||
|
||||
def edges(tr):
|
||||
"""Seconds at which the floor alarm goes False -> True."""
|
||||
out, was = [], False
|
||||
for x in tr:
|
||||
if x["alarm"] and not was:
|
||||
out.append(x["t"])
|
||||
was = x["alarm"]
|
||||
return out
|
||||
|
||||
|
||||
def red_secs(tr, t0=None, t1=None):
|
||||
t0 = E - 120 if t0 is None else t0
|
||||
t1 = E + 900 if t1 is None else t1
|
||||
return [x["t"] for x in window(tr, t0, t1) if x["red"]]
|
||||
|
||||
|
||||
def errors(tr):
|
||||
return [x["t"] for x in tr if x["err"]]
|
||||
|
||||
|
||||
def commands(r, tr):
|
||||
"""A digest of every command: the units' setpoints, the charger's writes,
|
||||
and the guard's floor and claim per cycle (N4)."""
|
||||
h = hashlib.sha256()
|
||||
for u in sorted(r["plant"].hists):
|
||||
h.update(repr((u, r["plant"].hists[u])).encode())
|
||||
h.update(repr(r["sim"].writes()).encode())
|
||||
h.update(repr([(x["t"], x["floor_w"], x["lo"], x["sp"])
|
||||
for x in tr]).encode())
|
||||
return h.hexdigest()[:16]
|
||||
|
||||
|
||||
def energy_gap(at, secs=1):
|
||||
"""The charger's energy entity is missing (unknown) for `secs` from `at`."""
|
||||
def on(p, c):
|
||||
p.ch.no_energy = True
|
||||
|
||||
def off(p, c):
|
||||
p.ch.no_energy = False
|
||||
return {at: on, at + secs: off}
|
||||
|
||||
|
||||
def restart(c):
|
||||
"""A restart as the car side sees it: a fresh `car_init` and an empty
|
||||
corroboration history, and no floor alarm standing."""
|
||||
mode, n, a = c.car_mode, c.car_n, c.car_a
|
||||
c.car_init(c.o, c.store)
|
||||
c.car_mode, c.car_n, c.car_a = mode, n, a
|
||||
c.car._hist.clear()
|
||||
c._peak_floor_limited = False
|
||||
@@ -0,0 +1,752 @@
|
||||
"""EV-19: the real Controller, N=2, when the batteries first reach the peak
|
||||
reserve `R` early in a Manual car session (EV-15 F-B). Used by test_ev19.py.
|
||||
|
||||
python3 tools/ev19_reserve.py # the T1 grid, one row per cell
|
||||
|
||||
The units stand at 21 % and give `bw` W (`force`) until `R`, where both read
|
||||
19 %; after `R` they follow the trajectory `traj`. The house is set so that
|
||||
house + car with the batteries at 0 W lands at aim + `over` W (F-B: +520 W,
|
||||
less than the 1 380 W car). Manual is set, then the car plugs in, `rp` s
|
||||
before `R`. The run starts `E` s before a quarter edge (rig.BASE moved back),
|
||||
so `R = E + r_rel`. One dict per cycle, taken after it.
|
||||
|
||||
Trajectories after R: t1 both 0 W; t2 a 0 W, b follows the house (the loop
|
||||
below the reserve covers house + car, up to b's rating); t3 both ramp to 0 W
|
||||
over 3 cycles; t4 as t1, but every battery reading is 10 s old (the rig reads
|
||||
battery W every 10 fake s, P1 every 5) while P1 is fresh; t4r as t1, but P1
|
||||
is 5 s late while the battery reading is fresh.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, HERE)
|
||||
|
||||
import ev04_peak as P # noqa: E402
|
||||
import ev18_peak as H # noqa: E402
|
||||
import opt11_identity as rig # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
from app import peakguard # noqa: E402
|
||||
from chargersim import SimCharger # noqa: E402
|
||||
|
||||
AIM = H.AIM
|
||||
CAR = 1380.0
|
||||
FLOOR = H.FLOOR
|
||||
RATE = {"a": 5000.0, "b": 4600.0}
|
||||
OPTS = H.OPTS
|
||||
OPTS1 = {"peak_soc_floor": 20, "inverters": [OPTS["inverters"][0]]}
|
||||
|
||||
|
||||
class Meter(SimCharger):
|
||||
"""A charger whose energy meter shows no 10 Wh step until `hold_until`
|
||||
(sim seconds; None: always live, float('inf'): never)."""
|
||||
|
||||
hold_until = None
|
||||
_held = None
|
||||
|
||||
def _build(self):
|
||||
if self.hold_until is None or self.t >= self.hold_until:
|
||||
self._held = None
|
||||
return super()._build()
|
||||
if self._held is None:
|
||||
self._held = self.kwh
|
||||
keep, self.kwh = self.kwh, self._held
|
||||
try:
|
||||
return super()._build()
|
||||
finally:
|
||||
self.kwh = keep
|
||||
|
||||
|
||||
class Draw(Meter):
|
||||
"""A charger that draws `real_w` while charging and reports `say_w`
|
||||
(as test_ev18's). `c_at_0`: it stays in mode3 C while drawing 0 W."""
|
||||
|
||||
def __init__(self, real_w, say_w, c_at_0=False, **kw):
|
||||
super().__init__(**kw)
|
||||
self.real_w, self.say_w, self.c_at_0 = real_w, say_w, c_at_0
|
||||
|
||||
def target_w(self):
|
||||
if super().target_w() <= 0.0:
|
||||
return 0.0
|
||||
return self.real_w
|
||||
|
||||
def tick(self, seconds=1.0):
|
||||
super().tick(seconds)
|
||||
if self.c_at_0 and self.state == "B" and not self.full:
|
||||
self.state = "C"
|
||||
|
||||
def _build(self):
|
||||
keep, self._frozen_w = self._frozen_w, self.say_w
|
||||
try:
|
||||
return super()._build()
|
||||
finally:
|
||||
self._frozen_w = keep
|
||||
|
||||
|
||||
class Plant(H.Plant):
|
||||
"""`batt_lag`: every battery reading is that many s old. `p1_lag` with
|
||||
`p1_from`: P1 that many s late from that second on."""
|
||||
|
||||
batt_lag = 0.0
|
||||
p1_lag = 0.0
|
||||
p1_from = 0.0
|
||||
house = None
|
||||
|
||||
def batt_of(self, u, at):
|
||||
f = self.force.get(u)
|
||||
if f is not None:
|
||||
return float(f(at, self))
|
||||
return P.CarPlantN.batt_of(self, u, at)
|
||||
|
||||
def grid(self, at):
|
||||
if self.p1_lag and at >= self.p1_from:
|
||||
at = at - self.p1_lag
|
||||
return super().grid(at)
|
||||
|
||||
async def number(self, e, invert=False):
|
||||
for u, secs in self.lost.items():
|
||||
if e == "sensor.batt_" + u and int(self.t) in secs:
|
||||
return None
|
||||
if self.batt_lag and e.startswith("sensor.batt_") \
|
||||
and e[-1] in self.socs:
|
||||
return self.batt_of(e[-1], self.t - self.batt_lag)
|
||||
return await P.CarPlantN.number(self, e, invert)
|
||||
|
||||
|
||||
def split(bw, units="ab"):
|
||||
"""`bw` over the units, each capped at its rating."""
|
||||
if len(units) == 1:
|
||||
return {units: min(bw, RATE[units])}
|
||||
a = min(RATE["a"], bw / 2.0)
|
||||
b = min(RATE["b"], bw - a)
|
||||
a = min(RATE["a"], bw - b)
|
||||
return {"a": a, "b": b}
|
||||
|
||||
|
||||
def traj_fn(u, traj, before, R, house, step=1):
|
||||
"""Unit `u`'s W at time `at`: `before` until the first cycle after R
|
||||
(R + `step`), then the trajectory. P1 is sampled 0.3 s before each cycle,
|
||||
so the battery reading shows a change one cycle before the meter does."""
|
||||
def f(at, plant):
|
||||
if at < R + step:
|
||||
return before
|
||||
if traj in ("t1", "t4", "t4r"):
|
||||
return 0.0
|
||||
if traj == "t2":
|
||||
if u == "a":
|
||||
return 0.0
|
||||
return min(RATE["b"], house(at) + plant.ch.power_w)
|
||||
if traj == "t3":
|
||||
k = int((at - R) // step)
|
||||
return before * max(0.0, (3 - k) / 3.0)
|
||||
if traj == "keep":
|
||||
return before
|
||||
raise ValueError(traj)
|
||||
return f
|
||||
|
||||
|
||||
def run(*, bw=4250.0, traj="t1", rp=180, r_rel=43, order="manual",
|
||||
energy="ok", x=1, mono_x=None, aim=AIM, over=520.0, house_w=None,
|
||||
house_fn=None, car_a=6, n=2, extra=None, rel=None, lost=None,
|
||||
after=900,
|
||||
soc_after=None, soc0=21.0, mode="manual", sim=None,
|
||||
explain_off=False, latch_off=False, force=None, plug_at=None,
|
||||
man_at=None, opts=None, pre_w=H.PRE_W):
|
||||
"""One run; returns (run, trace, meta). `over`: house + car at batteries
|
||||
0 W lands at aim + `over` W (ignored with `house_w`). `order`: 'manual'
|
||||
(Manual at plug-in - 3 s), 'plug' (plug-in at R-185, Manual at R-180),
|
||||
'off120' (plug-in and charging in Off from R-180, Manual at R-60).
|
||||
`energy`: 'ok', 'late' (first 10 Wh step at plug-in + 150 s), 'never'.
|
||||
`mode`: 'manual' or 'off' (Off throughout: the base for honest alarms).
|
||||
`house_fn`: fn(t, R) for the house after the step. `extra`: events at
|
||||
run seconds, `rel`: at seconds from R. `lost`: {unit: seconds from R}.
|
||||
`plug_at` / `man_at`: plug-in / Manual at these seconds from R (override
|
||||
`order`). `force`: {unit: fn(at, plant) or None (the unit obeys)}.
|
||||
`opts`: added to the options. `pre_w`: the house before its step."""
|
||||
units = "ab" if n == 2 else "a"
|
||||
step = int(x)
|
||||
if order == "plug":
|
||||
lead = 185
|
||||
elif order == "off120":
|
||||
lead = 180
|
||||
else:
|
||||
lead = rp + 3
|
||||
if plug_at is not None or man_at is not None:
|
||||
lead = -min(v for v in (plug_at, man_at) if v is not None)
|
||||
E = 150
|
||||
while E + r_rel - lead - 2 * step < 10:
|
||||
E += 150
|
||||
E = int(-(-E // step) * step)
|
||||
R = E + r_rel
|
||||
if x != 1:
|
||||
R = int(-(-R // step) * step)
|
||||
hw = (aim + over - CAR) if house_w is None else house_w
|
||||
t_house = min(E - 120, R - lead - step)
|
||||
if x != 1:
|
||||
t_house = int(t_house // step * step)
|
||||
|
||||
def house(t):
|
||||
if t < t_house:
|
||||
return pre_w
|
||||
if house_fn is not None:
|
||||
return house_fn(t, R)
|
||||
return hw
|
||||
|
||||
sp = split(bw, units)
|
||||
frc = {u: traj_fn(u, traj, sp[u], R, house, step) for u in units}
|
||||
frc.update(force or {})
|
||||
soc_after = soc_after or {u: 19.0 for u in units}
|
||||
lagb = 10.0 if traj == "t4" else 0.0
|
||||
cls = type("Plant", (Plant,), {
|
||||
"force": frc, "batt_lag": lagb,
|
||||
"lost": {u: {R + k for k in v} for u, v in (lost or {}).items()},
|
||||
"p1_lag": 5.0 if traj == "t4r" else 0.0, "p1_from": float(R)})
|
||||
|
||||
s = sim or Meter(setpoint_a=car_a)
|
||||
if energy == "never":
|
||||
s.hold_until = float("inf")
|
||||
if x != 1:
|
||||
tick = s.tick
|
||||
s.tick = lambda secs=1.0: tick(secs * x)
|
||||
|
||||
if order == "plug":
|
||||
t_plug, t_man = R - 185, R - 180
|
||||
elif order == "off120":
|
||||
t_plug, t_man = R - 180, R - 60
|
||||
else:
|
||||
t_plug, t_man = R - rp, R - rp - 3
|
||||
if plug_at is not None:
|
||||
t_plug = R + plug_at
|
||||
if man_at is not None:
|
||||
t_man = R + man_at
|
||||
if x != 1:
|
||||
t_plug = int(t_plug // step * step)
|
||||
t_man = int(t_man // step * step)
|
||||
if t_man == t_plug and order != "plug":
|
||||
t_man -= step
|
||||
|
||||
tr = []
|
||||
n_err = [len(H.ERR.rec)]
|
||||
|
||||
def hook(plant, c):
|
||||
orig = c.car_settle
|
||||
if explain_off:
|
||||
c._car_explains_alarm = lambda *a_, **k_: False
|
||||
if latch_off:
|
||||
c._car_contradicted = lambda *a_, **k_: False
|
||||
if mono_x is not None and mono_x != x:
|
||||
c.car_now = (lambda f=c.car_now: f() * mono_x / x)
|
||||
|
||||
async def settle():
|
||||
await orig()
|
||||
g = c.peak_guard
|
||||
red = [r_["id"] for r_ in c.checks()
|
||||
if r_["ok"] is False and not r_["warn"]
|
||||
and r_["id"] == "peak_guard"]
|
||||
errs = [m for m in H.ERR.rec[n_err[0]:]
|
||||
if "may not draw the battery lower" in m]
|
||||
n_err[0] = len(H.ERR.rec)
|
||||
cl = peakguard.claim(g) if g is not None else None
|
||||
mono = c.car_now()
|
||||
tr.append({
|
||||
"t": plant.t, "explains": c.car_explains,
|
||||
"lim": bool(g is not None and (g.floor_limited
|
||||
or g.saturated)),
|
||||
"floor_lim": bool(g is not None and g.floor_limited),
|
||||
"within_aim": bool(g is not None and g.within_aim),
|
||||
"wants": bool(g is not None and g.engaged
|
||||
and (g.wanted_w or 0.0) > 0.0),
|
||||
"wanted": None if g is None else g.wanted_w,
|
||||
"target": None if g is None else g.target_w,
|
||||
"alarm": c._peak_floor_limited, "red": red, "err": errs,
|
||||
"w": c.car_alarm_w(), "car_raw": c.car.car_w(mono),
|
||||
"batt": c.site_batt_w,
|
||||
"true_batt": plant.batt(plant.t),
|
||||
"need_real": c._car_need_real, "need_excl": c._car_need_excl,
|
||||
"need_house": c._car_need_house, "over_now": c._car_over_now,
|
||||
"contra": c._car_contra_block is not None and (
|
||||
c._peak_proj_real is not None
|
||||
and c._car_contra_block
|
||||
== c._peak_proj_real.block_start),
|
||||
"idle": c._car_idle(mono), "peak_needed": c._peak_needed,
|
||||
"key": c._carq["key"],
|
||||
"block": (c._peak_proj_real.block_start
|
||||
if c._peak_proj_real is not None else None),
|
||||
"floor_w": g.floor_w if g is not None else None,
|
||||
"lo": getattr(cl, "lo", None),
|
||||
"sp": tuple(i.last_write for i in c.inverters)})
|
||||
c.car_settle = settle
|
||||
|
||||
def set_manual(p, c):
|
||||
c._car_action("car_mode", "manual", c.car_now())
|
||||
|
||||
def plug(p, c):
|
||||
p.ch.plug_in()
|
||||
if energy == "late":
|
||||
p.ch.hold_until = p.ch.t + 150.0
|
||||
|
||||
def reserve(p, c):
|
||||
p.socs.update(soc_after)
|
||||
|
||||
ev = {}
|
||||
|
||||
def add(t, fn):
|
||||
t = int(t)
|
||||
old = ev.get(t)
|
||||
ev[t] = fn if old is None else (
|
||||
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
|
||||
|
||||
add(0, hook)
|
||||
add(t_plug, plug)
|
||||
if mode == "manual":
|
||||
add(t_man, set_manual)
|
||||
add(R, reserve)
|
||||
for t, fn in (extra or {}).items():
|
||||
add(t, fn)
|
||||
for t, fn in (rel or {}).items():
|
||||
add(R + t, fn)
|
||||
base, tick0 = rig.BASE, s81.TICK
|
||||
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
|
||||
o = dict(OPTS if n == 2 else OPTS1, **(opts or {}))
|
||||
try:
|
||||
r = P.drive(house, dur=R + after + step, rating=5000.0,
|
||||
soc={u: soc0 for u in units}, cap=aim + H.MARGIN,
|
||||
phases=1, n=n, plant_cls=cls, opts=o, dev_w=5000.0,
|
||||
setpoint=car_a, user_a=car_a, mode="off", events=ev,
|
||||
sim=s, plug=False)
|
||||
finally:
|
||||
rig.BASE, s81.TICK = base, tick0
|
||||
meta = {"E": E, "R": R, "t_plug": t_plug, "t_man": t_man,
|
||||
"t_house": t_house, "house_w": hw, "step": step}
|
||||
return r, tr, meta
|
||||
|
||||
|
||||
# ---------------------------------------------------------- event helpers
|
||||
# For `rel` (seconds from R) or `extra` (run seconds).
|
||||
def p1_gap(t0, secs):
|
||||
"""No P1 sample reaches the add-on for `secs` from `t0` (it is late)."""
|
||||
def off(p, c):
|
||||
c.p1._ev19_submit = c.p1.submit
|
||||
c.p1.submit = lambda *a, **k: None
|
||||
|
||||
def on(p, c):
|
||||
c.p1.submit = c.p1._ev19_submit
|
||||
return {t0: off, t0 + secs: on}
|
||||
|
||||
|
||||
def stale(t0, t1):
|
||||
"""The charger's readings stop reaching the car tracker from t0 to t1:
|
||||
its figure ages past `stale_s`."""
|
||||
def off(p, c):
|
||||
c.car._ev19_observe = c.car.observe
|
||||
c.car.observe = lambda *a, **k: None
|
||||
|
||||
def on(p, c):
|
||||
c.car.observe = c.car._ev19_observe
|
||||
return {t0: off, t1: on}
|
||||
|
||||
|
||||
def unavailable(t0, t1):
|
||||
return {t0: lambda p, c: p.ch.go_unavailable(True),
|
||||
t1: lambda p, c: p.ch.go_unavailable(False)}
|
||||
|
||||
|
||||
def restart(t0):
|
||||
return {t0: lambda p, c: H.restart(c)}
|
||||
|
||||
|
||||
def phases(t0, n=3):
|
||||
"""The user asks for `n` phases (the add-on's own 0 A pause follows)."""
|
||||
return {t0: lambda p, c: c._car_action("car_phases", n, c.car_now())}
|
||||
|
||||
|
||||
def socs(t0, **s):
|
||||
return {t0: lambda p, c: p.socs.update(s)}
|
||||
|
||||
|
||||
def merge(*evs):
|
||||
out = {}
|
||||
for e in evs:
|
||||
for t, fn in e.items():
|
||||
old = out.get(t)
|
||||
out[t] = fn if old is None else (
|
||||
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
|
||||
return out
|
||||
|
||||
|
||||
# --------------------------------------------------------------- grading
|
||||
def window(tr, t0, t1):
|
||||
return [x for x in tr if t0 <= x["t"] <= t1]
|
||||
|
||||
|
||||
def alarms(r):
|
||||
return H.alarms(r)
|
||||
|
||||
|
||||
def edges(tr):
|
||||
return H.edges(tr)
|
||||
|
||||
|
||||
def bad(x):
|
||||
"""An alarm, red sample or ERROR in this cycle."""
|
||||
return bool(x["alarm"] or x["red"] or x["err"])
|
||||
|
||||
|
||||
def repro(r, tr, meta, t0=-10, t1=60):
|
||||
"""T1's definition: a floor notice, ERROR or red sample in R-10..R+60 in
|
||||
a cycle where the car figure is trusted (the shape lands under the aim
|
||||
without the car, so the car explains). Returns (cycles, C5-only cycles)."""
|
||||
R = meta["R"]
|
||||
w = window(tr, R + t0, R + t1)
|
||||
notes = [t for t in alarms(r) if R + t0 <= t <= R + t1]
|
||||
hit = [x["t"] for x in w if bad(x) and x["w"] is not None
|
||||
and x["w"] > 0.0]
|
||||
c5 = [x["t"] for x in w if bad(x) and not (x["w"] is not None
|
||||
and x["w"] > 0.0)]
|
||||
return hit, c5, notes
|
||||
|
||||
|
||||
def quiet(r, tr, t0, t1):
|
||||
return (not [t for t in alarms(r) if t0 <= t <= t1]
|
||||
and not any(bad(x) for x in window(tr, t0, t1)))
|
||||
|
||||
|
||||
def commands(r, tr):
|
||||
h = hashlib.sha256()
|
||||
for u in sorted(r["plant"].hists):
|
||||
h.update(repr((u, r["plant"].hists[u])).encode())
|
||||
h.update(repr(r["sim"].writes()).encode())
|
||||
h.update(repr([(x["t"], x["floor_w"], x["lo"], x["sp"])
|
||||
for x in tr]).encode())
|
||||
return h.hexdigest()[:16]
|
||||
|
||||
|
||||
def row(name, r, tr, meta):
|
||||
hit, c5, notes = repro(r, tr, meta)
|
||||
R = meta["R"]
|
||||
first = hit[:1]
|
||||
cause = ""
|
||||
if first:
|
||||
x = next(y for y in tr if y["t"] == first[0])
|
||||
cause = (f"w={x['w']:.0f} batt={x['batt']} true={x['true_batt']:.0f}"
|
||||
f" real={x['need_real']:d} excl={x['need_excl']:d} "
|
||||
f"house={x['need_house']:d} over={x['over_now']:d} "
|
||||
f"contra={x['contra']:d} pn={x['peak_needed']:d} "
|
||||
f"wa={x['within_aim']:d} wanted={x['wanted']:.0f}")
|
||||
return (f"{name:42s} R={R:5d} notes {[t - R for t in notes]} "
|
||||
f"hit {[t - R for t in hit][:6]}{'...' if len(hit) > 6 else ''}"
|
||||
f" n={len(hit)} c5 {len(c5)} err "
|
||||
f"{len([x for x in window(tr, R - 10, R + 60) if x['err']])} "
|
||||
f"red900 {len([x for x in window(tr, R - 60, R + 900) if x['red']])}"
|
||||
f" {cause}")
|
||||
|
||||
|
||||
def t2_shape(**kw):
|
||||
"""The reproducing shape (T2): b follows the house from R, 0 W before."""
|
||||
return dict(dict(bw=0.0, traj="t2"), **kw)
|
||||
|
||||
|
||||
def t5_shape(**kw):
|
||||
"""The honest shape (T5): the house alone misses the aim by 1 680 W, more
|
||||
than the 1 380 W car; the batteries give 4 250 W until R."""
|
||||
return dict(dict(bw=4250.0, traj="t1", house_w=AIM + 1680.0), **kw)
|
||||
|
||||
|
||||
def flicker_force(bw=2000.0):
|
||||
"""T17: each unit gives bw/2 above its reserve and ramps to 0 W over 3
|
||||
cycles once at it (tau3); back above it, it gives bw/2 again at once."""
|
||||
def mk(u):
|
||||
st = {"since": None}
|
||||
|
||||
def f(at, plant):
|
||||
if plant.socs[u] >= 20.0:
|
||||
st["since"] = None
|
||||
return bw / 2.0
|
||||
if st["since"] is None:
|
||||
st["since"] = at
|
||||
k = int(at - st["since"])
|
||||
return bw / 2.0 * max(0.0, (3 - k) / 3.0)
|
||||
return f
|
||||
return {"a": mk("a"), "b": mk("b")}
|
||||
|
||||
|
||||
def _step_house(k, lo=AIM + 520.0 - CAR, hi=AIM + 1900.0):
|
||||
return lambda t, R: lo if t < R + k else hi
|
||||
|
||||
|
||||
def _ignoring():
|
||||
"""The charger accepts the 6 A write and ignores it: the car stays at
|
||||
0 A."""
|
||||
s = Meter(setpoint_a=0)
|
||||
s.refuse = "ignore"
|
||||
return s
|
||||
|
||||
|
||||
def _full_at_plug(p, c):
|
||||
"""The car is full (after the plug-in at R-180): mode3 B, 0 W."""
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
def _no_energy(p, c):
|
||||
"""The charger has no energy entity."""
|
||||
p.ch.no_energy = True
|
||||
|
||||
|
||||
def _freeze_stop(p, c):
|
||||
p.ch.freeze()
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
def jobs():
|
||||
"""Every controller run test_ev19.py grades: {name: kwargs}."""
|
||||
j = {}
|
||||
for name, kw in grid():
|
||||
j["T1 " + name] = kw
|
||||
# T3: the battery W sweep
|
||||
for tj in ("t1", "t2"):
|
||||
for bw in range(0, 4601, 200):
|
||||
j[f"T3 {tj} bw={bw}"] = dict(bw=float(bw), traj=tj)
|
||||
j[f"T3 {tj} tau5"] = dict(bw=9600.0, traj=tj, aim=6000.0,
|
||||
house_w=5200.0)
|
||||
# T4: the landing without the car at aim + 9 / + 11 W
|
||||
for d in (9, 11):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T4 +{d} {md}"] = t2_shape(house_w=AIM + d, mode=md)
|
||||
# T5: honest at the reserve
|
||||
for tj in ("t1", "t4"):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T5 {tj} {md}"] = t5_shape(traj=tj, mode=md)
|
||||
for md in ("manual", "off"):
|
||||
j[f"T5 tau5 {md}"] = dict(bw=9600.0, traj="t1", aim=6000.0,
|
||||
house_w=7700.0, mode=md)
|
||||
# T6: the honest step in the reserve cycle
|
||||
for k in (0, 1, 5):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T6 step R+{k} {md}"] = dict(bw=4250.0, traj="t1", mode=md,
|
||||
house_fn=_step_house(k))
|
||||
# T7: unknown values
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
j[f"T7(a) {nm}"] = sh(lost={"a": {0, 1}})
|
||||
j[f"T7(b) {nm}"] = sh(rel=unavailable(0, 1))
|
||||
j["T7(a) T5 off"] = t5_shape(lost={"a": {0, 1}}, mode="off")
|
||||
j["T7(b) T5 off"] = t5_shape(rel=unavailable(0, 1), mode="off")
|
||||
# T8: a stale car figure
|
||||
j["T8(a) Off 120 s, Manual R-5"] = t2_shape(plug_at=-125, man_at=-5)
|
||||
j["T8(b) stale R-5..R+20"] = t2_shape(rel=stale(-5, 20))
|
||||
j["T8(c) frozen, the car stops"] = t5_shape(rel={-30: _freeze_stop})
|
||||
j["T8(c) off"] = t5_shape(rel={-30: _freeze_stop}, mode="off")
|
||||
# T9: comms
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
j[f"T9(a) {nm} b lost at R"] = sh(lost={"b": {0}})
|
||||
j[f"T9(a) {nm} b lost at R-1"] = sh(lost={"b": {-1}})
|
||||
j[f"T9(b) {nm} P1 5 s late at R"] = sh(rel=p1_gap(0, 5))
|
||||
# T10: a restart
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
j[f"T10 {nm} twin"] = sh()
|
||||
for k in (-2, 2):
|
||||
j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k))
|
||||
# T11: the quarter edge
|
||||
for rr in (-1, 0, 1, 43):
|
||||
j[f"T11 T2 R=E{rr:+d}"] = t2_shape(r_rel=rr)
|
||||
j[f"T11 T5 R=E{rr:+d}"] = t5_shape(r_rel=rr)
|
||||
j[f"T11 T5 R=E{rr:+d} off"] = t5_shape(r_rel=rr, mode="off")
|
||||
# C4: the old quarter heads over the aim (the house high all along), so the
|
||||
# guard wants power in its last 60 s and SAFETY-126's latch is carried
|
||||
j["T11 C4 T2 R=E+1"] = t2_shape(r_rel=1, house_w=13350.0, pre_w=13350.0)
|
||||
# T12: our own phase change
|
||||
for k in (-15, 5):
|
||||
j[f"T12 T2 1->3 at R{k:+d}"] = t2_shape(rel=phases(k))
|
||||
j[f"T12 T5 1->3 at R{k:+d}"] = t5_shape(rel=phases(k))
|
||||
j[f"T12 T5 1->3 at R{k:+d} off"] = t5_shape(rel=phases(k),
|
||||
mode="off")
|
||||
# T13: a wrong charger reply
|
||||
# (a): the house + the 400 W it really draws lands at aim + 520 W, so the
|
||||
# house alone misses by 120 W; (b) and T14(a): the car draws 0 W and the
|
||||
# house alone lands at aim + 520 W. An alarm is due in each.
|
||||
for md in ("manual", "off"):
|
||||
j[f"T13(a) draws 400 W {md}"] = t2_shape(
|
||||
sim=Draw(400.0, CAR, setpoint_a=6), house_w=AIM + 120.0, mode=md)
|
||||
j[f"T13(a) draws 100 W {md}"] = t2_shape(
|
||||
sim=Draw(100.0, CAR, setpoint_a=6), house_w=AIM + 420.0, mode=md)
|
||||
j[f"T13(b) the write ignored, 0 A {md}"] = t2_shape(
|
||||
sim=_ignoring(), house_w=AIM + 520.0, mode=md)
|
||||
# T14: configuration
|
||||
j[f"T14(a) 0 W in C {md}"] = t2_shape(
|
||||
sim=Draw(0.0, 0.0, c_at_0=True, setpoint_a=6),
|
||||
house_w=AIM + 520.0, mode=md)
|
||||
j[f"T14(a) idle B {md}"] = t2_shape(
|
||||
house_w=AIM + 520.0, mode=md, rel={-179: _full_at_plug})
|
||||
j["T14(b) ev_charger off"] = t2_shape(opts={"ev_charger": "off"})
|
||||
j["T14(b) off"] = t2_shape(mode="off")
|
||||
for tj in ("t1", "t4"):
|
||||
j[f"T14(c) N=1 anchor {tj}"] = dict(n=1, bw=4250.0, traj=tj)
|
||||
j["T14(c) N=1 T5"] = t5_shape(n=1)
|
||||
j["T14(c) N=1 T5 off"] = t5_shape(n=1, mode="off")
|
||||
# T15: one battery first (SAFETY-87)
|
||||
for nm, hw in (("anchor", AIM + 520.0 - CAR), ("honest", 19000.0)):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T15 {nm} {md}"] = dict(
|
||||
bw=4250.0, traj="t1", house_w=hw, mode=md,
|
||||
force={"b": None}, soc_after={"a": 19.0, "b": 35.0},
|
||||
rel=socs(360, b=19.0))
|
||||
# T16: x10 (wall and mono), and mono x1 / wall x10
|
||||
for xn, xk in (("x10", dict(x=10)), ("mono1", dict(x=10, mono_x=1))):
|
||||
xk = dict(xk, r_rel=40)
|
||||
# x10: b at 1 200 W before R (at 0 W, which the forced unit holds
|
||||
# against the guard's floor, SAFETY-37's gate reads it as frozen)
|
||||
xk2 = dict(xk, bw=1200.0)
|
||||
j[f"T16 {xn} T2"] = t2_shape(**xk2)
|
||||
for tj in ("t1", "t4"):
|
||||
for bw in (0.0, 2000.0, 4250.0):
|
||||
j[f"T16 {xn} T3 {tj} bw={bw:.0f}"] = dict(bw=bw, traj=tj,
|
||||
**xk)
|
||||
for md in ("manual", "off"):
|
||||
j[f"T16 {xn} T5 {md}"] = t5_shape(mode=md, **xk)
|
||||
j[f"T16 {xn} T6 {md}"] = dict(bw=4250.0, traj="t1", mode=md,
|
||||
house_fn=_step_house(0), **xk)
|
||||
j[f"T16 {xn} T7(b) T2"] = t2_shape(rel=unavailable(0, 10), **xk2)
|
||||
for rr in (-10, 0, 10, 40):
|
||||
j[f"T16 {xn} T11 T2 R=E{rr:+d}"] = t2_shape(
|
||||
**dict(xk2, r_rel=rr))
|
||||
j[f"T16 {xn} T11 T5 R=E{rr:+d}"] = t5_shape(**dict(xk, r_rel=rr))
|
||||
# T17: no flicker
|
||||
j["T17 flicker"] = dict(
|
||||
force=flicker_force(), after=1200,
|
||||
rel=merge(socs(300, a=21.0, b=21.0), socs(600, a=19.0, b=19.0)),
|
||||
house_fn=lambda t, R: AIM + 10.0 + (40.0 if int(t // 7) % 2
|
||||
else -40.0))
|
||||
# N2: figures only `car_w_trusted` keeps out of the alarm path: no energy
|
||||
# entity (never corroborated, never contradicted) and 11 kW reported at
|
||||
# a 6 A read-back (capped at 1 518 W; the house alone misses by 1 680 W)
|
||||
for md in ("manual", "off"):
|
||||
j[f"N2 no energy entity {md}"] = t2_shape(extra={0: _no_energy},
|
||||
mode=md)
|
||||
j[f"N2 reports 11 kW at 6 A {md}"] = t5_shape(
|
||||
sim=Draw(CAR, 11000.0, setpoint_a=6), mode=md)
|
||||
# T20 / N4: the same runs with the car never explaining
|
||||
j["N4 T2 explain off"] = t2_shape(explain_off=True)
|
||||
j["N4 T5 explain off"] = t5_shape(explain_off=True)
|
||||
return j
|
||||
|
||||
|
||||
def grid():
|
||||
"""The T1 cells: (name, kwargs)."""
|
||||
cells = []
|
||||
for bw in (0.0, 400.0, 800.0, 2000.0, 4250.0, 9600.0):
|
||||
for tj in ("t1", "t2", "t3", "t4", "t4r"):
|
||||
for rp in (30, 100, 110, 180, 600):
|
||||
kw = dict(bw=bw, traj=tj, rp=rp)
|
||||
if bw == 9600.0:
|
||||
kw.update(aim=6000.0, house_w=5200.0)
|
||||
cells.append((f"core bw={bw:.0f} {tj} rp={rp}", kw))
|
||||
cells.append(("a: plug R-185, Manual R-180", dict(order="plug")))
|
||||
cells.append(("a: Off 120 s, Manual R-60", dict(order="off120")))
|
||||
cells.append(("b: energy first step late", dict(energy="late")))
|
||||
cells.append(("b: energy never steps", dict(energy="never")))
|
||||
for rr in (-60, 0, 1, 43, 450, 890):
|
||||
cells.append((f"c: R=E{rr:+d}", dict(r_rel=rr)))
|
||||
cells.append(("d: x10 wall+mono", dict(x=10, r_rel=40)))
|
||||
cells.append(("d: x10 wall, mono x1", dict(x=10, mono_x=1, r_rel=40)))
|
||||
for tj, bw in (("t4", 4250.0), ("t2", 4250.0), ("t2", 1200.0)):
|
||||
cells.append((f"d: x10 wall+mono {tj} bw={bw:.0f}",
|
||||
dict(x=10, r_rel=40, traj=tj, bw=bw)))
|
||||
cells.append((f"d: x10 wall, mono x1 {tj} bw={bw:.0f}",
|
||||
dict(x=10, mono_x=1, r_rel=40, traj=tj, bw=bw)))
|
||||
return cells
|
||||
|
||||
|
||||
class Res:
|
||||
"""What a check needs from one run, picklable: the notices (`raised`,
|
||||
seconds and ids), the trace, the command digest and the run's times."""
|
||||
|
||||
def __init__(self, r, tr, meta):
|
||||
self.raised = list(r["raised"])
|
||||
self.tr, self.meta = tr, meta
|
||||
self.cmd = commands(r, tr)
|
||||
self.R, self.E = meta["R"], meta["E"]
|
||||
|
||||
def alarms(self):
|
||||
return [t for t, n in self.raised if n == FLOOR]
|
||||
|
||||
def rel_alarms(self):
|
||||
return [int(t - self.R) for t in self.alarms()]
|
||||
|
||||
def edges(self):
|
||||
return [int(t - self.R) for t in edges(self.tr)]
|
||||
|
||||
def errors(self):
|
||||
return [int(x["t"] - self.R) for x in self.tr if x["err"]]
|
||||
|
||||
def red(self, t0=-60, t1=900):
|
||||
return [int(x["t"] - self.R) for x in
|
||||
window(self.tr, self.R + t0, self.R + t1) if x["red"]]
|
||||
|
||||
def at(self, k):
|
||||
return next((x for x in self.tr if x["t"] == self.R + k), None)
|
||||
|
||||
def win(self, t0, t1):
|
||||
return window(self.tr, self.R + t0, self.R + t1)
|
||||
|
||||
def quiet(self, t0=-60, t1=900):
|
||||
return quiet({"raised": self.raised}, self.tr,
|
||||
self.R + t0, self.R + t1)
|
||||
|
||||
def edges_per_quarter(self):
|
||||
"""False -> True edges of the floor alarm per quarter (N5)."""
|
||||
out = {}
|
||||
for t in edges(self.tr):
|
||||
q = int((t - self.E) // 900)
|
||||
out[q] = out.get(q, 0) + 1
|
||||
return out
|
||||
|
||||
def summary(self):
|
||||
return {"alarms": self.rel_alarms(), "edges": self.edges(),
|
||||
"errors": self.errors(), "red": len(self.red()),
|
||||
"cmd": self.cmd}
|
||||
|
||||
|
||||
_JOBS = {}
|
||||
|
||||
|
||||
def _job(name):
|
||||
import logging
|
||||
logging.disable(logging.WARNING)
|
||||
return name, Res(*run(**_JOBS[name]))
|
||||
|
||||
|
||||
def run_many(jobs, procs=None):
|
||||
"""{name: kwargs} -> {name: Res}, `procs` runs at a time (fork: the
|
||||
kwargs may hold functions)."""
|
||||
import multiprocessing
|
||||
_JOBS.clear()
|
||||
_JOBS.update(jobs)
|
||||
procs = procs or int(os.environ.get("EV19_JOBS", "0")) \
|
||||
or min(8, os.cpu_count() or 1)
|
||||
ctx = multiprocessing.get_context("fork")
|
||||
with ctx.Pool(procs) as pool:
|
||||
return dict(pool.imap_unordered(_job, list(jobs), chunksize=1))
|
||||
|
||||
|
||||
def _one(cell):
|
||||
import logging
|
||||
logging.disable(logging.WARNING)
|
||||
name, kw = cell
|
||||
try:
|
||||
r, tr, meta = run(**kw)
|
||||
except Exception as e: # noqa: BLE001
|
||||
import traceback
|
||||
return name, f"{name:42s} Traceback {e!r}\n{traceback.format_exc()}"
|
||||
return name, row(name, r, tr, meta)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import multiprocessing
|
||||
cells = grid()
|
||||
if len(sys.argv) > 1:
|
||||
cells = [c for c in cells if any(a in c[0] for a in sys.argv[1:])]
|
||||
with multiprocessing.Pool(int(os.environ.get("EV19_JOBS", "8"))) as pool:
|
||||
for _name, line in pool.imap(_one, cells):
|
||||
print(line, flush=True)
|
||||
Reference in New Issue
Block a user