From 642a6594f3abd4a88f7bf495dd8cba4d0f28540a Mon Sep 17 00:00:00 2001 From: mfuchs1984 <57141790+mfuchs1984@users.noreply.github.com> Date: Wed, 29 Oct 2025 10:50:53 +0100 Subject: [PATCH] Bender: add semp-based phase switching (#24377) --- charger/bender.go | 186 ++++++++++++++++++-- charger/semp.go | 2 +- charger/semp/connection.go | 6 +- templates/definition/charger/bender-cc.yaml | 12 +- 4 files changed, 180 insertions(+), 26 deletions(-) diff --git a/charger/bender.go b/charger/bender.go index 58472e344..cb6ee3946 100644 --- a/charger/bender.go +++ b/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,13 +431,13 @@ 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) @@ -338,20 +445,61 @@ func (wb *BenderCC) phases1p3p(phases int) error { 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 + } + + 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 { diff --git a/charger/semp.go b/charger/semp.go index 440c98b7f..e8f00b515 100644 --- a/charger/semp.go +++ b/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) } diff --git a/charger/semp/connection.go b/charger/semp/connection.go index 11fac830b..05be583a3 100644 --- a/charger/semp/connection.go +++ b/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 } diff --git a/templates/definition/charger/bender-cc.yaml b/templates/definition/charger/bender-cc.yaml index 8f891291d..83c74e10d 100644 --- a/templates/definition/charger/bender-cc.yaml +++ b/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