feat(battery): make the fast loop the whole controller (snapshot + continuous direction)

Invert the main/fast split: the main loop becomes a supervisor that sets
the battery mode and publishes a snapshot (per-battery SoC/limits/caps +
config), and the 1s fast loop owns every power decision - direction,
tiering, sticky selection, swaps, scaling, stops - off fresh grid and
battery readings. Direction is continuous (the sign of the ramp-invariant
energy-balance need), so there is no separate charge/discharge decision
and no flip-latency to bridge.

Running the full selection every tick off a measured target lets
computeTier absorb both saturation and under-delivery and makes direction
fall out of the sign, so the previous bridge machinery is deleted:
crossing detector, out-of-band replan poke + channel, dual offsets,
explicit tier-up/standby, shortfall dwell, single-writer carve-outs, and
the batteryControlPlan type. Net less code, one controller, one cadence.

Charge↔discharge reversals keep a 1s dwell plus adaptive backoff to bound
thrash; same-direction and idle transitions are immediate. Swaps keep the
write-before-stop ordering but drop the ACK check and one-tick overlap
(brief blip on infrequent SoC-driven swaps).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: webalexeu

core/site.go

@@ -52,9 +52,8 @@ var _ site.API = (*Site)(nil)
 
 // Site is the main configuration container. A site can host multiple loadpoints.
 type Site struct {
-	valueChan         chan<- util.Param // client push messages
-	lpUpdateChan      chan *Loadpoint
-	batteryReplanChan chan struct{} // fast loop requests an out-of-band battery re-decision (direction flip)
+	valueChan    chan<- util.Param // client push messages
+	lpUpdateChan chan *Loadpoint
 
 	sync.RWMutex
 	log *util.Logger
@@ -76,26 +75,30 @@ type Site struct {
 	consumerMeters []config.Device[api.Meter] // Consumer meters
 
 	// battery settings
-	prioritySoc             float64  // prefer battery up to this Soc
-	bufferSoc               float64  // continue charging on battery above this Soc (EV loadpoints)
-	bufferStartSoc          float64  // start charging on battery above this Soc (EV loadpoints)
-	batteryDischargeControl bool     // prevent battery discharge for fast and planned charging
-	batterySolarControl      bool     // actively charge from surplus / discharge to cover loads
-	batteryCalibrationCharge bool     // one-shot: bypass maxSoc and charge to 100% for LFP calibration (not persisted)
-	batteryControlDeadBand  float64  // minimum surplus/deficit (W) to start charge or discharge (stability dead band)
-	batteryGridChargeLimit  *float64 // grid charging limit
-	batterySolarPool        bool     // distribute power equally across all batteries (no per-battery selection)
-	batterySolarTiering     bool     // activate minimum number of batteries needed to stay above inverter's effective power floor
-	batterySolarSticky      bool     // keep the same battery selection across ticks; swap only on significant SoC divergence
-	batterySolarTapering    bool     // linearly reduce charge power in the last SoC band before maxSoc to protect cells
-	batteryChargeTier       int      // tiered activation: current number of batteries charging (0 = uninitialised)
-	batteryDischargeTier    int      // tiered activation: current number of batteries discharging (0 = uninitialised)
-	batteryChargeActive     []string // sticky selection: names of batteries currently in the charge tier
-	batteryDischargeActive  []string // sticky selection: names of batteries currently in the discharge tier
-	batteryStopped          map[string]int // ticks since stop was last sent per battery; skips redundant re-stops
-	batteryPlanMu           sync.Mutex           // guards batteryPlan and serializes main loop battery section vs fast loop
-	batteryPlan             *batteryControlPlan  // contract between main loop (writes) and fast loop (adjusts)
-	batteryLastDirection    batteryPlanDirection // direction of the previous solar control tick; direction changes force fresh power commands
+	prioritySoc              float64              // prefer battery up to this Soc
+	bufferSoc                float64              // continue charging on battery above this Soc (EV loadpoints)
+	bufferStartSoc           float64              // start charging on battery above this Soc (EV loadpoints)
+	batteryDischargeControl  bool                 // prevent battery discharge for fast and planned charging
+	batterySolarControl      bool                 // actively charge from surplus / discharge to cover loads
+	batteryCalibrationCharge bool                 // one-shot: bypass maxSoc and charge to 100% for LFP calibration (not persisted)
+	batteryControlDeadBand   float64              // minimum surplus/deficit (W) to start charge or discharge (stability dead band)
+	batteryGridChargeLimit   *float64             // grid charging limit
+	batterySolarPool         bool                 // distribute power equally across all batteries (no per-battery selection)
+	batterySolarTiering      bool                 // activate minimum number of batteries needed to stay above inverter's effective power floor
+	batterySolarSticky       bool                 // keep the same battery selection across ticks; swap only on significant SoC divergence
+	batterySolarTapering     bool                 // linearly reduce charge power in the last SoC band before maxSoc to protect cells
+	batteryChargeTier        int                  // tiered activation: current number of batteries charging (0 = uninitialised)
+	batteryDischargeTier     int                  // tiered activation: current number of batteries discharging (0 = uninitialised)
+	batteryChargeActive      []string             // sticky selection: names of batteries currently in the charge tier
+	batteryDischargeActive   []string             // sticky selection: names of batteries currently in the discharge tier
+	batteryStopped           map[string]int       // ticks since stop was last sent per battery; skips redundant re-stops
+	batteryPlanMu            sync.Mutex           // guards batterySnapshot and serializes snapshot build vs fast loop
+	batterySnapshot          *batterySnapshot     // main loop → fast loop contract (SoC/limits/caps + config, no power)
+	batteryFastDirection     batteryPlanDirection // direction the fast loop is currently committed to
+	batteryLastGrid          float64              // fast loop meter guard: previous grid reading
+	batteryLastBatt          float64              // fast loop meter guard: previous total battery reading
+	batteryGuardValid        bool                 // fast loop meter guard: previous readings are valid
+	batteryFlipSince         time.Time            // fast loop: when the opposite direction first became wanted
 
 	// optimizer settings
 	optimizerChargingStrategy string // optimizer grid charging strategy
@@ -117,10 +120,8 @@ type Site struct {
 	batteryMode              api.BatteryMode    // Battery mode (runtime only, not persisted)
 	batteryModeExternal      api.BatteryMode    // Battery mode (external, runtime only, not persisted)
 	batteryModeExternalTimer time.Time          // Battery mode timer for external control
-	lastFlexiblePower        float64            // last PV-mode charge flexibility, reused by out-of-band battery replan
-	lastTotalChargePower     float64            // last total loadpoint charge power, reused by out-of-band battery replan
-	lastBatteryFlipRequest   time.Time          // last fast-loop flip poke; adaptive spacing to bound direction thrash
-	batteryFlipBackoff       time.Duration      // current minimum spacing between flip pokes; grows on rapid re-flips, resets when calm
+	lastBatteryFlipRequest   time.Time          // fast loop: last direction flip; adaptive spacing to bound thrash
+	batteryFlipBackoff       time.Duration      // fast loop: current minimum spacing between flips; grows on rapid re-flips, resets when calm
 }
 
 // MetersConfig contains the site's meter configuration
@@ -1146,11 +1147,6 @@ func (site *Site) update(lp updater) {
 		site.log.WARN.Println("planner:", msg)
 	}
 
-	// cache loadpoint-derived scalars so an out-of-band battery replan can reuse them
-	// without re-running the loadpoint cycle (see replanBattery)
-	site.lastFlexiblePower = flexiblePower
-	site.lastTotalChargePower = totalChargePower
-
 	// update battery after reading meters to ensure that (modbus) connection is open
 	batteryGridChargeActive := site.batteryGridChargeActive(rate)
 	site.publish(keys.BatteryGridChargeActive, batteryGridChargeActive)
@@ -1159,31 +1155,6 @@ func (site *Site) update(lp updater) {
 	site.stats.Update(site)
 }
 
-// replanBattery re-runs only the battery direction decision with fresh meter
-// readings, without re-running the loadpoint cycle. Triggered out-of-band by the
-// fast loop when it detects a charge<->discharge crossing, so a direction flip does
-// not wait for the next scheduled tick. Reuses the last loadpoint-derived scalars
-// (flexiblePower is irrelevant unless an EV charges in PV mode; totalChargePower is
-// unused when grid and PV meters are present). Runs in the Run goroutine, so it never
-// overlaps a scheduled update.
-func (site *Site) replanBattery() {
-	consumption, err := site.tariffRates(api.TariffUsagePlanner)
-	if err != nil {
-		site.log.WARN.Println("planner:", err)
-	}
-
-	sitePower, _, _, err := site.sitePower(site.lastTotalChargePower, site.lastFlexiblePower)
-	if err != nil {
-		site.log.ERROR.Println(err)
-		return
-	}
-
-	rate, _ := consumption.At(time.Now())
-	batteryGridChargeActive := site.batteryGridChargeActive(rate)
-	site.publish(keys.BatteryGridChargeActive, batteryGridChargeActive)
-	site.updateBatteryMode(batteryGridChargeActive, rate, sitePower, true)
-}
-
 // prepare publishes initial values
 func (site *Site) prepare() {
 	if err := site.restoreSettings(); err != nil {
@@ -1245,8 +1216,7 @@ func (site *Site) Prepare(valueChan chan<- util.Param, pushChan chan<- messenger
 		}
 	}()
 
-	site.lpUpdateChan = make(chan *Loadpoint, 1)  // 1 capacity to avoid deadlock
-	site.batteryReplanChan = make(chan struct{}, 1) // 1 capacity; non-blocking send coalesces requests
+	site.lpUpdateChan = make(chan *Loadpoint, 1) // 1 capacity to avoid deadlock
 
 	site.prepare()
 
@@ -1321,8 +1291,6 @@ func (site *Site) Run(stopC chan struct{}, interval time.Duration) {
 			site.update(<-loadpointChan)
 		case lp := <-site.lpUpdateChan:
 			site.update(lp)
-		case <-site.batteryReplanChan:
-			site.replanBattery()
 		case <-stopC:
 			return
 		}