fix: PV recovery gate to avoid grid import

Author: gmlexx

scheduler/mpc.go

@@ -638,15 +638,41 @@ type batteryAction struct {
 
 // decideBatteryAction translates an MPC control decision into a concrete battery
 // action without any side-effects, making the mapping easy to read and test.
-func decideBatteryAction(decision *mpc.ControlDecision, maxCharge float64) batteryAction {
+//
+// recentAvgPV is the short-term average PV output (kW) measured just before
+// execution.  When it is high enough to cover the load plus the full planned
+// charge rate, grid charging is suppressed and the inverter is switched to
+// PV-only self-use mode instead.  Pass 0 to disable the gate (e.g. in tests
+// that are not exercising the cloud-recovery logic).
+func decideBatteryAction(decision *mpc.ControlDecision, maxCharge float64, recentAvgPV float64) batteryAction {
 	switch {
 	case decision.BatteryChargeFromGrid > 0.01:
+		totalPlannedCharge := decision.BatteryChargeFromPV + decision.BatteryChargeFromGrid
+
+		// PV recovery gate: the MPC may have planned grid charging because it
+		// observed low solar at optimisation time (a cloud was passing).  If
+		// actual PV is now high enough to cover both the load and the full
+		// planned charge, the cloud has cleared and the grid import is no longer
+		// needed.  Switch to Mode 2 (PV self-use) so the battery still charges
+		// at the planned rate but entirely from solar.
+		if recentAvgPV >= decision.LoadForecast+totalPlannedCharge {
+			limit := math.Min(totalPlannedCharge, maxCharge)
+			return batteryAction{
+				mode:        2,
+				chargeLimit: limit,
+				setCharge:   true,
+				logMsg: fmt.Sprintf(
+					"Grid charging suppressed (PV recovery): recent PV %.1f kW >= load %.1f kW + planned charge %.1f kW; switching to PV-only mode, limit %.1f kW",
+					recentAvgPV, decision.LoadForecast, totalPlannedCharge, limit),
+			}
+		}
+
 		// Mode 4: Command charging (PV first, then grid).
 		// The charge limit must be the total desired charge rate so that the
 		// inverter can draw from both PV surplus and the grid to reach it.
 		// Clamp to maxCharge: the inverter rejects any value above the
 		// hardware-rated maximum with a Modbus illegal-data-address exception.
-		limit := math.Min(decision.BatteryChargeFromPV+decision.BatteryChargeFromGrid, maxCharge)
+		limit := math.Min(totalPlannedCharge, maxCharge)
 		return batteryAction{
 			mode:        4,
 			chargeLimit: limit,
@@ -737,7 +763,14 @@ func (s *MinerScheduler) executeMPCDecision(ctx context.Context, decision *mpc.C
 	}
 	s.logger.Printf("Enabled Remote EMS control")
 
-	action := decideBatteryAction(decision, config.BatteryMaxCharge)
+	// Get recent average PV power for the grid-charging gate.  A 5-minute
+	// window covers ~30 readings at the default 10 s poll interval and is
+	// long enough to distinguish a sustained cloud-free period from a brief
+	// spike.  Falls back to 0 (gate disabled) when no samples are available.
+	const pvGateWindow = 5 * time.Minute
+	recentAvgPV := s.dataSamples.AveragePVPowerLast(pvGateWindow)
+
+	action := decideBatteryAction(decision, config.BatteryMaxCharge, recentAvgPV)
 	s.logger.Print(action.logMsg)
 
 	if err := client.SetRemoteEMSMode(action.mode); err != nil {

scheduler/mpc_test.go

@@ -697,7 +697,7 @@ func TestDecideBatteryAction_DischargeNegativeExportUsesMode2(t *testing.T) {
 		BatteryChargeFromGrid: 0,
 		BatteryChargeFromPV:   0,
 	}
-	action := decideBatteryAction(decision, 5.0)
+	action := decideBatteryAction(decision, 5.0, 0.0)
 	if action.mode != 2 {
 		t.Errorf("expected mode 2, got %d", action.mode)
 	}
@@ -713,7 +713,7 @@ func TestDecideBatteryAction_DischargeZeroExportUsesMode2(t *testing.T) {
 		BatteryChargeFromGrid: 0,
 		BatteryChargeFromPV:   0,
 	}
-	action := decideBatteryAction(decision, 5.0)
+	action := decideBatteryAction(decision, 5.0, 0.0)
 	if action.mode != 2 {
 		t.Errorf("expected mode 2, got %d", action.mode)
 	}
@@ -732,7 +732,7 @@ func TestDecideBatteryAction_DischargeWithPlannedGridExportUsesMode5(t *testing.
 		BatteryChargeFromGrid: 0,
 		BatteryChargeFromPV:   0,
 	}
-	action := decideBatteryAction(decision, 5.0)
+	action := decideBatteryAction(decision, 5.0, 0.0)
 	if action.mode != 5 {
 		t.Errorf("expected mode 5, got %d", action.mode)
 	}
@@ -743,3 +743,99 @@ func TestDecideBatteryAction_DischargeWithPlannedGridExportUsesMode5(t *testing.
 		t.Errorf("expected dischargeLimit 3.0, got %.2f", action.dischargeLimit)
 	}
 }
+
+// ---------------------------------------------------------------------------
+// PV recovery gate tests (grid charging suppression when cloud clears)
+// ---------------------------------------------------------------------------
+
+// TestDecideBatteryAction_GridCharge_GateSuppressesWhenPVCoversAll verifies that
+// when recent PV is high enough to cover load + full planned charge, the gate
+// fires and switches from Mode 4 (grid+PV) to Mode 2 (PV-only).
+func TestDecideBatteryAction_GridCharge_GateSuppressesWhenPVCoversAll(t *testing.T) {
+	decision := &mpc.ControlDecision{
+		BatteryChargeFromPV:   2.0,
+		BatteryChargeFromGrid: 3.0,
+		LoadForecast:          4.0,
+	}
+	// recentAvgPV = 9.0 >= load(4.0) + charge(5.0) → gate fires
+	action := decideBatteryAction(decision, 12.0, 9.0)
+
+	if action.mode != 2 {
+		t.Errorf("expected mode 2 (PV-only) after gate, got %d", action.mode)
+	}
+	if !action.setCharge {
+		t.Errorf("expected setCharge true")
+	}
+	// Limit must equal the full planned charge (PV + grid portions)
+	if action.chargeLimit != 5.0 {
+		t.Errorf("expected chargeLimit 5.0 (full planned charge), got %.2f", action.chargeLimit)
+	}
+}
+
+// TestDecideBatteryAction_GridCharge_GateDoesNotFireWhenPVInsufficient verifies
+// that the gate does NOT fire when recent PV is below the load + charge threshold,
+// preserving Mode 4 (grid + PV) charging.
+func TestDecideBatteryAction_GridCharge_GateDoesNotFireWhenPVInsufficient(t *testing.T) {
+	decision := &mpc.ControlDecision{
+		BatteryChargeFromPV:   2.0,
+		BatteryChargeFromGrid: 3.0,
+		LoadForecast:          4.0,
+	}
+	// recentAvgPV = 8.9 < load(4.0) + charge(5.0) = 9.0 → gate must NOT fire
+	action := decideBatteryAction(decision, 12.0, 8.9)
+
+	if action.mode != 4 {
+		t.Errorf("expected mode 4 (grid+PV) when PV insufficient, got %d", action.mode)
+	}
+}
+
+// TestDecideBatteryAction_GridCharge_GateDoesNotFireWhenRecentPVIsZero verifies
+// that passing recentAvgPV=0 (no samples / startup) never triggers the gate.
+func TestDecideBatteryAction_GridCharge_GateDoesNotFireWhenRecentPVIsZero(t *testing.T) {
+	decision := &mpc.ControlDecision{
+		BatteryChargeFromPV:   1.0,
+		BatteryChargeFromGrid: 2.0,
+		LoadForecast:          0.0,
+	}
+	// recentAvgPV = 0 → gate must NOT fire even though load is also 0
+	action := decideBatteryAction(decision, 12.0, 0.0)
+
+	if action.mode != 4 {
+		t.Errorf("expected mode 4 when recentAvgPV is 0, got %d", action.mode)
+	}
+}
+
+// TestDecideBatteryAction_GridCharge_GateAtExactThreshold verifies the gate fires
+// at exactly the threshold (>=, not >).
+func TestDecideBatteryAction_GridCharge_GateAtExactThreshold(t *testing.T) {
+	decision := &mpc.ControlDecision{
+		BatteryChargeFromPV:   1.0,
+		BatteryChargeFromGrid: 2.0,
+		LoadForecast:          3.0,
+	}
+	// threshold = load(3.0) + charge(3.0) = 6.0; pass exactly 6.0 → gate fires
+	action := decideBatteryAction(decision, 12.0, 6.0)
+
+	if action.mode != 2 {
+		t.Errorf("expected mode 2 at exact threshold, got %d", action.mode)
+	}
+}
+
+// TestDecideBatteryAction_GridCharge_LimitClampedToMaxCharge verifies that when
+// the gate fires and the planned charge exceeds maxCharge, the limit is clamped.
+func TestDecideBatteryAction_GridCharge_LimitClampedToMaxCharge(t *testing.T) {
+	decision := &mpc.ControlDecision{
+		BatteryChargeFromPV:   4.0,
+		BatteryChargeFromGrid: 5.0, // total = 9.0, above maxCharge
+		LoadForecast:          1.0,
+	}
+	// recentAvgPV = 10.0 >= load(1.0) + charge(9.0) → gate fires
+	action := decideBatteryAction(decision, 8.0, 10.0) // maxCharge = 8.0
+
+	if action.mode != 2 {
+		t.Errorf("expected mode 2, got %d", action.mode)
+	}
+	if action.chargeLimit != 8.0 {
+		t.Errorf("expected chargeLimit clamped to maxCharge 8.0, got %.2f", action.chargeLimit)
+	}
+}