feat: add ev charging control task

Author: gmlexx

config.example.json

@@ -17,7 +17,7 @@
   "location": "CET",
   "plant_modbus_address": "192.168.1.100:502",
   "device_id": 0,
-  "pv_poll_interval": "10s",
+  "pv_poll_interval": "5s",
   "pv_integration_period": "15m",
   "postgres_conn_string": "<your-neon-connection-string>",
   "battery_capacity": 24.0,

scheduler/config.go

@@ -112,7 +112,7 @@ func DefaultConfig() *Config {
 		MinerTimeout:                     5 * time.Second,
 		HealthCheckPort:                  0,
 		DeviceID:                         0,
-		PVPollInterval:                   10 * time.Second,
+		PVPollInterval:                   5 * time.Second,
 		PVIntegrationPeriod:              15 * time.Minute,
 		PostgresConnString:               "",
 		URLFormat:                        "https://web-api.tp.entsoe.eu/api?documentType=A44&out_Domain=10YLV-1001A00074&in_Domain=10YLV-1001A00074&periodStart=%s&periodEnd=%s&securityToken=%s",

scheduler/ev.go

@@ -0,0 +1,90 @@
+package scheduler
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/devskill-org/ems/sigenergy"
+)
+
+// runEVControl is the single owner of all DC-charger EV session logic.
+// It runs at PVPollInterval (default 5 s) — fast enough to react within the
+// EV protocol handshake window — and is responsible for:
+//
+//  1. Detecting cable plug-in via DCChargerVehicleVoltage (register 31500).
+//     Voltage is at or above the plug-in threshold for the entire session
+//     (negotiation, BMS pauses, thermal holds, full battery) whereas output
+//     power drops to zero in all those cases and would incorrectly appear as
+//     "no EV present".  A 10 V floor filters out the ~1–2 V residual bus
+//     charge that persists briefly after physical cable removal.
+//
+//  2. Maintaining the sticky evSessionActive flag with a 2-reading debounce
+//     on session-end to survive transient Modbus glitches.
+//
+//  3. Applying Mode 2 (Maximum self-consumption) with full battery charge and
+//     discharge limits whenever a session is active, so the battery buffers
+//     intermittent PV and prevents power gaps from reaching the DC charger.
+//
+// executeMPCDecision reads evSessionActive as a read-only guard and yields
+// control to this task for the duration of the EV session.  No other function
+// writes evSessionActive or issues EV-related inverter commands.
+func (s *MinerScheduler) runEVControl(ctx context.Context) error {
+	config := s.GetConfig()
+
+	if config.PlantModbusAddress == "" {
+		return nil
+	}
+
+	client, err := sigenergy.NewTCPClient(ctx, config.PlantModbusAddress, sigenergy.PlantAddress)
+	if err != nil {
+		return fmt.Errorf("EV control: failed to connect to Plant Modbus: %w", err)
+	}
+	defer client.Close()
+
+	// ReadPlantRunningInfo now returns an error when the DC charger registers
+	// cannot be read (fail-safe), so a Modbus failure here causes this task to
+	// return an error and be retried on the next tick rather than silently
+	// treating the EV as absent.
+	info, err := client.ReadPlantRunningInfo(byte(config.DCChargerSlaveID)) //nolint:gosec // SlaveID is expected to be in [0,255] range
+	if err != nil {
+		return fmt.Errorf("EV control: failed to read plant info: %w", err)
+	}
+
+	// Update sticky session state.
+	s.mu.Lock()
+	if info.EVPluggedIn {
+		s.evSessionActive = true
+		s.evSessionClearCount = 0
+	} else if s.evSessionActive {
+		// Require two consecutive zero-voltage readings before declaring the
+		// session ended.  This prevents a single transient Modbus glitch from
+		// releasing battery control mid-session.
+		s.evSessionClearCount++
+		if s.evSessionClearCount >= 2 {
+			s.evSessionActive = false
+			s.evSessionClearCount = 0
+			s.logger.Printf("EV control: session ended (2 consecutive zero-voltage readings)")
+		} else {
+			s.logger.Printf("EV control: zero vehicle voltage detected (pending session-end debounce %d/2)", s.evSessionClearCount)
+		}
+	}
+	evActive := s.evSessionActive
+	s.mu.Unlock()
+
+	if !evActive {
+		return nil
+	}
+
+	// Session is active — apply Mode 2 so the battery supports intermittent PV
+	// and prevents power gaps from reaching the DC charger.
+	s.logger.Printf("EV control: session active - Mode 2 battery support (VehicleVoltage: %.0f V, ChargePower: %.1f kW, VehicleSOC: %.1f%%)",
+		info.DCChargerVehicleVoltage, info.DCChargerOutputPower, info.DCChargerVehicleSOC)
+
+	if config.DryRun {
+		s.logger.Printf("EV control: DRY-RUN - would apply Mode 2 (chargeLimit: %.1f kW, dischargeLimit: %.1f kW)",
+			config.BatteryMaxCharge, config.BatteryMaxDischarge)
+		return nil
+	}
+
+	return s.applyInverterMode(client, 2, config.BatteryMaxCharge, config.BatteryMaxDischarge, true, true)
+}

