Bender: add semp-based phase switching

charger/bender.go

@@ -28,19 +28,31 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math"
+	"strings"
+	"time"
 
 	"github.com/evcc-io/evcc/api"
+	"github.com/evcc-io/evcc/charger/semp"
 	"github.com/evcc-io/evcc/util"
 	"github.com/evcc-io/evcc/util/modbus"
 	"github.com/evcc-io/evcc/util/sponsor"
 )
 
+type sempHandler struct {
+	deviceID string
+	conn     *semp.Connection
+	deviceG  util.Cacheable[semp.Device2EM]
+	phases   int
+}
+
 // BenderCC charger implementation
 type BenderCC struct {
 	conn    *modbus.Connection
 	current uint16
 	regCurr uint16
 	legacy  bool
+	log     *util.Logger
+	semp    sempHandler
 }
 
 const (
@@ -54,13 +66,14 @@ const (
 	bendRegUserID             = 720  // User ID (OCPP IdTag) from the current session. Bytes 0 to 19.
 	bendRegEVBatteryState     = 730  // EV Battery State (% 0-100)
 	bendRegEVCCID             = 741  // ASCII representation of the Hex. Values corresponding to the EVCCID. Bytes 0 to 11.
-	bendRegHemsCurrentLimit   = 1000 // HEMS Current Limit (A)
-	bendRegHemsCurrentLimit10 = 1001 // HEMS Current Limit 1/10 (0.1 A)
-	bendRegHemsPowerLimit     = 1002 // HEMS Power Limit (W)
+	bendRegHemsCurrentLimit   = 1000 // HEMS Current Limit (A). Only available on Mennekes Amtron 4You / 4Business chargers.
+	bendRegHemsCurrentLimit10 = 1001 // HEMS Current Limit 1/10 (0.1 A). Only available on Mennekes Amtron 4You / 4Business chargers.
+	bendRegHemsPowerLimit     = 1002 // HEMS Power Limit (W). Only available on Mennekes Amtron 4You / 4Business chargers.
 
 	bendRegFirmware             = 100 // Application version number
 	bendRegOcppCpStatus         = 104 // Charge Point status according to the OCPP spec. enumaration
 	bendRegProtocolVersion      = 120 // Ebee Modbus TCP Server Protocol Version number
+	bendRegRelayState           = 140 // State of the internal relay (0: off, 1: 3 phases active 5: 1 phase active)
 	bendRegChargePointModel     = 142 // ChargePoint Model. Bytes 0 to 19.
 	bendRegSmartVehicleDetected = 740 // Returns 1 if an EV currently connected is a smart vehicle, or 0 if no EV connected or it is not a smart vehicle
 
@@ -70,8 +83,8 @@ const (
 	// bendRegChargedEnergy          = 716 // Sum of charged energy for the current session (Wh)
 	// bendRegChargingDuration       = 718 // Duration since beginning of charge (Seconds)
 
-	powerLimit1p uint16 = 3725 // 207V * 3p * 6A - 1W
-	powerLimit3p uint16 = 0xffff
+	powerLimit1pMennekes uint16 = 3725 // 207V * 3p * 6A - 1W
+	powerLimit3pMennekes uint16 = 0xffff
 )
 
 func init() {
@@ -80,21 +93,27 @@ func init() {
 
 // NewBenderCCFromConfig creates a BenderCC charger from generic config
 func NewBenderCCFromConfig(ctx context.Context, other map[string]interface{}) (api.Charger, error) {
-	cc := modbus.TcpSettings{
-		ID: 255,
+	cc := struct {
+		modbus.TcpSettings `mapstructure:",squash"`
+		Cache              time.Duration
+	}{
+		TcpSettings: modbus.TcpSettings{
+			ID: 255, // default
+		},
+		Cache: 5 * time.Second,
 	}
 
 	if err := util.DecodeOther(other, &cc); err != nil {
 		return nil, err
 	}
 
-	return NewBenderCC(ctx, cc.URI, cc.ID)
+	return NewBenderCC(ctx, cc.URI, cc.ID, cc.Cache)
 }
 
 // NewBenderCC creates BenderCC charger
 //
 //go:generate go tool decorate -f decorateBenderCC -b *BenderCC -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.PhaseVoltages,Voltages,func() (float64, float64, float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.Battery,Soc,func() (float64, error)" -t "api.Identifier,Identify,func() (string, error)" -t "api.ChargerEx,MaxCurrentMillis,func(float64) error" -t "api.PhaseSwitcher,Phases1p3p,func(int) error" -t "api.PhaseGetter,GetPhases,func() (int, error)"
-func NewBenderCC(ctx context.Context, uri string, id uint8) (api.Charger, error) {
+func NewBenderCC(ctx context.Context, uri string, id uint8, cache time.Duration) (api.Charger, error) {
 	conn, err := modbus.NewConnection(ctx, uri, "", "", 0, modbus.Tcp, id)
 	if err != nil {
 		return nil, err
@@ -111,6 +130,7 @@ func NewBenderCC(ctx context.Context, uri string, id uint8) (api.Charger, error)
 		conn:    conn,
 		current: 6, // assume min current
 		regCurr: bendRegHemsCurrentLimit,
+		log:     log,
 	}
 
 	// check legacy register set
@@ -159,10 +179,25 @@ func NewBenderCC(ctx context.Context, uri string, id uint8) (api.Charger, error)
 		wb.regCurr = bendRegHemsCurrentLimit10
 	}
 
-	// check feature power control/1p3p
+	// check feature modbus power control/1p3p fpr Mennekes 4you / 4business chargers
 	if _, err := wb.conn.ReadHoldingRegisters(bendRegHemsPowerLimit, 1); err == nil {
-		phases1p3p = wb.phases1p3p
-		getPhases = wb.getPhases
+		phases1p3p = wb.phases1p3pMennekes
+		getPhases = wb.getPhasesMennekes
+	}
+
+	// check feature semp phase switching
+	if phases1p3p == nil {
+		if wb.supportsSEMPPhaseSwitching(uri, cache) {
+			// set initial SEMP power limit to max so modbus control from 6 to 16 A is possible
+			if err := wb.semp.conn.SendDeviceControl(wb.semp.deviceID, 0xffff); err == nil {
+				phases1p3p = wb.phases1p3pSEMP
+				getPhases = wb.getPhases
+				// start heartbeat to keep connection alive
+				go wb.heartbeat(ctx)
+			} else {
+				log.ERROR.Println("SEMP phase switching: could not set initial SEMP power limit:", err)
+			}
+		}
 	}
 
 	// check feature rfid
@@ -173,6 +208,78 @@ func NewBenderCC(ctx context.Context, uri string, id uint8) (api.Charger, error)
 	return decorateBenderCC(wb, currentPower, currents, voltages, totalEnergy, soc, identify, maxCurrentMillis, phases1p3p, getPhases), nil
 }
 
+// heartbeat ensures that SEMP device control updates are sent about once per minute
+func (wb *BenderCC) heartbeat(ctx context.Context) {
+	for tick := time.Tick(5 * time.Second); ; {
+		select {
+		case <-tick:
+		case <-ctx.Done():
+			return
+		}
+		if time.Since(wb.semp.conn.Updated()) >= time.Minute {
+			// Send a very high power value to allow full control between 6 and 16A via modbus
+			// Note: This will not trigger a phase switch, as the value is above the max. power consumption
+			if err := wb.semp.conn.SendDeviceControl(wb.semp.deviceID, 0xffff); err != nil {
+				wb.log.ERROR.Printf("heartbeat: failed to send update: %v", err)
+			}
+		}
+	}
+}
+
+// supportsSEMPPhaseSwitching checks if SEMP phase switching is supported by querying device info
+func (wb *BenderCC) supportsSEMPPhaseSwitching(uri string, cache time.Duration) bool {
+	wb.semp.conn = semp.NewConnection(wb.log, "http://"+strings.Split(uri, ":")[0]+":8888/SimpleEnergyManagementProtocol")
+	wb.semp.deviceG = util.ResettableCached(func() (semp.Device2EM, error) {
+		return wb.semp.conn.GetDeviceXML()
+	}, cache)
+
+	doc, err := wb.semp.deviceG.Get()
+	if err != nil {
+		wb.log.DEBUG.Println("SEMP phase switching: cannot get XML", err)
+		return false
+	}
+	if len(doc.DeviceInfo) == 0 {
+		wb.log.DEBUG.Println("SEMP phase switching: no devices found")
+		return false
+	}
+
+	// Use first device ID found
+	wb.semp.deviceID = doc.DeviceInfo[0].Identification.DeviceID
+	wb.log.DEBUG.Printf("SEMP phase switching: found device ID: %s", wb.semp.deviceID)
+
+	// Check if device supports phase switching by checking power characteristics
+	info, err := wb.getDeviceInfo()
+	if err != nil {
+		wb.log.DEBUG.Println("SEMP phase switching: cannot get device info:", err)
+		return false
+	}
+
+	// Assume Phase switching support if MinPowerConsumption < 4140W and MaxPowerConsumption > 4600W
+	if info.Characteristics.MinPowerConsumption > 0 && info.Characteristics.MinPowerConsumption < 4140 &&
+		info.Characteristics.MaxPowerConsumption > 4600 {
+		return true
+	}
+
+	wb.log.DEBUG.Println("SEMP phase switching: not supported")
+	return false
+}
+
+// getDeviceInfo retrieves device info from cached document
+func (wb *BenderCC) getDeviceInfo() (semp.DeviceInfo, error) {
+	doc, err := wb.semp.deviceG.Get()
+	if err != nil {
+		return semp.DeviceInfo{}, err
+	}
+
+	for _, info := range doc.DeviceInfo {
+		if info.Identification.DeviceID == wb.semp.deviceID {
+			return info, nil
+		}
+	}
+
+	return semp.DeviceInfo{}, fmt.Errorf("device %s not found in info response", wb.semp.deviceID)
+}
+
 // Status implements the api.Charger interface
 func (wb *BenderCC) Status() (api.ChargeStatus, error) {
 	b, err := wb.conn.ReadHoldingRegisters(bendRegChargePointState, 1)
@@ -324,34 +431,73 @@ func (wb *BenderCC) voltages() (float64, float64, float64, error) {
 	return wb.getPhaseValues(bendRegVoltages, 1)
 }
 
-// phases1p3p implements the api.PhaseSwitcher interface
-func (wb *BenderCC) phases1p3p(phases int) error {
+// phases1p3pMennekes implements the api.PhaseSwitcher interface for Mennekes AMTRON 4You / 4Business chargers
+func (wb *BenderCC) phases1p3pMennekes(phases int) error {
 	b := make([]byte, 2)
-	binary.BigEndian.PutUint16(b, powerLimit3p)
+	binary.BigEndian.PutUint16(b, powerLimit3pMennekes)
 
 	if phases == 1 {
-		binary.BigEndian.PutUint16(b, powerLimit1p)
+		binary.BigEndian.PutUint16(b, powerLimit1pMennekes)
 	}
 
 	_, err := wb.conn.WriteMultipleRegisters(bendRegHemsPowerLimit, 1, b)
 
 	return err
 }
 
-// getPhases implements the api.PhaseGetter interface
-func (wb *BenderCC) getPhases() (int, error) {
+// getPhases implements the api.PhaseGetter interface for Mennekes AMTRON 4You / 4Business chargers
+func (wb *BenderCC) getPhasesMennekes() (int, error) {
 	b, err := wb.conn.ReadHoldingRegisters(bendRegHemsPowerLimit, 1)
 	if err != nil {
 		return 0, err
 	}
 
-	if binary.BigEndian.Uint16(b) <= powerLimit1p {
+	if binary.BigEndian.Uint16(b) <= powerLimit1pMennekes {
 		return 1, nil
 	}
 
 	return 3, nil
 }
 
+// phases1p3pSEMP implements the api.PhaseSwitcher interface via SEMP
+func (wb *BenderCC) phases1p3pSEMP(phases int) error {
+	// to switch to 3 phases, we have to uese a power value that is reachable with 3 phases
+	// between 207 and 253V, but never with just 1 phase
+	phaseSwitchPower := 9936 // 207V * 3p * 16A
+	if phases == 1 {
+		// to switch to 1 phase, we have to use a power value that is reachable with 1 phase
+		// between 207 and 253V, but never with 3 phases
+		phaseSwitchPower = 1518 // 253 * 1p * 6A
+	}
+
+	if err := wb.semp.conn.SendDeviceControl(wb.semp.deviceID, phaseSwitchPower); err != nil {
+		return err
+	}
+
+	wb.semp.phases = phases
+
+	wb.semp.deviceG.Reset()
+
+	return nil
+}
+
+// getPhases implements the api.PhaseGetter interface for semp phase switching by reading the relay state through modbus
+func (wb *BenderCC) getPhases() (int, error) {
+	// check relay register
+	b, err := wb.conn.ReadHoldingRegisters(bendRegRelayState, 1)
+	if err != nil {
+		return 0, err
+	}
+
+	if binary.BigEndian.Uint16(b) == 5 {
+		return 1, nil
+	} else if binary.BigEndian.Uint16(b) == 1 {
+		return 3, nil
+	}
+
+	return wb.semp.phases, nil
+}
+
 // identify implements the api.Identifier interface
 func (wb *BenderCC) identify() (string, error) {
 	if !wb.legacy {

charger/semp.go

@@ -163,7 +163,7 @@ func (wb *SEMP) heartbeat(ctx context.Context) {
 		select {
 		case <-ticker.C:
 			// Check if we need to send an update
-			if wb.conn.TimeSinceLastUpdate() >= time.Minute {
+			if time.Since(wb.conn.Updated()) >= time.Minute {
 				if err := wb.conn.SendDeviceControl(wb.deviceID, wb.calcPower(wb.enabled, wb.current, wb.phases)); err != nil {
 					wb.log.ERROR.Printf("heartbeat: failed to send update: %v", err)
 				}

charger/semp/connection.go

@@ -85,9 +85,9 @@ func (c *Connection) SendDeviceControl(deviceId string, power int) error {
 	return err
 }
 
-// TimeSinceLastUpdate returns the duration since the last successful device control update
-func (c *Connection) TimeSinceLastUpdate() time.Duration {
+// Updated returns the last successful device control update time
+func (c *Connection) Updated() time.Time {
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	return time.Since(c.updated)
+	return c.updated
 }

templates/definition/charger/bender-cc.yaml

@@ -61,11 +61,17 @@ products:
   - brand: SMA
     description:
       generic: EV Charger Business
-capabilities: ["rfid"]
+capabilities: ["rfid", "1p3p"]
 requirements:
   description:
-    de: Der 'Modbus TCP Server für Energiemanagement-Systeme' muss aktiviert sein. 'Registersatz' darf NICHT auf 'Phoenix' oder 'TQ-DM100' eingestellt sein. Die dritte Auswahlmöglichkeit 'Ebee', 'Bender', 'MENNEKES' etc. ist richtig. 'UID Übertragung erlauben' muss aktiviert sein.
-    en: The 'Modbus TCP Server' must be enabled. The setting 'Register Address Set' must NOT be set to 'Phoenix' or 'TQ-DM100'. Use the third selection labeled 'Ebee', 'Bender', 'MENNEKES' etc. Set 'Allow UID Disclose' to On.
+    de: |
+      Der 'Modbus TCP Server für Energiemanagement-Systeme' muss aktiviert sein. 'Registersatz' darf NICHT auf 'Phoenix' oder 'TQ-DM100' eingestellt sein. Die dritte Auswahlmöglichkeit 'Ebee', 'Bender', 'MENNEKES' etc. ist richtig. 'UID Übertragung erlauben' muss aktiviert sein. 
+
+      Für Phasenumschaltung ist mindestens Firmware 5.33 notwendig. Das 'SEMP interface' muss aktiviert sein, der 'SEMP Charging Mode' muss auf 'Surplus Charging' stehen. 'Software function to use phase switching' muss auf SEMP konfiguriert sein.
+    en: |
+      The 'Modbus TCP Server' must be enabled. The setting 'Register Address Set' must NOT be set to 'Phoenix' or 'TQ-DM100'. Use the third selection labeled 'Ebee', 'Bender', 'MENNEKES' etc. Set 'Allow UID Disclose' to On.
+
+      Firmware 5.33 or higher is required for phase switching. The 'SEMP interface' must be enabled, the 'SEMP Charging Mode' must be set to 'Surplus Charging'. Set 'Software function to use phase switching' to SEMP.
   evcc: ["sponsorship"]
 params:
   - name: modbus