From 7b5df178ce8ee99c3abf2f45c7f14472f8270941 Mon Sep 17 00:00:00 2001 From: andig Date: Tue, 2 Jun 2026 13:53:13 +0200 Subject: [PATCH] Add MeterReturnEnergy (#29805) --- api/api.go | 7 +++++- api/implement/implementations.go | 15 +++++++++++ api/mock.go | 43 ++++++++++++++++++++++++++++++-- charger/charger.go | 4 +-- charger/heatpump.go | 3 ++- charger/measurement/energy.go | 17 +++++++++---- charger/sgready-relay.go | 3 ++- charger/sgready.go | 3 ++- cmd/dumper.go | 7 ++++++ cmd/implement/implement.go | 1 + meter/measurement/energy.go | 17 +++++++++---- meter/meter.go | 3 ++- meter/meter_average.go | 7 ++++++ meter/shelly/connection.go | 12 +++++---- meter/shelly/gen1.go | 19 ++++++++++++++ meter/shelly/gen2.go | 22 +++++++++++++++- plugin/meter.go | 36 ++++++++++++-------------- plugin/method.go | 1 + plugin/method_enumer.go | 28 ++++++++++++--------- server/http_config_helper.go | 5 ++++ 20 files changed, 196 insertions(+), 57 deletions(-) diff --git a/api/api.go b/api/api.go index f2be451dc..61768c299 100644 --- a/api/api.go +++ b/api/api.go @@ -9,7 +9,7 @@ import ( "golang.org/x/oauth2" ) -//go:generate go tool mockgen -package api -destination mock.go github.com/evcc-io/evcc/api Charger,ChargeState,CurrentLimiter,CurrentGetter,PhaseSwitcher,PhaseGetter,FeatureDescriber,Identifier,Meter,MeterEnergy,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff +//go:generate go tool mockgen -package api -destination mock.go github.com/evcc-io/evcc/api Charger,ChargeState,CurrentLimiter,CurrentGetter,PhaseSwitcher,PhaseGetter,FeatureDescriber,Identifier,Meter,MeterEnergy,MeterReturnEnergy,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff // Meter provides total active power in W type Meter interface { @@ -21,6 +21,11 @@ type MeterEnergy interface { TotalEnergy() (float64, error) } +// MeterReturnEnergy provides total returned energy in kWh +type MeterReturnEnergy interface { + ReturnEnergy() (float64, error) +} + // PhaseCurrents provides per-phase current A type PhaseCurrents interface { Currents() (float64, float64, float64, error) diff --git a/api/implement/implementations.go b/api/implement/implementations.go index 70a5fc630..c7c4776c2 100644 --- a/api/implement/implementations.go +++ b/api/implement/implementations.go @@ -273,6 +273,21 @@ func (i *iMeterEnergy) TotalEnergy() (float64, error) { return i.meterEnergy0() } +func MeterReturnEnergy(meterReturnEnergy0 func() (float64, error)) api.MeterReturnEnergy { + if meterReturnEnergy0 == nil { + return nil + } + return &iMeterReturnEnergy{meterReturnEnergy0} +} + +type iMeterReturnEnergy struct { + meterReturnEnergy0 func() (float64, error) +} + +func (i *iMeterReturnEnergy) ReturnEnergy() (float64, error) { + return i.meterReturnEnergy0() +} + func PhaseCurrents(phaseCurrents0 func() (float64, float64, float64, error)) api.PhaseCurrents { if phaseCurrents0 == nil { return nil diff --git a/api/mock.go b/api/mock.go index 937dd667f..6adc62aaf 100644 --- a/api/mock.go +++ b/api/mock.go @@ -1,9 +1,9 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/evcc-io/evcc/api (interfaces: Charger,ChargeState,CurrentLimiter,CurrentGetter,PhaseSwitcher,PhaseGetter,FeatureDescriber,Identifier,Meter,MeterEnergy,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff) +// Source: github.com/evcc-io/evcc/api (interfaces: Charger,ChargeState,CurrentLimiter,CurrentGetter,PhaseSwitcher,PhaseGetter,FeatureDescriber,Identifier,Meter,MeterEnergy,MeterReturnEnergy,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff) // // Generated by this command: // -// mockgen -package api -destination mock.go github.com/evcc-io/evcc/api Charger,ChargeState,CurrentLimiter,CurrentGetter,PhaseSwitcher,PhaseGetter,FeatureDescriber,Identifier,Meter,MeterEnergy,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff +// mockgen -package api -destination mock.go github.com/evcc-io/evcc/api Charger,ChargeState,CurrentLimiter,CurrentGetter,PhaseSwitcher,PhaseGetter,FeatureDescriber,Identifier,Meter,MeterEnergy,MeterReturnEnergy,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff // // Package api is a generated GoMock package. @@ -448,6 +448,45 @@ func (mr *MockMeterEnergyMockRecorder) TotalEnergy() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalEnergy", reflect.TypeOf((*MockMeterEnergy)(nil).TotalEnergy)) } +// MockMeterReturnEnergy is a mock of MeterReturnEnergy interface. +type MockMeterReturnEnergy struct { + ctrl *gomock.Controller + recorder *MockMeterReturnEnergyMockRecorder + isgomock struct{} +} + +// MockMeterReturnEnergyMockRecorder is the mock recorder for MockMeterReturnEnergy. +type MockMeterReturnEnergyMockRecorder struct { + mock *MockMeterReturnEnergy +} + +// NewMockMeterReturnEnergy creates a new mock instance. +func NewMockMeterReturnEnergy(ctrl *gomock.Controller) *MockMeterReturnEnergy { + mock := &MockMeterReturnEnergy{ctrl: ctrl} + mock.recorder = &MockMeterReturnEnergyMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMeterReturnEnergy) EXPECT() *MockMeterReturnEnergyMockRecorder { + return m.recorder +} + +// ReturnEnergy mocks base method. +func (m *MockMeterReturnEnergy) ReturnEnergy() (float64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReturnEnergy") + ret0, _ := ret[0].(float64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReturnEnergy indicates an expected call of ReturnEnergy. +func (mr *MockMeterReturnEnergyMockRecorder) ReturnEnergy() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReturnEnergy", reflect.TypeOf((*MockMeterReturnEnergy)(nil).ReturnEnergy)) +} + // MockPhaseCurrents is a mock of PhaseCurrents interface. type MockPhaseCurrents struct { ctrl *gomock.Controller diff --git a/charger/charger.go b/charger/charger.go index 5e47a74da..7d7fce0b2 100644 --- a/charger/charger.go +++ b/charger/charger.go @@ -146,13 +146,13 @@ func NewConfigurableFromConfig(ctx context.Context, other map[string]any) (api.C implement.May(c, implement.Battery(soc)) implement.May(c, implement.SocLimiter(limitsoc)) - // decorate measurements - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, energyG, returnG, err := cc.Energy.Configure(ctx) if err != nil { return nil, err } implement.May(c, implement.Meter(powerG)) implement.May(c, implement.MeterEnergy(energyG)) + implement.May(c, implement.MeterReturnEnergy(returnG)) currentsG, voltagesG, _, err := cc.Phases.Configure(ctx) if err != nil { diff --git a/charger/heatpump.go b/charger/heatpump.go index 0eb44b2ec..f523c4de6 100644 --- a/charger/heatpump.go +++ b/charger/heatpump.go @@ -82,12 +82,13 @@ func NewHeatpumpFromConfig(ctx context.Context, other map[string]any) (api.Charg return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, energyG, returnG, err := cc.Energy.Configure(ctx) if err != nil { return nil, err } implement.May(res, implement.Meter(powerG)) implement.May(res, implement.MeterEnergy(energyG)) + implement.May(res, implement.MeterReturnEnergy(returnG)) tempG, limitTempG, err := cc.Temperature.Configure(ctx) if err != nil { diff --git a/charger/measurement/energy.go b/charger/measurement/energy.go index ed173643c..fc8b4a12a 100644 --- a/charger/measurement/energy.go +++ b/charger/measurement/energy.go @@ -8,24 +8,31 @@ import ( ) type Energy struct { - Power *plugin.Config // optional - Energy *plugin.Config // optional + Power *plugin.Config // optional + Energy *plugin.Config // optional + ReturnEnergy *plugin.Config // optional } func (cc *Energy) Configure(ctx context.Context) ( + func() (float64, error), func() (float64, error), func() (float64, error), error, ) { powerG, err := cc.Power.FloatGetter(ctx) if err != nil { - return nil, nil, fmt.Errorf("power: %w", err) + return nil, nil, nil, fmt.Errorf("power: %w", err) } energyG, err := cc.Energy.FloatGetter(ctx) if err != nil { - return nil, nil, fmt.Errorf("energy: %w", err) + return nil, nil, nil, fmt.Errorf("energy: %w", err) } - return powerG, energyG, nil + returnG, err := cc.ReturnEnergy.FloatGetter(ctx) + if err != nil { + return nil, nil, nil, fmt.Errorf("returnEnergy: %w", err) + } + + return powerG, energyG, returnG, nil } diff --git a/charger/sgready-relay.go b/charger/sgready-relay.go index 62e17cc4a..92336b2a4 100644 --- a/charger/sgready-relay.go +++ b/charger/sgready-relay.go @@ -61,12 +61,13 @@ func NewSgReadyRelayFromConfig(ctx context.Context, other map[string]any) (api.C return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, energyG, returnG, err := cc.Energy.Configure(ctx) if err != nil { return nil, err } implement.May(res, implement.Meter(powerG)) implement.May(res, implement.MeterEnergy(energyG)) + implement.May(res, implement.MeterReturnEnergy(returnG)) tempG, limitTempG, err := cc.Temperature.Configure(ctx) if err != nil { diff --git a/charger/sgready.go b/charger/sgready.go index bc152b4f5..d18012c6f 100644 --- a/charger/sgready.go +++ b/charger/sgready.go @@ -107,12 +107,13 @@ func NewSgReadyFromConfig(ctx context.Context, other map[string]any) (api.Charge return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, energyG, returnG, err := cc.Energy.Configure(ctx) if err != nil { return nil, err } implement.May(res, implement.Meter(powerG)) implement.May(res, implement.MeterEnergy(energyG)) + implement.May(res, implement.MeterReturnEnergy(returnG)) tempG, limitTempG, err := cc.Temperature.Configure(ctx) if err != nil { diff --git a/cmd/dumper.go b/cmd/dumper.go index 6d6e17521..4fd084071 100644 --- a/cmd/dumper.go +++ b/cmd/dumper.go @@ -92,6 +92,13 @@ func (d *dumper) Dump(name string, v any) { }) } + if v, ok := api.Cap[api.MeterReturnEnergy](v); ok { + d.measureTime(w, "Return Energy", func() (string, error) { + energy, err := v.ReturnEnergy() + return fmt.Sprintf("%.1fkWh", energy), err + }) + } + if v, ok := api.Cap[api.PhaseCurrents](v); ok { d.measureTime(w, "Current L1..L3", func() (string, error) { i1, i2, i3, err := v.Currents() diff --git a/cmd/implement/implement.go b/cmd/implement/implement.go index 19b7e7ca0..ec034e1f4 100644 --- a/cmd/implement/implement.go +++ b/cmd/implement/implement.go @@ -75,6 +75,7 @@ func generate(out io.Writer) error { reflect.TypeFor[api.MaxACPowerGetter](), reflect.TypeFor[api.Meter](), reflect.TypeFor[api.MeterEnergy](), + reflect.TypeFor[api.MeterReturnEnergy](), reflect.TypeFor[api.PhaseCurrents](), reflect.TypeFor[api.PhaseGetter](), reflect.TypeFor[api.PhasePowers](), diff --git a/meter/measurement/energy.go b/meter/measurement/energy.go index 658a91460..f7f3d3cfd 100644 --- a/meter/measurement/energy.go +++ b/meter/measurement/energy.go @@ -8,24 +8,31 @@ import ( ) type Energy struct { - Power plugin.Config - Energy *plugin.Config // optional + Power plugin.Config + Energy *plugin.Config // optional + ReturnEnergy *plugin.Config // optional } func (cc *Energy) Configure(ctx context.Context) ( + func() (float64, error), func() (float64, error), func() (float64, error), error, ) { powerG, err := cc.Power.FloatGetter(ctx) if err != nil { - return nil, nil, fmt.Errorf("power: %w", err) + return nil, nil, nil, fmt.Errorf("power: %w", err) } energyG, err := cc.Energy.FloatGetter(ctx) if err != nil { - return nil, nil, fmt.Errorf("energy: %w", err) + return nil, nil, nil, fmt.Errorf("energy: %w", err) } - return powerG, energyG, nil + returnG, err := cc.ReturnEnergy.FloatGetter(ctx) + if err != nil { + return nil, nil, nil, fmt.Errorf("returnEnergy: %w", err) + } + + return powerG, energyG, returnG, nil } diff --git a/meter/meter.go b/meter/meter.go index 63fde31ed..8cfc61381 100644 --- a/meter/meter.go +++ b/meter/meter.go @@ -44,13 +44,14 @@ func NewConfigurableFromConfig(ctx context.Context, other map[string]any) (api.M return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, energyG, returnG, err := cc.Energy.Configure(ctx) if err != nil { return nil, err } m, _ := NewConfigurable(powerG) implement.May(m, implement.MeterEnergy(energyG)) + implement.May(m, implement.MeterReturnEnergy(returnG)) // dim/curtail if err := cc.Dimmer.Implement(ctx, m); err != nil { diff --git a/meter/meter_average.go b/meter/meter_average.go index f217f75ae..8da82d251 100644 --- a/meter/meter_average.go +++ b/meter/meter_average.go @@ -47,6 +47,12 @@ func NewMovingAverageFromConfig(ctx context.Context, other map[string]any) (api. totalEnergy = m.TotalEnergy } + // decorate return energy reading + var returnEnergy func() (float64, error) + if m, ok := api.Cap[api.MeterReturnEnergy](m); ok { + returnEnergy = m.ReturnEnergy + } + // decorate battery reading var batterySoc func() (float64, error) if m, ok := api.Cap[api.Battery](m); ok { @@ -72,6 +78,7 @@ func NewMovingAverageFromConfig(ctx context.Context, other map[string]any) (api. } implement.May(meter, implement.MeterEnergy(totalEnergy)) + implement.May(meter, implement.MeterReturnEnergy(returnEnergy)) if batterySoc != nil { implement.Has(meter, implement.Battery(batterySoc)) diff --git a/meter/shelly/connection.go b/meter/shelly/connection.go index 180614023..0bc5d402d 100644 --- a/meter/shelly/connection.go +++ b/meter/shelly/connection.go @@ -6,22 +6,24 @@ import ( "strings" "time" + "github.com/evcc-io/evcc/api" "github.com/evcc-io/evcc/util" "github.com/evcc-io/evcc/util/request" "github.com/evcc-io/evcc/util/transport" ) type Generation interface { - CurrentPower() (float64, error) Enabled() (bool, error) Enable(bool) error - TotalEnergy() (float64, error) + api.Meter + api.MeterEnergy + api.MeterReturnEnergy } type Phases interface { - Currents() (float64, float64, float64, error) - Voltages() (float64, float64, float64, error) - Powers() (float64, float64, float64, error) + api.PhaseCurrents + api.PhaseVoltages + api.PhasePowers } // Connection is the Shelly connection diff --git a/meter/shelly/gen1.go b/meter/shelly/gen1.go index 512111f28..3856a5840 100644 --- a/meter/shelly/gen1.go +++ b/meter/shelly/gen1.go @@ -125,6 +125,25 @@ func (c *gen1) TotalEnergy() (float64, error) { return c.energy(energy) / 1000, nil } +func (c *gen1) ReturnEnergy() (float64, error) { + var energy float64 + res, err := c.status.Get() + if err != nil { + return 0, err + } + + switch { + case c.channel < len(res.Meters): + energy = res.Meters[c.channel].Total_Returned + case c.channel < len(res.EMeters): + energy = res.EMeters[c.channel].Total_Returned + default: + return 0, errors.New("invalid channel, missing power meter") + } + + return c.energy(energy) / 1000, nil +} + // gen1Energy in kWh func (c *gen1) energy(energy float64) float64 { // Gen 1 Shelly EM devices are providing Watt hours, Gen 1 Shelly PM devices are providing Watt minutes diff --git a/meter/shelly/gen2.go b/meter/shelly/gen2.go index 58209b2e1..2551c07a8 100644 --- a/meter/shelly/gen2.go +++ b/meter/shelly/gen2.go @@ -219,7 +219,7 @@ func (c *gen2) Enable(enable bool) error { return c.execEnableCmd(c.switchchannel, "Switch.Set", enable, &res) } -// TotalEnergy implements the api.Meter interface +// TotalEnergy implements the api.MeterEnergy interface func (c *gen2) TotalEnergy() (float64, error) { switch { case c.hasEM1Endpoint(): @@ -239,6 +239,26 @@ func (c *gen2) TotalEnergy() (float64, error) { } } +// ReturnEnergy implements the api.MeterReturnEnergy interface +func (c *gen2) ReturnEnergy() (float64, error) { + switch { + case c.hasEM1Endpoint(): + res, err := c.em1data() + return res.TotalActRetEnergy / 1000, err + + case c.hasEMEndpoint(): + res, err := c.emdata() + return res.TotalActRet / 1000, err + + case c.hasSwitchEndpoint(): + res, err := c.switchstatus.Get() + return res.Ret_Aenergy.Total / 1000, err + + default: + return 0, fmt.Errorf("unknown shelly model: %s", c.model) + } +} + // Currents implements the api.PhaseCurrents interface func (c *gen2) Currents() (float64, float64, float64, error) { switch { diff --git a/plugin/meter.go b/plugin/meter.go index a59d89fa7..fda8458e2 100644 --- a/plugin/meter.go +++ b/plugin/meter.go @@ -51,32 +51,28 @@ func NewMeterFromConfig(ctx context.Context, other map[string]any) (Plugin, erro var _ FloatGetter = (*meterPlugin)(nil) func (o *meterPlugin) FloatGetter() (func() (float64, error), error) { - err := fmt.Errorf("unsupported method: %s", o.method.String()) - - switch o.method { - case Energy: - if !api.HasCap[api.MeterEnergy](o.meter) { - return nil, err - } - case Soc: - if !api.HasCap[api.Battery](o.meter) { - return nil, err - } - } - return func() (float64, error) { switch o.method { case Energy: - m, _ := api.Cap[api.MeterEnergy](o.meter) - f, err := m.TotalEnergy() - return f * o.scale, err + if m, ok := api.Cap[api.MeterEnergy](o.meter); ok { + f, err := m.TotalEnergy() + return f * o.scale, err + } + case ReturnEnergy: + if m, ok := api.Cap[api.MeterReturnEnergy](o.meter); ok { + f, err := m.ReturnEnergy() + return f * o.scale, err + } case Soc: - m, _ := api.Cap[api.Battery](o.meter) - f, err := m.Soc() - return f * o.scale, err - default: + if m, ok := api.Cap[api.Battery](o.meter); ok { + f, err := m.Soc() + return f * o.scale, err + } + case Power: f, err := o.meter.CurrentPower() return f * o.scale, err } + + return 0, fmt.Errorf("unsupported method: %s", o.method.String()) }, nil } diff --git a/plugin/method.go b/plugin/method.go index daddac79a..487ab0918 100644 --- a/plugin/method.go +++ b/plugin/method.go @@ -6,6 +6,7 @@ type Method int const ( _ Method = iota Energy + ReturnEnergy Power Soc ) diff --git a/plugin/method_enumer.go b/plugin/method_enumer.go index dcff2998f..7c5eaf679 100644 --- a/plugin/method_enumer.go +++ b/plugin/method_enumer.go @@ -7,11 +7,11 @@ import ( "strings" ) -const _MethodName = "EnergyPowerSoc" +const _MethodName = "EnergyReturnEnergyPowerSoc" -var _MethodIndex = [...]uint8{0, 6, 11, 14} +var _MethodIndex = [...]uint8{0, 6, 18, 23, 26} -const _MethodLowerName = "energypowersoc" +const _MethodLowerName = "energyreturnenergypowersoc" func (i Method) String() string { i -= 1 @@ -26,25 +26,29 @@ func (i Method) String() string { func _MethodNoOp() { var x [1]struct{} _ = x[Energy-(1)] - _ = x[Power-(2)] - _ = x[Soc-(3)] + _ = x[ReturnEnergy-(2)] + _ = x[Power-(3)] + _ = x[Soc-(4)] } -var _MethodValues = []Method{Energy, Power, Soc} +var _MethodValues = []Method{Energy, ReturnEnergy, Power, Soc} var _MethodNameToValueMap = map[string]Method{ _MethodName[0:6]: Energy, _MethodLowerName[0:6]: Energy, - _MethodName[6:11]: Power, - _MethodLowerName[6:11]: Power, - _MethodName[11:14]: Soc, - _MethodLowerName[11:14]: Soc, + _MethodName[6:18]: ReturnEnergy, + _MethodLowerName[6:18]: ReturnEnergy, + _MethodName[18:23]: Power, + _MethodLowerName[18:23]: Power, + _MethodName[23:26]: Soc, + _MethodLowerName[23:26]: Soc, } var _MethodNames = []string{ _MethodName[0:6], - _MethodName[6:11], - _MethodName[11:14], + _MethodName[6:18], + _MethodName[18:23], + _MethodName[23:26], } // MethodString retrieves an enum value from the enum constants string name. diff --git a/server/http_config_helper.go b/server/http_config_helper.go index 921449c55..04ba19fcb 100644 --- a/server/http_config_helper.go +++ b/server/http_config_helper.go @@ -279,6 +279,11 @@ func testInstance(instance any) map[string]testResult { makeResult("energy", val, err) } + if dev, ok := api.Cap[api.MeterReturnEnergy](instance); ok { + val, err := dev.ReturnEnergy() + makeResult("returnEnergy", val, err) + } + if dev, ok := api.Cap[api.Battery](instance); ok { val, err := dev.Soc() key := "soc"