From 7e81a5986ff826d2542544e6118cee42d5d8b56f Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Mon, 26 Oct 2026 18:43:02 +0100 Subject: [PATCH 1/3] fix(control): enforce configured battery charge ceilings --- .changeset/ems-battery-soc-max.md | 8 + go/cmd/ftw/battery_soc_max_test.go | 68 +++++++++ go/cmd/ftw/control_state.go | 2 +- go/cmd/ftw/main.go | 19 ++- go/cmd/ftw/modbus_owner_test.go | 2 +- go/internal/api/api_battery_soc_max_test.go | 42 ++++++ go/internal/api/api_control_feedback.go | 10 +- go/internal/control/battery_full.go | 18 ++- go/internal/control/battery_soc_max_test.go | 154 ++++++++++++++++++++ go/internal/control/dispatch.go | 17 ++- 10 files changed, 323 insertions(+), 17 deletions(-) create mode 100644 .changeset/ems-battery-soc-max.md create mode 100644 go/cmd/ftw/battery_soc_max_test.go create mode 100644 go/internal/api/api_battery_soc_max_test.go create mode 100644 go/internal/control/battery_soc_max_test.go diff --git a/.changeset/ems-battery-soc-max.md b/.changeset/ems-battery-soc-max.md new file mode 100644 index 000000000..fcb4bc7c9 --- /dev/null +++ b/.changeset/ems-battery-soc-max.md @@ -0,0 +1,8 @@ +--- +"ftw": patch +--- + +Stop battery charging at the configured maximum charge level in every EMS mode, +including manual holds and self-tuning. Use each battery's soc_max, or the +planner's limit when the battery has none. Charging resumes one percentage +point below that limit; discharge remains available. diff --git a/go/cmd/ftw/battery_soc_max_test.go b/go/cmd/ftw/battery_soc_max_test.go new file mode 100644 index 000000000..6f8f4dfce --- /dev/null +++ b/go/cmd/ftw/battery_soc_max_test.go @@ -0,0 +1,68 @@ +package main + +import ( + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/control" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +// The planner's earlier charge budget cannot override the owner's SoC limit. +// No solar or export is needed to reproduce the 10 kW order at 90%. +func TestConfiguredSoCMaxStopsDispatch(t *testing.T) { + for _, mode := range []control.Mode{control.ModeCharge, control.ModePlannerArbitrage} { + t.Run(string(mode), func(t *testing.T) { + cfg := parseBatteryLimitConfig(t, "", " soc_max: 0.9\n max_charge_w: 10000\n") + ctrl := newControlStateFromConfig(cfg) + ctrl.Mode = mode + ctrl.SlewEnabled = false + ctrl.UseEnergyDispatch = true + ctrl.SlotDirective = func(now time.Time) (control.SlotDirective, bool) { + return control.SlotDirective{ + SlotStart: now, SlotEnd: now.Add(15 * time.Minute), + BatteryEnergyWh: 2500, PlannedGridW: 11000, HasPlannedGridW: true, + }, true + } + tel := batteryLimitStore(1000) + soc := 0.9 + tel.Update("battery", telemetry.DerBattery, 0, &soc, nil) + got := control.ComputeDispatch(tel, ctrl, map[string]float64{"battery": 15000}, 40000) + if len(got) != 1 || got[0].TargetW != 0 { + t.Fatalf("soc_max=0.9 at 90%% sent %+v, want one 0 W target", got) + } + }) + } +} + +func TestSoCMaxConfigPrecedenceAndReload(t *testing.T) { + cfg := parseBatteryLimitConfig(t, "", " soc_max: 0.9\n") + cfg.Planner = &config.Planner{SoCMax: .8} + ctrl := newControlStateFromConfig(cfg) + ctrl.Mode, ctrl.SlewEnabled = control.ModeCharge, false + tel := batteryLimitStore(1000) + capacities := map[string]float64{"battery": 10000} + check := func(soc float64, charging bool) { + t.Helper() + tel.Update("battery", telemetry.DerBattery, 0, &soc, nil) + got := control.ComputeDispatch(tel, ctrl, capacities, 40000) + if len(got) != 1 || (got[0].TargetW > 0) != charging { + t.Fatalf("SoC %.2f: got %+v, want charging=%v", soc, got, charging) + } + } + check(.85, true) // The battery's 90% overrides the planner's 80%. + check(.9, false) + // The config watcher replaces the limits through this same function. + cfg.Batteries = nil + ctrl.DriverLimits = driverLimitsFrom(cfg.ModbusControlDrivers(), cfg.Batteries, cfg.Planner) + check(.85, false) // With no battery override, the planner's 80% applies. + cfg.Planner = nil + ctrl.DriverLimits = driverLimitsFrom(cfg.ModbusControlDrivers(), cfg.Batteries, cfg.Planner) + check(.99, true) // No configured ceiling keeps the 100% default. + check(1, false) + zero := 0.0 + cfg.Batteries = map[string]config.Battery{"battery": {SoCMax: &zero}} + ctrl.DriverLimits = driverLimitsFrom(cfg.ModbusControlDrivers(), cfg.Batteries, cfg.Planner) + check(.5, false) // An explicit zero is not an absent limit. +} diff --git a/go/cmd/ftw/control_state.go b/go/cmd/ftw/control_state.go index f97581f66..6bdd681de 100644 --- a/go/cmd/ftw/control_state.go +++ b/go/cmd/ftw/control_state.go @@ -24,7 +24,7 @@ func newControlStateFromConfig(cfg *config.Config) *control.State { ctrl.InverterGroups = inverterGroupsFrom(cfg.Drivers) ctrl.SupportsPVCurtail = supportsPVCurtailFrom(cfg.Drivers) ctrl.SolarFeedDrivers = solarFeedDriversFrom(cfg.Drivers) - ctrl.DriverLimits = driverLimitsFrom(cfg.ModbusControlDrivers(), cfg.Batteries) + ctrl.DriverLimits = driverLimitsFrom(cfg.ModbusControlDrivers(), cfg.Batteries, cfg.Planner) // Per-phase fuse params for the per-phase clamp inside applyFuseGuard // + forceFuseDischarge. Reads l1_a/l2_a/l3_a from the meter driver // when SiteFuseAmps > 0; otherwise the per-phase clamp is disabled. diff --git a/go/cmd/ftw/main.go b/go/cmd/ftw/main.go index ad1a18932..4c1f24485 100644 --- a/go/cmd/ftw/main.go +++ b/go/cmd/ftw/main.go @@ -1157,7 +1157,7 @@ func main() { ctrl.InverterGroups = inverterGroupsFrom(newCfg.Drivers) ctrl.SupportsPVCurtail = supportsPVCurtailFrom(newCfg.Drivers) ctrl.SolarFeedDrivers = solarFeedDriversFrom(newCfg.Drivers) - ctrl.DriverLimits = driverLimitsFrom(newCfg.ModbusControlDrivers(), newCfg.Batteries) + ctrl.DriverLimits = driverLimitsFrom(newCfg.ModbusControlDrivers(), newCfg.Batteries, newCfg.Planner) // Fuse params + safety margin: previously startup-only. // Hot-reload them so operators can tune the per-phase margin // from the UI without restarting (e.g. raising it after the @@ -3624,12 +3624,23 @@ func driverCapacitiesFrom(drvList []config.Driver, loadpoints []config.Loadpoint return out } -// driverLimitsFrom gives dispatch the same per-driver limits as the planner. -func driverLimitsFrom(drivers []config.Driver, batteries map[string]config.Battery) map[string]control.PowerLimits { +// driverLimitsFrom gives dispatch the same per-driver power limits and charge +// ceilings as the planner. Each battery's soc_max overrides the planner's. +func driverLimitsFrom(drivers []config.Driver, batteries map[string]config.Battery, planner *config.Planner) map[string]control.PowerLimits { + ceiling := 1.0 + if planner != nil && planner.SoCMax > 0 { + ceiling = planner.SoCMax + } out := map[string]control.PowerLimits{} for _, d := range drivers { if !d.ObserveOnly { - out[d.Name] = batteryPowerLimits(d, batteries[d.Name]) + limits := batteryPowerLimits(d, batteries[d.Name]) + limits.SoCMax = ceiling + if b := batteries[d.Name]; b.SoCMax != nil { + limits.SoCMax = *b.SoCMax + limits.SoCMaxSet = true + } + out[d.Name] = limits } } return out diff --git a/go/cmd/ftw/modbus_owner_test.go b/go/cmd/ftw/modbus_owner_test.go index 1675e7934..28343c2e1 100644 --- a/go/cmd/ftw/modbus_owner_test.go +++ b/go/cmd/ftw/modbus_owner_test.go @@ -19,7 +19,7 @@ func TestExternalModbusOwnerKeepsTelemetryButLeavesPlannerAndDispatch(t *testing if got := driverCapacitiesFrom(cfg.Drivers, nil, evCatalog(), false); got["sungrow"] != 10000 { t.Fatalf("telemetry capacity lost: %v", got) } - if len(driverLimitsFrom(cfg.ModbusControlDrivers(), cfg.Batteries)) != 0 { + if len(driverLimitsFrom(cfg.ModbusControlDrivers(), cfg.Batteries, cfg.Planner)) != 0 { t.Fatal("external battery remains in dispatch limits") } if !config.ObserveOnlyDriverSet(cfg)["sungrow"] { diff --git a/go/internal/api/api_battery_soc_max_test.go b/go/internal/api/api_battery_soc_max_test.go new file mode 100644 index 000000000..e0a8038e9 --- /dev/null +++ b/go/internal/api/api_battery_soc_max_test.go @@ -0,0 +1,42 @@ +package api + +import ( + "encoding/json" + "sync" + "testing" + "testing/synctest" + "time" + + "github.com/srcfl/ftw/go/internal/control" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +func TestSoCMaxFeedbackUsesTheDispatchResumeLevel(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + tel := telemetry.NewStore() + soc := .9 + tel.Update("battery", telemetry.DerBattery, 0, &soc, nil) + tel.RecordDriverSuccess("battery") + tel.Update("meter", telemetry.DerMeter, 1000, nil, nil) + tel.RecordDriverSuccess("meter") + st := control.NewState(0, 50, "meter") + st.Mode = control.ModeCharge + st.DriverLimits = map[string]control.PowerLimits{"battery": {SoCMax: .9}} + got := control.ComputeDispatch(tel, st, map[string]float64{"battery": 15000}, 13800) + if len(got) != 1 || got[0].TargetW != 0 { + t.Fatalf("charge not stopped: %+v", got) + } + request, _ := json.Marshal(map[string]any{"action": "battery", "power_w": 0}) + cmd := tel.BeginCommand("battery", request, time.Now()) + tel.CompleteCommand(cmd, "accepted") + for range 16 { + tel.Update("battery", telemetry.DerBattery, 0, &soc, []byte(`{"setpoint_w":0}`)) + time.Sleep(3 * time.Second) + } + srv := New(&Deps{Tel: tel, Ctrl: st, CtrlMu: &sync.Mutex{}}) + f := srv.controlFeedback(time.Now())[0] + if f.Status != "limited" || f.Reason != "battery_full" || f.Severity != "info" || f.ChargeResumeSoC == nil || *f.ChargeResumeSoC != .89 { + t.Fatalf("wrong explanation of the 90%% stop: %+v", f) + } + }) +} diff --git a/go/internal/api/api_control_feedback.go b/go/internal/api/api_control_feedback.go index 1ed31dd9d..f2cc18fdb 100644 --- a/go/internal/api/api_control_feedback.go +++ b/go/internal/api/api_control_feedback.go @@ -90,7 +90,7 @@ func (s *Server) controlFeedback(now time.Time) []ControlFeedback { } mode, meter := "", "" clamped := map[string]bool{} - full := map[string]bool{} + full := map[string]float64{} targeted := map[string]bool{} var hold control.BatteryManualHold var held bool @@ -100,7 +100,9 @@ func (s *Server) controlFeedback(now time.Time) []ControlFeedback { meter = s.deps.Ctrl.SiteMeterDriver for _, t := range s.deps.Ctrl.LastTargets { clamped[t.Driver] = t.Clamped - full[t.Driver] = s.deps.Ctrl.BatteryChargePaused(t.Driver) + if s.deps.Ctrl.BatteryChargePaused(t.Driver) { + full[t.Driver] = s.deps.Ctrl.BatteryChargeResumeSoC(t.Driver) + } targeted[t.Driver] = true } hold, held = s.deps.Ctrl.GetBatteryManualHold(now) @@ -186,9 +188,9 @@ func (s *Server) controlFeedback(now time.Time) []ControlFeedback { if clamped[rd.Driver] && kind == telemetry.DerBattery { coreReason = "core_limit" } - if full[rd.Driver] && kind == telemetry.DerBattery && f.BatterySoC != nil { + if resume, paused := full[rd.Driver]; paused && kind == telemetry.DerBattery && f.BatterySoC != nil { coreReason = "battery_full" - f.ChargeResumeSoC = watts(control.BatteryChargeResumeSoC) + f.ChargeResumeSoC = watts(resume) } if held && kind == telemetry.DerBattery && (hold.Driver == "" || hold.Driver == rd.Driver) { f.Mode = "manual" diff --git a/go/internal/control/battery_full.go b/go/internal/control/battery_full.go index b7c358404..f36dc75de 100644 --- a/go/internal/control/battery_full.go +++ b/go/internal/control/battery_full.go @@ -6,9 +6,14 @@ import ( "github.com/srcfl/ftw/go/internal/telemetry" ) -// A one percentage point gap prevents repeated starts at a rounded 100%. -// This limits charging only; the plan can discharge a full battery at once. -const BatteryChargeResumeSoC = 0.99 +// A one percentage point gap prevents repeated starts at the charge ceiling. +const batteryChargeHysteresisSoC = 0.01 + +// BatteryChargeResumeSoC uses the same ceiling as dispatch. Callers hold the +// control lock, as they do for BatteryChargePaused. +func (s *State) BatteryChargeResumeSoC(driver string) float64 { + return math.Max(0, s.DriverLimits[driver].socCeiling()-batteryChargeHysteresisSoC) +} // BatteryChargePaused reports the dispatcher's full-battery stop. Callers use // the same lock as ComputeDispatch; this state is local to the running device. @@ -17,6 +22,9 @@ func (s *State) BatteryChargePaused(driver string) bool { } func (s *State) updateBatteryChargeFull(store *telemetry.Store, capacities map[string]float64) { + if s == nil || store == nil { + return + } if s.batteryChargeFull == nil { s.batteryChargeFull = map[string]bool{} } @@ -36,9 +44,9 @@ func (s *State) updateBatteryChargeFull(store *telemetry.Store, capacities map[s if age < 0 || age > telemetry.BatterySoCMaxAge || math.IsNaN(soc) || math.IsInf(soc, 0) || soc < 0 || soc > 1 { continue } - if soc == 1 { + if soc >= s.DriverLimits[name].socCeiling() { s.batteryChargeFull[name] = true - } else if soc <= BatteryChargeResumeSoC { + } else if soc <= s.BatteryChargeResumeSoC(name) { delete(s.batteryChargeFull, name) } } diff --git a/go/internal/control/battery_soc_max_test.go b/go/internal/control/battery_soc_max_test.go new file mode 100644 index 000000000..aad083d1d --- /dev/null +++ b/go/internal/control/battery_soc_max_test.go @@ -0,0 +1,154 @@ +package control + +import ( + "testing" + "testing/synctest" + "time" + + "github.com/srcfl/ftw/go/internal/telemetry" +) + +func cappedBatterySite(soc, power float64) (*telemetry.Store, *State, map[string]float64) { + tel, st, capacities := fullBatterySite(soc, power) + st.DriverLimits = map[string]PowerLimits{"battery": {SoCMax: .9, MaxChargeW: 10000}} + return tel, st, capacities +} + +func TestSoCMaxStopsChargingInEveryMode(t *testing.T) { + for _, mode := range AllModes() { + for _, energy := range []bool{false, true} { + t.Run(string(mode)+"/energy="+map[bool]string{false: "off", true: "on"}[energy], func(t *testing.T) { + tel, st, capacities := cappedBatterySite(.9, 2000) + st.Mode, st.UseEnergyDispatch = mode, energy + st.SlewEnabled, st.SlewRateW = true, 10 + st.SlotDirective = func(now time.Time) (SlotDirective, bool) { + return SlotDirective{SlotStart: now, SlotEnd: now.Add(15 * time.Minute), BatteryEnergyWh: 500}, true + } + st.PlanTarget = func(time.Time) (string, float64, string, bool) { + return string(ModeCharge), 2000, "charge", true + } + got := ComputeDispatch(tel, st, capacities, 13800) + if len(got) != 1 || got[0].TargetW > 0 || !st.BatteryChargePaused("battery") { + t.Fatalf("90%% ceiling did not stop charging: %+v", got) + } + }) + } + } +} + +func TestSoCMaxManualHoldAndSibling(t *testing.T) { + tel, st, capacities := cappedBatterySite(.9, 0) + tel.Update("other", telemetry.DerBattery, 0, ptrF64(.8), nil) + tel.RecordDriverSuccess("other") + capacities["other"] = 9600 + st.DriverLimits["other"] = PowerLimits{SoCMax: .95} + st.SlewEnabled = false + st.SetBatteryManualHold(BatteryManualHold{PowerW: 3000, ExpiresAt: time.Now().Add(time.Hour)}) + got := ComputeDispatch(tel, st, capacities, 13800) + if targetFor(t, got, "battery").TargetW != 0 || targetFor(t, got, "other").TargetW < 2900 { + t.Fatalf("charge must go to the battery below its own ceiling: %+v", got) + } + st.SetBatteryManualHold(BatteryManualHold{PowerW: -2000, ExpiresAt: time.Now().Add(time.Hour)}) + got = ComputeDispatch(tel, st, capacities, 13800) + if targetFor(t, got, "battery").TargetW >= 0 { + t.Fatalf("charge ceiling blocked discharge: %+v", got) + } + st.BatteryHoldTargetValid = func(driver, id string) bool { return driver == "battery" && id == "hardware" } + st.SetBatteryManualHold(BatteryManualHold{Driver: "battery", DeviceID: "hardware", PowerW: 3000, ExpiresAt: time.Now().Add(time.Hour)}) + got = ComputeDispatch(tel, st, capacities, 13800) + if targetFor(t, got, "battery").TargetW != 0 || targetFor(t, got, "other").TargetW != 0 { + t.Fatalf("scoped hold bypassed its ceiling or charged another battery: %+v", got) + } +} + +func TestSoCMaxStopsSelfTuneWithoutPriorControlTick(t *testing.T) { + tel, st, capacities := cappedBatterySite(.9, 1000) + got := SelfTuneDispatch(tel, st, capacities, 13800, "battery", 3000) + if len(got) != 1 || got[0].TargetW != 0 || !got[0].Clamped { + t.Fatalf("self-tune crossed the charge ceiling: %+v", got) + } +} + +func TestSoCMaxStopsPreviousOrderDuringQuietOrHeldTick(t *testing.T) { + for _, holdoff := range []bool{false, true} { + tel, st, capacities := cappedBatterySite(.9, 0) + st.Mode = ModeSelfConsumption + tel.Update("ferroamp", telemetry.DerMeter, 0, nil, nil) + st.PrevTargets["battery"] = 10000 + st.LastTargets = []DispatchTarget{{Driver: "battery", TargetW: 10000}} + if holdoff { + now := time.Now() + st.LastDispatch, st.MinDispatchIntervalS = &now, 60 + } + got := ComputeDispatch(tel, st, capacities, 13800) + if len(got) != 1 || got[0].TargetW != 0 || st.LastTargets[0].TargetW != 0 || st.PrevTargets["battery"] != 0 { + t.Fatalf("holdoff=%v left the prior charge active: %+v", holdoff, got) + } + } +} + +func TestSoCMaxHysteresisAndMissingLevel(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + tel, st, capacities := cappedBatterySite(.899, 0) + check := func(paused bool) { + t.Helper() + got := ComputeDispatch(tel, st, capacities, 13800) + if len(got) != 1 || st.BatteryChargePaused("battery") != paused || (got[0].TargetW == 0) != paused { + t.Fatalf("paused=%v targets=%+v, want paused=%v", st.BatteryChargePaused("battery"), got, paused) + } + } + check(false) + for _, level := range []float64{.9, .92, .899, .891} { + tel.Update("battery", telemetry.DerBattery, 0, &level, nil) + check(true) + } + time.Sleep(6 * time.Minute) + tel.Update("battery", telemetry.DerBattery, 0, nil, nil) + tel.RecordDriverSuccess("battery") + check(true) + tel.Update("battery", telemetry.DerBattery, 0, ptrF64(.89), nil) + check(false) + }) +} + +func TestSoCMaxReloadTakesEffectOnNextTick(t *testing.T) { + tel, st, capacities := cappedBatterySite(.9, 0) + ComputeDispatch(tel, st, capacities, 13800) + st.DriverLimits["battery"] = PowerLimits{SoCMax: .95} + got := ComputeDispatch(tel, st, capacities, 13800) + if len(got) != 1 || got[0].TargetW <= 0 { + t.Fatalf("raising the ceiling did not release the stop: %+v", got) + } + st.DriverLimits["battery"] = PowerLimits{SoCMax: .85} + got = ComputeDispatch(tel, st, capacities, 13800) + if len(got) != 1 || got[0].TargetW != 0 { + t.Fatalf("lowering the ceiling did not stop charging: %+v", got) + } +} + +func TestSoCMaxStillAllowsFuseRelief(t *testing.T) { + tel, st, capacities := cappedBatterySite(.9, 0) + tel.Update("ferroamp", telemetry.DerMeter, 16000, nil, nil) + st.Mode = ModeIdle + st.SiteFuseAmps, st.SiteFuseVoltage, st.SiteFusePhases = 20, 230, 3 + got := ComputeDispatch(tel, st, capacities, 13800) + if len(got) != 1 || got[0].TargetW >= 0 { + t.Fatalf("charge ceiling blocked fuse relief: %+v", got) + } +} + +func TestSoCMaxExportGuardCannotRestorePausedCharge(t *testing.T) { + tel, st, capacities := cappedBatterySite(.9, 2000) + st.Mode = ModeIdle + st.SiteFuseAmps, st.SiteFuseVoltage, st.SiteFusePhases = 20, 230, 3 + st.batteryCommands = map[string]commandLog{"battery": commandLog{}.add(st.now(), 2000)} + st.updateBatteryChargeFull(tel, capacities) + // The stop remains active below the ceiling until the resume level. Even + // an export overage must not restore the charge that the stop removed. + tel.Update("battery", telemetry.DerBattery, 2000, ptrF64(.895), nil) + tel.Update("ferroamp", telemetry.DerMeter, -20000, nil, nil) + got := ComputeDispatch(tel, st, capacities, 13800) + if len(got) != 1 || got[0].TargetW != 0 { + t.Fatalf("export guard restored paused charging: %+v", got) + } +} diff --git a/go/internal/control/dispatch.go b/go/internal/control/dispatch.go index 388e73afc..6745ff96a 100644 --- a/go/internal/control/dispatch.go +++ b/go/internal/control/dispatch.go @@ -227,6 +227,16 @@ type PowerLimits struct { MaxDischargeW float64 MaxChargeWSet bool MaxDischargeWSet bool + // SoCMax is the battery's charge ceiling, 0..1. An unset limit uses 100%. + SoCMax float64 + SoCMaxSet bool +} + +func (l PowerLimits) socCeiling() float64 { + if (l.SoCMaxSet || l.SoCMax > 0) && l.SoCMax >= 0 && l.SoCMax <= 1 { + return l.SoCMax + } + return 1 } func effectivePowerLimit(value float64, set bool) float64 { @@ -2336,6 +2346,9 @@ func applyDispatchSafetyPipeline( fuseMaxW float64, opts dispatchSafetyOptions, ) []DispatchTarget { + if state != nil { + state.updateBatteryChargeFull(store, driverCapacities) + } // ---- Fuse guard (bidirectional, #145) ---- targets = applyFuseGuard(targets, store, state, fuseMaxW) @@ -2378,8 +2391,8 @@ func applyDispatchSafetyPipeline( targets = clampTargetsToPowerLimits(targets, state.DriverLimits) } targets = floorMissingSoCDischarge(targets, store) - targets = state.floorFullBatteryCharge(targets) targets = clampEVBatteryHeadroom(targets, store, state, fuseMaxW) + targets = state.floorFullBatteryCharge(targets) republishFuseEVCapAfterFuseDischarge(targets, store, state, fuseMaxW) recordDispatchTargets(targets, state, opts.updatePrevTargets, opts.recordDispatch) return targets @@ -4103,7 +4116,7 @@ func fuseTargetBounds(r *telemetry.DerReading, lim PowerLimits) (lower, upper fl if r.SoC == nil || *r.SoC < dischargeFloorSoC || dischargeBlocked { lower = 0 } - if chargeBlocked { + if chargeBlocked || r.SoC != nil && *r.SoC >= lim.socCeiling() { upper = 0 } return lower, upper From d95492524bc3855a1ac320d2856768f0ad724077 Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Tue, 27 Oct 2026 06:17:49 +0100 Subject: [PATCH 2/3] fix(control): end manual Charge at restart --- .changeset/charge-ends-at-restart.md | 8 +++ go/cmd/ftw/charge_restart_test.go | 83 ++++++++++++++++++++++++++ go/cmd/ftw/control_state.go | 33 ++++++++-- go/cmd/ftw/control_state_test.go | 17 ++++-- go/cmd/ftw/main.go | 8 +-- go/internal/ha/bridge.go | 6 ++ go/internal/ha/charge_restart_test.go | 45 ++++++++++++++ go/internal/mpc/startup_replan_test.go | 63 +++++++++++++++++++ 8 files changed, 248 insertions(+), 15 deletions(-) create mode 100644 .changeset/charge-ends-at-restart.md create mode 100644 go/cmd/ftw/charge_restart_test.go create mode 100644 go/internal/ha/charge_restart_test.go create mode 100644 go/internal/mpc/startup_replan_test.go diff --git a/.changeset/charge-ends-at-restart.md b/.changeset/charge-ends-at-restart.md new file mode 100644 index 000000000..74ddb07cd --- /dev/null +++ b/.changeset/charge-ends-at-restart.md @@ -0,0 +1,8 @@ +--- +"ftw": patch +--- + +End manual battery Charge when FTW restarts. Return to automatic planning +with the saved battery export permission, or Idle when the planner is disabled. +Ignore old retained MQTT Charge commands so reconnecting cannot resume the +override. A new Charge command still works. diff --git a/go/cmd/ftw/charge_restart_test.go b/go/cmd/ftw/charge_restart_test.go new file mode 100644 index 000000000..c5feb3fb4 --- /dev/null +++ b/go/cmd/ftw/charge_restart_test.go @@ -0,0 +1,83 @@ +package main + +import ( + "context" + "path/filepath" + "sync" + "testing" + + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/control" + "github.com/srcfl/ftw/go/internal/state" +) + +func TestRestartEndsManualCharge(t *testing.T) { + for _, tc := range []struct { + name string + planner *config.Planner + storedExport string + want control.Mode + }{ + {"planner enabled", &config.Planner{Enabled: true}, "", control.ModePlannerPassiveArbitrage}, + {"export allowed", &config.Planner{Enabled: true}, "allowed", control.ModePlannerArbitrage}, + {"export refused", &config.Planner{Enabled: true, BatteryExport: "allowed"}, "not_allowed", control.ModePlannerPassiveArbitrage}, + {"export unknown", &config.Planner{Enabled: true, BatteryExport: "allowed"}, "unknown", control.ModePlannerPassiveArbitrage}, + {"export from config", &config.Planner{Enabled: true, BatteryExport: "allowed"}, "", control.ModePlannerArbitrage}, + {"invalid stored permission", &config.Planner{Enabled: true, BatteryExport: "allowed"}, "invalid", control.ModePlannerArbitrage}, + {"no export permission", &config.Planner{Enabled: true, BatteryExport: "invalid"}, "invalid", control.ModePlannerPassiveArbitrage}, + {"planner disabled", &config.Planner{Enabled: false}, "allowed", control.ModeIdle}, + {"no planner", nil, "", control.ModeIdle}, + } { + t.Run(tc.name, func(t *testing.T) { + cfg := parseBatteryLimitConfig(t, "", " max_charge_w: 10000\n soc_max: 0.9\n") + cfg.Planner = tc.planner + path := filepath.Join(t.TempDir(), "state.db") + st, err := state.Open(path) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + if err := st.SaveConfig(config.StateKeyBatteryExport, tc.storedExport); err != nil { + t.Fatal(err) + } + // A new, explicit Charge still works during this process. + ctrl := newControlStateFromConfig(cfg) + modes := appModes{ctrl: ctrl, ctrlMu: &sync.Mutex{}, state: st} + if err := modes.SetMode(context.Background(), control.ModeCharge); err != nil { + t.Fatal(err) + } + if targets := control.ComputeDispatch(batteryLimitStore(1000), ctrl, map[string]float64{"battery": 15000}, 40000); len(targets) != 1 || targets[0].TargetW != 10000 { + t.Fatalf("explicit Charge: %+v, want 10000 W", targets) + } + for boot := 1; boot <= 2; boot++ { + if err := st.Close(); err != nil { + t.Fatal(err) + } + st, err = state.Open(path) + if err != nil { + t.Fatal(err) + } + ctrl = newControlStateFromConfig(cfg) + restoreStoredMode(ctrl, st, cfg) + if ctrl.Mode != tc.want { + t.Fatalf("boot %d: mode = %q, want %q", boot, ctrl.Mode, tc.want) + } + if saved, _ := st.LoadConfig("mode"); saved != string(tc.want) { + t.Fatalf("boot %d: stored mode = %q, want %q", boot, saved, tc.want) + } + if tc.name == "planner enabled" || tc.name == "export unknown" { + if export, _ := st.LoadConfig(config.StateKeyBatteryExport); export != "unknown" { + t.Fatalf("boot %d: unknown export permission became %q", boot, export) + } + } + // Before the fresh plan arrives, import without solar must + // not resume the earlier full-power charging order. + for _, target := range control.ComputeDispatch(batteryLimitStore(1000), ctrl, map[string]float64{"battery": 15000}, 40000) { + if target.TargetW > 0 { + t.Fatalf("boot %d: charging before a fresh plan: %+v", boot, target) + } + } + } + }) + } +} diff --git a/go/cmd/ftw/control_state.go b/go/cmd/ftw/control_state.go index 6bdd681de..89c03dad9 100644 --- a/go/cmd/ftw/control_state.go +++ b/go/cmd/ftw/control_state.go @@ -77,14 +77,39 @@ func energyDispatchEnabled(cfg *config.Config) bool { // and weighted split equally because nothing set its weights. var removedModes = map[string]bool{"priority": true, "weighted": true} -// restoreStoredMode applies the mode saved in state.db. A removed mode becomes -// manual self-consumption and is saved back, so the stored mode matches what -// the site runs. Any other unknown value keeps the default mode, as before. -func restoreStoredMode(ctrl *control.State, st *state.Store) { +// restoreStoredMode keeps durable modes, but never resumes forced Charge. +// Charge returns to the planner, or Idle if planning is disabled. Removed +// modes become self-consumption; unknown values keep the default mode. +func restoreStoredMode(ctrl *control.State, st *state.Store, cfg *config.Config) { v, ok := st.LoadConfig("mode") if !ok { return } + if control.Mode(v) == control.ModeCharge { + next := control.ModeIdle + values := map[string]string{} + if cfg != nil && cfg.Planner != nil && cfg.Planner.Enabled { + export := config.BatteryExportUnknown + if e, valid := config.ParseBatteryExport(cfg.Planner.BatteryExport); valid { + export = e + } + storedExport, _ := st.LoadConfig(config.StateKeyBatteryExport) + if e, valid := config.ParseBatteryExport(storedExport); valid { + export = e + } + next = control.Mode(export.PlannerModeKey()) + // Keep unknown as unknown. Otherwise the later preference + // migration would infer a refusal from the new passive mode. + values[config.StateKeyBatteryExport] = string(export) + } + ctrl.Mode = next + values["mode"] = string(next) + if err := st.SaveConfigValues(values); err != nil { + slog.Warn("could not save the mode after ending manual Charge at restart", "mode", next, "err", err) + } + slog.Info("manual Charge ended at restart", "previous_mode", v, "mode", next) + return + } if m := control.Mode(v); control.IsValidMode(m) { ctrl.Mode = m return diff --git a/go/cmd/ftw/control_state_test.go b/go/cmd/ftw/control_state_test.go index e0f650357..8c516be71 100644 --- a/go/cmd/ftw/control_state_test.go +++ b/go/cmd/ftw/control_state_test.go @@ -184,10 +184,15 @@ func TestRestoredGridTargetIgnoresNonFinite(t *testing.T) { // self-consumption and store it, not keep a mode no door accepts any more. func TestRestoreStoredModeMapsRemovedModesToSelfConsumption(t *testing.T) { for stored, want := range map[string]control.Mode{ - "priority": control.ModeSelfConsumption, - "weighted": control.ModeSelfConsumption, - "planner_arbitrage": control.ModePlannerArbitrage, - "peak_shaving": control.ModePeakShaving, + "priority": control.ModeSelfConsumption, + "weighted": control.ModeSelfConsumption, + "idle": control.ModeIdle, + "self_consumption": control.ModeSelfConsumption, + "peak_shaving": control.ModePeakShaving, + "planner_self": control.ModePlannerSelf, + "planner_cheap": control.ModePlannerCheap, + "planner_passive_arbitrage": control.ModePlannerPassiveArbitrage, + "planner_arbitrage": control.ModePlannerArbitrage, } { t.Run(stored, func(t *testing.T) { st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) @@ -201,7 +206,7 @@ func TestRestoreStoredModeMapsRemovedModesToSelfConsumption(t *testing.T) { ctrl := control.NewState(0, 50, "meter") ctrl.Mode = control.ModeIdle - restoreStoredMode(ctrl, st) + restoreStoredMode(ctrl, st, nil) if ctrl.Mode != want { t.Fatalf("mode = %q, want %q", ctrl.Mode, want) @@ -225,7 +230,7 @@ func TestRestoreStoredModeLeavesAnUnknownValueAlone(t *testing.T) { } ctrl := control.NewState(0, 50, "meter") - restoreStoredMode(ctrl, st) + restoreStoredMode(ctrl, st, nil) if ctrl.Mode != control.ModeSelfConsumption { t.Fatalf("mode = %q, want the default", ctrl.Mode) diff --git a/go/cmd/ftw/main.go b/go/cmd/ftw/main.go index 4c1f24485..57e59b4df 100644 --- a/go/cmd/ftw/main.go +++ b/go/cmd/ftw/main.go @@ -598,11 +598,9 @@ func main() { // ---- Control state ---- ctrl := newControlStateFromConfig(cfg) - // Restore persisted mode + target if present. The planner variants - // have to be listed too — without them the strategy the user picked in - // the UI (planner_self / planner_cheap / planner_arbitrage) is silently - // dropped on restart and the dashboard appears to forget the selection. - restoreStoredMode(ctrl, st) + // Restore durable modes and targets. Forced Charge ends at restart; + // the planner makes a fresh plan instead of resuming that override. + restoreStoredMode(ctrl, st, cfg) storedTrust, _ := st.LoadConfig(config.StateKeyForecastTrust) storedExport, _ := st.LoadConfig(config.StateKeyBatteryExport) storedSafetyK, _ := st.LoadConfig(config.StateKeySafetyK) diff --git a/go/internal/ha/bridge.go b/go/internal/ha/bridge.go index 9aae52446..39c4bfbe9 100644 --- a/go/internal/ha/bridge.go +++ b/go/internal/ha/bridge.go @@ -816,6 +816,12 @@ func metricUnitAndClass(name, explicitUnit string) (unit, devClass string) { func (b *Bridge) subscribeCommands() { b.client.Subscribe(b.cmdTopic("mode"), 0, func(_ paho.Client, m paho.Message) { mode := string(m.Payload()) + // A stored broker command is replayed on every reconnect. It + // must not undo the boot rule that ends manual Charge. + if mode == string(control.ModeCharge) && m.Retained() { + slog.Warn("HA: ignored a retained Charge command; send a new command to charge") + return + } if b.cb.SetMode != nil { if err := b.cb.SetMode(mode); err != nil { slog.Warn("HA set mode failed", "err", err) diff --git a/go/internal/ha/charge_restart_test.go b/go/internal/ha/charge_restart_test.go new file mode 100644 index 000000000..03fce2067 --- /dev/null +++ b/go/internal/ha/charge_restart_test.go @@ -0,0 +1,45 @@ +package ha + +import ( + "fmt" + "testing" + + paho "github.com/eclipse/paho.mqtt.golang" +) + +type retainedModeMessage struct { + commandMessage + retained bool +} + +func (m retainedModeMessage) Retained() bool { return m.retained } + +func TestRetainedChargeCannotRestartManualCharging(t *testing.T) { + for _, tc := range []struct { + mode string + retained bool + want bool + }{ + {"charge", true, false}, + {"charge", false, true}, + {"idle", true, true}, + {"planner_passive_arbitrage", true, true}, + } { + t.Run(fmt.Sprintf("%s/retained=%t", tc.mode, tc.retained), func(t *testing.T) { + cli := &commandClient{handlers: map[string]paho.MessageHandler{}} + var called bool + b := &Bridge{topicPrefix: "ftw", client: cli, cb: CommandCallbacks{SetMode: func(mode string) error { + called = true + if mode != tc.mode { + t.Errorf("mode = %q, want %q", mode, tc.mode) + } + return nil + }}} + b.subscribeCommands() + cli.handlers[b.cmdTopic("mode")](cli, retainedModeMessage{commandMessage: commandMessage{payload: []byte(tc.mode)}, retained: tc.retained}) + if called != tc.want { + t.Fatalf("SetMode called = %v, want %v", called, tc.want) + } + }) + } +} diff --git a/go/internal/mpc/startup_replan_test.go b/go/internal/mpc/startup_replan_test.go new file mode 100644 index 000000000..b92b1e0cf --- /dev/null +++ b/go/internal/mpc/startup_replan_test.go @@ -0,0 +1,63 @@ +package mpc + +import ( + "context" + "math" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/state" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +func TestStartReplansAnArchivedPlanWithFreshSoC(t *testing.T) { + old := newCancellationTestService(t, nil) + if _, err := old.Store.ClearPrices(); err != nil { + t.Fatal(err) + } + start := time.Now().UTC().Truncate(15 * time.Minute) + var prices []state.PricePoint + for i := 0; i < 16; i++ { + prices = append(prices, state.PricePoint{ + Zone: "SE3", SlotTsMs: start.Add(time.Duration(i) * 15 * time.Minute).UnixMilli(), + SlotLenMin: 15, SpotOreKwh: 50, TotalOreKwh: 100, + Source: "test", FetchedAtMs: start.UnixMilli(), + }) + } + if err := old.Store.SavePrices(prices); err != nil { + t.Fatal(err) + } + if old.Replan(context.Background()) == nil { + t.Fatal("could not create the previous process's plan") + } + archived := old.Diagnose() + + tel := telemetry.NewStore() + soc := .4 + tel.Update("battery", telemetry.DerBattery, 0, &soc, nil) + tel.RecordDriverSuccess("battery") + svc := New(old.Store, tel, "SE3", old.Defaults) + svc.Horizon, svc.BaseLoad = old.Horizon, old.BaseLoad + svc.Interval = time.Hour + if !svc.RestoreDiagnostic(archived, time.Now(), "restored_diagnostic") { + t.Fatal("could not restore the archived plan") + } + saved := make(chan *Diagnostic, 1) + svc.SaveDiag = func(d *Diagnostic, _ string) error { + saved <- d + return nil + } + svc.Start(context.Background()) + t.Cleanup(svc.Stop) + select { + case d := <-saved: + if math.Abs(d.Params.InitialSoC-soc) > 1e-9 { + t.Fatalf("startup SoC = %v, want the fresh %v", d.Params.InitialSoC, soc) + } + if d.DecisionID == archived.DecisionID { + t.Fatal("startup reused the previous process's decision") + } + case <-time.After(5 * time.Second): + t.Fatal("startup waited for the scheduled interval instead of making a fresh plan") + } +} From 4742c9e4f7f77b7589f8be007f7467039d40db51 Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Tue, 27 Oct 2026 06:23:02 +0100 Subject: [PATCH 3/3] test(control): seed the live fuse reading for the SOC ceiling check --- go/internal/control/battery_soc_max_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/go/internal/control/battery_soc_max_test.go b/go/internal/control/battery_soc_max_test.go index aad083d1d..b9de473f0 100644 --- a/go/internal/control/battery_soc_max_test.go +++ b/go/internal/control/battery_soc_max_test.go @@ -127,10 +127,9 @@ func TestSoCMaxReloadTakesEffectOnNextTick(t *testing.T) { } func TestSoCMaxStillAllowsFuseRelief(t *testing.T) { - tel, st, capacities := cappedBatterySite(.9, 0) - tel.Update("ferroamp", telemetry.DerMeter, 16000, nil, nil) + tel, st, capacities := setupFuseSaver(16000, 0, .9, 10000) + st.DriverLimits["bat"] = PowerLimits{SoCMax: .9, MaxChargeW: 10000, MaxDischargeW: 10000} st.Mode = ModeIdle - st.SiteFuseAmps, st.SiteFuseVoltage, st.SiteFusePhases = 20, 230, 3 got := ComputeDispatch(tel, st, capacities, 13800) if len(got) != 1 || got[0].TargetW >= 0 { t.Fatalf("charge ceiling blocked fuse relief: %+v", got)