Stefan/evcc-io
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Bender: add semp-based phase switching (#24377)

Browse source
This commit is contained in:
mfuchs1984 2025-10-29 10:50:53 +01:00 • committed by GitHub
parent 4d33297cad
commit 642a6594f3
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 180 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

186
charger/bender.go
View file

@ -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 {

2
charger/semp.go
View file

@ -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)
}

6
charger/semp/connection.go
View file

@ -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
}

12
templates/definition/charger/bender-cc.yaml
View file

@ -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