scheduler/mpc.go

@@ -88,6 +88,7 @@ func (s *MinerScheduler) RunMPCOptimize(ctx context.Context) error {
 	s.mu.Lock()
 	s.mpcDecisions = decisions
 	s.lastExecutedDecision = nil // Clear last executed decision for new optimization
+	s.lastWrittenMode = 0        // Force re-write of inverter registers after new plan
 	s.mu.Unlock()
 
 	// Step 5.1: Persist decisions to database (only when not in dry run mode)
@@ -297,7 +298,7 @@ func (s *MinerScheduler) getSolarForecast(config *Config, now time.Time, slotDur
 	// A single instantaneous sample can be near zero if a cloud passes at the
 	// exact moment the MPC optimization runs, causing the optimizer to pull from
 	// the grid for the entire slot even though the day is otherwise sunny.
-	// Averaging the last 5 minutes of samples (≈30 readings at the default 10 s
+	// Averaging the last 5 minutes of samples (≈60 readings at the default 5 s
 	// poll interval) smooths out these transient dips while still tracking genuine
 	// sustained low-irradiance conditions.  Falls back to the latest single reading
 	// when the buffer has no samples within that window (e.g. on startup).
@@ -744,27 +745,21 @@ func (s *MinerScheduler) executeMPCDecision(ctx context.Context, decision *mpc.C
 	}
 	defer client.Close()
 
-	// Check whether an EV is plugged into the DC charger. When it is, the
-	// inverter is already managing power delivery for the fast-charge session
-	// and we must not override its control mode or limits.
-	plantInfo, err := client.ReadPlantRunningInfo(byte(config.DCChargerSlaveID)) //nolint:gosec // SlaveID is expected to be in [0,255] range
-	if err != nil {
-		return fmt.Errorf("failed to read plant info for EV DC-charger check: %w", err)
-	}
-	if plantInfo.DCChargerOutputPower > 0 {
-		s.logger.Printf("Skipping MPC battery control: EV is plugged into DC charger (ChargePower: %.1f kW, VehicleSOC: %.1f%%)",
-			plantInfo.DCChargerOutputPower, plantInfo.DCChargerVehicleSOC)
-		return nil
-	}
+	// Check whether an EV session is currently active.  All session state
+	// management (register reads, evSessionActive updates, debounce, and Mode 2
+	// writes) is owned exclusively by runEVControl, which runs at PVPollInterval.
+	// This function only reads the flag — it never writes it.
+	s.mu.RLock()
+	evActive := s.evSessionActive
+	s.mu.RUnlock()
 
-	// Enable Remote EMS control
-	if err := client.EnableRemoteEMS(true); err != nil {
-		return fmt.Errorf("failed to enable remote EMS: %w", err)
+	if evActive {
+		s.logger.Printf("EV session active - MPC battery control deferred to runEVControl")
+		return nil
 	}
-	s.logger.Printf("Enabled Remote EMS control")
 
 	// 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
+	// window covers ~60 readings at the default 5 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
@@ -773,18 +768,8 @@ func (s *MinerScheduler) executeMPCDecision(ctx context.Context, decision *mpc.C
 	action := decideBatteryAction(decision, config.BatteryMaxCharge, recentAvgPV)
 	s.logger.Print(action.logMsg)
 
-	if err := client.SetRemoteEMSMode(action.mode); err != nil {
-		return fmt.Errorf("failed to set remote EMS mode: %w", err)
-	}
-	if action.setCharge {
-		if err := client.SetESSMaxChargingLimit(action.chargeLimit); err != nil {
-			return fmt.Errorf("failed to set ESS charging limit: %w", err)
-		}
-	}
-	if action.setDischarge {
-		if err := client.SetESSMaxDischargingLimit(action.dischargeLimit); err != nil {
-			return fmt.Errorf("failed to set ESS discharging limit: %w", err)
-		}
+	if err := s.applyInverterMode(client, action.mode, action.chargeLimit, action.dischargeLimit, action.setCharge, action.setDischarge); err != nil {
+		return err
 	}
 
 	s.logger.Printf("Successfully executed MPC decision - Mode: %d, SOC: %.1f%%, ChargeFromPV: %.1f kW, ChargeFromGrid: %.1f kW, Discharge: %.1f kW, GridImport: %.1f kW, GridExport: %.1f kW",
@@ -793,6 +778,59 @@ func (s *MinerScheduler) executeMPCDecision(ctx context.Context, decision *mpc.C
 	return nil
 }
 
+// applyInverterMode writes Remote EMS enable + mode + charge/discharge limits to
+// the inverter via Modbus.  Writes are suppressed when the values are identical
+// to what was last successfully written, reducing register churn that can disturb
+// the DC charging protocol during an active EV session.
+func (s *MinerScheduler) applyInverterMode(
+	client interface {
+		EnableRemoteEMS(bool) error
+		SetRemoteEMSMode(uint16) error
+		SetESSMaxChargingLimit(float64) error
+		SetESSMaxDischargingLimit(float64) error
+	},
+	mode uint16, chargeLimit, dischargeLimit float64,
+	setCharge, setDischarge bool,
+) error {
+	s.mu.Lock()
+	lastMode := s.lastWrittenMode
+	lastCharge := s.lastWrittenChargeLimit
+	lastDischarge := s.lastWrittenDischargeLimit
+	s.mu.Unlock()
+
+	// Always enable Remote EMS on the first write (lastMode == 0) or when
+	// switching modes, but skip the Modbus call when nothing changed.
+	if lastMode == 0 || lastMode != mode || (setCharge && lastCharge != chargeLimit) || (setDischarge && lastDischarge != dischargeLimit) {
+		if err := client.EnableRemoteEMS(true); err != nil {
+			return fmt.Errorf("failed to enable remote EMS: %w", err)
+		}
+		if err := client.SetRemoteEMSMode(mode); err != nil {
+			return fmt.Errorf("failed to set remote EMS mode: %w", err)
+		}
+		if setCharge {
+			if err := client.SetESSMaxChargingLimit(chargeLimit); err != nil {
+				return fmt.Errorf("failed to set ESS charging limit: %w", err)
+			}
+		}
+		if setDischarge {
+			if err := client.SetESSMaxDischargingLimit(dischargeLimit); err != nil {
+				return fmt.Errorf("failed to set ESS discharging limit: %w", err)
+			}
+		}
+		s.mu.Lock()
+		s.lastWrittenMode = mode
+		if setCharge {
+			s.lastWrittenChargeLimit = chargeLimit
+		}
+		if setDischarge {
+			s.lastWrittenDischargeLimit = dischargeLimit
+		}
+		s.mu.Unlock()
+		s.logger.Printf("Inverter mode applied: mode=%d chargeLimit=%.1f kW dischargeLimit=%.1f kW", mode, chargeLimit, dischargeLimit)
+	}
+	return nil
+}
+
 // runMPCExecution re-executes the current MPC decision only if previous execution failed
 // This ensures the decision is applied even if previous execution failed
 func (s *MinerScheduler) runMPCExecution(ctx context.Context) error {

scheduler/scheduler.go

@@ -131,6 +131,18 @@ type MinerScheduler struct {
 	mpcDecisions         []mpc.ControlDecision
 	lastExecutedDecision *mpc.ControlDecision // Tracks the last successfully executed decision
 
+	// EV session state — tracks whether a DC charging cable is currently
+	// connected so that the fast-poll path can apply battery support mode
+	// immediately on plug-in without waiting for the next MPC execution tick.
+	evSessionActive     bool // true while an EV cable is confirmed connected
+	evSessionClearCount int  // consecutive zero-voltage readings since last plug-in
+
+	// Last inverter control values written via Remote EMS so we can skip
+	// redundant Modbus writes when nothing has changed.
+	lastWrittenMode           uint16
+	lastWrittenChargeLimit    float64
+	lastWrittenDischargeLimit float64
+
 	// Web server
 	webServer *WebServer
 
@@ -335,6 +347,14 @@ func (s *MinerScheduler) Start(ctx context.Context, serverOnly bool) error {
 				return s.runDataPoll(ctx, dataSamples)
 			},
 		},
+		{
+			name:         "EVControl",
+			initialDelay: 0, // Run immediately so the first poll catches a cable already connected on startup
+			interval:     config.PVPollInterval,
+			runFunc: func() error {
+				return s.runEVControl(ctx)
+			},
+		},
 		{
 			name:          "DataIntegration",
 			initialDelay:  pvDataInitialDelay,

sigenergy/info.go

@@ -103,6 +103,9 @@ func ShowPlantInfo(ctx context.Context, plantModbusAddress string, dcChargerSlav
 	// DC Charger Information
 	fmt.Println("DC CHARGER")
 	fmt.Println("--------------------------------------------------")
+	fmt.Printf("  Cable Connected:                %s\n", getEVPluggedInStatus(info.EVPluggedIn))
+	fmt.Printf("  Vehicle Battery Voltage:        %.1f V\n", info.DCChargerVehicleVoltage)
+	fmt.Printf("  Charging Current:               %.1f A\n", info.DCChargerChargingCurrent)
 	fmt.Printf("  Output Power:                   %.3f kW\n", info.DCChargerOutputPower)
 	fmt.Printf("  Vehicle SOC:                    %.1f %%\n", info.DCChargerVehicleSOC)
 	fmt.Println()
@@ -171,3 +174,10 @@ func getESSPowerStatus(power float64) string {
 	}
 	return "(Idle)"
 }
+
+func getEVPluggedInStatus(pluggedIn bool) string {
+	if pluggedIn {
+		return "Yes"
+	}
+	return "No"
+}

sigenergy/registers.go

@@ -40,8 +40,19 @@ type PlantRunningInfo struct {
 	ESSDischargeOffSOC              float64 // %
 	ESSSOH                          float64 // %
 	ESSAvgCellTemperature           float64 // °C
-	DCChargerOutputPower            float64 // kW
-	DCChargerVehicleSOC             float64 // %
+	DCChargerVehicleVoltage         float64 // V  (register 31500) — ≥ evPluggedInVoltageThreshold whenever a vehicle is physically connected
+	DCChargerChargingCurrent        float64 // A  (register 31501)
+	DCChargerOutputPower            float64 // kW (register 31502)
+	DCChargerVehicleSOC             float64 // %  (register 31504)
+	// EVPluggedIn is true when the DC charger reports a vehicle battery voltage
+	// at or above evPluggedInVoltageThreshold, indicating a cable is physically
+	// connected regardless of whether power is currently flowing.  A hard
+	// threshold (rather than > 0) is used because the DC bus retains a small
+	// residual charge (~1–2 V) after cable removal due to capacitor discharge,
+	// which would otherwise produce a false "plugged in" reading.  Any real EV
+	// battery presents at least 100 V on the DC bus, so a 10 V floor cleanly
+	// separates genuine connections from noise.
+	EVPluggedIn bool
 }
 
 // ReadPlantRunningInfo reads plant running information (slave address 247).
@@ -99,17 +110,34 @@ func (c *SigenModbusClient) ReadPlantRunningInfo(dcChargerSlaveID byte) (*PlantR
 	}
 
 	// Read DC Charger and ESS cell temperature from first inverter (slave address 1)
-	// Registers 31502-31504 are Hybrid Inverter registers (section 5.3) and only respond
+	// Registers 31500-31504 are Hybrid Inverter registers (section 5.3) and only respond
 	// to slave addresses 1-246, NOT the plant address 247.
 	// Note: This assumes at least one hybrid inverter is present with slave ID 1
 	c.SetSlaveID(dcChargerSlaveID)
 
-	// Read DC Charger data (31502-31504)
-	data3, err := c.client.ReadInputRegisters(31502, 3)
-	if err == nil {
-		info.DCChargerOutputPower = float64(bytesToS32(data3[0:4])) / 1000.0
-		info.DCChargerVehicleSOC = float64(bytesToU16(data3[4:6])) / 10.0
+	// Read DC Charger data (31500-31504): vehicle voltage, charging current, output
+	// power (2 registers), and vehicle SOC — 5 registers total.
+	// Register 31500 (vehicle battery voltage) is non-zero whenever a cable is
+	// physically connected to a vehicle, even when power flow is zero (BMS pause,
+	// thermal hold, negotiation phase, or fully charged battery).
+	// On read error we propagate the failure instead of leaving the fields at zero,
+	// so the caller can distinguish "read succeeded, no vehicle" from "read failed".
+	data3, err := c.client.ReadInputRegisters(31500, 5)
+	if err != nil {
+		c.SetSlaveID(PlantAddress)
+		return nil, fmt.Errorf("failed to read DC charger registers: %w", err)
 	}
+	info.DCChargerVehicleVoltage  = float64(bytesToU16(data3[0:2])) / 10.0
+	info.DCChargerChargingCurrent = float64(bytesToU16(data3[2:4])) / 10.0
+	info.DCChargerOutputPower     = float64(bytesToS32(data3[4:8])) / 1000.0
+	info.DCChargerVehicleSOC      = float64(bytesToU16(data3[8:10])) / 10.0
+	// evPluggedInVoltageThreshold is the minimum vehicle battery voltage (V)
+	// treated as evidence of a physical cable connection.  The DC bus retains a
+	// small residual charge after disconnection (~1–2 V from capacitor bleed-off);
+	// a real EV battery always presents ≥ 100 V, so 10 V cleanly separates
+	// genuine connections from post-disconnect noise.
+	const evPluggedInVoltageThreshold = 10.0
+	info.EVPluggedIn = info.DCChargerVehicleVoltage >= evPluggedInVoltageThreshold
 
 	data4, err := c.client.ReadInputRegisters(30603, 1)
 	if err == nil {