diff --git a/.changeset/c7-soc-floor-inclusive.md b/.changeset/c7-soc-floor-inclusive.md new file mode 100644 index 000000000..2bcff2dab --- /dev/null +++ b/.changeset/c7-soc-floor-inclusive.md @@ -0,0 +1,5 @@ +--- +"ftw": patch +--- + +A battery at or under its minimum level no longer discharges. Before, a battery at exactly 5.0 % (or exactly at `soc_min`) still counted as above the floor. Planner modes now keep `soc_min` with a fresh plan too, not only when the plan is missing. A discharge already running stops at the floor even when the grid sits inside the deadband; before, the battery kept its last setpoint and drained on. Plain `self_consumption` and manual holds still use Core's 5 % floor. diff --git a/go/internal/control/dispatch.go b/go/internal/control/dispatch.go index e3c6b44bb..b474429a4 100644 --- a/go/internal/control/dispatch.go +++ b/go/internal/control/dispatch.go @@ -241,8 +241,8 @@ type PowerLimits struct { SoCMin float64 } -// socFloor is the lowest SoC that the stale-plan fallback, fuse relief and -// the hourly import limit may discharge to. +// socFloor is the lowest SoC that planner modes, fuse relief and the hourly +// import limit may discharge to. func (l PowerLimits) socFloor() float64 { if l.SoCMin > dischargeFloorSoC && l.SoCMin <= 1 { return l.SoCMin @@ -1198,10 +1198,10 @@ type batteryInfo struct { dischargeBlocked bool chargeBlocked bool socMissing bool // no fresh SoC reading; soc is 0 - // belowStaleFloor: a planner mode without a plan, and SoC under the - // owner's floor. Unlike a driver's transient report, this must also - // stop a discharge already running, past the deadband and slew. - belowStaleFloor bool + // belowOwnerFloor: a planner mode, with or without a plan, and SoC at + // or under the owner's floor. Unlike a driver's transient report, this + // must also stop a discharge already running, past the deadband and slew. + belowOwnerFloor bool } // chargeCap returns the effective per-battery charge ceiling, falling @@ -1536,8 +1536,8 @@ func ComputeDispatch( } // ---- Gather online batteries ---- - // Without a plan, a planner mode keeps the owner's reserve. - staleFloor := !manualHoldActive && state.Mode.IsPlannerMode() && state.PlanStale + // A planner mode keeps the owner's reserve, with or without a plan. + ownerFloor := !manualHoldActive && state.Mode.IsPlannerMode() batteries := make([]batteryInfo, 0, len(driverCapacities)) for name, cap := range driverCapacities { r := store.Get(name, telemetry.DerBattery) @@ -1559,8 +1559,8 @@ func ComputeDispatch( // A configured zero is a hard direction block, not the legacy // "use MaxCommandW" sentinel. Feed it into the allocator as well as // the clamps so capable siblings receive the blocked battery's share. - belowStaleFloor := staleFloor && soc < lim.socFloor() - dischargeBlocked = dischargeBlocked || lim.dischargeCap() == 0 || belowStaleFloor + belowOwnerFloor := ownerFloor && soc <= lim.socFloor() + dischargeBlocked = dischargeBlocked || lim.dischargeCap() == 0 || belowOwnerFloor chargeBlocked = chargeBlocked || lim.chargeCap() == 0 || state.BatteryChargePaused(name) batteries = append(batteries, batteryInfo{ driver: name, @@ -1576,7 +1576,7 @@ func ComputeDispatch( dischargeBlocked: dischargeBlocked, chargeBlocked: chargeBlocked, socMissing: socMissing, - belowStaleFloor: belowStaleFloor, + belowOwnerFloor: belowOwnerFloor, }) } onlineBats := make([]batteryInfo, 0, len(batteries)) @@ -1850,7 +1850,8 @@ func ComputeDispatch( // and the held-meter exit both fall through to cut it. batteryBreaksLimit := (noSelfDischarge && anyBatteryDischarging(onlineBats)) || anyExplicitZeroDischargeViolation(onlineBats) || - anyBelowStaleFloorDischarging(onlineBats) || + anyBelowOwnerFloorDischarging(onlineBats, state.PrevTargets) || + anyAtHardFloorDischarging(onlineBats, state.PrevTargets) || anyBlockedBatteryCharging(onlineBats, noSelfCharge) // The PI acts on the meter alone. A held sample carries no new @@ -2344,7 +2345,7 @@ func ComputeDispatch( noSelfDischarge: noSelfDischarge, noSelfCharge: noSelfCharge, chargeBlocked: chargeBlockedDrivers(onlineBats), - floorBlocked: belowStaleFloorDrivers(onlineBats), + floorBlocked: belowOwnerFloorDrivers(onlineBats), updatePrevTargets: true, recordDispatch: true, }) @@ -2439,13 +2440,13 @@ func chargeBlockedDrivers(bats []batteryInfo) map[string]bool { return out } -// belowStaleFloorDrivers is the set of online batteries under the stale-plan -// SoC floor. Slew anchors on measured power and would hand back part of a -// discharge the allocator already withdrew. -func belowStaleFloorDrivers(bats []batteryInfo) map[string]bool { +// belowOwnerFloorDrivers is the set of online batteries at or under the +// owner SoC floor. Slew anchors on measured power and would hand back part +// of a discharge the allocator already withdrew. +func belowOwnerFloorDrivers(bats []batteryInfo) map[string]bool { var out map[string]bool for _, b := range bats { - if !b.belowStaleFloor { + if !b.belowOwnerFloor { continue } if out == nil { @@ -2456,22 +2457,46 @@ func belowStaleFloorDrivers(bats []batteryInfo) map[string]bool { return out } -// anyBelowStaleFloorDischarging reports a battery under the stale-plan floor -// that is measured discharging. The deadband exit returns no targets, and a +// floorStandbyW is the largest draw a pack parked at its floor may read +// without counting as a discharge. Packs report tens of watts of standby +// draw there; treating that as a discharge sent an order every tick. +const floorStandbyW = 50.0 + +// dischargingAtFloor reports a real discharge on a pack at its floor: past +// standby draw, or any measured discharge after FTW's own last order to it +// was a discharge, which the driver would otherwise hold. +func dischargingAtFloor(b batteryInfo, prev map[string]float64) bool { + return b.currentW < -floorStandbyW || b.currentW < -1 && prev[b.driver] < 0 +} + +// anyBelowOwnerFloorDischarging reports a battery at or under the owner +// floor that is discharging. The deadband exit returns no targets, and a // driver keeps its last setpoint, so such a battery would drain on. -func anyBelowStaleFloorDischarging(bats []batteryInfo) bool { +func anyBelowOwnerFloorDischarging(bats []batteryInfo, prev map[string]float64) bool { + for _, b := range bats { + if b.belowOwnerFloor && dischargingAtFloor(b, prev) { + return true + } + } + return false +} + +// anyAtHardFloorDischarging reports a battery at or under Core's 5 % floor +// that is discharging, in any mode. The deadband exit would leave the +// driver on its last discharge setpoint. +func anyAtHardFloorDischarging(bats []batteryInfo, prev map[string]float64) bool { for _, b := range bats { - if b.belowStaleFloor && b.currentW < -1 { + if !b.socMissing && b.soc <= dischargeFloorSoC && dischargingAtFloor(b, prev) { return true } } return false } -// floorBelowStaleFloorDischarge moves a discharge target to 0 W for each -// battery under the stale-plan floor. Fuse relief runs later and stops at +// floorBelowOwnerFloorDischarge moves a discharge target to 0 W for each +// battery at or under the owner floor. Fuse relief runs later and stops at // the same floor, so it cannot reopen the discharge. -func floorBelowStaleFloorDischarge(targets []DispatchTarget, blocked map[string]bool) []DispatchTarget { +func floorBelowOwnerFloorDischarge(targets []DispatchTarget, blocked map[string]bool) []DispatchTarget { if len(blocked) == 0 { return targets } @@ -2530,7 +2555,7 @@ func applyDispatchSafetyPipeline( targets = floorNegativeTargets(targets) } targets = floorBlockedCharge(targets, opts.noSelfCharge, opts.chargeBlocked) - targets = floorBelowStaleFloorDischarge(targets, opts.floorBlocked) + targets = floorBelowOwnerFloorDischarge(targets, opts.floorBlocked) targets = floorBlockedDischarge(targets, store, state, driverCapacities, fuseMaxW) // A battery-boost lease may never draw the stationary fleet below its @@ -3672,12 +3697,12 @@ func floorBlockedDischarge( } // dischargeParked reports whether the distributor parks a pack's discharge -// at 0 W: no SoC, SoC under Core's 5 % floor, discharge_capable=false or a -// zero discharge limit. The owner's soc_min is a planner rule; the stale-plan -// floor applies it separately (floorBelowStaleFloorDischarge). +// at 0 W: no SoC, SoC at or under Core's 5 % floor, discharge_capable=false +// or a zero discharge limit. The owner's soc_min is a planner rule; the +// owner floor applies it separately (floorBelowOwnerFloorDischarge). func dischargeParked(r *telemetry.DerReading, lim PowerLimits) bool { dischargeBlocked, _ := batteryDirectionBlocks(r.Data) - return r.SoC == nil || *r.SoC < dischargeFloorSoC || dischargeBlocked || lim.dischargeCap() == 0 + return r.SoC == nil || *r.SoC <= dischargeFloorSoC || dischargeBlocked || lim.dischargeCap() == 0 } // blockedDischargeKeepW is the discharge the blocked packs must keep after @@ -3851,7 +3876,7 @@ func clampTargetsToPowerLimits(targets []DispatchTarget, limits map[string]Power const dischargeFloorSoC = 0.05 // clampWithSoC applies the hard safety clamps for one battery command: -// - don't discharge below SoC 5 % (site: don't make target < 0 when SoC < 0.05); +// - don't discharge at or below SoC 5 % (no target < 0 when SoC <= 0.05); // BMS handles fine-grained SoC but we never ask it to pull an empty pack. // - cap charge at the battery's MaxChargeW (falls back to MaxCommandW default). // - cap discharge at the battery's MaxDischargeW (same fallback). @@ -3863,7 +3888,7 @@ func clampWithSoC(target float64, b batteryInfo) (float64, bool) { clamped := target wasClamped := false // Block discharge when the battery is empty. - if b.soc < dischargeFloorSoC && target < 0 { + if b.soc <= dischargeFloorSoC && target < 0 { clamped = 0 wasClamped = true } @@ -4778,7 +4803,7 @@ func fuseTargetBounds(r *telemetry.DerReading, lim PowerLimits) (lower, upper fl lower = -lim.dischargeCap() upper = lim.chargeCap() dischargeBlocked, chargeBlocked := batteryDirectionBlocks(r.Data) - if r.SoC == nil || *r.SoC < lim.socFloor() || dischargeBlocked { + if r.SoC == nil || *r.SoC <= lim.socFloor() || dischargeBlocked { lower = 0 } if chargeBlocked || r.SoC != nil && *r.SoC >= lim.socCeiling() { diff --git a/go/internal/control/soc_floor_test.go b/go/internal/control/soc_floor_test.go index e3d1bfb64..a13c1ab87 100644 --- a/go/internal/control/soc_floor_test.go +++ b/go/internal/control/soc_floor_test.go @@ -1,6 +1,7 @@ package control import ( + "math" "testing" "time" @@ -212,3 +213,282 @@ func TestSplitReliefUsesBothBatteries(t *testing.T) { t.Errorf("want bat -3000 W, bat2 -5000 W; got bat %.0f W, bat2 %.0f W", got["bat"], got["bat2"]) } } + +// No discharge order goes out at exactly the floor (C7: rig seeds 207534 +// and 207536 ordered discharge at 5.0 %). +func TestClampWithSoCBlocksDischargeAtFloor(t *testing.T) { + if v, was := clampWithSoC(-1000, batteryInfo{soc: dischargeFloorSoC}); v != 0 || !was { + t.Fatalf("SoC exactly 5 %%: got %.0f W clamped=%v, want 0 W", v, was) + } + if v, was := clampWithSoC(-1000, batteryInfo{soc: 0.051}); v != -1000 || was { + t.Fatalf("SoC 5.1 %%: got %.0f W clamped=%v, want -1000 W", v, was) + } +} + +// A fresh plan that asks for discharge at exactly 5 % gets no discharge. +func TestFreshPlanNoDischargeAtFloor(t *testing.T) { + for _, energy := range []bool{false, true} { + store := seedStore(2000, []struct { + name string + currentW, soc float64 + }{{"bat", 0, 0.05}}) + st := NewState(0, 50, "ferroamp") + st.Mode = ModePlannerArbitrage + st.UseEnergyDispatch = energy + st.SlewRateW = 10000 + st.MinDispatchIntervalS = 0 + st.SlotDirective = func(now time.Time) (SlotDirective, bool) { + return SlotDirective{SlotStart: now, SlotEnd: now.Add(15 * time.Minute), BatteryEnergyWh: -500, Strategy: "arbitrage"}, true + } + st.PlanTarget = func(time.Time) (string, float64, string, bool) { return "discharge", -2000, "discharge", true } + targets := ComputeDispatch(store, st, caps(map[string]float64{"bat": 15200}), 11040) + if st.PlanStale { + t.Fatalf("energy=%v: expected a fresh plan", energy) + } + for _, tg := range targets { + if tg.TargetW < 0 { + t.Errorf("energy=%v: SoC exactly 5 %%, %s ordered %.0f W", energy, tg.Driver, tg.TargetW) + } + } + } +} + +// Stale plan, soc_min 10 %: just under the floor (207531, 207532 at +// 5.5-5.8 %) and exactly at it, the battery gets 0 W. +func TestStaleFloorZeroAtAndUnderFloor(t *testing.T) { + for _, soc := range []float64{0.058, 0.10} { + store := seedStore(2000, []struct { + name string + currentW, soc float64 + }{{"bat", -1500, soc}}) + st := staleFloorState(10000) + targets := ComputeDispatch(store, st, caps(map[string]float64{"bat": 15200}), 11040) + if !st.PlanStale { + t.Fatalf("SoC %.3f: expected stale-plan fallback", soc) + } + if len(targets) != 1 || targets[0].TargetW != 0 { + t.Errorf("SoC %.3f, floor 10 %%: got %+v, want bat 0 W", soc, targets) + } + } +} + +// Fuse relief and the hourly import limit stop at exactly the floor. +func TestFuseTargetBoundsAtFloor(t *testing.T) { + soc := 0.10 + r := &telemetry.DerReading{SoC: &soc} + if lower, _ := fuseTargetBounds(r, PowerLimits{SoCMin: 0.10}); lower != 0 { + t.Fatalf("SoC exactly at the 10 %% floor: lower bound %.0f W, want 0", lower) + } + soc = 0.101 + if lower, _ := fuseTargetBounds(r, PowerLimits{SoCMin: 0.10}); lower >= 0 { + t.Fatalf("SoC 10.1 %%, floor 10 %%: lower bound %.0f W, want discharge allowed", lower) + } +} + +// A planner mode keeps the owner's floor with a fresh plan too. In the rig +// the planner sets soc_min 10 %, and most discharge orders in seeds 207534 +// and 207536 came on a fresh plan. +func TestFreshPlanKeepsSoCMin(t *testing.T) { + run := func(energy bool, soc float64) []DispatchTarget { + store := seedStore(2000, []struct { + name string + currentW, soc float64 + }{{"bat", 0, soc}}) + st := NewState(0, 50, "ferroamp") + st.Mode = ModePlannerSelf + st.UseEnergyDispatch = energy + st.SlewRateW = 10000 + st.MinDispatchIntervalS = 0 + st.DriverLimits = map[string]PowerLimits{"bat": {SoCMin: 0.10}} + st.SlotDirective = func(now time.Time) (SlotDirective, bool) { + return SlotDirective{SlotStart: now, SlotEnd: now.Add(15 * time.Minute), BatteryEnergyWh: -500, Strategy: "self_consumption"}, true + } + st.PlanTarget = func(time.Time) (string, float64, string, bool) { return "self_consumption", 0, "self", true } + targets := ComputeDispatch(store, st, caps(map[string]float64{"bat": 15200}), 11040) + if st.PlanStale { + t.Fatalf("energy=%v SoC %.2f: expected a fresh plan", energy, soc) + } + return targets + } + for _, energy := range []bool{false, true} { + for _, soc := range []float64{0.08, 0.10} { + for _, tg := range run(energy, soc) { + if tg.TargetW < 0 { + t.Errorf("energy=%v SoC %.2f, soc_min 10 %%: %s ordered %.0f W", energy, soc, tg.Driver, tg.TargetW) + } + } + } + if targets := run(energy, 0.12); len(targets) == 0 || targets[0].TargetW >= 0 { + t.Errorf("energy=%v SoC 12 %%, soc_min 10 %%: %+v, want discharge", energy, targets) + } + } +} + +// Core's 5 % floor stops a discharge already running, in every mode. +// Inside the deadband a tick with no targets leaves the driver on its last +// -2000 W setpoint; outside it slew hands back part of the discharge. +func TestHardFloorStopsRunningDischarge(t *testing.T) { + cases := []struct { + name string + gridW, slewW float64 + }{ + {"inside deadband", 20, 10000}, + {"after slew", 2000, 500}, + } + for _, mode := range []Mode{ModeSelfConsumption, ModePlannerSelf} { + for _, c := range cases { + for _, soc := range []float64{0.05, 0.04} { + store := seedStore(c.gridW, []struct { + name string + currentW, soc float64 + }{{"bat", -2000, soc}}) + st := NewState(0, 50, "ferroamp") + st.Mode = mode + st.SlewEnabled = true + st.SlewRateW = c.slewW + st.MinDispatchIntervalS = 0 + st.SlotDirective = func(now time.Time) (SlotDirective, bool) { + return SlotDirective{SlotStart: now, SlotEnd: now.Add(15 * time.Minute), Strategy: "self_consumption"}, true + } + st.PlanTarget = func(time.Time) (string, float64, string, bool) { return "self_consumption", 0, "self", true } + targets := ComputeDispatch(store, st, caps(map[string]float64{"bat": 15200}), 11040) + if len(targets) == 0 { + t.Errorf("%s %s SoC %.2f: no target, the -2000 W setpoint stays", mode, c.name, soc) + } + for _, tg := range targets { + if tg.TargetW < 0 { + t.Errorf("%s %s SoC %.2f: %s %.0f W at or under 5 %%", mode, c.name, soc, tg.Driver, tg.TargetW) + } + } + } + } + } +} + +// Closed loop: the battery covers a 2 kW house at -2000 W and SoC walks +// down through 5 %. The driver keeps its last setpoint when no target +// comes. No tick at or under the floor may keep a discharge. +func TestHardFloorDeadbandClosedLoop(t *testing.T) { + st := NewState(0, 50, "ferroamp") + st.Mode = ModeSelfConsumption + st.SlewEnabled = true + st.SlewRateW = 3000 + st.MinDispatchIntervalS = 0 + setpoint := -2000.0 + soc := 0.0505 + bad := 0 + for tick := 0; tick < 60; tick++ { + store := seedStore(2000+setpoint, []struct { + name string + currentW, soc float64 + }{{"bat", setpoint, soc}}) + for _, tg := range ComputeDispatch(store, st, caps(map[string]float64{"bat": 15200}), 11040) { + setpoint = tg.TargetW + } + if soc <= dischargeFloorSoC && setpoint < 0 { + bad++ + } + soc -= -setpoint / 10000 / 3600 * 2 // 10 kWh, 2 s tick + } + if bad > 0 { + t.Errorf("%d of 60 ticks kept a discharge at or under 5 %% (final SoC %.4f, setpoint %.0f W)", bad, soc, setpoint) + } +} + +// Fuse relief through the full safety pipeline, no soc_min: SoC exactly +// 5 % orders no discharge; 5.1 % may. +func TestFuseReliefPipelineAtHardFloor(t *testing.T) { + run := func(soc, curW float64) float64 { + store, st, cp := setupPerPhaseSite(3, 230, 13000, 19, 19, 19, soc, 5000) + if curW != 0 { + s := soc + store.Update("bat", telemetry.DerBattery, curW, &s, nil) + } + out := applyDispatchSafetyPipeline([]DispatchTarget{{Driver: "bat"}}, store, st, cp, 16*230*3, dispatchSafetyOptions{}) + return out[0].TargetW + } + for _, cur := range []float64{0, -5000} { + if got := run(0.05, cur); got < 0 { + t.Errorf("SoC exactly 5 %% (battery at %.0f W): ordered %.0f W", cur, got) + } + } + if got := run(0.051, 0); got >= 0 { + t.Errorf("SoC 5.1 %%: got %.0f W, want discharge", got) + } +} + +// floorStandbyWalk runs 300 ticks with a pack parked at its floor that +// reads a -15 W standby draw while the grid wanders inside the 50 W +// deadband. It returns how many ticks sent an order. +func floorStandbyWalk(st *State, soc float64) int { + sent := 0 + gridW := 0.0 + seed := uint32(7) + for tick := 0; tick < 300; tick++ { + seed = seed*1664525 + 1013904223 + gridW += float64(int(seed>>24)%21 - 10) + gridW = math.Max(-45, math.Min(45, gridW)) + store := seedStore(gridW, []struct { + name string + currentW, soc float64 + }{{"bat", -15, soc}}) + if len(ComputeDispatch(store, st, caps(map[string]float64{"bat": 15200}), 11040)) > 0 { + sent++ + } + } + return sent +} + +// A pack parked at Core's 5 % floor with standby draw is not discharging. +// The deadband holds, so the PI does not chase meter noise. +func TestHardFloorStandbyRandomWalk(t *testing.T) { + for _, soc := range []float64{0.05, 0.049} { + st := NewState(0, 50, "ferroamp") + st.Mode = ModeSelfConsumption + st.SlewEnabled = true + st.SlewRateW = 3000 + st.MinDispatchIntervalS = 0 + if sent := floorStandbyWalk(st, soc); sent != 0 { + t.Errorf("SoC %.3f, -15 W standby: %d of 300 ticks sent an order, want 0", soc, sent) + } + } +} + +// The same at the owner floor, in a planner mode with a fresh plan. +func TestOwnerFloorStandbyRandomWalk(t *testing.T) { + for _, energy := range []bool{false, true} { + st := NewState(0, 50, "ferroamp") + st.Mode = ModePlannerSelf + st.UseEnergyDispatch = energy + st.SlewEnabled = true + st.SlewRateW = 3000 + st.MinDispatchIntervalS = 0 + st.DriverLimits = map[string]PowerLimits{"bat": {SoCMin: 0.10}} + st.SlotDirective = func(now time.Time) (SlotDirective, bool) { + return SlotDirective{SlotStart: now, SlotEnd: now.Add(15 * time.Minute), Strategy: "self_consumption"}, true + } + st.PlanTarget = func(time.Time) (string, float64, string, bool) { return "self_consumption", 0, "self", true } + if sent := floorStandbyWalk(st, 0.10); sent != 0 { + t.Errorf("planner_self energy=%v, SoC 10 %%, -15 W standby: %d of 300 ticks sent an order, want 0", energy, sent) + } + } +} + +// A small discharge that FTW itself ordered still stops at the floor, +// though it reads under the standby threshold: the driver would hold it. +func TestHardFloorStopsOwnSmallDischarge(t *testing.T) { + st := NewState(0, 50, "ferroamp") + st.Mode = ModeSelfConsumption + st.SlewEnabled = true + st.SlewRateW = 3000 + st.MinDispatchIntervalS = 0 + st.PrevTargets["bat"] = -30 + store := seedStore(10, []struct { + name string + currentW, soc float64 + }{{"bat", -30, 0.05}}) + targets := ComputeDispatch(store, st, caps(map[string]float64{"bat": 15200}), 11040) + if len(targets) == 0 || targets[0].TargetW < 0 { + t.Fatalf("own -30 W order at 5 %%: %+v, want a 0 W order", targets) + } +} diff --git a/go/internal/control/testdata/golden/seeded_siblings.json b/go/internal/control/testdata/golden/seeded_siblings.json index e6339aa3a..1433c45b8 100644 --- a/go/internal/control/testdata/golden/seeded_siblings.json +++ b/go/internal/control/testdata/golden/seeded_siblings.json @@ -1,7 +1,7 @@ { "family": "seeded_siblings", "generated_by": "FTW_GOLDEN_DUMP=1 go test ./internal/control/ -run TestGoldenDump", - "ftw_commit": "b3af71859a912dcae3a512f6c1ca79a21c2bb631", + "ftw_commit": "c41dc64bb5a70b8c838e50225566995f3331fa70", "record_count": 60, "records": [ { @@ -3774,13 +3774,14 @@ }, { "driver": "sungrow", - "target_w": -3200, - "clamped": false + "target_w": -5000, + "clamped": true } ], "clamp_attributions": { "clamped_drivers": [ - "ferroamp" + "ferroamp", + "sungrow" ], "all_targets_zero_clamped": false, "plan_sign_intent": -1, @@ -3799,9 +3800,9 @@ }, "site_totals": { "battery_current_w": -1969, - "battery_target_sum_w": -3200, + "battery_target_sum_w": -5000, "raw_grid_w": 5401, - "projected_grid_w": 4170 + "projected_grid_w": 2370 } }, {