From 551b44da506b0e40dd2343e71c0fe8d373cf77a1 Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Tue, 27 Oct 2026 14:33:18 +0100 Subject: [PATCH 1/2] fix(mpc): deadline reserve waits for the latest start (#1718) Without an accepted plan, a saved goal reserved full charger power whatever the slack, so a restart or one failed replan started the car and the next plan paused it. The reserve now acts only once the rest of the goal at full power plus one hourly slot reaches the deadline; a running reserve keeps a second slot so a SoC step does not cycle it. DeadlineNeed checks the passed minW, so a loadpoint with min_charge_w 0 and steps gets the reserve. Co-Authored-By: Claude Opus 5.5 --- .../d6-deadline-reserve-latest-start.md | 5 + go/internal/cars/reserve_test.go | 8 +- go/internal/loadpoint/deadline_need.go | 2 +- go/internal/mpc/deadline_directive.go | 18 ++++ go/internal/mpc/deadline_directive_test.go | 1 + go/internal/mpc/deadline_runtime_test.go | 2 + go/internal/mpc/deadline_slack_test.go | 101 ++++++++++++++++++ 7 files changed, 135 insertions(+), 2 deletions(-) create mode 100644 .changeset/d6-deadline-reserve-latest-start.md create mode 100644 go/internal/mpc/deadline_slack_test.go diff --git a/.changeset/d6-deadline-reserve-latest-start.md b/.changeset/d6-deadline-reserve-latest-start.md new file mode 100644 index 000000000..00fb2efbc --- /dev/null +++ b/.changeset/d6-deadline-reserve-latest-start.md @@ -0,0 +1,5 @@ +--- +"ftw": patch +--- + +A saved car goal no longer starts the car at full power when no plan is in force, such as just after a restart or after one failed replan. Without a plan the car now waits at 0 W until its latest start: the time the rest of the goal takes at full power, plus one hour. A loadpoint whose minimum charge power is 0 W now also gets this reserve. diff --git a/go/internal/cars/reserve_test.go b/go/internal/cars/reserve_test.go index 634b070de..623a608d9 100644 --- a/go/internal/cars/reserve_test.go +++ b/go/internal/cars/reserve_test.go @@ -16,7 +16,13 @@ import ( func fallback(t *testing.T, h *harness) (ok bool, maxW float64) { t.Helper() svc := &mpc.Service{LoadpointStates: h.mgr.States} - d, _ := svc.SlotDirectiveAt(h.now) + // Ask at the goal's deadline: before its latest start a goal with + // slack holds 0 W (#1718). + at := h.now + if st, ok := h.mgr.State("easee"); ok && st.TargetTime.After(at) { + at = st.TargetTime + } + d, _ := svc.SlotDirectiveAt(at) return d.LoadpointFallback["easee"], d.LoadpointMaxPowerW["easee"] } diff --git a/go/internal/loadpoint/deadline_need.go b/go/internal/loadpoint/deadline_need.go index c061943d0..9e9ffeae7 100644 --- a/go/internal/loadpoint/deadline_need.go +++ b/go/internal/loadpoint/deadline_need.go @@ -13,7 +13,7 @@ func DeadlineNeed(st State, minW, maxW float64, steps []float64) (energyWh, powe !finite(st.CurrentSoC) || st.CurrentSoC < 0 || st.CurrentSoC > 1 || !finite(st.TargetSoC) || st.TargetSoC < 0 || st.TargetSoC > 1 || !finite(st.VehicleCapacityWh) || st.VehicleCapacityWh <= 0 || - !finite(st.MinChargeW) || !finite(st.MaxChargeW) || st.MinChargeW <= 0 || st.MaxChargeW < st.MinChargeW { + !finite(st.MinChargeW) || !finite(st.MaxChargeW) || !(minW > 0) || st.MaxChargeW < st.MinChargeW { return 0, 0, false } // A vehicle-limit goal aims at 1, and the controller still stops at the diff --git a/go/internal/mpc/deadline_directive.go b/go/internal/mpc/deadline_directive.go index e943a10b4..db59ef73f 100644 --- a/go/internal/mpc/deadline_directive.go +++ b/go/internal/mpc/deadline_directive.go @@ -7,6 +7,10 @@ import ( "github.com/srcfl/ftw/go/internal/loadpoint" ) +// deadlineReserveMargin is one slot at the planner's longest (hourly) price +// slot. +const deadlineReserveMargin = time.Hour + // withDeadlineReserve supplies current EV intent. It never activates or // invents an optimizer plan, battery energy, a price or a solar forecast. func (s *Service) withDeadlineReserve(now time.Time, d SlotDirective, accepted bool) (SlotDirective, bool) { @@ -43,6 +47,20 @@ func (s *Service) withDeadlineReserve(now time.Time, d SlotDirective, accepted b continue } if !st.ManualActive { + // A goal with slack waits for its latest start: the time the + // remaining need takes at full power, plus an hourly price slot. + // Before that the car holds 0 W, as at startup, so a missing + // plan does not start a car the next plan would pause (#1718). + // A running reserve keeps a second slot, so one SoC step does + // not stop and restart it. + margin := deadlineReserveMargin + if st.CommandedKnown && st.CommandedW > 0 { + margin *= 2 + } + latestStart := st.TargetTime.Add(-time.Duration(need / peak * float64(time.Hour))).Add(-margin) + if now.Before(latestStart) { + continue + } // Near the goal use the smallest legal offer that can deliver // this minute's need, rather than reserving the charger's full // rating for a final few Wh. A charger without a table takes diff --git a/go/internal/mpc/deadline_directive_test.go b/go/internal/mpc/deadline_directive_test.go index 924b49204..0cee1974c 100644 --- a/go/internal/mpc/deadline_directive_test.go +++ b/go/internal/mpc/deadline_directive_test.go @@ -159,6 +159,7 @@ func TestGoalReserveHoldsToThePlansLimits(t *testing.T) { } { st := deadlineGoalState(now, "a") st.MinChargeW, st.MaxChargeW, st.AllowedStepsW, st.CarMaxW, st.CarPhases, st.CurrentSoC = 1380, 11040, steps, 3680, c.carPhases, c.soc + st.TargetTime = now.Add(30 * time.Minute) // Within the latest start, even near the goal. svc := &Service{ LoadpointStates: func() []loadpoint.State { return []loadpoint.State{st} }, PlanningLimits: func(st loadpoint.State) (float64, float64, []float64) { diff --git a/go/internal/mpc/deadline_runtime_test.go b/go/internal/mpc/deadline_runtime_test.go index 20d901a9b..a45bdff5b 100644 --- a/go/internal/mpc/deadline_runtime_test.go +++ b/go/internal/mpc/deadline_runtime_test.go @@ -100,6 +100,8 @@ func TestDeadlineReserveSmallRemainderLeavesRoomForOtherGoal(t *testing.T) { now := time.Now() a, b := deadlineGoalState(now, "a"), deadlineGoalState(now, "b") a.CurrentSoC = a.TargetSoC - loadpoint.DefaultChargeEfficiency/a.VehicleCapacityWh // 1 AC Wh. + // Within the latest start. + a.TargetTime = now.Add(30 * time.Minute) svc := &Service{LoadpointStates: func() []loadpoint.State { return []loadpoint.State{a, b} }} d, ok := svc.SlotDirectiveAt(now) if !ok || math.Abs(d.LoadpointEnergyWh["a"]-1) > 1e-6 || d.LoadpointMaxPowerW["a"] != a.MinChargeW || d.LoadpointMaxPowerW["b"] != b.MaxChargeW { diff --git a/go/internal/mpc/deadline_slack_test.go b/go/internal/mpc/deadline_slack_test.go new file mode 100644 index 000000000..e08d0055c --- /dev/null +++ b/go/internal/mpc/deadline_slack_test.go @@ -0,0 +1,101 @@ +package mpc + +import ( + "context" + "encoding/json" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/loadpoint" +) + +// #1718: a goal with hours of slack must not start the car at full +// power merely because no executable plan exists right now. +// Car 30 % -> 80 % of 60 kWh needs ~33.3 kWh AC, ~3 h at 11 kW; deadline in +// 10 h, so ~7 h of slack. +func TestDeadlineReserveWaitsForLatestStart(t *testing.T) { + for _, fault := range []string{"no plan", "failed replacement", "restored archive"} { + t.Run(fault, func(t *testing.T) { + now := time.Now() + mgr := loadpoint.NewManager() + cfg := loadpoint.Config{ID: "a", DriverName: "charger-a", VehicleCapacityWh: 60000, PluginSoC: .3, + MinChargeW: 1380, MaxChargeW: 11000, AllowedStepsW: []float64{0, 1380, 4140, 6900, 11000}} + mgr.Load([]loadpoint.Config{cfg}) + mgr.Observe(cfg.ID, true, 0, 0, true) + mgr.SetCurrentSoC(cfg.ID, .3) + mgr.SetTarget(cfg.ID, .8, now.Add(10*time.Hour)) + svc := &Service{LoadpointStates: mgr.States} + // The accepted plan holds 0 W now (cheap hours are at night). + zeroPlan := Plan{GeneratedAtMs: now.UnixMilli(), Actions: []Action{{SlotStartMs: now.UnixMilli(), SlotLenMin: 15, + LoadpointPowerW: map[string]float64{"a": 0}, LoadpointMaxPowerW: map[string]float64{"a": 11000}}}} + switch fault { + case "failed replacement": + svc.InstallPlan(zeroPlan, Params{}, cfg.ID) + svc.failedReplanGeneration = svc.publishedReplanGeneration + 1 + case "restored archive": + // RestoreDiagnostic sets s.last but never s.executionPlan. + p := zeroPlan + svc.last = &p + svc.lastLoadpointID = cfg.ID + } + var commanded float64 = -1 + ctrl := loadpoint.NewController(mgr, func(at time.Time) (loadpoint.Directive, bool) { + d, ok := svc.SlotDirectiveAt(at) + return d.LoadpointDirective(), ok + }, func(string) (loadpoint.EVSample, bool) { + return loadpoint.EVSample{Connected: true, RequestActive: true}, true + }, func(_ context.Context, _ string, payload []byte) error { + var cmd struct { + Action string `json:"action"` + PowerW float64 `json:"power_w"` + } + if err := json.Unmarshal(payload, &cmd); err != nil { + return err + } + if cmd.Action == "ev_set_current" { + commanded = cmd.PowerW + } + return nil + }) + ctrl.SetFuseEVMax(func() (float64, bool) { return 11000, true }) + ctrl.TickWithDispatch(context.Background(), now, true) + st, _ := mgr.State(cfg.ID) + t.Logf("fault=%s commanded=%.0f W reason=%q", fault, commanded, st.CommandedReason) + if commanded > 0 { + t.Fatalf("fault=%s: car started at %.0f W (%q) with ~7 h of slack before deadline", fault, commanded, st.CommandedReason) + } + }) + } +} + +// The reserve starts at the latest start: the need at full power plus one +// hourly slot before the deadline. A running reserve keeps a second slot, so +// one SoC step does not stop it and start it again a few minutes later. +func TestDeadlineReserveLatestStart(t *testing.T) { + now := time.Now() + base := deadlineGoalState(now, "a") // ~33.3 kWh at 11 kW: ~3.03 h. + need := (base.TargetSoC - base.CurrentSoC) * base.VehicleCapacityWh / loadpoint.DefaultChargeEfficiency + atFull := time.Duration(need / base.MaxChargeW * float64(time.Hour)) + for _, c := range []struct { + name string + slack time.Duration + running bool + want bool + }{ + {"inside the latest start", 59 * time.Minute, false, true}, + {"before the latest start", 61 * time.Minute, false, false}, + {"running, inside two slots", 119 * time.Minute, true, true}, + {"running, before two slots", 121 * time.Minute, true, false}, + } { + st := base + st.TargetTime = now.Add(atFull + c.slack) + if c.running { + st.CommandedKnown, st.CommandedW = true, 11000 + } + svc := &Service{LoadpointStates: func() []loadpoint.State { return []loadpoint.State{st} }} + d, _ := svc.SlotDirectiveAt(now) + if got := d.LoadpointFallback["a"]; got != c.want { + t.Errorf("%s: reserve %v, want %v (%+v)", c.name, got, c.want, d) + } + } +} From 49ce18de255ec51a7808d6ab96cf0ce871f30cc9 Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Tue, 27 Oct 2026 15:52:06 +0100 Subject: [PATCH 2/2] fix(mpc): count shared goals in the deadline reserve's latest start (#1718) Each car's latest start assumed it alone got its full peak. Two goal cars on one EV fuse allowance with no plan then both waited until about need/peak + 1 h, and the fuse budget, which serves the earliest deadline first, could not finish both. A goal's latest start now counts the hours at full power of every saved goal due at or before its deadline. With one car the rule is unchanged; with cars on separate fuse room they only start earlier, as before #1718. Adds TestDeadlineReserveSharedAllowance (two cars, shared 11 kW, earliest deadline first and even split) and TestDeadlineReserveZeroMinWithSteps, which covers the DeadlineNeed minW change at directive and controller level. Both fail without their fix. Co-Authored-By: Claude Opus 5.5 --- .../d6-deadline-reserve-latest-start.md | 2 +- go/internal/mpc/deadline_directive.go | 28 ++++- go/internal/mpc/deadline_slack_test.go | 112 ++++++++++++++++++ 3 files changed, 139 insertions(+), 3 deletions(-) diff --git a/.changeset/d6-deadline-reserve-latest-start.md b/.changeset/d6-deadline-reserve-latest-start.md index 00fb2efbc..70ec9afb2 100644 --- a/.changeset/d6-deadline-reserve-latest-start.md +++ b/.changeset/d6-deadline-reserve-latest-start.md @@ -2,4 +2,4 @@ "ftw": patch --- -A saved car goal no longer starts the car at full power when no plan is in force, such as just after a restart or after one failed replan. Without a plan the car now waits at 0 W until its latest start: the time the rest of the goal takes at full power, plus one hour. A loadpoint whose minimum charge power is 0 W now also gets this reserve. +A saved car goal no longer starts the car at full power when no plan is in force, such as just after a restart or after one failed replan. Without a plan the car now waits at 0 W until its latest start: the time the rest of its goal, and of every other car goal due by the same time, takes at full power, plus one hour. A loadpoint whose minimum charge power is 0 W now also gets this reserve. diff --git a/go/internal/mpc/deadline_directive.go b/go/internal/mpc/deadline_directive.go index db59ef73f..030b96cd9 100644 --- a/go/internal/mpc/deadline_directive.go +++ b/go/internal/mpc/deadline_directive.go @@ -27,6 +27,23 @@ func (s *Service) withDeadlineReserve(now time.Time, d SlotDirective, accepted b if !accepted { d = SlotDirective{SlotStart: now, SlotEnd: now.Add(time.Minute), EVOnly: true} } + // Each saved goal's hours at its own peak. Cars may share one fuse + // allowance, which the controller gives earliest deadline first, so a + // goal's latest start counts every goal due at or before it (#1718). + type goalHours struct { + due time.Time + hours float64 + } + var goals []goalHours + for _, st := range states { + if st.ID == "" || st.ManualActive || st.SurplusOnly { + continue + } + minW, maxW, steps := limits(st) + if need, peak, ok := loadpoint.DeadlineNeed(st, minW, maxW, steps); ok { + goals = append(goals, goalHours{due: st.TargetTime, hours: need / peak}) + } + } for _, st := range states { if _, hasBudget := d.LoadpointEnergyWh[st.ID]; hasBudget && !st.ManualActive { continue // An accepted zero budget is a price decision, too. @@ -48,7 +65,8 @@ func (s *Service) withDeadlineReserve(now time.Time, d SlotDirective, accepted b } if !st.ManualActive { // A goal with slack waits for its latest start: the time the - // remaining need takes at full power, plus an hourly price slot. + // remaining need of every goal due by its deadline takes at + // full power, one car after another, plus an hourly price slot. // Before that the car holds 0 W, as at startup, so a missing // plan does not start a car the next plan would pause (#1718). // A running reserve keeps a second slot, so one SoC step does @@ -57,7 +75,13 @@ func (s *Service) withDeadlineReserve(now time.Time, d SlotDirective, accepted b if st.CommandedKnown && st.CommandedW > 0 { margin *= 2 } - latestStart := st.TargetTime.Add(-time.Duration(need / peak * float64(time.Hour))).Add(-margin) + var hours float64 + for _, g := range goals { + if !g.due.After(st.TargetTime) { + hours += g.hours + } + } + latestStart := st.TargetTime.Add(-time.Duration(hours * float64(time.Hour))).Add(-margin) if now.Before(latestStart) { continue } diff --git a/go/internal/mpc/deadline_slack_test.go b/go/internal/mpc/deadline_slack_test.go index e08d0055c..590fc90bb 100644 --- a/go/internal/mpc/deadline_slack_test.go +++ b/go/internal/mpc/deadline_slack_test.go @@ -3,6 +3,7 @@ package mpc import ( "context" "encoding/json" + "math" "testing" "time" @@ -99,3 +100,114 @@ func TestDeadlineReserveLatestStart(t *testing.T) { } } } + +// A loadpoint with min_charge_w 0 and a step table takes its legal minimum +// from the steps, so it gets the reserve within its latest start, and the +// controller orders power. +func TestDeadlineReserveZeroMinWithSteps(t *testing.T) { + now := time.Now() + st := deadlineGoalState(now, "a") + st.MinChargeW = 0 + st.TargetTime = now.Add(30 * time.Minute) + svc := &Service{LoadpointStates: func() []loadpoint.State { return []loadpoint.State{st} }} + d, ok := svc.SlotDirectiveAt(now) + if !ok || !d.LoadpointFallback["a"] || d.LoadpointMaxPowerW["a"] != 11000 { + t.Fatalf("no reserve for min 0 with steps: ok=%v %+v", ok, d) + } + + mgr := loadpoint.NewManager() + cfg := loadpoint.Config{ID: "a", DriverName: "charger-a", VehicleCapacityWh: 60000, PluginSoC: .3, + MinChargeW: 0, MaxChargeW: 11000, AllowedStepsW: []float64{0, 1380, 4140, 6900, 11000}} + mgr.Load([]loadpoint.Config{cfg}) + mgr.Observe(cfg.ID, true, 0, 0, true) + mgr.SetCurrentSoC(cfg.ID, .3) + mgr.SetTarget(cfg.ID, .8, now.Add(2*time.Hour)) + svc = &Service{LoadpointStates: mgr.States} + var commanded float64 = -1 + ctrl := loadpoint.NewController(mgr, func(at time.Time) (loadpoint.Directive, bool) { + d, ok := svc.SlotDirectiveAt(at) + return d.LoadpointDirective(), ok + }, func(string) (loadpoint.EVSample, bool) { + return loadpoint.EVSample{Connected: true, RequestActive: true}, true + }, func(_ context.Context, _ string, payload []byte) error { + var cmd struct { + Action string `json:"action"` + PowerW float64 `json:"power_w"` + } + if err := json.Unmarshal(payload, &cmd); err != nil { + return err + } + if cmd.Action == "ev_set_current" { + commanded = cmd.PowerW + } + return nil + }) + ctrl.SetFuseEVMax(func() (float64, bool) { return 11000, true }) + ctrl.TickWithDispatch(context.Background(), now, true) + if commanded <= 0 { + st, _ := mgr.State(cfg.ID) + t.Fatalf("min 0 loadpoint within its latest start got %.0f W (%q)", commanded, st.CommandedReason) + } +} + +// Two goal cars share one 11 kW EV allowance and no plan is in force. Each +// latest start counts every goal due by that car's deadline, so both goals +// are met when the allowance goes earliest deadline first, as +// freezeFuseBudget gives it, and also, for equal deadlines, when it is split +// evenly. SoC is read in whole percent, as cars report it. +func TestDeadlineReserveSharedAllowance(t *testing.T) { + t0 := time.Date(2026, 10, 27, 18, 0, 0, 0, time.UTC) + for _, c := range []struct { + name string + dueA, dueB time.Duration + edf bool + }{ + {"same deadline, earliest first", 10 * time.Hour, 10 * time.Hour, true}, + {"same deadline, even split", 10 * time.Hour, 10 * time.Hour, false}, + {"b one hour later, earliest first", 10 * time.Hour, 11 * time.Hour, true}, + {"b far later, earliest first", 4*time.Hour + 30*time.Minute, 20 * time.Hour, true}, + } { + t.Run(c.name, func(t *testing.T) { + a, b := deadlineGoalState(t0, "a"), deadlineGoalState(t0, "b") + a.TargetTime, b.TargetTime = t0.Add(c.dueA), t0.Add(c.dueB) + soc := map[string]float64{"a": .3, "b": .3} + commanded := map[string]float64{} + for now := t0; now.Before(b.TargetTime); now = now.Add(time.Minute) { + var states []loadpoint.State + for _, base := range []loadpoint.State{a, b} { // deadline order + if !now.Before(base.TargetTime) { + continue + } + cur := base + cur.CurrentSoC = math.Floor(soc[base.ID]*100+1e-9) / 100 + cur.CommandedKnown, cur.CommandedW = true, commanded[base.ID] + states = append(states, cur) + } + svc := &Service{LoadpointStates: func() []loadpoint.State { return states }} + d, _ := svc.SlotDirectiveAt(now) + var want []string + for _, st := range states { + if d.LoadpointFallback[st.ID] && d.LoadpointMaxPowerW[st.ID] > 0 && soc[st.ID] < st.TargetSoC { + want = append(want, st.ID) + } + } + clear(commanded) + room := 11000.0 + for _, id := range want { + w := min(d.LoadpointMaxPowerW[id], room) + if !c.edf { + w = min(d.LoadpointMaxPowerW[id], 11000/float64(len(want))) + } + room -= w + commanded[id] = w + soc[id] = min(.8, soc[id]+w/60*loadpoint.DefaultChargeEfficiency/60000) + } + } + for _, id := range []string{"a", "b"} { + if soc[id] < .8-1e-9 { + t.Errorf("%s missed its goal: SoC %.3f, want 0.80", id, soc[id]) + } + } + }) + } +}