From 7a5b1e756065138460a3e3f6ddd73aa585c20a9c Mon Sep 17 00:00:00 2001 From: andig Date: Sat, 9 May 2026 16:20:18 +0200 Subject: [PATCH] api: split MeterEnergy into MeterImport and MeterExport (#29788) Co-authored-by: Claude Opus 4.7 (1M context) --- api/api.go | 13 +++-- api/capable_test.go | 44 ++++++++--------- api/implement/implementations.go | 29 ++++++++--- api/mock.go | 77 ++++++++++++++++++++++-------- charger/_blueprint.go | 6 +-- charger/abb.go | 2 +- charger/abl-em4.go | 6 +-- charger/alfen.go | 6 +-- charger/alpitronic.go | 6 +-- charger/amperfied.go | 6 +-- charger/bender.go | 4 +- charger/cfos.go | 4 +- charger/charger.go | 4 +- charger/compleo.go | 2 +- charger/connectiq.go | 6 +-- charger/dadapower.go | 6 +-- charger/daheimladen.go | 6 +-- charger/e3dc.go | 6 +-- charger/easee.go | 6 +-- charger/easee_test.go | 12 ++--- charger/em2go-duo.go | 6 +-- charger/em2go.go | 6 +-- charger/eprowallbox.go | 6 +-- charger/etek.go | 4 +- charger/evecube.go | 6 +-- charger/evsemaster.go | 8 ++-- charger/evsewifi.go | 4 +- charger/evsewifi_test.go | 4 +- charger/fritzdect.go | 8 ++-- charger/go-e.go | 6 +-- charger/go-e_test.go | 4 +- charger/hardybarth-ecb1.go | 6 +-- charger/hardybarth-salia.go | 4 +- charger/heatpump.go | 4 +- charger/heidelberg-ec.go | 6 +-- charger/hesotec.go | 6 +-- charger/homeassistant.go | 2 +- charger/homematic.go | 8 ++-- charger/homewizard.go | 8 ++-- charger/innogy.go | 4 +- charger/kathrein.go | 6 +-- charger/keba-modbus.go | 4 +- charger/keba-udp.go | 4 +- charger/kse.go | 8 ++-- charger/lektrico.go | 6 +-- charger/measurement/energy.go | 26 ++++++++-- charger/mennekes-compact.go | 8 ++-- charger/mennekes-hcc3.go | 2 +- charger/nexblue.go | 6 +-- charger/nrgble_linux.go | 6 +-- charger/nrgconnect.go | 6 +-- charger/nrggen2.go | 6 +-- charger/ocpp.go | 2 +- charger/ocpp/connector.go | 2 +- charger/ocpp/connector_test.go | 18 +++---- charger/openevse.go | 6 +-- charger/openwb-2.0.go | 6 +-- charger/openwb-pro.go | 6 +-- charger/openwb.go | 6 +-- charger/pcelectric.go | 4 +- charger/peblar.go | 4 +- charger/phoenix-charx.go | 4 +- charger/phoenix-em-eth.go | 4 +- charger/phoenix-ev-eth.go | 4 +- charger/pulsatrix.go | 6 +-- charger/schneider-v3.go | 6 +-- charger/sgready-relay.go | 4 +- charger/sgready.go | 4 +- charger/shelly-topac.go | 6 +-- charger/shelly.go | 8 ++-- charger/sigenergy.go | 6 +-- charger/smaevcharger.go | 6 +-- charger/smart-evse.go | 4 +- charger/smartevse.go | 6 +-- charger/solax.go | 6 +-- charger/sungrow.go | 6 +-- charger/switchsocket.go | 2 +- charger/tasmota.go | 8 ++-- charger/tplink.go | 8 ++-- charger/versicharge.go | 6 +-- charger/vestel.go | 6 +-- charger/victron.go | 2 +- charger/warp-ws.go | 2 +- charger/warp2-mqtt.go | 4 +- charger/webasto-next.go | 6 +-- charger/weidmüller.go | 4 +- cmd/dumper.go | 13 +++-- cmd/implement/implement.go | 3 +- core/capable_test.go | 14 +++--- core/loadpoint.go | 6 +-- core/loadpoint_session.go | 4 +- core/loadpoint_session_test.go | 42 ++++++++-------- core/metrics/accumulator_test.go | 4 +- core/site.go | 23 ++++++--- core/wrapper/chargerater.go | 28 +++++------ core/wrapper/chargerater_test.go | 32 ++++++------- meter/_blueprint.go | 6 +-- meter/cfos.go | 6 +-- meter/danfoss.go | 2 +- meter/discovergy.go | 4 +- meter/dsmr.go | 4 +- meter/eebus.go | 4 +- meter/fritz/aha/aha.go | 6 +-- meter/fritz/api.go | 2 +- meter/fritz/smarthome/smarthome.go | 6 +-- meter/homeassistant.go | 2 +- meter/homematic.go | 10 ++-- meter/homematic/connection.go | 8 ++-- meter/homewizard.go | 8 ++-- meter/homewizard/connection.go | 4 +- meter/lgess.go | 4 +- meter/mbmd.go | 2 +- meter/measurement/energy.go | 34 +++++++++++-- meter/meter.go | 5 +- meter/meter_average.go | 17 +++++-- meter/powerwall.go | 10 ++-- meter/rct.go | 4 +- meter/shelly/connection.go | 2 +- meter/shelly/gen1.go | 2 +- meter/shelly/gen2.go | 4 +- meter/sma.go | 8 ++-- meter/tasmota.go | 8 ++-- meter/tasmota/connection.go | 4 +- meter/tplink/connection.go | 4 +- meter/tq-em.go | 4 +- meter/tq-em420.go | 4 +- plugin/meter.go | 10 ++-- server/http_config_helper.go | 7 ++- 128 files changed, 570 insertions(+), 435 deletions(-) diff --git a/api/api.go b/api/api.go index d92a7e65b..432b4c8ca 100644 --- a/api/api.go +++ b/api/api.go @@ -9,16 +9,21 @@ 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,MeterImport,MeterExport,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff // Meter provides total active power in W type Meter interface { CurrentPower() (float64, error) } -// MeterEnergy provides total energy in kWh -type MeterEnergy interface { - TotalEnergy() (float64, error) +// MeterImport provides total import in kWh +type MeterImport interface { + ImportEnergy() (float64, error) +} + +// MeterExport provides total export in kWh +type MeterExport interface { + ExportEnergy() (float64, error) } // PhaseCurrents provides per-phase current A diff --git a/api/capable_test.go b/api/capable_test.go index 565dd596e..457da528c 100644 --- a/api/capable_test.go +++ b/api/capable_test.go @@ -19,9 +19,9 @@ func (d *decoratedMeter) Capability(typ reflect.Type) (any, bool) { return c, ok } -type testMeterEnergyImpl struct{} +type testMeterImportImpl struct{} -func (t *testMeterEnergyImpl) TotalEnergy() (float64, error) { +func (t *testMeterImportImpl) ImportEnergy() (float64, error) { return 99.0, nil } @@ -32,13 +32,13 @@ func (t *testMeterImpl) CurrentPower() (float64, error) { } func TestCap_DirectTypeAssertion(t *testing.T) { - // concrete type that directly implements MeterEnergy - impl := &testMeterEnergyImpl{} + // concrete type that directly implements MeterImport + impl := &testMeterImportImpl{} - me, ok := Cap[MeterEnergy](impl) + me, ok := Cap[MeterImport](impl) require.True(t, ok) - energy, err := me.TotalEnergy() + energy, err := me.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 99.0, energy) } @@ -49,15 +49,15 @@ func TestCap_CapableRegistryLookup(t *testing.T) { decorated := &decoratedMeter{ Meter: base, caps: map[reflect.Type]any{ - reflect.TypeFor[MeterEnergy](): &testMeterEnergyImpl{}, + reflect.TypeFor[MeterImport](): &testMeterImportImpl{}, }, } - // should find MeterEnergy via registry - me, ok := Cap[MeterEnergy](decorated) + // should find MeterImport via registry + me, ok := Cap[MeterImport](decorated) require.True(t, ok) - energy, err := me.TotalEnergy() + energy, err := me.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 99.0, energy) @@ -81,11 +81,11 @@ func TestCap_ExtractedCapabilityLosesRegistry(t *testing.T) { // Reproduces https://github.com/evcc-io/evcc/issues/28915 // When a Meter is extracted from a decorated charger via Cap[Meter], // the extracted impl does NOT carry the Capable interface, so - // subsequent Cap[MeterEnergy] on the extracted value fails. + // subsequent Cap[MeterImport] on the extracted value fails. decorated := &decoratedCharger{ caps: map[reflect.Type]any{ reflect.TypeFor[Meter](): &testMeterImpl{}, - reflect.TypeFor[MeterEnergy](): &testMeterEnergyImpl{}, + reflect.TypeFor[MeterImport](): &testMeterImportImpl{}, }, } @@ -93,9 +93,9 @@ func TestCap_ExtractedCapabilityLosesRegistry(t *testing.T) { mt, ok := Cap[Meter](decorated) require.True(t, ok) - // Bug: extracted meter cannot find MeterEnergy because it's a standalone impl - _, ok = Cap[MeterEnergy](mt) - assert.False(t, ok, "extracted meter should NOT have MeterEnergy capability") + // Bug: extracted meter cannot find MeterImport because it's a standalone impl + _, ok = Cap[MeterImport](mt) + assert.False(t, ok, "extracted meter should NOT have MeterImport capability") // Fix: wrapping extracted meter with source's Capable preserves registry type capableMeter struct { @@ -104,32 +104,32 @@ func TestCap_ExtractedCapabilityLosesRegistry(t *testing.T) { } wrapped := &capableMeter{Meter: mt, Capable: decorated} - me, ok := Cap[MeterEnergy](wrapped) - require.True(t, ok, "wrapped meter should find MeterEnergy via Capable") + me, ok := Cap[MeterImport](wrapped) + require.True(t, ok, "wrapped meter should find MeterImport via Capable") - energy, err := me.TotalEnergy() + energy, err := me.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 99.0, energy) } func TestCap_NilValue(t *testing.T) { - _, ok := Cap[MeterEnergy](nil) + _, ok := Cap[MeterImport](nil) assert.False(t, ok) } func TestCap_DirectTakesPrecedence(t *testing.T) { // type that both directly implements AND has registry type directAndCapable struct { - testMeterEnergyImpl + testMeterImportImpl caps map[reflect.Type]any //nolint:unused } v := &directAndCapable{} - me, ok := Cap[MeterEnergy](v) + me, ok := Cap[MeterImport](v) require.True(t, ok) - energy, err := me.TotalEnergy() + energy, err := me.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 99.0, energy) } diff --git a/api/implement/implementations.go b/api/implement/implementations.go index efe9cf657..697e3a32e 100644 --- a/api/implement/implementations.go +++ b/api/implement/implementations.go @@ -203,19 +203,34 @@ func (i *iChargeState) Status() (api.ChargeStatus, error) { return i.chargeState0() } -func MeterEnergy(meterEnergy0 func() (float64, error)) api.MeterEnergy { - if meterEnergy0 == nil { +func MeterImport(meterImport0 func() (float64, error)) api.MeterImport { + if meterImport0 == nil { return nil } - return &iMeterEnergy{meterEnergy0} + return &iMeterImport{meterImport0} } -type iMeterEnergy struct { - meterEnergy0 func() (float64, error) +type iMeterImport struct { + meterImport0 func() (float64, error) } -func (i *iMeterEnergy) TotalEnergy() (float64, error) { - return i.meterEnergy0() +func (i *iMeterImport) ImportEnergy() (float64, error) { + return i.meterImport0() +} + +func MeterExport(meterExport0 func() (float64, error)) api.MeterExport { + if meterExport0 == nil { + return nil + } + return &iMeterExport{meterExport0} +} + +type iMeterExport struct { + meterExport0 func() (float64, error) +} + +func (i *iMeterExport) ExportEnergy() (float64, error) { + return i.meterExport0() } func PhaseCurrents(phaseCurrents0 func() (float64, float64, float64, error)) api.PhaseCurrents { diff --git a/api/mock.go b/api/mock.go index 4591c1e38..8cd83f0d3 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,MeterImport,MeterExport,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,MeterImport,MeterExport,PhaseCurrents,Vehicle,ConnectionTimer,ChargeRater,Battery,BatteryController,BatterySocLimiter,Circuit,Dimmer,Tariff // // Package api is a generated GoMock package. @@ -409,43 +409,82 @@ func (mr *MockMeterMockRecorder) CurrentPower() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentPower", reflect.TypeOf((*MockMeter)(nil).CurrentPower)) } -// MockMeterEnergy is a mock of MeterEnergy interface. -type MockMeterEnergy struct { +// MockMeterImport is a mock of MeterImport interface. +type MockMeterImport struct { ctrl *gomock.Controller - recorder *MockMeterEnergyMockRecorder + recorder *MockMeterImportMockRecorder isgomock struct{} } -// MockMeterEnergyMockRecorder is the mock recorder for MockMeterEnergy. -type MockMeterEnergyMockRecorder struct { - mock *MockMeterEnergy +// MockMeterImportMockRecorder is the mock recorder for MockMeterImport. +type MockMeterImportMockRecorder struct { + mock *MockMeterImport } -// NewMockMeterEnergy creates a new mock instance. -func NewMockMeterEnergy(ctrl *gomock.Controller) *MockMeterEnergy { - mock := &MockMeterEnergy{ctrl: ctrl} - mock.recorder = &MockMeterEnergyMockRecorder{mock} +// NewMockMeterImport creates a new mock instance. +func NewMockMeterImport(ctrl *gomock.Controller) *MockMeterImport { + mock := &MockMeterImport{ctrl: ctrl} + mock.recorder = &MockMeterImportMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockMeterEnergy) EXPECT() *MockMeterEnergyMockRecorder { +func (m *MockMeterImport) EXPECT() *MockMeterImportMockRecorder { return m.recorder } -// TotalEnergy mocks base method. -func (m *MockMeterEnergy) TotalEnergy() (float64, error) { +// ImportEnergy mocks base method. +func (m *MockMeterImport) ImportEnergy() (float64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TotalEnergy") + ret := m.ctrl.Call(m, "ImportEnergy") ret0, _ := ret[0].(float64) ret1, _ := ret[1].(error) return ret0, ret1 } -// TotalEnergy indicates an expected call of TotalEnergy. -func (mr *MockMeterEnergyMockRecorder) TotalEnergy() *gomock.Call { +// ImportEnergy indicates an expected call of ImportEnergy. +func (mr *MockMeterImportMockRecorder) ImportEnergy() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalEnergy", reflect.TypeOf((*MockMeterEnergy)(nil).TotalEnergy)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportEnergy", reflect.TypeOf((*MockMeterImport)(nil).ImportEnergy)) +} + +// MockMeterExport is a mock of MeterExport interface. +type MockMeterExport struct { + ctrl *gomock.Controller + recorder *MockMeterExportMockRecorder + isgomock struct{} +} + +// MockMeterExportMockRecorder is the mock recorder for MockMeterExport. +type MockMeterExportMockRecorder struct { + mock *MockMeterExport +} + +// NewMockMeterExport creates a new mock instance. +func NewMockMeterExport(ctrl *gomock.Controller) *MockMeterExport { + mock := &MockMeterExport{ctrl: ctrl} + mock.recorder = &MockMeterExportMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMeterExport) EXPECT() *MockMeterExportMockRecorder { + return m.recorder +} + +// ExportEnergy mocks base method. +func (m *MockMeterExport) ExportEnergy() (float64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportEnergy") + ret0, _ := ret[0].(float64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportEnergy indicates an expected call of ExportEnergy. +func (mr *MockMeterExportMockRecorder) ExportEnergy() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportEnergy", reflect.TypeOf((*MockMeterExport)(nil).ExportEnergy)) } // MockPhaseCurrents is a mock of PhaseCurrents interface. diff --git a/charger/_blueprint.go b/charger/_blueprint.go index f448cf711..b2e3fa624 100644 --- a/charger/_blueprint.go +++ b/charger/_blueprint.go @@ -95,10 +95,10 @@ func (wb *Blueprint) ChargedEnergy() (float64, error) { return 0, api.ErrNotAvailable } -var _ api.MeterEnergy = (*Blueprint)(nil) +var _ api.MeterImport = (*Blueprint)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Blueprint) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Blueprint) ImportEnergy() (float64, error) { return 0, api.ErrNotAvailable } diff --git a/charger/abb.go b/charger/abb.go index 294d37a46..c698c2ab9 100644 --- a/charger/abb.go +++ b/charger/abb.go @@ -207,7 +207,7 @@ func (wb *ABB) CurrentPower() (float64, error) { var _ api.ChargeRater = (*ABB)(nil) -// ChargedEnergy implements the api.MeterEnergy interface +// ChargedEnergy implements the api.MeterImport interface func (wb *ABB) ChargedEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(abbRegEnergy, 2) if err != nil { diff --git a/charger/abl-em4.go b/charger/abl-em4.go index 38e93109f..4c5b033a5 100644 --- a/charger/abl-em4.go +++ b/charger/abl-em4.go @@ -197,10 +197,10 @@ func (wb *AblEm4) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), nil } -var _ api.MeterEnergy = (*AblEm4)(nil) +var _ api.MeterImport = (*AblEm4)(nil) -// totalEnergy implements the api.MeterEnergy interface -func (wb *AblEm4) TotalEnergy() (float64, error) { +// totalEnergy implements the api.MeterImport interface +func (wb *AblEm4) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(wb.base+abl4RegEnergy, 2) if err != nil { return 0, err diff --git a/charger/alfen.go b/charger/alfen.go index 46d41ae39..1da47d51d 100644 --- a/charger/alfen.go +++ b/charger/alfen.go @@ -210,10 +210,10 @@ func (wb *Alfen) CurrentPower() (float64, error) { return rs485.RTUIeee754ToFloat64(b), err } -var _ api.MeterEnergy = (*Alfen)(nil) +var _ api.MeterImport = (*Alfen)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Alfen) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Alfen) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(alfenRegEnergy, 4) if err != nil { return 0, err diff --git a/charger/alpitronic.go b/charger/alpitronic.go index 13f8e2e40..1e5239411 100644 --- a/charger/alpitronic.go +++ b/charger/alpitronic.go @@ -211,10 +211,10 @@ func (wb *AlpitronicHYC) ChargedEnergy() (float64, error) { return float64(encoding.Uint16(b)) / 100, err } -var _ api.MeterEnergy = (*AlpitronicHYC)(nil) +var _ api.MeterImport = (*AlpitronicHYC)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *AlpitronicHYC) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *AlpitronicHYC) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(wb.reg(hycRegTotalChargedEnergy), 4) if err != nil { return 0, err diff --git a/charger/amperfied.go b/charger/amperfied.go index ab2317754..edc2c834f 100644 --- a/charger/amperfied.go +++ b/charger/amperfied.go @@ -255,10 +255,10 @@ func (wb *Amperfied) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint16(b)), nil } -var _ api.MeterEnergy = (*Amperfied)(nil) +var _ api.MeterImport = (*Amperfied)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Amperfied) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Amperfied) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(ampRegEnergy, 2) if err != nil { return 0, err diff --git a/charger/bender.go b/charger/bender.go index 8c68186ea..28438fce6 100644 --- a/charger/bender.go +++ b/charger/bender.go @@ -148,7 +148,7 @@ func NewBenderCC(ctx context.Context, uri string, id uint8, cache time.Duration) if b, err := wb.conn.ReadHoldingRegisters(reg, 2); err == nil && binary.BigEndian.Uint32(b) != math.MaxUint32 { implement.Has(wb, implement.Meter(wb.currentPower)) implement.Has(wb, implement.PhaseCurrents(wb.currents)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) // check presence of "ocpp meter" if b, err := wb.conn.ReadHoldingRegisters(bendRegVoltages, 2); err == nil && binary.BigEndian.Uint32(b) > 0 { @@ -374,7 +374,7 @@ func (wb *BenderCC) currentPower() (float64, error) { // removed: https://github.com/evcc-io/evcc/issues/13726 // var _ api.ChargeRater = (*BenderCC)(nil) -// TotalEnergy implements the api.MeterEnergy interface +// ImportEnergy implements the api.MeterImport interface func (wb *BenderCC) totalEnergy() (float64, error) { if wb.legacy { b, err := wb.conn.ReadHoldingRegisters(bendRegPhaseEnergy, 6) diff --git a/charger/cfos.go b/charger/cfos.go index 370ad3ce8..959527b37 100644 --- a/charger/cfos.go +++ b/charger/cfos.go @@ -77,7 +77,7 @@ func NewCfosPowerBrain(ctx context.Context, uri string, id uint8) (api.Charger, // decorate meter if b, err := wb.conn.ReadHoldingRegisters(cfosRegMeter, 1); err == nil && binary.BigEndian.Uint16(b) != 0 { implement.Has(wb, implement.Meter(wb.currentPower)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) if b, err := wb.conn.ReadHoldingRegisters(cfosRegMeterFlags, 1); err == nil && binary.BigEndian.Uint16(b) != 0 { implement.Has(wb, implement.PhaseCurrents(wb.currents)) @@ -156,7 +156,7 @@ func (wb *CfosPowerBrain) currentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *CfosPowerBrain) totalEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(cfosRegEnergy, 4) if err != nil { diff --git a/charger/charger.go b/charger/charger.go index bf7a6f1cb..42257d9d3 100644 --- a/charger/charger.go +++ b/charger/charger.go @@ -145,12 +145,12 @@ func NewConfigurableFromConfig(ctx context.Context, other map[string]any) (api.C implement.May(c, implement.SocLimiter(limitsoc)) // decorate measurements - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, importG, _, 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.MeterImport(importG)) currentsG, voltagesG, _, err := cc.Phases.Configure(ctx) if err != nil { diff --git a/charger/compleo.go b/charger/compleo.go index 16d955542..2ea308135 100644 --- a/charger/compleo.go +++ b/charger/compleo.go @@ -235,7 +235,7 @@ func (wb *Compleo) CurrentPower() (float64, error) { var _ api.ChargeRater = (*Compleo)(nil) -// ChargedEnergy implements the api.MeterEnergy interface +// ChargedEnergy implements the api.MeterImport interface func (wb *Compleo) ChargedEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(wb.reg(compleoRegEnergy), 1) if err != nil { diff --git a/charger/connectiq.go b/charger/connectiq.go index 1c629e4a3..28e3006f9 100644 --- a/charger/connectiq.go +++ b/charger/connectiq.go @@ -162,10 +162,10 @@ func (wb *ConnectIq) CurrentPower() (float64, error) { return (res.Pow[0] + res.Pow[1] + res.Pow[2]) * 1e3, nil } -var _ api.MeterEnergy = (*ConnectIq)(nil) +var _ api.MeterImport = (*ConnectIq)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *ConnectIq) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *ConnectIq) ImportEnergy() (float64, error) { var res connectiq.MeterRead uri := fmt.Sprintf("%s/meter/read", wb.uri) err := wb.GetJSON(uri, &res) diff --git a/charger/dadapower.go b/charger/dadapower.go index 20babd9fb..de881eb9d 100644 --- a/charger/dadapower.go +++ b/charger/dadapower.go @@ -184,10 +184,10 @@ func (wb *Dadapower) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), err } -var _ api.MeterEnergy = (*Dadapower)(nil) +var _ api.MeterImport = (*Dadapower)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Dadapower) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Dadapower) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(dadapowerRegEnergyImportTotal+wb.regOffset, 4) if err != nil { return 0, err diff --git a/charger/daheimladen.go b/charger/daheimladen.go index ad5f469e9..5da18df38 100644 --- a/charger/daheimladen.go +++ b/charger/daheimladen.go @@ -250,10 +250,10 @@ func (wb *DaheimLaden) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), err } -var _ api.MeterEnergy = (*DaheimLaden)(nil) +var _ api.MeterImport = (*DaheimLaden)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *DaheimLaden) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *DaheimLaden) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(dlRegTotalEnergy, 2) if err != nil { return 0, err diff --git a/charger/e3dc.go b/charger/e3dc.go index f04b79d3e..ce1c2c688 100644 --- a/charger/e3dc.go +++ b/charger/e3dc.go @@ -362,9 +362,9 @@ func (wb *E3dc) CurrentPower() (float64, error) { return p1 + p2 + p3, nil } -var _ api.MeterEnergy = (*E3dc)(nil) +var _ api.MeterImport = (*E3dc)(nil) -// TotalEnergy implements the api.MeterEnergy interface +// ImportEnergy implements the api.MeterImport interface // // E3DC stores wallbox energy in two separate counters that must be added: // - DB_TEC_WALLBOX_ENERGYALL: Historical energy stored in the database (persisted) @@ -372,7 +372,7 @@ var _ api.MeterEnergy = (*E3dc)(nil) // // The sum of both values matches the total energy shown in the E3DC portal. // Testing showed: DB_TEC (8319 kWh) + WB_ENERGY (699 kWh) = 9018 kWh ≈ Portal (9019 kWh) -func (wb *E3dc) TotalEnergy() (float64, error) { +func (wb *E3dc) ImportEnergy() (float64, error) { // Query both energy sources sequentially res, err := wb.conn.Send(*rscp.NewMessage(rscp.DB_REQ_TEC_WALLBOX_VALUES, nil)) if err != nil { diff --git a/charger/easee.go b/charger/easee.go index 5c6f9cdf8..e791a80c9 100644 --- a/charger/easee.go +++ b/charger/easee.go @@ -717,10 +717,10 @@ func (c *Easee) Currents() (float64, float64, float64, error) { return c.currentL1, c.currentL2, c.currentL3, nil } -var _ api.MeterEnergy = (*Easee)(nil) +var _ api.MeterImport = (*Easee)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *Easee) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *Easee) ImportEnergy() (float64, error) { c.mux.RLock() defer c.mux.RUnlock() // updates for this are only sent once an hour, so inaccurate by design diff --git a/charger/easee_test.go b/charger/easee_test.go index a9905ad42..f85fc950d 100644 --- a/charger/easee_test.go +++ b/charger/easee_test.go @@ -563,7 +563,7 @@ func TestChargeSessionStart_SetsFields(t *testing.T) { assert.Equal(t, 801, e.currentSessionID) - total, err := e.TotalEnergy() + total, err := e.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 9141.414622, total) } @@ -581,7 +581,7 @@ func TestChargingSession_UpdatesBothWhenIdMatches(t *testing.T) { assert.NoError(t, err) assert.Equal(t, 16.2, charged) - total, err := e.TotalEnergy() + total, err := e.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 9173.5, total) } @@ -600,7 +600,7 @@ func TestChargingSession_MismatchedId_ProtectsSessionEnergy(t *testing.T) { assert.NoError(t, err) assert.Equal(t, 5.0, charged) // sessionEnergy unchanged - total, err := e.TotalEnergy() + total, err := e.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 9173.5, total) // totalEnergy updated } @@ -619,18 +619,18 @@ func TestChargingSession_AtStartup_ProtectsSessionEnergy(t *testing.T) { assert.NoError(t, err) assert.Equal(t, 0.0, charged) // sessionEnergy protected (Id 803 != 0) - total, err := e.TotalEnergy() + total, err := e.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 9173.5, total) // totalEnergy updated } -func TestLifetimeEnergy_DoesNotDecreaseTotalEnergy(t *testing.T) { +func TestLifetimeEnergy_DoesNotDecreaseImportEnergy(t *testing.T) { e := newEasee() e.totalEnergy = 9173.5 e.ProductUpdate(createPayload(easee.LIFETIME_ENERGY, time.Now(), easee.Double, "9170.0")) - total, err := e.TotalEnergy() + total, err := e.ImportEnergy() assert.NoError(t, err) assert.Equal(t, 9173.5, total) } diff --git a/charger/em2go-duo.go b/charger/em2go-duo.go index f14df296d..d54d33251 100644 --- a/charger/em2go-duo.go +++ b/charger/em2go-duo.go @@ -216,10 +216,10 @@ func (wb *Em2GoDuo) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), nil } -var _ api.MeterEnergy = (*Em2GoDuo)(nil) +var _ api.MeterImport = (*Em2GoDuo)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Em2GoDuo) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Em2GoDuo) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(wb.base+em2GoDuoRegConEnergy, 2) if err != nil { return 0, err diff --git a/charger/em2go.go b/charger/em2go.go index d4bb5635e..70c675ef2 100644 --- a/charger/em2go.go +++ b/charger/em2go.go @@ -288,10 +288,10 @@ func (wb *Em2Go) CurrentPower() (float64, error) { return rs485.RTUUint32ToFloat64(b), nil } -var _ api.MeterEnergy = (*Em2Go)(nil) +var _ api.MeterImport = (*Em2Go)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Em2Go) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Em2Go) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(em2GoRegEnergy, 2) if err != nil { return 0, err diff --git a/charger/eprowallbox.go b/charger/eprowallbox.go index c857d5791..b9b412acd 100644 --- a/charger/eprowallbox.go +++ b/charger/eprowallbox.go @@ -186,10 +186,10 @@ func (wb *EProWallbox) CurrentPower() (float64, error) { return l1 + l2 + l3, err } -var _ api.MeterEnergy = (*EProWallbox)(nil) +var _ api.MeterImport = (*EProWallbox)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *EProWallbox) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *EProWallbox) ImportEnergy() (float64, error) { l1, l2, l3, err := wb.getPhaseValues(eproRegActiveEnergies, 1000) return -(l1 + l2 + l3), err } diff --git a/charger/etek.go b/charger/etek.go index 14e1b2385..1c2d610b3 100644 --- a/charger/etek.go +++ b/charger/etek.go @@ -95,7 +95,7 @@ func NewEtekFromConfig(ctx context.Context, other map[string]any) (api.Charger, // Check energy register (95) if b, err := wb.conn.ReadHoldingRegisters(etekRegMeterEnergyAddr, 1); err == nil { if binary.BigEndian.Uint16(b) != etekRegInvalidMeterAddr { - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) } } @@ -246,7 +246,7 @@ func (wb *Etek) currentPower() (float64, error) { return float64(binary.BigEndian.Uint16(b)), nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *Etek) totalEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(etekRegEnergy, 2) if err != nil { diff --git a/charger/evecube.go b/charger/evecube.go index 06582c1f9..69f94c3ea 100644 --- a/charger/evecube.go +++ b/charger/evecube.go @@ -314,10 +314,10 @@ func (wb *EVECUBE) CurrentPower() (float64, error) { return status.Voltage * status.Current, nil } -var _ api.MeterEnergy = (*EVECUBE)(nil) +var _ api.MeterImport = (*EVECUBE)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *EVECUBE) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *EVECUBE) ImportEnergy() (float64, error) { status, err := wb.getStatus() if err != nil { return 0, err diff --git a/charger/evsemaster.go b/charger/evsemaster.go index 7cd0ec443..af454aa53 100644 --- a/charger/evsemaster.go +++ b/charger/evsemaster.go @@ -45,7 +45,7 @@ const ( evsemasterConnectTimeout = 15 * time.Second ) -// EVSEMaster implements api.Charger (and api.Meter / api.MeterEnergy / +// EVSEMaster implements api.Charger (and api.Meter / api.MeterImport / // api.PhaseCurrents / api.PhaseVoltages) for charging stations that use the // EVSE Master UDP protocol – e.g. Sync EV and generic Chinese EVSE devices. // @@ -288,10 +288,10 @@ func (wb *EVSEMaster) CurrentPower() (float64, error) { return res.Power, nil } -var _ api.MeterEnergy = (*EVSEMaster)(nil) +var _ api.MeterImport = (*EVSEMaster)(nil) -// TotalEnergy implements the api.MeterEnergy interface. -func (wb *EVSEMaster) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface. +func (wb *EVSEMaster) ImportEnergy() (float64, error) { res, err := wb.data.Get() if err != nil { return 0, err diff --git a/charger/evsewifi.go b/charger/evsewifi.go index 498385146..691f4fae8 100644 --- a/charger/evsewifi.go +++ b/charger/evsewifi.go @@ -76,7 +76,7 @@ func NewEVSEWifiFromConfig(other map[string]any) (api.Charger, error) { } if cc.Meter.Energy { - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) } if cc.Meter.Currents { @@ -210,7 +210,7 @@ func (wb *EVSEWifi) currentPower() (float64, error) { return 1000 * params.ActualPower, err } -// TotalEnergy implements the api.MeterEnergy interface +// ImportEnergy implements the api.MeterImport interface func (wb *EVSEWifi) totalEnergy() (float64, error) { params, err := wb.paramG.Get() return params.MeterReading, err diff --git a/charger/evsewifi_test.go b/charger/evsewifi_test.go index 03fd1cd2f..e2e4a276f 100644 --- a/charger/evsewifi_test.go +++ b/charger/evsewifi_test.go @@ -32,8 +32,8 @@ func TestEvseWifi(t *testing.T) { t.Error("missing api.Meter") } - if _, ok := api.Cap[api.MeterEnergy](wb); !ok { - t.Error("missing api.MeterEnergy") + if _, ok := api.Cap[api.MeterImport](wb); !ok { + t.Error("missing api.MeterImport") } if _, ok := api.Cap[api.PhaseCurrents](wb); !ok { diff --git a/charger/fritzdect.go b/charger/fritzdect.go index f49462bc1..e50d42181 100644 --- a/charger/fritzdect.go +++ b/charger/fritzdect.go @@ -92,9 +92,9 @@ func (c *FritzDECT) Enable(enable bool) error { return c.conn.SwitchOff() } -var _ api.MeterEnergy = (*FritzDECT)(nil) +var _ api.MeterImport = (*FritzDECT)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *FritzDECT) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *FritzDECT) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } diff --git a/charger/go-e.go b/charger/go-e.go index 9597e2b36..058836b5b 100644 --- a/charger/go-e.go +++ b/charger/go-e.go @@ -207,10 +207,10 @@ func (c *GoE) Identify() (string, error) { return resp.Identify(), nil } -var _ api.MeterEnergy = (*GoE)(nil) +var _ api.MeterImport = (*GoE)(nil) -// totalEnergy implements the api.MeterEnergy interface - v2 only -func (c *GoE) TotalEnergy() (float64, error) { +// totalEnergy implements the api.MeterImport interface - v2 only +func (c *GoE) ImportEnergy() (float64, error) { resp, err := c.api.Status() if err != nil { return 0, err diff --git a/charger/go-e_test.go b/charger/go-e_test.go index ed77a96ff..2c0c4af4d 100644 --- a/charger/go-e_test.go +++ b/charger/go-e_test.go @@ -78,8 +78,8 @@ func TestGoEV2(t *testing.T) { t.Error("missing Identifier api") } - if _, ok := api.Cap[api.MeterEnergy](wb); !ok { - t.Error("missing MeterEnergy api") + if _, ok := api.Cap[api.MeterImport](wb); !ok { + t.Error("missing MeterImport api") } if _, ok := api.Cap[api.PhaseSwitcher](wb); !ok { diff --git a/charger/hardybarth-ecb1.go b/charger/hardybarth-ecb1.go index fb5bdd752..47bb74bea 100644 --- a/charger/hardybarth-ecb1.go +++ b/charger/hardybarth-ecb1.go @@ -206,10 +206,10 @@ func (wb *HardyBarth) CurrentPower() (float64, error) { return res.Data[obis.PowerConsumption], nil } -var _ api.MeterEnergy = (*HardyBarth)(nil) +var _ api.MeterImport = (*HardyBarth)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *HardyBarth) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *HardyBarth) ImportEnergy() (float64, error) { res, err := wb.meterG() if err != nil { return 0, err diff --git a/charger/hardybarth-salia.go b/charger/hardybarth-salia.go index f5d5f66a0..6f7100e08 100644 --- a/charger/hardybarth-salia.go +++ b/charger/hardybarth-salia.go @@ -141,7 +141,7 @@ func NewSalia(ctx context.Context, uri, user, password string, cache time.Durati if res.Secc.Port0.Metering.Meter.Available > 0 { implement.Has(wb, implement.Meter(wb.currentPower)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) implement.Has(wb, implement.PhaseCurrents(wb.currents)) } @@ -266,7 +266,7 @@ func (wb *Salia) currentPower() (float64, error) { return res.Secc.Port0.Metering.Power.ActiveTotal.Actual / 10, err } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *Salia) totalEnergy() (float64, error) { res, err := wb.apiG.Get() return res.Secc.Port0.Metering.Energy.ActiveImport.Actual / 1e3, err diff --git a/charger/heatpump.go b/charger/heatpump.go index 40b64caf3..5ca3d1b49 100644 --- a/charger/heatpump.go +++ b/charger/heatpump.go @@ -80,12 +80,12 @@ func NewHeatpumpFromConfig(ctx context.Context, other map[string]any) (api.Charg return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, importG, _, 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.MeterImport(importG)) tempG, limitTempG, err := cc.Temperature.Configure(ctx) if err != nil { diff --git a/charger/heidelberg-ec.go b/charger/heidelberg-ec.go index cf0082898..77a0e17ea 100644 --- a/charger/heidelberg-ec.go +++ b/charger/heidelberg-ec.go @@ -251,10 +251,10 @@ func (wb *HeidelbergEC) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint16(b)), nil } -var _ api.MeterEnergy = (*HeidelbergEC)(nil) +var _ api.MeterImport = (*HeidelbergEC)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *HeidelbergEC) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *HeidelbergEC) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(hecRegEnergy, 2) if err != nil { return 0, err diff --git a/charger/hesotec.go b/charger/hesotec.go index 0cf78d86d..bc4b60714 100644 --- a/charger/hesotec.go +++ b/charger/hesotec.go @@ -165,10 +165,10 @@ func (wb *Hesotec) ChargeDuration() (time.Duration, error) { return time.Duration(binary.BigEndian.Uint32(b)) * time.Second, nil } -var _ api.MeterEnergy = (*Hesotec)(nil) +var _ api.MeterImport = (*Hesotec)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Hesotec) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Hesotec) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(hesotecRegEnergy, 2) if err != nil { return 0, err diff --git a/charger/homeassistant.go b/charger/homeassistant.go index 9da621a4f..17de107df 100644 --- a/charger/homeassistant.go +++ b/charger/homeassistant.go @@ -79,7 +79,7 @@ func NewHomeAssistantFromConfig(other map[string]any) (api.Charger, error) { implement.Has(c, implement.Meter(func() (float64, error) { return conn.GetFloatState(cc.Power) })) } if cc.Energy != "" { - implement.Has(c, implement.MeterEnergy(func() (float64, error) { return conn.GetFloatState(cc.Energy) })) + implement.Has(c, implement.MeterImport(func() (float64, error) { return conn.GetFloatState(cc.Energy) })) } // phase currents (optional) diff --git a/charger/homematic.go b/charger/homematic.go index 80ad932cc..f3b045b64 100644 --- a/charger/homematic.go +++ b/charger/homematic.go @@ -67,9 +67,9 @@ func (c *CCU) Enable(enable bool) error { return c.conn.Enable(enable) } -var _ api.MeterEnergy = (*CCU)(nil) +var _ api.MeterImport = (*CCU)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *CCU) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *CCU) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } diff --git a/charger/homewizard.go b/charger/homewizard.go index 48e3c8c3a..057c2a64f 100644 --- a/charger/homewizard.go +++ b/charger/homewizard.go @@ -72,9 +72,9 @@ func (c *HomeWizard) Enable(enable bool) error { return c.conn.Enable(enable) } -var _ api.MeterEnergy = (*HomeWizard)(nil) +var _ api.MeterImport = (*HomeWizard)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *HomeWizard) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *HomeWizard) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } diff --git a/charger/innogy.go b/charger/innogy.go index 1626487b4..f7d105adf 100644 --- a/charger/innogy.go +++ b/charger/innogy.go @@ -74,7 +74,7 @@ func NewInnogyFromConfig(ctx context.Context, other map[string]any) (api.Charger // check presence of energy meter & voltages registers if b, err := wb.conn.ReadInputRegisters(igyRegModbusTableVersion, 1); err == nil && binary.BigEndian.Uint16(b) >= 6 { - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) implement.Has(wb, implement.PhaseVoltages(wb.voltages)) wb.hasVoltages = true } @@ -226,7 +226,7 @@ func (wb *Innogy) voltages() (float64, float64, float64, error) { return res[0], res[1], res[2], nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *Innogy) totalEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(igyRegEnergy, 2) if err != nil { diff --git a/charger/kathrein.go b/charger/kathrein.go index f74cd7b25..e821c7025 100644 --- a/charger/kathrein.go +++ b/charger/kathrein.go @@ -314,10 +314,10 @@ func (wb *Kathrein) Voltages() (float64, float64, float64, error) { // removed since broken, see https://github.com/evcc-io/evcc/pull/25427 // var _ api.ChargeRater = (*Kathrein)(nil) -var _ api.MeterEnergy = (*Kathrein)(nil) +var _ api.MeterImport = (*Kathrein)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Kathrein) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Kathrein) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(kathreinRegTotalEnergy, 2) if err != nil { return 0, err diff --git a/charger/keba-modbus.go b/charger/keba-modbus.go index fbfa3028a..91aac97a1 100644 --- a/charger/keba-modbus.go +++ b/charger/keba-modbus.go @@ -131,7 +131,7 @@ func NewKebaFromConfig(ctx context.Context, other map[string]any) (api.Charger, if hasEnergyMeter { implement.Has(wb, implement.Meter(wb.currentPower)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) implement.Has(wb, implement.PhaseCurrents(wb.currents)) } @@ -329,7 +329,7 @@ func (wb *Keba) currentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)) / 1e3, nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *Keba) totalEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(kebaRegEnergy, 2) if err != nil { diff --git a/charger/keba-udp.go b/charger/keba-udp.go index 9e20b0cef..734f26172 100644 --- a/charger/keba-udp.go +++ b/charger/keba-udp.go @@ -61,7 +61,7 @@ func NewKebaUdpFromConfig(other map[string]any) (api.Charger, error) { if energy > 0 { implement.Has(k, implement.Meter(k.currentPower)) - implement.Has(k, implement.MeterEnergy(k.totalEnergy)) + implement.Has(k, implement.MeterImport(k.totalEnergy)) implement.Has(k, implement.PhaseCurrents(k.currents)) } @@ -284,7 +284,7 @@ func (c *KebaUdp) currentPower() (float64, error) { return float64(kr.P) / 1e3, err } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (c *KebaUdp) totalEnergy() (float64, error) { var kr keba.Report3 err := c.roundtrip("report", 3, &kr) diff --git a/charger/kse.go b/charger/kse.go index 8a136a888..64b3c6bcf 100644 --- a/charger/kse.go +++ b/charger/kse.go @@ -181,7 +181,7 @@ func (wb *KSE) CurrentPower() (float64, error) { var _ api.ChargeRater = (*KSE)(nil) -// ChargedEnergy implements the api.MeterEnergy interface +// ChargedEnergy implements the api.MeterImport interface func (wb *KSE) ChargedEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(kseRegCurrentLoadedEnergy, 1) if err != nil { @@ -191,10 +191,10 @@ func (wb *KSE) ChargedEnergy() (float64, error) { return float64(binary.BigEndian.Uint16(b)) / 100, err } -var _ api.MeterEnergy = (*KSE)(nil) +var _ api.MeterImport = (*KSE)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *KSE) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *KSE) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(kseRegEnergy, 2) if err != nil { return 0, err diff --git a/charger/lektrico.go b/charger/lektrico.go index 84878c7e0..def1e23aa 100644 --- a/charger/lektrico.go +++ b/charger/lektrico.go @@ -251,10 +251,10 @@ func (wb *Lektrico) CurrentPower() (float64, error) { return res.InstantPower, err } -var _ api.MeterEnergy = (*Lektrico)(nil) +var _ api.MeterImport = (*Lektrico)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Lektrico) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Lektrico) ImportEnergy() (float64, error) { res, err := wb.statusG.Get() return res.TotalChargedEnergy, err } diff --git a/charger/measurement/energy.go b/charger/measurement/energy.go index ed173643c..5b07ab672 100644 --- a/charger/measurement/energy.go +++ b/charger/measurement/energy.go @@ -9,23 +9,39 @@ import ( type Energy struct { Power *plugin.Config // optional - Energy *plugin.Config // optional + Import *plugin.Config // optional + Export *plugin.Config // optional + // Energy is a legacy alias for Import. Chargers always import energy, so + // the alias only feeds the Import getter (unlike meters, which alias to both). + Energy *plugin.Config } 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) + // legacy: chargers always import, so 'energy' aliases to import only. + importCfg := cc.Import + if cc.Energy != nil && importCfg == nil { + importCfg = cc.Energy + } + + importG, err := importCfg.FloatGetter(ctx) if err != nil { - return nil, nil, fmt.Errorf("energy: %w", err) + return nil, nil, nil, fmt.Errorf("import: %w", err) } - return powerG, energyG, nil + exportG, err := cc.Export.FloatGetter(ctx) + if err != nil { + return nil, nil, nil, fmt.Errorf("export: %w", err) + } + + return powerG, importG, exportG, nil } diff --git a/charger/mennekes-compact.go b/charger/mennekes-compact.go index f5e9d5b1a..03a4c4fbd 100644 --- a/charger/mennekes-compact.go +++ b/charger/mennekes-compact.go @@ -212,10 +212,10 @@ func (wb *MennekesCompact) CurrentPower() (float64, error) { return float64(encoding.Float32(b)), nil } -var _ api.MeterEnergy = (*MennekesCompact)(nil) +var _ api.MeterImport = (*MennekesCompact)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *MennekesCompact) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *MennekesCompact) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(mennekesRegChargedEnergyTotal, 2) if err != nil { return 0, err @@ -256,7 +256,7 @@ func (wb *MennekesCompact) getPhaseValues(reg uint16) (float64, float64, float64 /* var _ api.ChargeRater = (*MennekesCompact)(nil) -// ChargedEnergy implements the api.MeterEnergy interface +// ChargedEnergy implements the api.MeterImport interface func (wb *MennekesCompact) ChargedEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(mennekesRegChargedEnergySession, 2) if err != nil { diff --git a/charger/mennekes-hcc3.go b/charger/mennekes-hcc3.go index 8a5fb11f8..ba86304c2 100644 --- a/charger/mennekes-hcc3.go +++ b/charger/mennekes-hcc3.go @@ -161,7 +161,7 @@ func (wb *MennekesHcc3) CurrentPower() (float64, error) { var _ api.ChargeRater = (*MennekesHcc3)(nil) -// ChargedEnergy implements the api.MeterEnergy interface +// ChargedEnergy implements the api.MeterImport interface func (wb *MennekesHcc3) ChargedEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(mennekesHcc3RegEnergy, 2) if err != nil { diff --git a/charger/nexblue.go b/charger/nexblue.go index b8685d9c5..cdfa67afd 100644 --- a/charger/nexblue.go +++ b/charger/nexblue.go @@ -254,10 +254,10 @@ func (wb *Nexblue) ChargedEnergy() (float64, error) { return res.Energy, err } -var _ api.MeterEnergy = (*Nexblue)(nil) +var _ api.MeterImport = (*Nexblue)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Nexblue) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Nexblue) ImportEnergy() (float64, error) { res, err := wb.statusG.Get() return res.LifetimeEnergy, err } diff --git a/charger/nrgble_linux.go b/charger/nrgble_linux.go index 97371cc01..3a8286a0a 100644 --- a/charger/nrgble_linux.go +++ b/charger/nrgble_linux.go @@ -283,10 +283,10 @@ func (wb *NRGKickBLE) CurrentPower() (float64, error) { return float64(res.TotalPower) * 10, nil } -var _ api.MeterEnergy = (*NRGKickBLE)(nil) +var _ api.MeterImport = (*NRGKickBLE)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *NRGKickBLE) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *NRGKickBLE) ImportEnergy() (float64, error) { var res ble.Energy if err := wb.read(ble.EnergyService, &res); err != nil { return 0, err diff --git a/charger/nrgconnect.go b/charger/nrgconnect.go index 77bbacbfa..a8260c5cb 100644 --- a/charger/nrgconnect.go +++ b/charger/nrgconnect.go @@ -184,10 +184,10 @@ func (nrg *NRGKickConnect) CurrentPower() (float64, error) { return res.ChargingPower * 1e3, err } -var _ api.MeterEnergy = (*NRGKickConnect)(nil) +var _ api.MeterImport = (*NRGKickConnect)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (nrg *NRGKickConnect) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (nrg *NRGKickConnect) ImportEnergy() (float64, error) { res, err := nrg.measurementsG.Get() if err != nil { return 0, err diff --git a/charger/nrggen2.go b/charger/nrggen2.go index 21f812207..c4f14fc64 100644 --- a/charger/nrggen2.go +++ b/charger/nrggen2.go @@ -228,10 +228,10 @@ func (nrg *NRGKickGen2) CurrentPower() (float64, error) { return float64(encoding.Int32LswFirst(b)) * 1e-3, nil } -var _ api.MeterEnergy = (*NRGKickGen2)(nil) +var _ api.MeterImport = (*NRGKickGen2)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (nrg *NRGKickGen2) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (nrg *NRGKickGen2) ImportEnergy() (float64, error) { b, err := nrg.conn.ReadHoldingRegisters(nrgKickGen2TotalChargedEnergy, 4) if err != nil { return 0, err diff --git a/charger/ocpp.go b/charger/ocpp.go index 9a1d4932b..03f5b90da 100644 --- a/charger/ocpp.go +++ b/charger/ocpp.go @@ -109,7 +109,7 @@ func NewOCPPFromConfig(ctx context.Context, other map[string]any) (api.Charger, } if c.cp.HasMeasurement(types.MeasurandEnergyActiveImportRegister) { - implement.Has(c, implement.MeterEnergy(c.conn.TotalEnergy)) + implement.Has(c, implement.MeterImport(c.conn.ImportEnergy)) } if c.cp.HasMeasurement(types.MeasurandCurrentImport) { diff --git a/charger/ocpp/connector.go b/charger/ocpp/connector.go index 9e5622b51..96f0e61c3 100644 --- a/charger/ocpp/connector.go +++ b/charger/ocpp/connector.go @@ -310,7 +310,7 @@ func (conn *Connector) CurrentPower() (float64, error) { return 0, api.ErrNotAvailable } -func (conn *Connector) TotalEnergy() (float64, error) { +func (conn *Connector) ImportEnergy() (float64, error) { if !conn.cp.Connected() { return 0, api.ErrTimeout } diff --git a/charger/ocpp/connector_test.go b/charger/ocpp/connector_test.go index 459c612ce..3b67f8759 100644 --- a/charger/ocpp/connector_test.go +++ b/charger/ocpp/connector_test.go @@ -69,8 +69,8 @@ func (suite *connTestSuite) TestConnectorNoMeasurements() { suite.Equal(api.ErrTimeout, err, "GetMaxCurrent") // api.ErrNotAvailable - _, err = suite.conn.TotalEnergy() - suite.Equal(api.ErrNotAvailable, err, "TotalEnergy") + _, err = suite.conn.ImportEnergy() + suite.Equal(api.ErrNotAvailable, err, "ImportEnergy") _, err = suite.conn.Soc() suite.Equal(api.ErrNotAvailable, err, "Soc") _, _, _, err = suite.conn.Voltages() @@ -98,9 +98,9 @@ func (suite *connTestSuite) TestConnectorMeasurementsNoTxn() { suite.Equal(api.ErrTimeout, err, "GetMaxCurrent") // keep old values - res, err = suite.conn.TotalEnergy() - suite.NoError(err, "TotalEnergy") - suite.Equal(res, 0.001, "TotalEnergy") + res, err = suite.conn.ImportEnergy() + suite.NoError(err, "ImportEnergy") + suite.Equal(res, 0.001, "ImportEnergy") res, err = suite.conn.Soc() suite.NoError(err, "Soc") suite.Equal(res, 1.0, "Soc") @@ -119,8 +119,8 @@ func (suite *connTestSuite) TestConnectorMeasurementsRunningTxnOutdated() { _, err := suite.conn.CurrentPower() suite.Equal(api.ErrTimeout, err, "CurrentPower") - _, err = suite.conn.TotalEnergy() - suite.Equal(api.ErrTimeout, err, "TotalEnergy") + _, err = suite.conn.ImportEnergy() + suite.Equal(api.ErrTimeout, err, "ImportEnergy") _, err = suite.conn.GetMaxCurrent() suite.Equal(api.ErrTimeout, err, "GetMaxCurrent") _, err = suite.conn.Soc() @@ -140,8 +140,8 @@ func (suite *connTestSuite) TestConnectorMeasurementsRunningTxn() { _, err := suite.conn.CurrentPower() suite.NoError(err, "CurrentPower") - _, err = suite.conn.TotalEnergy() - suite.NoError(err, "TotalEnergy") + _, err = suite.conn.ImportEnergy() + suite.NoError(err, "ImportEnergy") _, err = suite.conn.GetMaxCurrent() suite.NoError(err, "GetMaxCurrent") _, err = suite.conn.Soc() diff --git a/charger/openevse.go b/charger/openevse.go index c2939e9f6..0618f51a3 100644 --- a/charger/openevse.go +++ b/charger/openevse.go @@ -213,10 +213,10 @@ func (c *OpenEVSE) ChargeDuration() (time.Duration, error) { return time.Duration(res.Elapsed) * time.Second, err } -var _ api.MeterEnergy = (*OpenEVSE)(nil) +var _ api.MeterImport = (*OpenEVSE)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *OpenEVSE) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *OpenEVSE) ImportEnergy() (float64, error) { res, err := c.statusG.Get() if err != nil { return 0, err diff --git a/charger/openwb-2.0.go b/charger/openwb-2.0.go index 19dcbb107..e118ee4aa 100644 --- a/charger/openwb-2.0.go +++ b/charger/openwb-2.0.go @@ -168,10 +168,10 @@ func (wb *OpenWB20) CurrentPower() (float64, error) { return float64(int32(binary.BigEndian.Uint32(b))), nil } -var _ api.MeterEnergy = (*OpenWB20)(nil) +var _ api.MeterImport = (*OpenWB20)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *OpenWB20) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *OpenWB20) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(wb.base+openwbRegImport, 2) if err != nil { return 0, err diff --git a/charger/openwb-pro.go b/charger/openwb-pro.go index 5844064e0..50359ee8c 100644 --- a/charger/openwb-pro.go +++ b/charger/openwb-pro.go @@ -164,10 +164,10 @@ func (wb *OpenWBPro) CurrentPower() (float64, error) { return res.PowerAll, err } -var _ api.MeterEnergy = (*OpenWBPro)(nil) +var _ api.MeterImport = (*OpenWBPro)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *OpenWBPro) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *OpenWBPro) ImportEnergy() (float64, error) { res, err := wb.statusG.Get() return res.Imported / 1e3, err } diff --git a/charger/openwb.go b/charger/openwb.go index d8fe23b80..8302b4305 100644 --- a/charger/openwb.go +++ b/charger/openwb.go @@ -241,10 +241,10 @@ func (m *OpenWB) CurrentPower() (float64, error) { return m.currentPowerG() } -var _ api.MeterEnergy = (*OpenWB)(nil) +var _ api.MeterImport = (*OpenWB)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (m *OpenWB) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (m *OpenWB) ImportEnergy() (float64, error) { return m.totalEnergyG() } diff --git a/charger/pcelectric.go b/charger/pcelectric.go index b09761359..c0c36130a 100644 --- a/charger/pcelectric.go +++ b/charger/pcelectric.go @@ -51,7 +51,7 @@ func NewPCElectricFromConfig(other map[string]any) (api.Charger, error) { var res pcelectric.MeterInfo if err := wb.GetJSON(wb.meter, &res); err == nil && res.MeterSerial != "" { implement.Has(wb, implement.Meter(wb.currentPower)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) implement.Has(wb, implement.PhaseCurrents(wb.currents)) return wb, nil } @@ -248,7 +248,7 @@ func (wb *PCElectric) currentPower() (float64, error) { return 230 * (l1 + l2 + l3), err } -// TotalEnergy implements the api.MeterEnergy interface kwh +// ImportEnergy implements the api.MeterImport interface kwh func (wb *PCElectric) totalEnergy() (float64, error) { var res pcelectric.MeterInfo uri := fmt.Sprintf("%s/meterinfo/%s", wb.uri, wb.meter) diff --git a/charger/peblar.go b/charger/peblar.go index d406f378e..2f50ec74f 100644 --- a/charger/peblar.go +++ b/charger/peblar.go @@ -204,8 +204,8 @@ func (wb *Peblar) CurrentPower() (float64, error) { // deliberately removed, see https://github.com/evcc-io/evcc/issues/25956 // var _ api.ChargeRater = (*Peblar)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Peblar) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Peblar) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(peblarRegEnergyTotal, 4) if err != nil { return 0, err diff --git a/charger/phoenix-charx.go b/charger/phoenix-charx.go index 26151e711..2814d3288 100644 --- a/charger/phoenix-charx.go +++ b/charger/phoenix-charx.go @@ -77,7 +77,7 @@ func NewPhoenixCharxFromConfig(ctx context.Context, other map[string]any) (api.C if meter > 0 && meter != 65535 { implement.Has(wb, implement.Meter(wb.currentPower)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) implement.Has(wb, implement.PhaseCurrents(wb.currents)) implement.Has(wb, implement.PhaseVoltages(wb.voltages)) } @@ -229,7 +229,7 @@ func (wb *PhoenixCharx) currentPower() (float64, error) { return float64(encoding.Int32(b)) / 1e3, nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *PhoenixCharx) totalEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(wb.register(charxRegEnergy), 4) if err != nil { diff --git a/charger/phoenix-em-eth.go b/charger/phoenix-em-eth.go index 8ef5de97a..04db0802c 100644 --- a/charger/phoenix-em-eth.go +++ b/charger/phoenix-em-eth.go @@ -54,7 +54,7 @@ func NewPhoenixEMEthFromConfig(ctx context.Context, other map[string]any) (api.C // check presence of meter by voltage on l1 if b, err := wb.conn.ReadInputRegisters(phxEMEthRegVoltages, 2); err == nil && encoding.Int32LswFirst(b) > 0 { implement.Has(wb, implement.Meter(wb.currentPower)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) implement.Has(wb, implement.PhaseCurrents(wb.currents)) implement.Has(wb, implement.PhaseVoltages(wb.voltages)) } @@ -145,7 +145,7 @@ func (wb *PhoenixEMEth) currentPower() (float64, error) { return float64(encoding.Int32LswFirst(b)*1e3) * phxEMEthSF, nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *PhoenixEMEth) totalEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(phxEMEthRegEnergy, 2) if err != nil { diff --git a/charger/phoenix-ev-eth.go b/charger/phoenix-ev-eth.go index 1e3af59eb..b9016e879 100644 --- a/charger/phoenix-ev-eth.go +++ b/charger/phoenix-ev-eth.go @@ -99,7 +99,7 @@ func NewPhoenixEVEth(ctx context.Context, uri string, slaveID uint8) (api.Charge // check presence of meter by voltage on l1 if b, err := wb.conn.ReadInputRegisters(phxRegVoltages, 2); err == nil && encoding.Uint32LswFirst(b) > 0 { implement.May(wb, implement.Meter(wb.currentPower)) - implement.May(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.May(wb, implement.MeterImport(wb.totalEnergy)) implement.May(wb, implement.PhaseCurrents(wb.currents)) implement.May(wb, implement.PhaseVoltages(wb.voltages)) } @@ -184,7 +184,7 @@ func (wb *PhoenixEVEth) currentPower() (float64, error) { return float64(encoding.Int32LswFirst(b)), nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *PhoenixEVEth) totalEnergy() (float64, error) { if wb.isWallbe { b, err := wb.conn.ReadHoldingRegisters(phxRegEnergyWallbe, 4) diff --git a/charger/pulsatrix.go b/charger/pulsatrix.go index b38bf6836..431a954b9 100644 --- a/charger/pulsatrix.go +++ b/charger/pulsatrix.go @@ -429,10 +429,10 @@ func (c *Pulsatrix) CurrentPower() (float64, error) { return res.LastActivePower, err } -var _ api.MeterEnergy = (*Pulsatrix)(nil) +var _ api.MeterImport = (*Pulsatrix)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *Pulsatrix) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *Pulsatrix) ImportEnergy() (float64, error) { res, err := c.data.Get() return res.EnergyImported, err } diff --git a/charger/schneider-v3.go b/charger/schneider-v3.go index 66cf87e09..096b95294 100644 --- a/charger/schneider-v3.go +++ b/charger/schneider-v3.go @@ -191,10 +191,10 @@ func (wb *Schneider) CurrentPower() (float64, error) { return float64(encoding.Float32LswFirst(b)) * 1e3, nil } -var _ api.MeterEnergy = (*Schneider)(nil) +var _ api.MeterImport = (*Schneider)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Schneider) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Schneider) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(schneiderRegEnergy, 4) if err != nil { return 0, err diff --git a/charger/sgready-relay.go b/charger/sgready-relay.go index 62e17cc4a..c281a2bb4 100644 --- a/charger/sgready-relay.go +++ b/charger/sgready-relay.go @@ -61,12 +61,12 @@ func NewSgReadyRelayFromConfig(ctx context.Context, other map[string]any) (api.C return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, importG, _, 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.MeterImport(importG)) tempG, limitTempG, err := cc.Temperature.Configure(ctx) if err != nil { diff --git a/charger/sgready.go b/charger/sgready.go index bc152b4f5..909dd66e9 100644 --- a/charger/sgready.go +++ b/charger/sgready.go @@ -107,12 +107,12 @@ func NewSgReadyFromConfig(ctx context.Context, other map[string]any) (api.Charge return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, importG, _, 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.MeterImport(importG)) tempG, limitTempG, err := cc.Temperature.Configure(ctx) if err != nil { diff --git a/charger/shelly-topac.go b/charger/shelly-topac.go index 092577418..aa1ae898d 100644 --- a/charger/shelly-topac.go +++ b/charger/shelly-topac.go @@ -183,10 +183,10 @@ func (c *ShellyTopAC) CurrentPower() (float64, error) { return phase.TotalPower * 1e3, nil } -var _ api.MeterEnergy = (*ShellyTopAC)(nil) +var _ api.MeterImport = (*ShellyTopAC)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *ShellyTopAC) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *ShellyTopAC) ImportEnergy() (float64, error) { res, err := c.phaseG.Get() if err != nil { return 0, err diff --git a/charger/shelly.go b/charger/shelly.go index 524266808..2884e519e 100644 --- a/charger/shelly.go +++ b/charger/shelly.go @@ -93,9 +93,9 @@ func (c *Shelly) Enable(enable bool) error { } } -var _ api.MeterEnergy = (*Shelly)(nil) +var _ api.MeterImport = (*Shelly)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *Shelly) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *Shelly) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } diff --git a/charger/sigenergy.go b/charger/sigenergy.go index 4aaa8be80..066440439 100644 --- a/charger/sigenergy.go +++ b/charger/sigenergy.go @@ -159,10 +159,10 @@ func (wb *Sigenergy) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), nil } -var _ api.MeterEnergy = (*Sigenergy)(nil) +var _ api.MeterImport = (*Sigenergy)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Sigenergy) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Sigenergy) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(regSigTotalEnergyConsumed, 2) if err != nil { return 0, err diff --git a/charger/smaevcharger.go b/charger/smaevcharger.go index 15c0aff55..6399ca0b5 100644 --- a/charger/smaevcharger.go +++ b/charger/smaevcharger.go @@ -242,10 +242,10 @@ func (wb *Smaevcharger) MaxCurrentMillis(current float64) error { return wb.Send(value("Parameter.Inverter.AcALim", fmt.Sprintf("%.2f", current))) } -var _ api.MeterEnergy = (*Smaevcharger)(nil) +var _ api.MeterImport = (*Smaevcharger)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Smaevcharger) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Smaevcharger) ImportEnergy() (float64, error) { res, err := wb.getMeasurement("Measurement.Metering.GridMs.TotWhIn") if _, ok := errors.AsType[*smaevcharger.ErrUnknownMeasurement](err); ok { res, err = wb.getMeasurement("Measurement.Metering.GridMs.TotWhIn.ChaSta") diff --git a/charger/smart-evse.go b/charger/smart-evse.go index 3c97d6252..1163397ad 100644 --- a/charger/smart-evse.go +++ b/charger/smart-evse.go @@ -166,7 +166,7 @@ func NewSmartEVSE3(uri string, cache time.Duration, mode int) (api.Charger, erro // decorate optional EV meter if configured in SmartEVSE if res.EvMeter.Description != "" && res.EvMeter.Description != "Disabled" { implement.Has(wb, implement.Meter(wb.currentPower)) - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) implement.Has(wb, implement.PhaseCurrents(wb.currents)) } @@ -315,7 +315,7 @@ func (wb *SmartEVSE3) currentPower() (float64, error) { return res.EvMeter.ImportActivePower, nil } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (wb *SmartEVSE3) totalEnergy() (float64, error) { res, err := wb.apiG.Get() if err != nil { diff --git a/charger/smartevse.go b/charger/smartevse.go index dc219ad90..2dd3498ae 100644 --- a/charger/smartevse.go +++ b/charger/smartevse.go @@ -174,10 +174,10 @@ func (wb *smartEVSE) CurrentPower() (float64, error) { return v1*i1 + v2*i2 + v3*i3, nil } -var _ api.MeterEnergy = (*smartEVSE)(nil) +var _ api.MeterImport = (*smartEVSE)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *smartEVSE) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *smartEVSE) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(smartEVSERegEnergy, 2) if err != nil { return 0, err diff --git a/charger/solax.go b/charger/solax.go index 9b79b6ad4..b8f116a3d 100644 --- a/charger/solax.go +++ b/charger/solax.go @@ -225,10 +225,10 @@ func (wb *Solax) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint16(b)), err } -var _ api.MeterEnergy = (*Solax)(nil) +var _ api.MeterImport = (*Solax)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Solax) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Solax) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(solaxRegTotalEnergy, 2) if err != nil { return 0, err diff --git a/charger/sungrow.go b/charger/sungrow.go index 53bde214c..491ad6dba 100644 --- a/charger/sungrow.go +++ b/charger/sungrow.go @@ -240,10 +240,10 @@ func (wb *Sungrow) Voltages() (float64, float64, float64, error) { return wb.getPhaseValues(sgRegVoltages, 10) } -var _ api.MeterEnergy = (*Sungrow)(nil) +var _ api.MeterImport = (*Sungrow)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Sungrow) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Sungrow) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(sgRegTotalEnergy, 2) if err != nil { return 0, err diff --git a/charger/switchsocket.go b/charger/switchsocket.go index 01294b77c..bd7f15b36 100644 --- a/charger/switchsocket.go +++ b/charger/switchsocket.go @@ -62,7 +62,7 @@ func NewSwitchSocketFromConfig(ctx context.Context, other map[string]any) (api.C if err != nil { return nil, err } - implement.May(c, implement.MeterEnergy(energy)) + implement.May(c, implement.MeterImport(energy)) soc, err := cc.Soc.FloatGetter(ctx) if err != nil { diff --git a/charger/tasmota.go b/charger/tasmota.go index c22f6ce76..2aa97ca21 100644 --- a/charger/tasmota.go +++ b/charger/tasmota.go @@ -92,11 +92,11 @@ func (c *Tasmota) Enable(enable bool) error { return c.conn.Enable(enable) } -var _ api.MeterEnergy = (*Tasmota)(nil) +var _ api.MeterImport = (*Tasmota)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *Tasmota) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *Tasmota) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } // Currents implements the api.PhaseCurrents interface diff --git a/charger/tplink.go b/charger/tplink.go index 27244f223..da37ed7bd 100644 --- a/charger/tplink.go +++ b/charger/tplink.go @@ -92,9 +92,9 @@ func (c *TPLink) Enable(enable bool) error { return nil } -var _ api.MeterEnergy = (*TPLink)(nil) +var _ api.MeterImport = (*TPLink)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *TPLink) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *TPLink) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } diff --git a/charger/versicharge.go b/charger/versicharge.go index 36d3cb68f..1da0327ed 100644 --- a/charger/versicharge.go +++ b/charger/versicharge.go @@ -167,10 +167,10 @@ func (wb *Versicharge) CurrentPower() (float64, error) { return sum, nil } -var _ api.MeterEnergy = (*Versicharge)(nil) +var _ api.MeterImport = (*Versicharge)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Versicharge) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Versicharge) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(versiRegTotalEnergy, 2) if err != nil { return 0, err diff --git a/charger/vestel.go b/charger/vestel.go index e268b54a0..dd03329e5 100644 --- a/charger/vestel.go +++ b/charger/vestel.go @@ -250,10 +250,10 @@ func (wb *Vestel) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), err } -var _ api.MeterEnergy = (*Vestel)(nil) +var _ api.MeterImport = (*Vestel)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *Vestel) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *Vestel) ImportEnergy() (float64, error) { b, err := wb.conn.ReadInputRegisters(vestelRegTotalEnergy, 2) if err != nil { return 0, err diff --git a/charger/victron.go b/charger/victron.go index f717edfbc..9f5d3613d 100644 --- a/charger/victron.go +++ b/charger/victron.go @@ -200,7 +200,7 @@ func (wb *Victron) CurrentPower() (float64, error) { var _ api.ChargeRater = (*Victron)(nil) -// ChargedEnergy implements the api.MeterEnergy interface +// ChargedEnergy implements the api.MeterImport interface func (wb *Victron) ChargedEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(wb.regs.Energy, 1+cast.ToUint16(wb.regs.isGX)) if err != nil { diff --git a/charger/warp-ws.go b/charger/warp-ws.go index dd79ab2cc..86d61d6c2 100644 --- a/charger/warp-ws.go +++ b/charger/warp-ws.go @@ -81,7 +81,7 @@ func NewWarpWSFromConfig(ctx context.Context, other map[string]any) (api.Charger // Feature: Meter -> Meter is legacy API, Meters is the new API if w.hasFeature(warp.FeatureMeter) || w.hasFeature(warp.FeatureMeters) { implement.Has(w, implement.Meter(w.currentPower)) - implement.Has(w, implement.MeterEnergy(w.totalEnergy)) + implement.Has(w, implement.MeterImport(w.totalEnergy)) } // Feature: Meters | MeterAllValues diff --git a/charger/warp2-mqtt.go b/charger/warp2-mqtt.go index 8ed3890a5..b7cf8f105 100644 --- a/charger/warp2-mqtt.go +++ b/charger/warp2-mqtt.go @@ -63,7 +63,7 @@ func NewWarp2FromConfig(other map[string]any) (api.Charger, error) { if wb.hasFeature(cc.Topic, warp.FeatureMeter, cc.Timeout) { implement.May(wb, implement.Meter(wb.currentPower)) - implement.May(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.May(wb, implement.MeterImport(wb.totalEnergy)) } if wb.hasFeature(cc.Topic, warp.FeatureMeterPhases, cc.Timeout) { @@ -244,7 +244,7 @@ func (wb *Warp2) currentPower() (float64, error) { return res.Power, err } -// TotalEnergy implements the api.MeterEnergy interface +// ImportEnergy implements the api.MeterImport interface func (wb *Warp2) totalEnergy() (float64, error) { var res warp.MeterValues err := wb.meterG(&res) diff --git a/charger/webasto-next.go b/charger/webasto-next.go index ddce64f28..cd0c1ffbb 100644 --- a/charger/webasto-next.go +++ b/charger/webasto-next.go @@ -210,10 +210,10 @@ func (wb *WebastoNext) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), nil } -var _ api.MeterEnergy = (*WebastoNext)(nil) +var _ api.MeterImport = (*WebastoNext)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *WebastoNext) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *WebastoNext) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(tqRegEnergyMeter, 2) if err != nil { return 0, err diff --git a/charger/weidmüller.go b/charger/weidmüller.go index 27b187a96..755012bfc 100644 --- a/charger/weidmüller.go +++ b/charger/weidmüller.go @@ -107,7 +107,7 @@ func NewWeidmüller(ctx context.Context, uri string, id uint8) (api.Charger, err // check presence of energy meter if b, err := wb.conn.ReadHoldingRegisters(wmRegTotalEnergy, 2); err == nil && binary.BigEndian.Uint32(b) > 0 { - implement.Has(wb, implement.MeterEnergy(wb.totalEnergy)) + implement.Has(wb, implement.MeterImport(wb.totalEnergy)) } return wb, nil @@ -218,7 +218,7 @@ func (wb *Weidmüller) CurrentPower() (float64, error) { return float64(encoding.Uint32LswFirst(b)) / 1e3, err } -// TotalEnergy implements the api.MeterEnergy interface +// ImportEnergy implements the api.MeterImport interface func (wb *Weidmüller) totalEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(wmRegTotalEnergy, 2) if err != nil { diff --git a/cmd/dumper.go b/cmd/dumper.go index 6d6e17521..dd01e28c8 100644 --- a/cmd/dumper.go +++ b/cmd/dumper.go @@ -85,9 +85,16 @@ func (d *dumper) Dump(name string, v any) { }) } - if v, ok := api.Cap[api.MeterEnergy](v); ok { - d.measureTime(w, "Energy", func() (string, error) { - energy, err := v.TotalEnergy() + if v, ok := api.Cap[api.MeterImport](v); ok { + d.measureTime(w, "Import", func() (string, error) { + energy, err := v.ImportEnergy() + return fmt.Sprintf("%.1fkWh", energy), err + }) + } + + if v, ok := api.Cap[api.MeterExport](v); ok { + d.measureTime(w, "Export", func() (string, error) { + energy, err := v.ExportEnergy() return fmt.Sprintf("%.1fkWh", energy), err }) } diff --git a/cmd/implement/implement.go b/cmd/implement/implement.go index a1681c4ec..addfd9272 100644 --- a/cmd/implement/implement.go +++ b/cmd/implement/implement.go @@ -71,7 +71,8 @@ func generate(out io.Writer) error { reflect.TypeFor[api.PhaseSwitcher](), reflect.TypeFor[api.Battery](), reflect.TypeFor[api.ChargeState](), - reflect.TypeFor[api.MeterEnergy](), + reflect.TypeFor[api.MeterImport](), + reflect.TypeFor[api.MeterExport](), reflect.TypeFor[api.PhaseCurrents](), reflect.TypeFor[api.PhaseVoltages](), reflect.TypeFor[api.MaxACPowerGetter](), diff --git a/core/capable_test.go b/core/capable_test.go index 40b9b9157..eacfbc060 100644 --- a/core/capable_test.go +++ b/core/capable_test.go @@ -34,9 +34,9 @@ func (c *charger) Capacity() float64 { return 0 } -var _ api.MeterEnergy = (*charger)(nil) +var _ api.MeterImport = (*charger)(nil) -func (c *charger) TotalEnergy() (float64, error) { +func (c *charger) ImportEnergy() (float64, error) { return 0, nil } @@ -69,7 +69,7 @@ func TestCapsWrapping(t *testing.T) { assert.True(t, ok) } { - _, ok := c.(api.MeterEnergy) + _, ok := c.(api.MeterImport) assert.True(t, ok) } { @@ -89,14 +89,14 @@ func TestCapsWrapping(t *testing.T) { } { - _, ok := m.(api.MeterEnergy) + _, ok := m.(api.MeterImport) assert.False(t, ok, "unexpected promoted energy") - assert.True(t, api.HasCap[api.MeterEnergy](m), "missing promoted energy cap") + assert.True(t, api.HasCap[api.MeterImport](m), "missing promoted energy cap") var mm any = m.(*capableMeter).Meter - _, ok = mm.(api.MeterEnergy) + _, ok = mm.(api.MeterImport) assert.True(t, ok, "missing embedded energy") - assert.True(t, api.HasCap[api.MeterEnergy](mm), "missing embedded energy cap") + assert.True(t, api.HasCap[api.MeterImport](mm), "missing embedded energy cap") } { _, ok := m.(api.Battery) diff --git a/core/loadpoint.go b/core/loadpoint.go index c0b88b78d..77e0c985b 100644 --- a/core/loadpoint.go +++ b/core/loadpoint.go @@ -403,7 +403,7 @@ func (lp *Loadpoint) requestUpdate() { } // capableMeter wraps a meter with capability lookup from its source. -// This preserves capability checks (like MeterEnergy, PhaseCurrents, PhaseVoltages) when +// This preserves capability checks (like MeterImport, MeterExport, PhaseCurrents, PhaseVoltages) when // the meter was extracted from a decorated charger's capability registry. type capableMeter struct { api.Meter @@ -420,7 +420,7 @@ func (lp *Loadpoint) configureChargerType(charger api.Charger) { if mt, ok := api.Cap[api.Meter](charger); ok { // preserve charger's capability registry so that subsequent - // capability checks on chargeMeter (e.g. MeterEnergy, PhaseCurrents) + // capability checks on chargeMeter (e.g. MeterImport, PhaseCurrents) // still work for decorated chargers (https://github.com/evcc-io/evcc/issues/28915) if c, ok := charger.(api.Capable); ok { lp.chargeMeter = &capableMeter{Meter: mt, Capable: c} @@ -1743,7 +1743,7 @@ func (lp *Loadpoint) publishChargeProgress() { // update energy, prefer totals var importTotal *float64 - if api.HasCap[api.MeterEnergy](lp.chargeMeter) { + if api.HasCap[api.MeterImport](lp.chargeMeter) { if f := lp.chargeMeterTotal(); f > 0 { lp.publish(keys.ChargeTotalImport, f) importTotal = &f diff --git a/core/loadpoint_session.go b/core/loadpoint_session.go index d30315ab8..6843f5ac3 100644 --- a/core/loadpoint_session.go +++ b/core/loadpoint_session.go @@ -13,12 +13,12 @@ import ( ) func (lp *Loadpoint) chargeMeterTotal() float64 { - m, ok := api.Cap[api.MeterEnergy](lp.chargeMeter) + m, ok := api.Cap[api.MeterImport](lp.chargeMeter) if !ok { return 0 } - f, err := m.TotalEnergy() + f, err := m.ImportEnergy() if err != nil { if !errors.Is(err, api.ErrNotAvailable) { lp.log.ERROR.Printf("charge total import: %v", err) diff --git a/core/loadpoint_session_test.go b/core/loadpoint_session_test.go index 83f6e8f13..d8813447e 100644 --- a/core/loadpoint_session_test.go +++ b/core/loadpoint_session_test.go @@ -36,14 +36,14 @@ func TestSession(t *testing.T) { defer ctrl.Finish() mm := api.NewMockMeter(ctrl) - me := api.NewMockMeterEnergy(ctrl) + me := api.NewMockMeterImport(ctrl) type EnergyDecorator struct { api.Meter - api.MeterEnergy + api.MeterImport } - cm := &EnergyDecorator{Meter: mm, MeterEnergy: me} + cm := &EnergyDecorator{Meter: mm, MeterImport: me} lp := &Loadpoint{ log: util.NewLogger("foo"), @@ -53,7 +53,7 @@ func TestSession(t *testing.T) { } // create session - me.EXPECT().TotalEnergy().Return(1.0, nil) + me.EXPECT().ImportEnergy().Return(1.0, nil) lp.createSession() assert.NotNil(t, lp.session) @@ -64,7 +64,7 @@ func TestSession(t *testing.T) { // stop charging clock.Add(time.Hour) lp.energyMetrics.Update(1.23) - me.EXPECT().TotalEnergy().Return(1.0+lp.getChargedEnergy()/1e3, nil) // match chargedEnergy + me.EXPECT().ImportEnergy().Return(1.0+lp.getChargedEnergy()/1e3, nil) // match chargedEnergy lp.stopSession() assert.NotNil(t, lp.session) @@ -79,7 +79,7 @@ func TestSession(t *testing.T) { // stop charging - 2nd leg clock.Add(time.Hour) lp.energyMetrics.Update(lp.getChargedEnergy() * 2) - me.EXPECT().TotalEnergy().Return(3.0, nil) // doesn't match chargedEnergy + me.EXPECT().ImportEnergy().Return(3.0, nil) // doesn't match chargedEnergy lp.stopSession() assert.NotNil(t, lp.session) @@ -213,14 +213,14 @@ func TestResetHeatingSession(t *testing.T) { }) mm := api.NewMockMeter(ctrl) - me := api.NewMockMeterEnergy(ctrl) + me := api.NewMockMeterImport(ctrl) type EnergyDecorator struct { api.Meter - api.MeterEnergy + api.MeterImport } - cm := &EnergyDecorator{Meter: mm, MeterEnergy: me} + cm := &EnergyDecorator{Meter: mm, MeterImport: me} lp := &Loadpoint{ log: util.NewLogger("foo"), @@ -231,7 +231,7 @@ func TestResetHeatingSession(t *testing.T) { } // create session - me.EXPECT().TotalEnergy().Return(1.0, nil) + me.EXPECT().ImportEnergy().Return(1.0, nil) lp.createSession() require.NotNil(t, lp.session) assert.True(t, lp.session.Created.IsZero()) @@ -241,7 +241,7 @@ func TestResetHeatingSession(t *testing.T) { assert.Equal(t, clock.Now(), lp.session.Created) clock.Add(36 * time.Hour) - me.EXPECT().TotalEnergy().Return(1.0, nil).MaxTimes(2) + me.EXPECT().ImportEnergy().Return(1.0, nil).MaxTimes(2) lp.resetHeatingSession() require.NotNil(t, lp.session) @@ -250,7 +250,7 @@ func TestResetHeatingSession(t *testing.T) { lp.updateSession(sessionStart(lp)) assert.Equal(t, clock.Now(), lp.session.Created) - me.EXPECT().TotalEnergy().Return(3.0, nil) + me.EXPECT().ImportEnergy().Return(3.0, nil) lp.stopSession() assert.NotNil(t, lp.session) @@ -260,7 +260,7 @@ func TestResetHeatingSession(t *testing.T) { } func TestFinalizeSessionEnergy(t *testing.T) { - setup := func(t *testing.T) (*Loadpoint, *api.MockMeterEnergy, *api.MockChargeRater) { + setup := func(t *testing.T) (*Loadpoint, *api.MockMeterImport, *api.MockChargeRater) { t.Helper() var err error serverdb.Instance, err = serverdb.New("sqlite", ":memory:") @@ -270,17 +270,17 @@ func TestFinalizeSessionEnergy(t *testing.T) { ctrl := gomock.NewController(t) mm := api.NewMockMeter(ctrl) - me := api.NewMockMeterEnergy(ctrl) + me := api.NewMockMeterImport(ctrl) rater := api.NewMockChargeRater(ctrl) type EnergyDecorator struct { api.Meter - api.MeterEnergy + api.MeterImport } cm := &EnergyDecorator{ Meter: mm, - MeterEnergy: me, + MeterImport: me, } lp := &Loadpoint{ @@ -296,17 +296,17 @@ func TestFinalizeSessionEnergy(t *testing.T) { t.Run("corrects session when ChargedEnergy increased", func(t *testing.T) { lp, me, rater := setup(t) - me.EXPECT().TotalEnergy().Return(9157.3, nil) + me.EXPECT().ImportEnergy().Return(9157.3, nil) lp.createSession() lp.session.Created = lp.clock.Now() lp.energyMetrics.Update(15.3) - me.EXPECT().TotalEnergy().Return(9164.0, nil) + me.EXPECT().ImportEnergy().Return(9164.0, nil) lp.stopSession() require.Equal(t, 15.3, lp.session.ChargedEnergy) rater.EXPECT().ChargedEnergy().Return(16.2, nil) - me.EXPECT().TotalEnergy().Return(9173.5, nil) + me.EXPECT().ImportEnergy().Return(9173.5, nil) lp.finalizeSessionEnergy() assert.Equal(t, 16.2, lp.session.ChargedEnergy) @@ -317,12 +317,12 @@ func TestFinalizeSessionEnergy(t *testing.T) { t.Run("no-op when ChargedEnergy unchanged", func(t *testing.T) { lp, me, rater := setup(t) - me.EXPECT().TotalEnergy().Return(9154.4, nil) + me.EXPECT().ImportEnergy().Return(9154.4, nil) lp.createSession() lp.session.Created = lp.clock.Now() lp.energyMetrics.Update(15.3) - me.EXPECT().TotalEnergy().Return(9164.0, nil) + me.EXPECT().ImportEnergy().Return(9164.0, nil) lp.stopSession() require.Equal(t, 15.3, lp.session.ChargedEnergy) diff --git a/core/metrics/accumulator_test.go b/core/metrics/accumulator_test.go index 62b496214..0de3ee1d4 100644 --- a/core/metrics/accumulator_test.go +++ b/core/metrics/accumulator_test.go @@ -9,7 +9,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestMeterEnergyMeterTotal(t *testing.T) { +func TestMeterImportMeterTotal(t *testing.T) { clock := clock.NewMock() clock.Set(now.BeginningOfDay()) @@ -23,7 +23,7 @@ func TestMeterEnergyMeterTotal(t *testing.T) { assert.Equal(t, 1.0, me.Imported()) } -func TestMeterEnergyAddPower(t *testing.T) { +func TestMeterImportAddPower(t *testing.T) { clock := clock.NewMock() clock.Set(now.BeginningOfDay()) diff --git a/core/site.go b/core/site.go index 8f3c39d14..58b576678 100644 --- a/core/site.go +++ b/core/site.go @@ -370,7 +370,7 @@ func meterCapabilities(name string, meter any) string { panic("not a meter: " + name) } - energy := api.HasCap[api.MeterEnergy](meter) + energy := api.HasCap[api.MeterImport](meter) || api.HasCap[api.MeterExport](meter) currents := api.HasCap[api.PhaseCurrents](meter) name += ":" @@ -455,7 +455,7 @@ func (site *Site) DumpConfig() { lp.log.INFO.Printf(" mode: %s", lp.GetMode()) _, power := api.Cap[api.Meter](lp.charger) - _, energy := api.Cap[api.MeterEnergy](lp.charger) + _, energy := api.Cap[api.MeterImport](lp.charger) _, currents := api.Cap[api.PhaseCurrents](lp.charger) _, phases := api.Cap[api.PhaseSwitcher](lp.charger) _, wakeup := api.Cap[api.Resurrector](lp.charger) @@ -516,10 +516,19 @@ func (site *Site) collectMeters(key string, meters []config.Device[api.Meter]) [ site.log.ERROR.Printf("%s %d power: %v", key, i+1, err) } - // energy (production) + // energy (production for pv/battery, consumption for aux/ext) var energy float64 - if m, ok := api.Cap[api.MeterEnergy](meter); err == nil && ok { - energy, err = m.TotalEnergy() + if err == nil { + switch key { + case "pv", "battery": + if m, ok := api.Cap[api.MeterExport](meter); ok { + energy, err = m.ExportEnergy() + } + default: + if m, ok := api.Cap[api.MeterImport](meter); ok { + energy, err = m.ImportEnergy() + } + } if err != nil { site.log.ERROR.Printf("%s %d energy: %v", key, i+1, err) } @@ -786,8 +795,8 @@ func (site *Site) updateGridMeter() error { // grid energy (import) var importEnergy *float64 - if energyMeter, ok := api.Cap[api.MeterEnergy](site.gridMeter); ok { - if f, err := energyMeter.TotalEnergy(); err == nil { + if energyMeter, ok := api.Cap[api.MeterImport](site.gridMeter); ok { + if f, err := energyMeter.ImportEnergy(); err == nil { mm.Energy = f importEnergy = &f } else { diff --git a/core/wrapper/chargerater.go b/core/wrapper/chargerater.go index 939f234f9..74a77a741 100644 --- a/core/wrapper/chargerater.go +++ b/core/wrapper/chargerater.go @@ -12,7 +12,7 @@ import ( ) // ChargeRater is responsible for providing charged energy amount -// by implementing api.ChargeRater. It uses the charge meter's TotalEnergy or +// by implementing api.ChargeRater. It uses the charge meter's ImportEnergy or // keeps track of consumed energy by regularly updating consumed power. type ChargeRater struct { sync.Mutex @@ -39,19 +39,19 @@ func NewChargeRater(log *util.Logger, meter api.Meter) *ChargeRater { } } -// StartCharge records meter start energy. If meter does not supply TotalEnergy, +// StartCharge records meter start energy. If meter does not supply ImportEnergy, // start time is recorded and charged energy set to zero. func (cr *ChargeRater) StartCharge(continued bool) { cr.Lock() defer cr.Unlock() - // time is needed if MeterEnergy is not supported + // time is needed if MeterImport is not supported cr.start = cr.clck.Now() cr.startEnergy = nil // get end energy amount - if m, ok := api.Cap[api.MeterEnergy](cr.meter); ok { - if f, err := m.TotalEnergy(); err == nil { + if m, ok := api.Cap[api.MeterImport](cr.meter); ok { + if f, err := m.ImportEnergy(); err == nil { cr.startEnergy = &f cr.log.DEBUG.Printf("charge start energy: %.3fkWh", f) } else if !loadpoint.AcceptableError(err) { @@ -66,7 +66,7 @@ func (cr *ChargeRater) StartCharge(continued bool) { } } -// StopCharge records meter stop energy. If meter does not supply TotalEnergy, +// StopCharge records meter stop energy. If meter does not supply ImportEnergy, // stop time is recorded and accumulating energy though SetChargePower stopped. func (cr *ChargeRater) StopCharge() { cr.Lock() @@ -75,8 +75,8 @@ func (cr *ChargeRater) StopCharge() { cr.charging = false // get end energy amount - if m, ok := api.Cap[api.MeterEnergy](cr.meter); ok { - if f, err := m.TotalEnergy(); err == nil { + if m, ok := api.Cap[api.MeterImport](cr.meter); ok { + if f, err := m.ImportEnergy(); err == nil { if cr.startEnergy != nil { cr.chargedEnergy += f - *cr.startEnergy } @@ -95,8 +95,8 @@ func (cr *ChargeRater) ResetCharge() { defer cr.Unlock() // get end energy amount - if m, ok := api.Cap[api.MeterEnergy](cr.meter); ok { - if f, err := m.TotalEnergy(); err == nil { + if m, ok := api.Cap[api.MeterImport](cr.meter); ok { + if f, err := m.ImportEnergy(); err == nil { if cr.startEnergy != nil { cr.chargedEnergy += f - *cr.startEnergy cr.log.DEBUG.Printf("charge final energy: %.3fkWh", cr.chargedEnergy) @@ -122,7 +122,7 @@ func (cr *ChargeRater) SetChargePower(power float64) { } // update energy amount if not provided by meter - if !api.HasCap[api.MeterEnergy](cr.meter) { + if !api.HasCap[api.MeterImport](cr.meter) { // convert power to energy in kWh cr.chargedEnergy += power / 1e3 * float64(cr.clck.Since(cr.start)) / float64(time.Hour) // move timestamp @@ -142,13 +142,13 @@ func (cr *ChargeRater) ChargedEnergy() (float64, error) { } // get current energy amount - if m, ok := api.Cap[api.MeterEnergy](cr.meter); ok { - f, err := m.TotalEnergy() + if m, ok := api.Cap[api.MeterImport](cr.meter); ok { + f, err := m.ImportEnergy() if err != nil { return 0, fmt.Errorf("charge total import: %v", err) } - // late-latch baseline if StartCharge could not read TotalEnergy + // late-latch baseline if StartCharge could not read ImportEnergy // (e.g. OCPP transaction recovery before first MeterValues frame) if cr.startEnergy == nil { cr.startEnergy = &f diff --git a/core/wrapper/chargerater_test.go b/core/wrapper/chargerater_test.go index 9bc6c7628..29e12ee2a 100644 --- a/core/wrapper/chargerater_test.go +++ b/core/wrapper/chargerater_test.go @@ -62,20 +62,20 @@ func TestWrappedMeter(t *testing.T) { defer ctrl.Finish() mm := api.NewMockMeter(ctrl) - me := api.NewMockMeterEnergy(ctrl) + me := api.NewMockMeterImport(ctrl) type EnergyDecorator struct { api.Meter - api.MeterEnergy + api.MeterImport } - cm := &EnergyDecorator{Meter: mm, MeterEnergy: me} + cm := &EnergyDecorator{Meter: mm, MeterImport: me} cr := NewChargeRater(util.NewLogger("foo"), cm) clck := clock.NewMock() cr.clck = clck - me.EXPECT().TotalEnergy().Return(2.0, nil) + me.EXPECT().ImportEnergy().Return(2.0, nil) cr.StartCharge(false) @@ -85,7 +85,7 @@ func TestWrappedMeter(t *testing.T) { clck.Add(time.Hour) cr.SetChargePower(0) - me.EXPECT().TotalEnergy().Return(3.0, nil) + me.EXPECT().ImportEnergy().Return(3.0, nil) cr.StopCharge() @@ -98,12 +98,12 @@ func TestWrappedMeter(t *testing.T) { cr.SetChargePower(1e3) // continue - me.EXPECT().TotalEnergy().Return(10.0, nil) + me.EXPECT().ImportEnergy().Return(10.0, nil) cr.StartCharge(true) clck.Add(time.Hour) // actual timing ignored as energy comes from meter - me.EXPECT().TotalEnergy().Return(12.0, nil) + me.EXPECT().ImportEnergy().Return(12.0, nil) cr.StopCharge() @@ -114,53 +114,53 @@ func TestWrappedMeter(t *testing.T) { // TestDeferredBaseline covers the OCPP transaction-recovery case: the meter is // not yet readable when StartCharge fires, so the baseline must be latched on -// the first successful TotalEnergy() read instead of defaulting to zero +// the first successful ImportEnergy() read instead of defaulting to zero // (which would cause the lifetime register to be reported as session energy). func TestDeferredBaseline(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() mm := api.NewMockMeter(ctrl) - me := api.NewMockMeterEnergy(ctrl) + me := api.NewMockMeterImport(ctrl) type EnergyDecorator struct { api.Meter - api.MeterEnergy + api.MeterImport } - cm := &EnergyDecorator{Meter: mm, MeterEnergy: me} + cm := &EnergyDecorator{Meter: mm, MeterImport: me} cr := NewChargeRater(util.NewLogger("foo"), cm) clck := clock.NewMock() cr.clck = clck // meter not yet available at StartCharge — recovered transaction before first MeterValues - me.EXPECT().TotalEnergy().Return(0.0, errors.New("not available")) + me.EXPECT().ImportEnergy().Return(0.0, errors.New("not available")) cr.StartCharge(true) // first read also fails — must surface the error, not a bogus delta - me.EXPECT().TotalEnergy().Return(0.0, errors.New("not available")) + me.EXPECT().ImportEnergy().Return(0.0, errors.New("not available")) if _, err := cr.ChargedEnergy(); err == nil { t.Errorf("expected error while meter unavailable") } // first successful read latches the baseline (lifetime register, e.g. 939 kWh) - me.EXPECT().TotalEnergy().Return(939.080, nil) + me.EXPECT().ImportEnergy().Return(939.080, nil) if f, err := cr.ChargedEnergy(); f != 0 || err != nil { t.Errorf("expected 0 on baseline-latch read, got %.3f %v", f, err) } // subsequent reads return delta against the latched baseline - me.EXPECT().TotalEnergy().Return(942.080, nil) + me.EXPECT().ImportEnergy().Return(942.080, nil) if f, err := cr.ChargedEnergy(); f != 3 || err != nil { t.Errorf("expected 3kWh delta, got %.3f %v", f, err) } - me.EXPECT().TotalEnergy().Return(944.080, nil) + me.EXPECT().ImportEnergy().Return(944.080, nil) cr.StopCharge() diff --git a/meter/_blueprint.go b/meter/_blueprint.go index 030b5b11d..db3be03a2 100644 --- a/meter/_blueprint.go +++ b/meter/_blueprint.go @@ -49,10 +49,10 @@ func (m *Blueprint) CurrentPower() (float64, error) { return 0, api.ErrNotAvailable } -var _ api.MeterEnergy = (*Blueprint)(nil) +var _ api.MeterImport = (*Blueprint)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (m *Blueprint) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (m *Blueprint) ImportEnergy() (float64, error) { return 0, api.ErrNotAvailable } diff --git a/meter/cfos.go b/meter/cfos.go index c350ef95f..57740754a 100644 --- a/meter/cfos.go +++ b/meter/cfos.go @@ -67,10 +67,10 @@ func (wb *CfosPowerBrain) CurrentPower() (float64, error) { return float64(binary.BigEndian.Uint32(b)), err } -var _ api.MeterEnergy = (*CfosPowerBrain)(nil) +var _ api.MeterImport = (*CfosPowerBrain)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (wb *CfosPowerBrain) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (wb *CfosPowerBrain) ImportEnergy() (float64, error) { b, err := wb.conn.ReadHoldingRegisters(cfosRegEnergy, 4) if err != nil { return 0, err diff --git a/meter/danfoss.go b/meter/danfoss.go index 75816e940..d3ac72f58 100644 --- a/meter/danfoss.go +++ b/meter/danfoss.go @@ -103,7 +103,7 @@ func NewDanfossTLX(ctx context.Context, cfg comlynx.Config, maxACPower func() fl } if hasEnergy == nil { - implement.Has(m, implement.MeterEnergy(m.totalEnergy)) + implement.Has(m, implement.MeterImport(m.totalEnergy)) } if hasVoltages == nil { implement.Has(m, implement.PhaseVoltages(m.phaseVoltages)) diff --git a/meter/discovergy.go b/meter/discovergy.go index 1c4c28bdb..1336e309e 100644 --- a/meter/discovergy.go +++ b/meter/discovergy.go @@ -100,9 +100,9 @@ func (m *Discovergy) CurrentPower() (float64, error) { return m.scale * float64(res.Values.Power) / 1e3, err } -var _ api.MeterEnergy = (*Discovergy)(nil) +var _ api.MeterImport = (*Discovergy)(nil) -func (m *Discovergy) TotalEnergy() (float64, error) { +func (m *Discovergy) ImportEnergy() (float64, error) { res, err := m.dataG() return float64(res.Values.Energy) / 1e10, err } diff --git a/meter/dsmr.go b/meter/dsmr.go index 696cb14d8..312a5cc5e 100644 --- a/meter/dsmr.go +++ b/meter/dsmr.go @@ -116,7 +116,7 @@ func NewDsmr(uri, energy string, timeout time.Duration) (api.Meter, error) { // decorate energy reading if energy != "" { - implement.Has(m, implement.MeterEnergy(m.totalEnergy)) + implement.Has(m, implement.MeterImport(m.totalEnergy)) } // decorate currents @@ -284,7 +284,7 @@ func (m *Dsmr) CurrentPower() (float64, error) { return (bezug - lief) * 1e3, errors.Join(err1, err2) } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (m *Dsmr) totalEnergy() (float64, error) { return m.get(m.energy) } diff --git a/meter/eebus.go b/meter/eebus.go index 383951c7b..5be2f46e2 100644 --- a/meter/eebus.go +++ b/meter/eebus.go @@ -176,9 +176,9 @@ func (c *EEBus) CurrentPower() (float64, error) { return c.readValue(c.scenarios.power, c.mm.Power) } -var _ api.MeterEnergy = (*EEBus)(nil) +var _ api.MeterImport = (*EEBus)(nil) -func (c *EEBus) TotalEnergy() (float64, error) { +func (c *EEBus) ImportEnergy() (float64, error) { return c.readValue(c.scenarios.energy, c.mm.EnergyConsumed) } diff --git a/meter/fritz/aha/aha.go b/meter/fritz/aha/aha.go index 8341585b4..6d1cf3257 100644 --- a/meter/fritz/aha/aha.go +++ b/meter/fritz/aha/aha.go @@ -91,10 +91,10 @@ func (c *Connection) CurrentPower() (float64, error) { return power / 1000, err // mW ==> W } -var _ api.MeterEnergy = (*Connection)(nil) +var _ api.MeterImport = (*Connection)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *Connection) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *Connection) ImportEnergy() (float64, error) { // Energy value in Wh (total switch energy, refresh approximately every 2 minutes) resp, err := c.ExecCmd("getswitchenergy") if err != nil { diff --git a/meter/fritz/api.go b/meter/fritz/api.go index 371f241ac..b00d6eeb8 100644 --- a/meter/fritz/api.go +++ b/meter/fritz/api.go @@ -3,7 +3,7 @@ package fritz // Meter defines the interface for Fritz connections (both legacy LUA and REST) type Meter interface { CurrentPower() (float64, error) - TotalEnergy() (float64, error) + ImportEnergy() (float64, error) } // Switch extends Meter with switch control capabilities diff --git a/meter/fritz/smarthome/smarthome.go b/meter/fritz/smarthome/smarthome.go index ef9db252a..f975a3480 100644 --- a/meter/fritz/smarthome/smarthome.go +++ b/meter/fritz/smarthome/smarthome.go @@ -138,10 +138,10 @@ func (c *Connection) CurrentPower() (float64, error) { return 0, api.ErrNotAvailable } -var _ api.MeterEnergy = (*Connection)(nil) +var _ api.MeterImport = (*Connection)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *Connection) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *Connection) ImportEnergy() (float64, error) { unit, err := c.unitG.Get() if err != nil { return 0, err diff --git a/meter/homeassistant.go b/meter/homeassistant.go index 58c14175b..64fb3d954 100644 --- a/meter/homeassistant.go +++ b/meter/homeassistant.go @@ -89,7 +89,7 @@ func NewHomeAssistantFromConfig(other map[string]any) (api.Meter, error) { powersG = func() (float64, float64, float64, error) { return conn.GetPhaseFloatStates(phases) } } - implement.May(m, implement.MeterEnergy(energyG)) + implement.May(m, implement.MeterImport(energyG)) if cc.Soc != "" { socG := func() (float64, error) { return conn.GetFloatState(cc.Soc) } diff --git a/meter/homematic.go b/meter/homematic.go index ef71a453d..0ce059fc4 100644 --- a/meter/homematic.go +++ b/meter/homematic.go @@ -63,12 +63,12 @@ func (c *CCU) CurrentPower() (float64, error) { return c.conn.CurrentPower() } -var _ api.MeterEnergy = (*CCU)(nil) +var _ api.MeterImport = (*CCU)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *CCU) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *CCU) ImportEnergy() (float64, error) { if c.usage == "grid" { - return c.conn.GridTotalEnergy() + return c.conn.GridImportEnergy() } - return c.conn.TotalEnergy() + return c.conn.ImportEnergy() } diff --git a/meter/homematic/connection.go b/meter/homematic/connection.go index 59083d1f8..7efbebb24 100644 --- a/meter/homematic/connection.go +++ b/meter/homematic/connection.go @@ -91,8 +91,8 @@ func (c *Connection) CurrentPower() (float64, error) { return res.FloatValue("POWER"), err } -// TotalEnergy reads the homematic HMIP-PSM meterchannel energy in Wh -func (c *Connection) TotalEnergy() (float64, error) { +// ImportEnergy reads the homematic HMIP-PSM meterchannel energy in Wh +func (c *Connection) ImportEnergy() (float64, error) { res, err := c.meterG.Get() return res.FloatValue("ENERGY_COUNTER") / 1e3, err } @@ -109,8 +109,8 @@ func (c *Connection) GridCurrentPower() (float64, error) { return res.FloatValue("IEC_POWER"), err } -// GridTotalEnergy reads the homematic HM-ES-TX-WM grid meterchannel energy in kWh -func (c *Connection) GridTotalEnergy() (float64, error) { +// GridImportEnergy reads the homematic HM-ES-TX-WM grid meterchannel energy in kWh +func (c *Connection) GridImportEnergy() (float64, error) { res, err := c.meterG.Get() return res.FloatValue("IEC_ENERGY_COUNTER"), err } diff --git a/meter/homewizard.go b/meter/homewizard.go index 7e72b7cd8..60b83cc0e 100644 --- a/meter/homewizard.go +++ b/meter/homewizard.go @@ -56,11 +56,11 @@ func (c *HomeWizard) CurrentPower() (float64, error) { return c.conn.CurrentPower() } -var _ api.MeterEnergy = (*HomeWizard)(nil) +var _ api.MeterImport = (*HomeWizard)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *HomeWizard) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *HomeWizard) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } var _ api.PhaseCurrents = (*HomeWizard)(nil) diff --git a/meter/homewizard/connection.go b/meter/homewizard/connection.go index 526712ef9..5683b9c29 100644 --- a/meter/homewizard/connection.go +++ b/meter/homewizard/connection.go @@ -107,8 +107,8 @@ func (c *Connection) CurrentPower() (float64, error) { return res.ActivePowerW, err } -// TotalEnergy implements the api.MeterEnergy interface -func (c *Connection) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *Connection) ImportEnergy() (float64, error) { res, err := c.dataG.Get() if c.usage == "pv" { return res.TotalPowerExportT1kWh + res.TotalPowerExportT2kWh + res.TotalPowerExportT3kWh + res.TotalPowerExportT4kWh, err diff --git a/meter/lgess.go b/meter/lgess.go index 2052530f9..f2710dd48 100644 --- a/meter/lgess.go +++ b/meter/lgess.go @@ -77,7 +77,7 @@ func NewLgEss(uri, usage, registration, password string, cache time.Duration, ba implement.May(m, implement.BatteryPowerLimiter(batteryPowerLimits.Decorator())) if m.usage == "grid" && essType != lgpcs.LgEss15 { - implement.Has(m, implement.MeterEnergy(m.totalEnergy)) + implement.Has(m, implement.MeterImport(m.totalEnergy)) } if usage == "battery" { @@ -111,7 +111,7 @@ func (m *LgEss) CurrentPower() (float64, error) { } } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (m *LgEss) totalEnergy() (float64, error) { data, err := m.conn.Data() if err != nil { diff --git a/meter/mbmd.go b/meter/mbmd.go index be773b5b9..c6a4c1762 100644 --- a/meter/mbmd.go +++ b/meter/mbmd.go @@ -100,7 +100,7 @@ func NewMbmdFromConfig(ctx context.Context, other map[string]any) (api.Meter, er if err != nil { return nil, fmt.Errorf("invalid measurement for energy: %s", cc.Energy) } - implement.Has(m, implement.MeterEnergy(totalEnergy)) + implement.Has(m, implement.MeterImport(totalEnergy)) } // decorate soc diff --git a/meter/measurement/energy.go b/meter/measurement/energy.go index 658a91460..e4b41b29d 100644 --- a/meter/measurement/energy.go +++ b/meter/measurement/energy.go @@ -9,23 +9,47 @@ import ( type Energy struct { Power plugin.Config - Energy *plugin.Config // optional + Import *plugin.Config // optional + Export *plugin.Config // optional + // Energy is a legacy alias used when neither Import nor Export is set. + // For meters, the same value is wired to both interfaces and the site role + // (pv/battery → Export; grid/aux/ext → Import) decides which one is read. + Energy *plugin.Config } 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) + // legacy: a single energy field is exposed as both import and export; + // the site role decides which interface is used. + importCfg := cc.Import + exportCfg := cc.Export + if cc.Energy != nil { + if importCfg == nil { + importCfg = cc.Energy + } + if exportCfg == nil { + exportCfg = cc.Energy + } + } + + importG, err := importCfg.FloatGetter(ctx) if err != nil { - return nil, nil, fmt.Errorf("energy: %w", err) + return nil, nil, nil, fmt.Errorf("import: %w", err) } - return powerG, energyG, nil + exportG, err := exportCfg.FloatGetter(ctx) + if err != nil { + return nil, nil, nil, fmt.Errorf("export: %w", err) + } + + return powerG, importG, exportG, nil } diff --git a/meter/meter.go b/meter/meter.go index 21b265c4a..dae579cb1 100644 --- a/meter/meter.go +++ b/meter/meter.go @@ -42,13 +42,14 @@ func NewConfigurableFromConfig(ctx context.Context, other map[string]any) (api.M return nil, err } - powerG, energyG, err := cc.Energy.Configure(ctx) + powerG, importG, exportG, err := cc.Energy.Configure(ctx) if err != nil { return nil, err } m, _ := NewConfigurable(powerG) - implement.May(m, implement.MeterEnergy(energyG)) + implement.May(m, implement.MeterImport(importG)) + implement.May(m, implement.MeterExport(exportG)) // decorate soc socG, err := cc.Soc.FloatGetter(ctx) diff --git a/meter/meter_average.go b/meter/meter_average.go index f217f75ae..5d1690ddd 100644 --- a/meter/meter_average.go +++ b/meter/meter_average.go @@ -41,10 +41,16 @@ func NewMovingAverageFromConfig(ctx context.Context, other map[string]any) (api. meter, _ := NewConfigurable(mav.CurrentPower) - // decorate energy reading - var totalEnergy func() (float64, error) - if m, ok := api.Cap[api.MeterEnergy](m); ok { - totalEnergy = m.TotalEnergy + // decorate import reading + var importEnergy func() (float64, error) + if m, ok := api.Cap[api.MeterImport](m); ok { + importEnergy = m.ImportEnergy + } + + // decorate export reading + var exportEnergy func() (float64, error) + if m, ok := api.Cap[api.MeterExport](m); ok { + exportEnergy = m.ExportEnergy } // decorate battery reading @@ -71,7 +77,8 @@ func NewMovingAverageFromConfig(ctx context.Context, other map[string]any) (api. powers = m.Powers } - implement.May(meter, implement.MeterEnergy(totalEnergy)) + implement.May(meter, implement.MeterImport(importEnergy)) + implement.May(meter, implement.MeterExport(exportEnergy)) if batterySoc != nil { implement.Has(meter, implement.Battery(batterySoc)) diff --git a/meter/powerwall.go b/meter/powerwall.go index c84d1e2df..6c36ba0f7 100644 --- a/meter/powerwall.go +++ b/meter/powerwall.go @@ -142,8 +142,12 @@ func NewPowerWall(uri, usage, user, password string, cache time.Duration, refres m.energySite = energySite } - if m.usage == "load" || m.usage == "solar" { - implement.Has(m, implement.MeterEnergy(m.totalEnergy)) + if m.usage == "load" { + implement.Has(m, implement.MeterImport(m.totalEnergy)) + } + + if m.usage == "solar" { + implement.Has(m, implement.MeterExport(m.totalEnergy)) } if usage == "battery" { @@ -193,7 +197,7 @@ func (m *PowerWall) CurrentPower() (float64, error) { return 0, fmt.Errorf("invalid usage: %s", m.usage) } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy returns import (load) or export (solar) energy depending on usage func (m *PowerWall) totalEnergy() (float64, error) { res, err := m.meterG() if err != nil { diff --git a/meter/rct.go b/meter/rct.go index 1b58a4c41..f1507f7be 100644 --- a/meter/rct.go +++ b/meter/rct.go @@ -100,7 +100,7 @@ func NewRCT(ctx context.Context, uri, usage string, batterySocLimits batterySocL } if usage == "grid" { - implement.Has(m, implement.MeterEnergy(m.totalEnergy)) + implement.Has(m, implement.MeterImport(m.totalEnergy)) } if usage == "pv" { @@ -264,7 +264,7 @@ func (m *RCT) CurrentPower() (float64, error) { } } -// totalEnergy implements the api.MeterEnergy interface +// totalEnergy implements the api.MeterImport interface func (m *RCT) totalEnergy() (float64, error) { switch m.usage { case "grid": diff --git a/meter/shelly/connection.go b/meter/shelly/connection.go index 180614023..c80dc6ff7 100644 --- a/meter/shelly/connection.go +++ b/meter/shelly/connection.go @@ -15,7 +15,7 @@ type Generation interface { CurrentPower() (float64, error) Enabled() (bool, error) Enable(bool) error - TotalEnergy() (float64, error) + ImportEnergy() (float64, error) } type Phases interface { diff --git a/meter/shelly/gen1.go b/meter/shelly/gen1.go index 512111f28..804b59657 100644 --- a/meter/shelly/gen1.go +++ b/meter/shelly/gen1.go @@ -106,7 +106,7 @@ func (c *gen1) Enable(enable bool) error { return c.GetJSON(uri, &res) } -func (c *gen1) TotalEnergy() (float64, error) { +func (c *gen1) ImportEnergy() (float64, error) { var energy float64 res, err := c.status.Get() if err != nil { diff --git a/meter/shelly/gen2.go b/meter/shelly/gen2.go index 58209b2e1..f5f835160 100644 --- a/meter/shelly/gen2.go +++ b/meter/shelly/gen2.go @@ -219,8 +219,8 @@ func (c *gen2) Enable(enable bool) error { return c.execEnableCmd(c.switchchannel, "Switch.Set", enable, &res) } -// TotalEnergy implements the api.Meter interface -func (c *gen2) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *gen2) ImportEnergy() (float64, error) { switch { case c.hasEM1Endpoint(): res, err := c.em1data() diff --git a/meter/sma.go b/meter/sma.go index 2ae5d59fe..92df4b884 100644 --- a/meter/sma.go +++ b/meter/sma.go @@ -87,7 +87,7 @@ func NewSMA(uri, password, iface string, serial uint32, scale float64, usage str go sm.device.Run() if usage == "battery" { - implement.May(sm, implement.MeterEnergy(sm.TotalEnergy)) + implement.May(sm, implement.MeterExport(sm.ExportEnergy)) implement.Has(sm, implement.Battery(sm.soc)) implement.May(sm, implement.BatteryCapacity(capacity)) implement.May(sm, implement.BatterySocLimiter(batterySocLimits)) @@ -103,10 +103,10 @@ func (sm *SMA) CurrentPower() (float64, error) { return sm.scale * (sma.AsFloat(values[sunny.ActivePowerPlus]) - sma.AsFloat(values[sunny.ActivePowerMinus])), err } -var _ api.MeterEnergy = (*SMA)(nil) +var _ api.MeterExport = (*SMA)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (sm *SMA) TotalEnergy() (float64, error) { +// ExportEnergy implements the api.MeterExport interface +func (sm *SMA) ExportEnergy() (float64, error) { values, err := sm.device.Values() if sm.scale < 0 { return sma.AsFloat(values[sunny.ActiveEnergyMinus]) / 3600000, err diff --git a/meter/tasmota.go b/meter/tasmota.go index 58aa21aae..45b9443b0 100644 --- a/meter/tasmota.go +++ b/meter/tasmota.go @@ -89,11 +89,11 @@ func (c *Tasmota) CurrentPower() (float64, error) { return power, nil } -var _ api.MeterEnergy = (*Tasmota)(nil) +var _ api.MeterImport = (*Tasmota)(nil) -// TotalEnergy implements the api.MeterEnergy interface -func (c *Tasmota) TotalEnergy() (float64, error) { - return c.conn.TotalEnergy() +// ImportEnergy implements the api.MeterImport interface +func (c *Tasmota) ImportEnergy() (float64, error) { + return c.conn.ImportEnergy() } // powers implements the api.PhasePowers interface diff --git a/meter/tasmota/connection.go b/meter/tasmota/connection.go index 2339a0157..f9ba6395d 100644 --- a/meter/tasmota/connection.go +++ b/meter/tasmota/connection.go @@ -222,8 +222,8 @@ func (c *Connection) CurrentPower() (float64, error) { return res, nil } -// TotalEnergy implements the api.MeterEnergy interface -func (c *Connection) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (c *Connection) ImportEnergy() (float64, error) { res, err := c.statusSnsG.Get() if err != nil { return 0, err diff --git a/meter/tplink/connection.go b/meter/tplink/connection.go index cd7c2d316..c7917da0e 100644 --- a/meter/tplink/connection.go +++ b/meter/tplink/connection.go @@ -94,8 +94,8 @@ func (d *Connection) CurrentPower() (float64, error) { return power, nil } -// TotalEnergy implements the api.MeterEnergy interface -func (d *Connection) TotalEnergy() (float64, error) { +// ImportEnergy implements the api.MeterImport interface +func (d *Connection) ImportEnergy() (float64, error) { var res EmeterResponse if err := d.ExecCmd(`{"emeter":{"get_realtime":null}}`, &res); err != nil { return 0, err diff --git a/meter/tq-em.go b/meter/tq-em.go index 86885d0ee..dce9cd201 100644 --- a/meter/tq-em.go +++ b/meter/tq-em.go @@ -143,9 +143,9 @@ func (m *TqEm) CurrentPower() (float64, error) { return res.Obis1_4_0 - res.Obis2_4_0, err } -var _ api.MeterEnergy = (*TqEm)(nil) +var _ api.MeterImport = (*TqEm)(nil) -func (m *TqEm) TotalEnergy() (float64, error) { +func (m *TqEm) ImportEnergy() (float64, error) { res, err := m.dataG() return res.Obis1_8_0 / 1e3, err } diff --git a/meter/tq-em420.go b/meter/tq-em420.go index 450efd547..092ec4aa2 100644 --- a/meter/tq-em420.go +++ b/meter/tq-em420.go @@ -146,9 +146,9 @@ func (m *TqEM420) CurrentPower() (float64, error) { return (res.SmartMeter.Values.ActivePowerP - res.SmartMeter.Values.ActivePowerM) / 1e3, err } -var _ api.MeterEnergy = (*TqEM420)(nil) +var _ api.MeterImport = (*TqEM420)(nil) -func (m *TqEM420) TotalEnergy() (float64, error) { +func (m *TqEM420) ImportEnergy() (float64, error) { res, err := m.dataG() return res.SmartMeter.Values.ActiveEnergyP / 1e6, err } diff --git a/plugin/meter.go b/plugin/meter.go index a59d89fa7..4ba89e20a 100644 --- a/plugin/meter.go +++ b/plugin/meter.go @@ -55,7 +55,7 @@ func (o *meterPlugin) FloatGetter() (func() (float64, error), error) { switch o.method { case Energy: - if !api.HasCap[api.MeterEnergy](o.meter) { + if !api.HasCap[api.MeterImport](o.meter) && !api.HasCap[api.MeterExport](o.meter) { return nil, err } case Soc: @@ -67,8 +67,12 @@ func (o *meterPlugin) FloatGetter() (func() (float64, error), error) { return func() (float64, error) { switch o.method { case Energy: - m, _ := api.Cap[api.MeterEnergy](o.meter) - f, err := m.TotalEnergy() + if m, ok := api.Cap[api.MeterImport](o.meter); ok { + f, err := m.ImportEnergy() + return f * o.scale, err + } + m, _ := api.Cap[api.MeterExport](o.meter) + f, err := m.ExportEnergy() return f * o.scale, err case Soc: m, _ := api.Cap[api.Battery](o.meter) diff --git a/server/http_config_helper.go b/server/http_config_helper.go index 921449c55..6570fc391 100644 --- a/server/http_config_helper.go +++ b/server/http_config_helper.go @@ -274,8 +274,11 @@ func testInstance(instance any) map[string]testResult { makeResult("power", val, err) } - if dev, ok := api.Cap[api.MeterEnergy](instance); ok { - val, err := dev.TotalEnergy() + if dev, ok := api.Cap[api.MeterImport](instance); ok { + val, err := dev.ImportEnergy() + makeResult("energy", val, err) + } else if dev, ok := api.Cap[api.MeterExport](instance); ok { + val, err := dev.ExportEnergy() makeResult("energy", val, err) }