From 50606d76fea194686adc94775dccb1ed425a4dde Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Sun, 25 Oct 2026 09:35:15 +0100 Subject: [PATCH 1/2] fix(loadpoint): a duty quarter runs the car for the plan's on-time The home box on 25 Oct 2026 ran at 230.8 V, so the car drew 10386 W against the plan's 10350 W and spent the quarter's energy about 3 s early. Core ordered 0 W; the stop reached the Easee in the next quarter, which wanted 8970 W. With Core's own offer at 0, the EV hard limit took the start path and read the car's own current still on L1 as house load: fuse_cap_w=0 for 84 s, then 9 A, then charging.interrupted and a replan that moved the car an hour later. A duty slot now commands its on-power for the plan's on-time, the slot's energy at that power from the plan's interval start, and on until the energy is spent. A car that draws more than its step keeps running for the on-time; one that draws less runs until the energy is spent, as before. The extra on-time only continues a running order, so a car something else stopped stays stopped. An off-time shorter than CommandSettle would reach the charger only in the next slot, so the car runs to the slot's end. The deadline reserve keeps its own rule. The sitesim rows replay the night at 230.8 V and 237 V and fail on master. Co-Authored-By: Claude Opus 5.5 --- .changeset/ev-keeps-order-at-quarter-end.md | 5 ++ docs/energyplan-contract.md | 6 +- go/internal/control/sitesim_test.go | 50 +++++++++++++ go/internal/loadpoint/controller.go | 20 +++++- .../loadpoint/controller_energy_test.go | 72 +++++++++++++++++++ 5 files changed, 149 insertions(+), 4 deletions(-) create mode 100644 .changeset/ev-keeps-order-at-quarter-end.md diff --git a/.changeset/ev-keeps-order-at-quarter-end.md b/.changeset/ev-keeps-order-at-quarter-end.md new file mode 100644 index 000000000..555e6d7d9 --- /dev/null +++ b/.changeset/ev-keeps-order-at-quarter-end.md @@ -0,0 +1,5 @@ +--- +"ftw": patch +--- + +A car the plan runs at a fixed step for a quarter no longer stops a few seconds early. On mains above 230 V the car draws a little more than its step, so it used up the quarter's energy early. The stop then reached the charger in the next quarter, and on a busy phase the start test kept the car off for over a minute. A car now runs for the plan's charging time in the quarter, or until the energy is used up if that comes later. Core no longer sends a pause shorter than 20 seconds at the end of a quarter. diff --git a/docs/energyplan-contract.md b/docs/energyplan-contract.md index e6dddfd4f..d15d238e7 100644 --- a/docs/energyplan-contract.md +++ b/docs/energyplan-contract.md @@ -110,8 +110,10 @@ not establish the greatest reachable energy or the cheapest plan. - `flex_max_power_w` is the allowed on-step; zero means off. Mean power must lie between zero and that step. - Stored EV energy increases by `mean_W * hours * charge_efficiency`. -- Core applies the on-step until the energy budget is spent, then pauses. - Validation must cover joint on/off pulse states, grid limits, surplus-only +- Core applies the on-step from the start of the executable part for its + on-time, the energy budget at the on-step, and on until the metered energy + is spent if that comes later, then pauses. An off-time under 20 s at the + slot's end is not sent. Validation must cover joint on/off pulse states, grid limits, surplus-only charging, battery-to-EV rules and the corresponding costs. For example, 1,000 Wh at efficiency 1 over a remaining 15 minutes requires diff --git a/go/internal/control/sitesim_test.go b/go/internal/control/sitesim_test.go index 61e0fba67..8e4bea715 100644 --- a/go/internal/control/sitesim_test.go +++ b/go/internal/control/sitesim_test.go @@ -495,6 +495,49 @@ func planEV(w float64) loadpoint.PlanFunc { } } +// homeBoxNightPlan is the home box's plan for the car on 25 Oct 2026: its +// on-power and the energy each quarter gives it. +func homeBoxNightPlan(now time.Time) (loadpoint.Directive, bool) { + slot, evW, onW := now.Truncate(15*time.Minute), 10350.0, 10350.0 + if slot.Minute() == 45 { + evW, onW = 8395, 8970 + } + return loadpoint.Directive{SlotStart: slot, SlotEnd: slot.Add(15 * time.Minute), + LoadpointEnergyWh: map[string]float64{"garage": evW / 4}, LoadpointMaxPowerW: map[string]float64{"garage": onW}}, true +} + +// homeBoxNight is the home box on 25 Oct 2026 from 02:29: a 3x20 A site +// whose mains runs at volts while Core reckons with 230 V, an Easee that +// answers in 8 s, a 9.6 kWh battery and the night's plan. The car must +// charge through 02:45 and run the plan's 13 A beside the battery's 2091 W. +func homeBoxNight(name string, volts float64) simScenario { + return simScenario{name: name, start: time.Date(2026, 10, 26, 2, 29, 0, 0, time.Local), run: 21 * time.Minute, + plant: func(p *sitesim.Plant) { + p.Fuse.RatingA, p.Voltage, p.HouseW = 20, volts, houseA(2.5, 1.3, 1.2) + p.EVSE.Delay, p.EVSE.ReadbackLag = 8*time.Second, 0 + p.Battery = &sitesim.Battery{Phases: 3, MaxChargeW: 5000, MaxDischargeW: 5000, CapacityWh: 9600, SoC: .21, Latency: 8 * time.Second} + }, + plan: homeBoxNightPlan, + setup: func(s *simSite) { + s.every, s.state.SiteFuseVoltage = 3*time.Second, 230 + s.ctrl.SetSiteFuse(loadpoint.SiteFuse{MaxAmps: 20, Voltage: 230, PhaseCnt: 3}) + s.state.Mode, s.state.UseEnergyDispatch = ModePlannerArbitrage, true + s.state.SlotDirective = func(now time.Time) (SlotDirective, bool) { + slot, w := now.Truncate(15*time.Minute), 711.0 + if slot.Minute() == 45 { + w = 2091 + } + return SlotDirective{SlotStart: slot, SlotEnd: slot.Add(15 * time.Minute), BatteryEnergyWh: w / 4, Strategy: "arbitrage"}, true + } + }, + expect: []simExpect{{21*time.Minute - time.Second, func(s *simSite) error { + if s.p.EVSE.OfferA != 13 || s.p.EVSE.DrawW <= 0 || math.Abs(s.p.Battery.W-2091) > 100 { + return fmt.Errorf("at 02:50: car offered %.0f A and draws %.0f W, battery %.0f W; want the plan's 13 A and 2091 W", s.p.EVSE.OfferA, s.p.EVSE.DrawW, s.p.Battery.W) + } + return nil + }}}} +} + // planBatteryCharge has the plan charge the battery at w for the hour. func planBatteryCharge(w float64) func(*simSite) { return func(s *simSite) { @@ -661,6 +704,13 @@ func simScenarios() []simScenario { return nil }}, }}, + // The home box, 25 Oct 2026, v0.155.1-beta.1: the car drew 10386 W of + // the plan's 10350 W and spent the quarter's energy 3 s early. Core + // stopped it; at 02:45 the plan wanted 8970 W with the battery at + // 2091 W, but the start test read the car's own current on L1 and kept + // it off for 84 s. At 237 V the energy runs out 27 s early. + homeBoxNight("home box night, quarter's energy spent 3 s early", 230.8), + homeBoxNight("home box night at 237 V, energy spent 27 s early", 237), // A one-phase car (a plug-in hybrid) on the field night's table: the // plan's 4.8 kW three-phase order is 7 A a phase, which the car takes // on L1 alone, 1.6 kW. Once the meter shows it, the order is the diff --git a/go/internal/loadpoint/controller.go b/go/internal/loadpoint/controller.go index b13b7e2d4..6cb11aee1 100644 --- a/go/internal/loadpoint/controller.go +++ b/go/internal/loadpoint/controller.go @@ -2517,14 +2517,30 @@ func (c *Controller) computeCommandForBudget(now time.Time, lpCfg Config, curren } maxW := lpCfg.MaxChargeW if ceiling, ok := d.LoadpointMaxPowerW[lpCfg.ID]; ok { + // A duty plan commands its legal on-power for its on-time, the slot's + // energy at that power, and on until the energy is spent. A car that + // draws more than its step, as on a mains above 230 V, spends the + // energy early but keeps running for the on-time; a car stopped by + // then stays stopped. An off-time shorter than CommandSettle would + // reach the charger only in the next slot, so the car runs to the + // slot's end. The energy and the ceiling are both the plan's watts, + // before a one-phase car's order is scaled. + onUntil := now + if ceiling > 0 && budgetWh > 0 && !now.Before(d.SlotStart) && !d.LoadpointFallback[lpCfg.ID] { + onUntil = d.SlotStart.Add(time.Duration(budgetWh / ceiling * float64(time.Hour))) + if d.SlotEnd.Sub(onUntil) < CommandSettle { + onUntil = d.SlotEnd + } + } + st, _ := c.manager.State(lpCfg.ID) + running := st.CommandedKnown && st.CommandedW > 0 if onePhaseCar { ceiling *= 3 } maxW = min(maxW, ceiling) - if maxW <= 0 || remainingWh <= 1e-6 || remainingS <= 0 { + if maxW <= 0 || remainingS <= 0 || (remainingWh <= 1e-6 && (!running || !now.Before(onUntil))) { return 0, true, false } - // A duty plan commands its legal on-power until the Wh budget is spent. wantW = maxW } // Joint fuse allocator (dispatch.go) caps EV demand when battery + EV diff --git a/go/internal/loadpoint/controller_energy_test.go b/go/internal/loadpoint/controller_energy_test.go index c282d0d65..43e635898 100644 --- a/go/internal/loadpoint/controller_energy_test.go +++ b/go/internal/loadpoint/controller_energy_test.go @@ -96,6 +96,78 @@ func TestDutyPlanCommandsOnPowerThenStopsAtEnergyBudget(t *testing.T) { } } +// A duty slot runs its on-power for the plan's on-time, its energy at that +// power. The home box on 25 Oct 2026: the plan gave the car 10350 W for the +// whole quarter, the mains ran at 230.8 V and the car drew 10386 W, so the +// energy ran out 3 s before the quarter ended. The stop reached the charger +// in the next quarter, which wanted the car too. +func TestDutySlotRunsItsOnTime(t *testing.T) { + for _, tc := range []struct { + name string + from int // seconds into the quarter the plan's interval starts, as after a replan + onS float64 // the plan's on-time at 10350 W from then + draw float64 // what the car draws per watt ordered + capFrom, capTo int // the fuse cap is capW in [capFrom, capTo) + capW float64 + stopAt int // the tick the order goes to 0 W; -1: never + finalW float64 // the order at the quarter's last tick, when it never stops + }{ + {name: "a full quarter at 230.8 V (the home box)", onS: 900, draw: 230.8 / 230, stopAt: -1, finalW: 10350}, + {name: "a full quarter at 239 V", onS: 900, draw: 239.0 / 230, stopAt: -1, finalW: 10350}, + {name: "replanned at 5 minutes, 239 V", from: 300, onS: 600, draw: 239.0 / 230, stopAt: -1, finalW: 10350}, + {name: "nine tenths, the car draws 4 % more", onS: 810, draw: 1.04, stopAt: 810}, + {name: "nine tenths, the car draws 5 % less", onS: 810, draw: .95, stopAt: 855}, + {name: "an off-time of 15 s", onS: 885, draw: 1, stopAt: -1, finalW: 10350}, + {name: "an off-time of 20 s", onS: 880, draw: 1, stopAt: 882}, + {name: "an off-time of 25 s, the car draws 2 % more", onS: 875, draw: 1.02, stopAt: 876}, + {name: "no energy", onS: 0, draw: 1, stopAt: 0}, + {name: "a fuse cap of 5000 W in the last minute", onS: 900, draw: 230.8 / 230, capFrom: 840, capTo: 900, capW: 5000, stopAt: -1, finalW: 4140}, + {name: "a fuse stop once the energy is spent", onS: 810, draw: 1.04, capFrom: 783, capTo: 795, stopAt: 783}, + } { + t.Run(tc.name, func(t *testing.T) { + quarter := time.Date(2026, 10, 25, 1, 30, 0, 0, time.UTC) + cfg := Config{ID: "garage", DriverName: "easee", MinChargeW: 4140, MaxChargeW: 11040, AllowedStepsW: []float64{0, 4140, 8970, 10350}} + budgetWh := 10350 * tc.onS / 3600 + dir := &Directive{SlotStart: quarter.Add(time.Duration(tc.from) * time.Second), SlotEnd: quarter.Add(15 * time.Minute), + LoadpointEnergyWh: map[string]float64{"garage": budgetWh}, LoadpointMaxPowerW: map[string]float64{"garage": 10350}} + samples := map[string]EVSample{"easee": {Connected: true, RequestActive: true, SessionWh: 1000}} + sender := &fakeSender{} + c := newTestController(t, []Config{cfg}, dir, samples, sender) + var s int + c.SetFuseEVMax(func() (float64, bool) { + if s >= tc.capFrom && s < tc.capTo { + return tc.capW, true + } + return 1e9, true + }) + var delivered, drawW, cmdW float64 + stoppedAt := -1 + for s = tc.from; s < 900; s += 3 { + now := quarter.Add(time.Duration(s) * time.Second) + delivered += drawW * 3 / 3600 + sample := samples["easee"] + sample.PowerW, sample.PowerAt, sample.SessionWh, sample.EnergyAt = drawW, now, 1000+delivered, now + samples["easee"] = sample + c.Tick(context.Background(), now) + cmd, ok := lastSetCurrent(sender.calls) + if !ok { + t.Fatal("missing current command") + } + if stoppedAt >= 0 && cmd.power > 0 { + t.Fatalf("started again at %ds after stopping at %ds", s, stoppedAt) + } + if stoppedAt < 0 && cmd.power == 0 { + stoppedAt = s + } + cmdW, drawW = cmd.power, cmd.power*tc.draw + } + if stoppedAt != tc.stopAt || tc.stopAt < 0 && cmdW != tc.finalW { + t.Fatalf("stopped at %ds (want %d), last order %.0f W (want %.0f); %.1f of %.1f Wh delivered", stoppedAt, tc.stopAt, cmdW, tc.finalW, delivered, budgetWh) + } + }) + } +} + func TestDutyDispatchStopsForUnavailablePowerAndKeepsSpentBudget(t *testing.T) { start := time.Now().Truncate(time.Minute) cfg := Config{ID: "garage", DriverName: "easee", MinChargeW: 4140, MaxChargeW: 11000} From 56f01080462d9f28e226337dd9962d1f6bad942c Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Sun, 25 Oct 2026 10:27:21 +0100 Subject: [PATCH 2/2] test(control): the import ceiling cuts a duty quarter's on-time At 237 V the car spends the 02:45 quarter's energy at 02:59:33 and the on-time keeps it on. At 02:59:40 the hour's ceiling leaves 5 kW for the rest of the hour. The EV hard limit's cap applies after the loadpoint's order, so the car goes to 0 W on import_limit at the next tick and stays off: the spent energy keeps it there. Co-Authored-By: Claude Opus 5.5 --- .../control/sitesim_duty_ceiling_test.go | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 go/internal/control/sitesim_duty_ceiling_test.go diff --git a/go/internal/control/sitesim_duty_ceiling_test.go b/go/internal/control/sitesim_duty_ceiling_test.go new file mode 100644 index 000000000..2f77d22f6 --- /dev/null +++ b/go/internal/control/sitesim_duty_ceiling_test.go @@ -0,0 +1,63 @@ +package control + +import ( + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/loadpoint" + "github.com/srcfl/ftw/go/internal/sitesim" +) + +// A duty quarter keeps the car on for the plan's on-time after its energy is +// spent. Core's import ceiling still cuts it: the on-time only shapes what +// the loadpoint asks for, and the EV hard limit's cap applies after it. Here +// the mains runs at 237 V, so the car draws 10665 W of the plan's 10350 W +// and spends the 02:45 quarter's energy at 02:59:33. At 02:59:40 the hour's +// ceiling leaves 5 kW for the rest of the hour, under the house and the car. +func TestSiteSimDutyOnTimeYieldsToTheImportCeiling(t *testing.T) { + start := time.Date(2026, 10, 26, 2, 30, 0, 0, time.Local) + p := simPlant(start) + p.Voltage, p.HouseW, p.EVSE.ReadbackLag = 237, houseA(1.5, 1.5, 1.5), 0 + quarter := start.Add(15 * time.Minute) + s := &simSite{p: p, lp: simLoadpoint(), plan: func(now time.Time) (loadpoint.Directive, bool) { + slot := now.Truncate(15 * time.Minute) + if now.Before(start) || !now.Before(quarter.Add(15*time.Minute)) { + return loadpoint.Directive{}, false + } + return loadpoint.Directive{SlotStart: slot, SlotEnd: slot.Add(15 * time.Minute), + LoadpointEnergyWh: map[string]float64{"garage": 10350.0 / 4}, LoadpointMaxPowerW: map[string]float64{"garage": 10350}}, true + }} + s.setup = func(s *simSite) { + s.state.SiteFuseVoltage = 230 + s.ctrl.SetSiteFuse(loadpoint.SiteFuse{MaxAmps: p.Fuse.RatingA, Voltage: 230, PhaseCnt: 3}) + s.mgr.SetSchedule(s.lp.ID, loadpoint.Schedule{SoC: .8}) + } + s.boot() + s.run(quarter.Sub(p.Now)) + quarterWh := p.EVSE.SessionWh + s.run(quarter.Add(14*time.Minute + 39*time.Second).Sub(p.Now)) + if s.failure != "" { + t.Fatal(s.failure) + } + if spentWh := p.EVSE.SessionWh - quarterWh; s.offerW != 10350 || spentWh < 10350.0/4 { + t.Fatalf("setup at 02:59:39: offer %.0f W, %.0f of %.0f Wh in the quarter; want the on-time running past the spent energy", s.offerW, spentWh, 10350.0/4) + } + s.state.PeakImportCeilingW = 5000 + cutAt := p.Now + for s.offerW != 0 && p.Now.Sub(cutAt) < 5*time.Second { + s.step() + } + // The cut is the ceiling's; after it the spent energy keeps the car off. + if st, _ := s.mgr.State(s.lp.ID); s.offerW != 0 || st.CommandedReason != "import_limit" { + t.Fatalf("%v after the ceiling: offer %.0f W (%s), want 0 W on import_limit", p.Now.Sub(cutAt), s.offerW, st.CommandedReason) + } + s.run(quarter.Add(15*time.Minute - sitesim.Step).Sub(p.Now)) + for _, c := range s.commands { + if c.device == "evse" && c.at.After(cutAt) && c.w > 0 { + t.Fatalf("ordered the car %.0f W at %s, after the ceiling cut it", c.w, c.at.Format("15:04:05")) + } + } + if p.EVSE.DrawW != 0 { + t.Fatalf("the car still draws %.0f W at the quarter's end", p.EVSE.DrawW) + } +}