Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions .changeset/charge-ends-at-restart.md
Original file line number Diff line number Diff line change
@@ -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.
8 changes: 8 additions & 0 deletions .changeset/ems-battery-soc-max.md
Original file line number Diff line number Diff line change
@@ -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.
68 changes: 68 additions & 0 deletions go/cmd/ftw/battery_soc_max_test.go
Original file line number Diff line number Diff line change
@@ -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.
}
83 changes: 83 additions & 0 deletions go/cmd/ftw/charge_restart_test.go
Original file line number Diff line number Diff line change
@@ -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)
}
}
}
})
}
}
35 changes: 30 additions & 5 deletions go/cmd/ftw/control_state.go
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand Down Expand Up @@ -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
Expand Down
17 changes: 11 additions & 6 deletions go/cmd/ftw/control_state_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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"))
Expand All @@ -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)
Expand All @@ -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)
Expand Down
27 changes: 18 additions & 9 deletions go/cmd/ftw/main.go
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -1157,7 +1155,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
Expand Down Expand Up @@ -3624,12 +3622,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
Expand Down
2 changes: 1 addition & 1 deletion go/cmd/ftw/modbus_owner_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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"] {
Expand Down
42 changes: 42 additions & 0 deletions go/internal/api/api_battery_soc_max_test.go
Original file line number Diff line number Diff line change
@@ -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)
}
})
}
10 changes: 6 additions & 4 deletions go/internal/api/api_control_feedback.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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)
Expand Down Expand Up @@ -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"
Expand Down
Loading
Loading