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

Cleanup api naming, rename phase measurement apis (#5611)

Browse source
This commit is contained in:
andig 2022-12-29 20:12:24 +01:00 • committed by GitHub
parent def5886c0a
commit 89ffe53b1e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
76 changed files with 2564 additions and 2555 deletions
Download patch file Download diff file Expand all files Collapse all files

51
api/actionconfig.go Normal file
View file

@ -0,0 +1,51 @@
package api
import (
"fmt"
"reflect"
"strings"
"github.com/fatih/structs"
)
// ActionConfig defines an action to take on event
type ActionConfig struct {
Mode *ChargeMode `mapstructure:"mode,omitempty"` // Charge Mode
MinCurrent *float64 `mapstructure:"minCurrent,omitempty"` // Minimum Current
MaxCurrent *float64 `mapstructure:"maxCurrent,omitempty"` // Maximum Current
MinSoc *int `mapstructure:"minSoc,omitempty"` // Minimum Soc
TargetSoc *int `mapstructure:"targetSoc,omitempty"` // Target Soc
}
// Merge merges all non-nil properties of the additional config into the base config.
// The receiver's config remains immutable.
func (a ActionConfig) Merge(m ActionConfig) ActionConfig {
if m.Mode != nil {
a.Mode = m.Mode
}
if m.MinCurrent != nil {
a.MinCurrent = m.MinCurrent
}
if m.MaxCurrent != nil {
a.MaxCurrent = m.MaxCurrent
}
if m.MinSoc != nil {
a.MinSoc = m.MinSoc
}
if m.TargetSoc != nil {
a.TargetSoc = m.TargetSoc
}
return a
}
// String implements Stringer and returns the ActionConfig as comma-separated key:value string
func (a ActionConfig) String() string {
var s []string
for k, v := range structs.Map(a) {
val := reflect.ValueOf(v)
if v != nil && !val.IsNil() {
s = append(s, fmt.Sprintf("%s:%v", k, val.Elem()))
}
}
return strings.Join(s, ", ")
}

71
api/api.go
View file

@ -2,14 +2,9 @@ package api
import (
"context"
"fmt"
"io"
"net/http"
"reflect"
"strings"
"time"
"github.com/fatih/structs"
)
//go:generate mockgen -package mock -destination ../mock/mock_api.go github.com/evcc-io/evcc/api Charger,ChargeState,PhaseSwitcher,Identifier,Meter,MeterEnergy,Vehicle,ChargeRater,Battery,Tariff
@ -50,79 +45,37 @@ func (c ChargeStatus) String() string {
return string(c)
}
// ActionConfig defines an action to take on event
type ActionConfig struct {
Mode *ChargeMode `mapstructure:"mode,omitempty"` // Charge Mode
MinCurrent *float64 `mapstructure:"minCurrent,omitempty"` // Minimum Current
MaxCurrent *float64 `mapstructure:"maxCurrent,omitempty"` // Maximum Current
MinSoc *int `mapstructure:"minSoc,omitempty"` // Minimum Soc
TargetSoc *int `mapstructure:"targetSoc,omitempty"` // Target Soc
}
// Merge merges all non-nil properties of the additional config into the base config.
// The receiver's config remains immutable.
func (a ActionConfig) Merge(m ActionConfig) ActionConfig {
if m.Mode != nil {
a.Mode = m.Mode
}
if m.MinCurrent != nil {
a.MinCurrent = m.MinCurrent
}
if m.MaxCurrent != nil {
a.MaxCurrent = m.MaxCurrent
}
if m.MinSoc != nil {
a.MinSoc = m.MinSoc
}
if m.TargetSoc != nil {
a.TargetSoc = m.TargetSoc
}
return a
}
// String implements Stringer and returns the ActionConfig as comma-separated key:value string
func (a ActionConfig) String() string {
var s []string
for k, v := range structs.Map(a) {
val := reflect.ValueOf(v)
if v != nil && !val.IsNil() {
s = append(s, fmt.Sprintf("%s:%v", k, val.Elem()))
}
}
return strings.Join(s, ", ")
}
// Meter is able to provide total active power in W
// Meter provides total active power in W
type Meter interface {
CurrentPower() (float64, error)
}
// MeterEnergy is able to provide total energy in kWh
// MeterEnergy provides total energy in kWh
type MeterEnergy interface {
TotalEnergy() (float64, error)
}
// MeterCurrent is able to provide per-phase current A
type MeterCurrent interface {
// PhaseCurrents provides per-phase current A
type PhaseCurrents interface {
Currents() (float64, float64, float64, error)
}
// MeterVoltage is able to provide per-phase voltage V
type MeterVoltage interface {
// PhaseVoltages provides per-phase voltage V
type PhaseVoltages interface {
Voltages() (float64, float64, float64, error)
}
// MeterPower is able to provide signed per-phase power W
type MeterPower interface {
// PhasePowers provides signed per-phase power W
type PhasePowers interface {
Powers() (float64, float64, float64, error)
}
// Battery is able to provide battery Soc in %
// Battery provides battery Soc in %
type Battery interface {
Soc() (float64, error)
}
// BatteryCapacity provides a capacity in Wh
// BatteryCapacity provides a capacity in kWh
type BatteryCapacity interface {
Capacity() float64
}
@ -132,12 +85,12 @@ type ChargeState interface {
Status() (ChargeStatus, error)
}
// CurrentLimiter provides current charging status
// CurrentLimiter provides settings charging maximum charging current
type CurrentLimiter interface {
MaxCurrent(current int64) error
}
// Charger is able to provide current charging status and enable/disable charging
// Charger provides current charging status and enable/disable charging
type Charger interface {
ChargeState
Enabled() (bool, error)

29
api/impl.go → api/chargemode.go
View file

@ -2,10 +2,8 @@ package api
import (
"encoding"
"errors"
"fmt"
"strings"
"time"
)
// ChargeModeString converts string to ChargeMode
@ -38,30 +36,3 @@ func (c *ChargeMode) UnmarshalText(text []byte) error {
return nil
}
// Current returns the rates current rate or error
func (r Rates) Current(now time.Time) (Rate, error) {
for _, rr := range r {
if (rr.Start.Before(now) || rr.Start.Equal(now)) && rr.End.After(now) {
return rr, nil
}
}
return Rate{}, errors.New("no matching rate")
}
// implement sort.Interface
func (r Rates) Len() int {
return len(r)
}
func (r Rates) Less(i, j int) bool {
if r[i].Price == r[j].Price {
return r[i].Start.After(r[j].Start)
}
return r[i].Price < r[j].Price
}
func (r Rates) Swap(i, j int) {
r[i], r[j] = r[j], r[i]
}

34
api/rates.go Normal file
View file

@ -0,0 +1,34 @@
package api
import (
"errors"
"time"
)
// Current returns the rates current rate or error
func (r Rates) Current(now time.Time) (Rate, error) {
for _, rr := range r {
if (rr.Start.Before(now) || rr.Start.Equal(now)) && rr.End.After(now) {
return rr, nil
}
}
return Rate{}, errors.New("no matching rate")
}
// implement sort.Interface
func (r Rates) Len() int {
return len(r)
}
func (r Rates) Less(i, j int) bool {
if r[i].Price == r[j].Price {
return r[i].Start.After(r[j].Start)
}
return r[i].Price < r[j].Price
}
func (r Rates) Swap(i, j int) {
r[i], r[j] = r[j], r[i]
}

0
api/impl_test.go → api/rates_test.go
View file

4
charger/_blueprint.go
View file

@ -102,9 +102,9 @@ func (wb *Blueprint) TotalEnergy() (float64, error) {
return 0, api.ErrNotAvailable
}
var _ api.MeterCurrent = (*Blueprint)(nil)
var _ api.PhaseCurrents = (*Blueprint)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *Blueprint) Currents() (float64, float64, float64, error) {
return 0, 0, 0, api.ErrNotAvailable
}

8
charger/abb.go
View file

@ -209,9 +209,9 @@ func (wb *ABB) ChargedEnergy() (float64, error) {
return float64(binary.BigEndian.Uint32(b)) / 1e3, err
}
var _ api.MeterCurrent = (*ABB)(nil)
var _ api.PhaseCurrents = (*ABB)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *ABB) Currents() (float64, float64, float64, error) {
b, err := wb.conn.ReadHoldingRegisters(abbRegCurrents, 6)
if err != nil {
@ -226,9 +226,9 @@ func (wb *ABB) Currents() (float64, float64, float64, error) {
return curr[0], curr[1], curr[2], nil
}
var _ api.MeterVoltage = (*ABB)(nil)
var _ api.PhaseVoltages = (*ABB)(nil)
// Voltages implements the api.MeterVoltage interface
// Voltages implements the api.PhaseVoltages interface
func (wb *ABB) Voltages() (float64, float64, float64, error) {
b, err := wb.conn.ReadHoldingRegisters(abbRegVoltages, 6)
if err != nil {

4
charger/abl.go
View file

@ -91,7 +91,7 @@ func NewABLeMHFromConfig(other map[string]interface{}) (api.Charger, error) {
return NewABLeMH(cc.URI, cc.Device, cc.Comset, cc.Baudrate, cc.ID)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateABLeMH -b *ABLeMH -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateABLeMH -b *ABLeMH -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewABLeMH creates ABLeMH charger
func NewABLeMH(uri, device, comset string, baudrate int, slaveID uint8) (api.Charger, error) {
@ -220,7 +220,7 @@ func (wb *ABLeMH) currentPower() (float64, error) {
return 230 * (l1 + l2 + l3), err
}
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *ABLeMH) currents() (float64, float64, float64, error) {
b, err := wb.get(ablRegStatusLong, 5)
if err != nil {

30
charger/abl_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateABLeMH(base *ABLeMH, meter func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Charger {
func decorateABLeMH(base *ABLeMH, meter func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Charger {
switch {
case meter == nil && meterCurrent == nil:
case meter == nil && phaseCurrents == nil:
return base
case meter != nil && meterCurrent == nil:
case meter != nil && phaseCurrents == nil:
return &struct {
*ABLeMH
api.Meter
@ -22,29 +22,29 @@ func decorateABLeMH(base *ABLeMH, meter func() (float64, error), meterCurrent fu
},
}
case meter == nil && meterCurrent != nil:
case meter == nil && phaseCurrents != nil:
return &struct {
*ABLeMH
api.MeterCurrent
api.PhaseCurrents
}{
ABLeMH: base,
MeterCurrent: &decorateABLeMHMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateABLeMHPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil:
case meter != nil && phaseCurrents != nil:
return &struct {
*ABLeMH
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
ABLeMH: base,
Meter: &decorateABLeMHMeterImpl{
meter: meter,
},
MeterCurrent: &decorateABLeMHMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateABLeMHPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -60,10 +60,10 @@ func (impl *decorateABLeMHMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateABLeMHMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
type decorateABLeMHPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateABLeMHMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
func (impl *decorateABLeMHPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

6
charger/alfen.go
View file

@ -223,14 +223,14 @@ func (wb *Alfen) TotalEnergy() (float64, error) {
return math.Float64frombits(binary.BigEndian.Uint64(b)) / 1e3, err
}
var _ api.MeterCurrent = (*Alfen)(nil)
var _ api.PhaseCurrents = (*Alfen)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *Alfen) Currents() (float64, float64, float64, error) {
return wb.voltagesOrCurrents(alfenRegCurrents)
}
// Voltages implements the api.MeterVoltage interface (tbc)
// Voltages implements the api.PhaseVoltages interface (tbc)
func (wb *Alfen) Voltages() (float64, float64, float64, error) {
return wb.voltagesOrCurrents(alfenRegVoltages)
}

6
charger/bender.go
View file

@ -82,7 +82,7 @@ func NewBenderCCFromConfig(other map[string]interface{}) (api.Charger, error) {
return NewBenderCC(cc.URI, cc.ID)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateBenderCC -b *BenderCC -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.MeterVoltage,Voltages,func() (float64, float64, float64, error)" -t "api.ChargeRater,ChargedEnergy,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.Identifier,Identify,func() (string, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateBenderCC -b *BenderCC -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.PhaseVoltages,Voltages,func() (float64, float64, float64, error)" -t "api.ChargeRater,ChargedEnergy,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.Identifier,Identify,func() (string, error)"
// NewBenderCC creates BenderCC charger
func NewBenderCC(uri string, id uint8) (api.Charger, error) {
@ -280,7 +280,7 @@ func (wb *BenderCC) totalEnergy() (float64, error) {
return float64(binary.BigEndian.Uint32(b)) / 1e3, nil
}
// currents implements the api.MeterCurrent interface
// currents implements the api.PhaseCurrents interface
func (wb *BenderCC) currents() (float64, float64, float64, error) {
b, err := wb.conn.ReadHoldingRegisters(bendRegCurrents, 6)
if err != nil {
@ -295,7 +295,7 @@ func (wb *BenderCC) currents() (float64, float64, float64, error) {
return curr[0], curr[1], curr[2], nil
}
// voltages implements the api.MeterVoltage interface
// voltages implements the api.PhaseVoltages interface
func (wb *BenderCC) voltages() (float64, float64, float64, error) {
b, err := wb.conn.ReadHoldingRegisters(bendRegVoltages, 6)
if err != nil {

820
charger/bender_decorators.go
View file

File diff suppressed because it is too large Load diff

4
charger/connectiq.go
View file

@ -173,9 +173,9 @@ func (wb *ConnectIq) TotalEnergy() (float64, error) {
return res.Energy, err
}
var _ api.MeterCurrent = (*ConnectIq)(nil)
var _ api.PhaseCurrents = (*ConnectIq)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *ConnectIq) Currents() (float64, float64, float64, error) {
res, err := wb.meterG()
if err != nil {

4
charger/dadapower.go
View file

@ -188,9 +188,9 @@ func (wb *Dadapower) ChargedEnergy() (float64, error) {
return float64(binary.BigEndian.Uint64(b)) / 1e3, err
}
var _ api.MeterCurrent = (*Dadapower)(nil)
var _ api.PhaseCurrents = (*Dadapower)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *Dadapower) Currents() (float64, float64, float64, error) {
var currents []float64
for _, regCurrent := range dadapowerRegCurrents {

4
charger/daheimladen.go
View file

@ -204,9 +204,9 @@ func (c *DaheimLaden) TotalEnergy() (float64, error) {
return float64(res.EnergyActiveImportRegister), err
}
var _ api.MeterCurrent = (*DaheimLaden)(nil)
var _ api.PhaseCurrents = (*DaheimLaden)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (c *DaheimLaden) Currents() (float64, float64, float64, error) {
res, err := c.meterG()
return float64(res.CurrentImportPhaseL1), float64(res.CurrentImportPhaseL2), float64(res.CurrentImportPhaseL3), err

6
charger/easee.go
View file

@ -490,9 +490,9 @@ func (c *Easee) ChargedEnergy() (float64, error) {
return c.sessionEnergy, nil
}
var _ api.MeterCurrent = (*Easee)(nil)
var _ api.PhaseCurrents = (*Easee)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (c *Easee) Currents() (float64, float64, float64, error) {
c.mux.L.Lock()
defer c.mux.L.Unlock()
@ -512,7 +512,7 @@ func (c *Easee) TotalEnergy() (float64, error) {
var _ api.Identifier = (*Easee)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (c *Easee) Identify() (string, error) {
c.mux.L.Lock()
defer c.mux.L.Unlock()

4
charger/eebus.go
View file

@ -59,7 +59,7 @@ func NewEEBusFromConfig(other map[string]interface{}) (api.Charger, error) {
return NewEEBus(cc.Ski, cc.Ip, cc.Meter, cc.ChargedEnergy)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateEEBus -b *EEBus -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.ChargeRater,ChargedEnergy,func() (float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateEEBus -b *EEBus -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.ChargeRater,ChargedEnergy,func() (float64, error)"
// NewEEBus creates EEBus charger
func NewEEBus(ski, ip string, hasMeter, hasChargedEnergy bool) (api.Charger, error) {
@ -381,7 +381,7 @@ func (c *EEBus) chargedEnergy() (float64, error) {
return energy, nil
}
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (c *EEBus) currents() (float64, float64, float64, error) {
chargeState, err := c.emobility.EVCurrentChargeState()
if err != nil {

50
charger/eebus_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateEEBus(base *EEBus, meter func() (float64, error), meterCurrent func() (float64, float64, float64, error), chargeRater func() (float64, error)) api.Charger {
func decorateEEBus(base *EEBus, meter func() (float64, error), phaseCurrents func() (float64, float64, float64, error), chargeRater func() (float64, error)) api.Charger {
switch {
case chargeRater == nil && meter == nil && meterCurrent == nil:
case chargeRater == nil && meter == nil && phaseCurrents == nil:
return base
case chargeRater == nil && meter != nil && meterCurrent == nil:
case chargeRater == nil && meter != nil && phaseCurrents == nil:
return &struct {
*EEBus
api.Meter
@ -22,33 +22,33 @@ func decorateEEBus(base *EEBus, meter func() (float64, error), meterCurrent func
},
}
case chargeRater == nil && meter == nil && meterCurrent != nil:
case chargeRater == nil && meter == nil && phaseCurrents != nil:
return &struct {
*EEBus
api.MeterCurrent
api.PhaseCurrents
}{
EEBus: base,
MeterCurrent: &decorateEEBusMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEEBusPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargeRater == nil && meter != nil && meterCurrent != nil:
case chargeRater == nil && meter != nil && phaseCurrents != nil:
return &struct {
*EEBus
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
EEBus: base,
Meter: &decorateEEBusMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEEBusMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEEBusPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargeRater != nil && meter == nil && meterCurrent == nil:
case chargeRater != nil && meter == nil && phaseCurrents == nil:
return &struct {
*EEBus
api.ChargeRater
@ -59,7 +59,7 @@ func decorateEEBus(base *EEBus, meter func() (float64, error), meterCurrent func
},
}
case chargeRater != nil && meter != nil && meterCurrent == nil:
case chargeRater != nil && meter != nil && phaseCurrents == nil:
return &struct {
*EEBus
api.ChargeRater
@ -74,27 +74,27 @@ func decorateEEBus(base *EEBus, meter func() (float64, error), meterCurrent func
},
}
case chargeRater != nil && meter == nil && meterCurrent != nil:
case chargeRater != nil && meter == nil && phaseCurrents != nil:
return &struct {
*EEBus
api.ChargeRater
api.MeterCurrent
api.PhaseCurrents
}{
EEBus: base,
ChargeRater: &decorateEEBusChargeRaterImpl{
chargeRater: chargeRater,
},
MeterCurrent: &decorateEEBusMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEEBusPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargeRater != nil && meter != nil && meterCurrent != nil:
case chargeRater != nil && meter != nil && phaseCurrents != nil:
return &struct {
*EEBus
api.ChargeRater
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
EEBus: base,
ChargeRater: &decorateEEBusChargeRaterImpl{
@ -103,8 +103,8 @@ func decorateEEBus(base *EEBus, meter func() (float64, error), meterCurrent func
Meter: &decorateEEBusMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEEBusMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEEBusPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -128,10 +128,10 @@ func (impl *decorateEEBusMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateEEBusMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
type decorateEEBusPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateEEBusMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
func (impl *decorateEEBusPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

4
charger/etrel.go
View file

@ -202,9 +202,9 @@ func (wb *Etrel) CurrentPower() (float64, error) {
return float64(encoding.Float32(b) * 1e3), err
}
var _ api.MeterCurrent = (*Etrel)(nil)
var _ api.PhaseCurrents = (*Etrel)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *Etrel) Currents() (float64, float64, float64, error) {
b, err := wb.conn.ReadInputRegisters(etrelRegCurrents, 6)
if err != nil {

6
charger/evsewifi.go
View file

@ -26,7 +26,7 @@ func init() {
registry.Add("evsewifi", NewEVSEWifiFromConfig)
}
// go:generate go run ../cmd/tools/decorate.go -f decorateEVSE -b *EVSEWifi -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.ChargerEx,MaxCurrentMillis,func(current float64) error" -t "api.Identifier,Identify,func() (string, error)"
// go:generate go run ../cmd/tools/decorate.go -f decorateEVSE -b *EVSEWifi -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.ChargerEx,MaxCurrentMillis,func(current float64) error" -t "api.Identifier,Identify,func() (string, error)"
// NewEVSEWifiFromConfig creates a EVSEWifi charger from generic config
func NewEVSEWifiFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -78,7 +78,7 @@ func NewEVSEWifiFromConfig(other map[string]interface{}) (api.Charger, error) {
totalEnergy = wb.totalEnergy
}
// decorate Charger with MeterCurrent
// decorate Charger with PhaseCurrents
var currents func() (float64, float64, float64, error)
if cc.Meter.Currents {
currents = wb.currents
@ -220,7 +220,7 @@ func (wb *EVSEWifi) totalEnergy() (float64, error) {
return params.MeterReading, err
}
// Currents implements the api.MeterCurrents interface
// Currents implements the api.PhaseCurrentss interface
func (wb *EVSEWifi) currents() (float64, float64, float64, error) {
params, err := wb.getParameters()
return params.CurrentP1, params.CurrentP2, params.CurrentP3, err

194
charger/evsewifi_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error), chargerEx func(float64) error, identifier func() (string, error)) api.Charger {
func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error), chargerEx func(current float64) error, identifier func() (string, error)) api.Charger {
switch {
case chargerEx == nil && identifier == nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case chargerEx == nil && identifier == nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.Meter
@ -22,7 +22,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.MeterEnergy
@ -33,7 +33,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.Meter
@ -48,67 +48,67 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier == nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx == nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier == nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx == nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -119,7 +119,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -134,7 +134,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -149,7 +149,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -168,27 +168,27 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
@ -197,37 +197,37 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx != nil && identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
chargerEx: chargerEx,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier == nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx != nil && identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
@ -236,15 +236,15 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.Identifier
@ -255,7 +255,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.Identifier
@ -270,7 +270,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.Identifier
@ -285,7 +285,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.Identifier
@ -304,27 +304,27 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.Identifier
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.Identifier
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
@ -333,37 +333,37 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx == nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.Identifier
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && identifier != nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx == nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.Identifier
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
Identifier: &decorateEVSEIdentifierImpl{
@ -372,15 +372,15 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -395,7 +395,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -414,7 +414,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -433,7 +433,7 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*EVSEWifi
api.ChargerEx
@ -456,12 +456,12 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
@ -470,18 +470,18 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
@ -493,18 +493,18 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx != nil && identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
@ -513,22 +513,22 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Identifier: &decorateEVSEIdentifierImpl{
identifier: identifier,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && identifier != nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx != nil && identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*EVSEWifi
api.ChargerEx
api.Identifier
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
EVSEWifi: base,
ChargerEx: &decorateEVSEChargerExImpl{
@ -540,12 +540,12 @@ func decorateEVSE(base *EVSEWifi, meter func() (float64, error), meterEnergy fun
Meter: &decorateEVSEMeterImpl{
meter: meter,
},
MeterCurrent: &decorateEVSEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateEVSEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateEVSEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -576,14 +576,6 @@ func (impl *decorateEVSEMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateEVSEMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateEVSEMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateEVSEMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -591,3 +583,11 @@ type decorateEVSEMeterEnergyImpl struct {
func (impl *decorateEVSEMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateEVSEPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateEVSEPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

4
charger/evsewifi_test.go
View file

@ -32,8 +32,8 @@ func TestEvseWifi(t *testing.T) {
t.Error("missing api.MeterEnergy")
}
if _, ok := wb.(api.MeterCurrent); !ok {
t.Error("missing api.MeterCurrent")
if _, ok := wb.(api.PhaseCurrents); !ok {
t.Error("missing api.PhaseCurrents")
}
if _, ok := wb.(api.ChargeTimer); !ok {

4
charger/go-e.go
View file

@ -162,9 +162,9 @@ func (c *GoE) ChargedEnergy() (float64, error) {
return resp.ChargedEnergy(), err
}
var _ api.MeterCurrent = (*GoE)(nil)
var _ api.PhaseCurrents = (*GoE)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (c *GoE) Currents() (float64, float64, float64, error) {
resp, err := c.api.Status()
if err != nil {

8
charger/go-e_test.go
View file

@ -47,8 +47,8 @@ func TestGoEV1(t *testing.T) {
t.Error("missing Meter api")
}
if _, ok := wb.(api.MeterCurrent); !ok {
t.Error("missing MeterCurrent api")
if _, ok := wb.(api.PhaseCurrents); !ok {
t.Error("missing PhaseCurrents api")
}
if _, ok := wb.(api.Identifier); !ok {
@ -72,8 +72,8 @@ func TestGoEV2(t *testing.T) {
t.Error("missing Meter api")
}
if _, ok := wb.(api.MeterCurrent); !ok {
t.Error("missing MeterCurrent api")
if _, ok := wb.(api.PhaseCurrents); !ok {
t.Error("missing PhaseCurrents api")
}
if _, ok := wb.(api.Identifier); !ok {

4
charger/hardybarth-ecb1.go
View file

@ -216,9 +216,9 @@ func (wb *HardyBarth) TotalEnergy() (float64, error) {
return res.Data[obis.EnergyConsumption], nil
}
var _ api.MeterCurrent = (*HardyBarth)(nil)
var _ api.PhaseCurrents = (*HardyBarth)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *HardyBarth) Currents() (float64, float64, float64, error) {
res, err := wb.meterG()
if err != nil {

4
charger/hardybarth-salia.go
View file

@ -50,7 +50,7 @@ func init() {
registry.Add("hardybarth-salia", NewSaliaFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateSalia -b *Salia -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateSalia -b *Salia -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewSaliaFromConfig creates a Salia cPH2 charger from generic config
func NewSaliaFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -229,7 +229,7 @@ func (wb *Salia) totalEnergy() (float64, error) {
return res.Secc.Port0.Metering.Energy.ActiveImport.Actual / 1e3, err
}
// currents implements the api.MeterCurrent interface
// currents implements the api.PhaseCurrents interface
func (wb *Salia) currents() (float64, float64, float64, error) {
res, err := wb.get()
i := res.Secc.Port0.Metering.Current.AC

62
charger/hardybarth-salia_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Charger {
func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Charger {
switch {
case meter == nil && meterCurrent == nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case meter != nil && meterCurrent == nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Salia
api.Meter
@ -22,7 +22,7 @@ func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func(
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Salia
api.MeterEnergy
@ -33,7 +33,7 @@ func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func(
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Salia
api.Meter
@ -48,64 +48,64 @@ func decorateSalia(base *Salia, meter func() (float64, error), meterEnergy func(
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Salia
api.MeterCurrent
api.PhaseCurrents
}{
Salia: base,
MeterCurrent: &decorateSaliaMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateSaliaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Salia
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Salia: base,
Meter: &decorateSaliaMeterImpl{
meter: meter,
},
MeterCurrent: &decorateSaliaMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateSaliaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Salia
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Salia: base,
MeterCurrent: &decorateSaliaMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateSaliaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateSaliaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Salia
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Salia: base,
Meter: &decorateSaliaMeterImpl{
meter: meter,
},
MeterCurrent: &decorateSaliaMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateSaliaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateSaliaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -120,14 +120,6 @@ func (impl *decorateSaliaMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateSaliaMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateSaliaMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateSaliaMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -135,3 +127,11 @@ type decorateSaliaMeterEnergyImpl struct {
func (impl *decorateSaliaMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateSaliaPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateSaliaPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

8
charger/heidelberg-ec.go
View file

@ -240,9 +240,9 @@ func (wb *HeidelbergEC) TotalEnergy() (float64, error) {
return float64(binary.BigEndian.Uint32(b)) / 1e3, nil
}
var _ api.MeterCurrent = (*HeidelbergEC)(nil)
var _ api.PhaseCurrents = (*HeidelbergEC)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *HeidelbergEC) Currents() (float64, float64, float64, error) {
b, err := wb.conn.ReadInputRegisters(abbRegCurrents, 3)
if err != nil {
@ -257,9 +257,9 @@ func (wb *HeidelbergEC) Currents() (float64, float64, float64, error) {
return curr[0], curr[1], curr[2], nil
}
var _ api.MeterVoltage = (*HeidelbergEC)(nil)
var _ api.PhaseVoltages = (*HeidelbergEC)(nil)
// Voltages implements the api.MeterVoltage interface
// Voltages implements the api.PhaseVoltages interface
func (wb *HeidelbergEC) Voltages() (float64, float64, float64, error) {
b, err := wb.conn.ReadInputRegisters(abbRegVoltages, 3)
if err != nil {

4
charger/innogy.go
View file

@ -172,9 +172,9 @@ func (wb *Innogy) CurrentPower() (float64, error) {
return 230 * (l1 + l2 + l3), err
}
var _ api.MeterCurrent = (*Innogy)(nil)
var _ api.PhaseCurrents = (*Innogy)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *Innogy) Currents() (float64, float64, float64, error) {
var currents []float64
for _, regCurrent := range igyRegCurrents {

4
charger/keba.go
View file

@ -37,7 +37,7 @@ func init() {
registry.Add("keba", NewKebaFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateKeba -b *Keba -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateKeba -b *Keba -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewKebaFromConfig creates a new configurable charger
func NewKebaFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -298,7 +298,7 @@ func (c *Keba) totalEnergy() (float64, error) {
return float64(kr.ETotal) / 1e4, err
}
// currents implements the api.MeterCurrent interface
// currents implements the api.PhaseCurrents interface
func (c *Keba) currents() (float64, float64, float64, error) {
var kr keba.Report3
err := c.roundtrip("report", 3, &kr)

62
charger/keba_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Charger {
func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Charger {
switch {
case meter == nil && meterCurrent == nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case meter != nil && meterCurrent == nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Keba
api.Meter
@ -22,7 +22,7 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Keba
api.MeterEnergy
@ -33,7 +33,7 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Keba
api.Meter
@ -48,64 +48,64 @@ func decorateKeba(base *Keba, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Keba
api.MeterCurrent
api.PhaseCurrents
}{
Keba: base,
MeterCurrent: &decorateKebaMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Keba
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Keba: base,
Meter: &decorateKebaMeterImpl{
meter: meter,
},
MeterCurrent: &decorateKebaMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Keba
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Keba: base,
MeterCurrent: &decorateKebaMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Keba
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Keba: base,
Meter: &decorateKebaMeterImpl{
meter: meter,
},
MeterCurrent: &decorateKebaMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateKebaMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateKebaPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -120,14 +120,6 @@ func (impl *decorateKebaMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateKebaMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateKebaMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateKebaMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -135,3 +127,11 @@ type decorateKebaMeterEnergyImpl struct {
func (impl *decorateKebaMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateKebaPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateKebaPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

4
charger/kse.go
View file

@ -185,9 +185,9 @@ func (wb *KSE) ChargedEnergy() (float64, error) {
return float64(binary.BigEndian.Uint16(b)) / 100, err
}
var _ api.MeterCurrent = (*KSE)(nil)
var _ api.PhaseCurrents = (*KSE)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *KSE) Currents() (float64, float64, float64, error) {
b, err := wb.conn.ReadInputRegisters(kseRegCurrents, 3)
if err != nil {

4
charger/mcc.go
View file

@ -350,9 +350,9 @@ func (mcc *MobileConnect) ChargingTime() (time.Duration, error) {
return time.Duration(currentSession.Duration) * time.Second, nil
}
var _ api.MeterCurrent = (*MobileConnect)(nil)
var _ api.PhaseCurrents = (*MobileConnect)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (mcc *MobileConnect) Currents() (float64, float64, float64, error) {
var energy MCCEnergy
err := mcc.getEscapedJSON(mcc.apiURL(mccAPIEnergy), &energy)

4
charger/nrgble_linux.go
View file

@ -317,9 +317,9 @@ func (nrg *NRGKickBLE) TotalEnergy() (float64, error) {
return float64(res.TotalEnergy) / 1000, nil
}
var _ api.MeterCurrent = (*NRGKickBLE)(nil)
var _ api.PhaseCurrents = (*NRGKickBLE)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (nrg *NRGKickBLE) Currents() (float64, float64, float64, error) {
res := nrgble.VoltageCurrent{}
if err := nrg.read(nrgble.VoltageCurrentService, &res); err != nil {

4
charger/nrgconnect.go
View file

@ -184,9 +184,9 @@ func (nrg *NRGKickConnect) TotalEnergy() (float64, error) {
return res.ChargingEnergyOverAll, err
}
var _ api.MeterCurrent = (*NRGKickConnect)(nil)
var _ api.PhaseCurrents = (*NRGKickConnect)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (nrg *NRGKickConnect) Currents() (float64, float64, float64, error) {
var res NRGMeasurements
err := nrg.GetJSON(nrg.apiURL(nrgMeasurements), &res)

4
charger/ocpp.go
View file

@ -97,7 +97,7 @@ func NewOCPPFromConfig(other map[string]interface{}) (api.Charger, error) {
return decorateOCPP(c, powerG, totalEnergyG, currentsG, phasesS), nil
}
// go:generate go run ../cmd/tools/decorate.go -f decorateOCPP -b *OCPP -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.PhaseSwitcher,Phases1p3p,func(int) (error)"
// go:generate go run ../cmd/tools/decorate.go -f decorateOCPP -b *OCPP -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.PhaseSwitcher,Phases1p3p,func(int) (error)"
// NewOCPP creates OCPP charger
func NewOCPP(id string, connector int, idtag string, meterValues string, meterInterval time.Duration, quirks bool, timeout time.Duration) (*OCPP, error) {
@ -416,7 +416,7 @@ func (c *OCPP) totalEnergy() (float64, error) {
return c.cp.TotalEnergy()
}
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (c *OCPP) currents() (float64, float64, float64, error) {
return c.cp.Currents()
}

2
charger/ocpp/cp.go
View file

@ -224,7 +224,7 @@ func getKeyCurrentPhase(phase int) string {
return string(types.MeasurandCurrentImport) + "@L" + strconv.Itoa(phase)
}
var _ api.MeterCurrent = (*CP)(nil)
var _ api.PhaseCurrents = (*CP)(nil)
func (cp *CP) Currents() (float64, float64, float64, error) {
cp.mu.Lock()

106
charger/ocpp_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error), phaseSwitcher func(int) error) api.Charger {
func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error), phaseSwitcher func(phases int) error) api.Charger {
switch {
case meter == nil && meterCurrent == nil && meterEnergy == nil && phaseSwitcher == nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher == nil:
return base
case meter != nil && meterCurrent == nil && meterEnergy == nil && phaseSwitcher == nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher == nil:
return &struct {
*OCPP
api.Meter
@ -22,7 +22,7 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil && phaseSwitcher == nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil:
return &struct {
*OCPP
api.MeterEnergy
@ -33,7 +33,7 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil && phaseSwitcher == nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher == nil:
return &struct {
*OCPP
api.Meter
@ -48,67 +48,67 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil && phaseSwitcher == nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*OCPP
api.MeterCurrent
api.PhaseCurrents
}{
OCPP: base,
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil && phaseSwitcher == nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*OCPP
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
OCPP: base,
Meter: &decorateOCPPMeterImpl{
meter: meter,
},
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil && phaseSwitcher == nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*OCPP
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
OCPP: base,
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil && phaseSwitcher == nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher == nil:
return &struct {
*OCPP
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
OCPP: base,
Meter: &decorateOCPPMeterImpl{
meter: meter,
},
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent == nil && meterEnergy == nil && phaseSwitcher != nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.PhaseSwitcher
@ -119,7 +119,7 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case meter != nil && meterCurrent == nil && meterEnergy == nil && phaseSwitcher != nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.Meter
@ -134,7 +134,7 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil && phaseSwitcher != nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.MeterEnergy
@ -149,7 +149,7 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil && phaseSwitcher != nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.Meter
@ -168,77 +168,77 @@ func decorateOCPP(base *OCPP, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil && phaseSwitcher != nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.MeterCurrent
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil && phaseSwitcher != nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.Meter
api.MeterCurrent
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
Meter: &decorateOCPPMeterImpl{
meter: meter,
},
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil && phaseSwitcher != nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil && phaseSwitcher != nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil && phaseSwitcher != nil:
return &struct {
*OCPP
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
api.PhaseSwitcher
}{
OCPP: base,
Meter: &decorateOCPPMeterImpl{
meter: meter,
},
MeterCurrent: &decorateOCPPMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateOCPPMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateOCPPPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
PhaseSwitcher: &decorateOCPPPhaseSwitcherImpl{
phaseSwitcher: phaseSwitcher,
},
@ -256,14 +256,6 @@ func (impl *decorateOCPPMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateOCPPMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateOCPPMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateOCPPMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -272,6 +264,14 @@ func (impl *decorateOCPPMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateOCPPPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateOCPPPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}
type decorateOCPPPhaseSwitcherImpl struct {
phaseSwitcher func(int) error
}

4
charger/openwb-pro.go
View file

@ -168,9 +168,9 @@ func (wb *OpenWBPro) TotalEnergy() (float64, error) {
return res.Imported / 1e3, err
}
var _ api.MeterCurrent = (*OpenWBPro)(nil)
var _ api.PhaseCurrents = (*OpenWBPro)(nil)
// Currents implements the api.MeterCurrents interface
// Currents implements the api.PhaseCurrentss interface
func (wb *OpenWBPro) Currents() (float64, float64, float64, error) {
res, err := wb.get()
if err != nil {

4
charger/openwb.go
View file

@ -210,9 +210,9 @@ func (m *OpenWB) TotalEnergy() (float64, error) {
return m.totalEnergyG()
}
var _ api.MeterCurrent = (*OpenWB)(nil)
var _ api.PhaseCurrents = (*OpenWB)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (m *OpenWB) Currents() (float64, float64, float64, error) {
var currents []float64
for _, currentG := range m.currentsG {

4
charger/pcelectric.go
View file

@ -30,7 +30,7 @@ func init() {
registry.Add("pcelectric", NewPCElectricFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decoratePCE -b *PCElectric -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decoratePCE -b *PCElectric -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewPCElectricFromConfig creates a PCElectric charger from generic config
func NewPCElectricFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -275,7 +275,7 @@ func (wb *PCElectric) totalEnergy() (float64, error) {
return float64(res.AccEnergy) / 1e3, err
}
// Currents implements the api.MeterCurrents interface A
// Currents implements the api.PhaseCurrentss interface A
func (wb *PCElectric) currents() (float64, float64, float64, error) {
var res pcelectric.MeterInfo
uri := fmt.Sprintf("%s/meterinfo/%s", wb.uri, wb.meter)

62
charger/pcelectric_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Charger {
func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Charger {
switch {
case meter == nil && meterCurrent == nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case meter != nil && meterCurrent == nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*PCElectric
api.Meter
@ -22,7 +22,7 @@ func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy fu
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PCElectric
api.MeterEnergy
@ -33,7 +33,7 @@ func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy fu
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PCElectric
api.Meter
@ -48,64 +48,64 @@ func decoratePCE(base *PCElectric, meter func() (float64, error), meterEnergy fu
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PCElectric
api.MeterCurrent
api.PhaseCurrents
}{
PCElectric: base,
MeterCurrent: &decoratePCEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decoratePCEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PCElectric
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
PCElectric: base,
Meter: &decoratePCEMeterImpl{
meter: meter,
},
MeterCurrent: &decoratePCEMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decoratePCEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PCElectric
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
PCElectric: base,
MeterCurrent: &decoratePCEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decoratePCEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePCEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PCElectric
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
PCElectric: base,
Meter: &decoratePCEMeterImpl{
meter: meter,
},
MeterCurrent: &decoratePCEMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decoratePCEMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePCEPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -120,14 +120,6 @@ func (impl *decoratePCEMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decoratePCEMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decoratePCEMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decoratePCEMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -135,3 +127,11 @@ type decoratePCEMeterEnergyImpl struct {
func (impl *decoratePCEMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decoratePCEPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decoratePCEPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

4
charger/phoenix-em-eth.go
View file

@ -32,7 +32,7 @@ func init() {
registry.Add("phoenix-em-eth", NewPhoenixEMEthFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decoratePhoenixEMEth -b *PhoenixEMEth -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decoratePhoenixEMEth -b *PhoenixEMEth -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewPhoenixEMEthFromConfig creates a Phoenix charger from generic config
func NewPhoenixEMEthFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -165,7 +165,7 @@ func (wb *PhoenixEMEth) totalEnergy() (float64, error) {
return rs485.RTUUint32ToFloat64Swapped(b) / 100, err
}
// currents implements the api.MeterCurrent interface
// currents implements the api.PhaseCurrents interface
func (wb *PhoenixEMEth) currents() (float64, float64, float64, error) {
var currents []float64
for _, regCurrent := range phxEMEthRegCurrents {

62
charger/phoenix-em-eth_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Charger {
func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Charger {
switch {
case meter == nil && meterCurrent == nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case meter != nil && meterCurrent == nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*PhoenixEMEth
api.Meter
@ -22,7 +22,7 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PhoenixEMEth
api.MeterEnergy
@ -33,7 +33,7 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PhoenixEMEth
api.Meter
@ -48,64 +48,64 @@ func decoratePhoenixEMEth(base *PhoenixEMEth, meter func() (float64, error), met
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PhoenixEMEth
api.MeterCurrent
api.PhaseCurrents
}{
PhoenixEMEth: base,
MeterCurrent: &decoratePhoenixEMEthMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PhoenixEMEth
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
PhoenixEMEth: base,
Meter: &decoratePhoenixEMEthMeterImpl{
meter: meter,
},
MeterCurrent: &decoratePhoenixEMEthMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PhoenixEMEth
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEMEth: base,
MeterCurrent: &decoratePhoenixEMEthMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decoratePhoenixEMEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PhoenixEMEth
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEMEth: base,
Meter: &decoratePhoenixEMEthMeterImpl{
meter: meter,
},
MeterCurrent: &decoratePhoenixEMEthMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decoratePhoenixEMEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEMEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -120,14 +120,6 @@ func (impl *decoratePhoenixEMEthMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decoratePhoenixEMEthMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decoratePhoenixEMEthMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decoratePhoenixEMEthMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -135,3 +127,11 @@ type decoratePhoenixEMEthMeterEnergyImpl struct {
func (impl *decoratePhoenixEMEthMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decoratePhoenixEMEthPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decoratePhoenixEMEthPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

4
charger/phoenix-em-eth_test.go
View file

@ -26,8 +26,8 @@ func TestPhoenixEMEthDecorators(t *testing.T) {
t.Error("missing MeterEnergy api")
}
if _, ok := wb.(api.MeterCurrent); !ok {
t.Error("missing MeterCurrent api")
if _, ok := wb.(api.PhaseCurrents); !ok {
t.Error("missing PhaseCurrents api")
}
if _, ok := wb.(api.ChargeTimer); !ok {

4
charger/phoenix-ev-eth.go
View file

@ -33,7 +33,7 @@ func init() {
registry.Add("phoenix-ev-eth", NewPhoenixEVEthFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decoratePhoenixEVEth -b *PhoenixEVEth -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decoratePhoenixEVEth -b *PhoenixEVEth -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewPhoenixEVEthFromConfig creates a Phoenix charger from generic config
func NewPhoenixEVEthFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -166,7 +166,7 @@ func (wb *PhoenixEVEth) totalEnergy() (float64, error) {
return rs485.RTUUint32ToFloat64Swapped(b) / 1000, err
}
// currents implements the api.MeterCurrent interface
// currents implements the api.PhaseCurrents interface
func (wb *PhoenixEVEth) currents() (float64, float64, float64, error) {
var currents []float64
for _, regCurrent := range phxEVEthRegCurrents {

62
charger/phoenix-ev-eth_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Charger {
func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Charger {
switch {
case meter == nil && meterCurrent == nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case meter != nil && meterCurrent == nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*PhoenixEVEth
api.Meter
@ -22,7 +22,7 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PhoenixEVEth
api.MeterEnergy
@ -33,7 +33,7 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*PhoenixEVEth
api.Meter
@ -48,64 +48,64 @@ func decoratePhoenixEVEth(base *PhoenixEVEth, meter func() (float64, error), met
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PhoenixEVEth
api.MeterCurrent
api.PhaseCurrents
}{
PhoenixEVEth: base,
MeterCurrent: &decoratePhoenixEVEthMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*PhoenixEVEth
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
PhoenixEVEth: base,
Meter: &decoratePhoenixEVEthMeterImpl{
meter: meter,
},
MeterCurrent: &decoratePhoenixEVEthMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PhoenixEVEth
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEVEth: base,
MeterCurrent: &decoratePhoenixEVEthMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*PhoenixEVEth
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
PhoenixEVEth: base,
Meter: &decoratePhoenixEVEthMeterImpl{
meter: meter,
},
MeterCurrent: &decoratePhoenixEVEthMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decoratePhoenixEVEthMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decoratePhoenixEVEthPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -120,14 +120,6 @@ func (impl *decoratePhoenixEVEthMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decoratePhoenixEVEthMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decoratePhoenixEVEthMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decoratePhoenixEVEthMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -135,3 +127,11 @@ type decoratePhoenixEVEthMeterEnergyImpl struct {
func (impl *decoratePhoenixEVEthMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decoratePhoenixEVEthPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decoratePhoenixEVEthPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

4
charger/phoenix-ev-eth_test.go
View file

@ -26,8 +26,8 @@ func TestPhoenixEVEthDecorators(t *testing.T) {
t.Error("missing MeterEnergy api")
}
if _, ok := wb.(api.MeterCurrent); !ok {
t.Error("missing MeterCurrent api")
if _, ok := wb.(api.PhaseCurrents); !ok {
t.Error("missing PhaseCurrents api")
}
if _, ok := wb.(api.ChargeTimer); !ok {

4
charger/smaevcharger.go
View file

@ -247,9 +247,9 @@ func (wb *Smaevcharger) ChargedEnergy() (float64, error) {
return res / 1e3, err
}
var _ api.MeterCurrent = (*Smaevcharger)(nil)
var _ api.PhaseCurrents = (*Smaevcharger)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *Smaevcharger) Currents() (float64, float64, float64, error) {
var curr []float64

4
charger/twc3.go
View file

@ -161,9 +161,9 @@ func (v *Twc3) ChargingTime() (time.Duration, error) {
return time.Duration(res.SessionS) * time.Second, err
}
var _ api.MeterCurrent = (*Twc3)(nil)
var _ api.PhaseCurrents = (*Twc3)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (v *Twc3) Currents() (float64, float64, float64, error) {
res, err := v.vitalsG()
return res.CurrentAA, res.CurrentBA, res.CurrentCA, err

4
charger/vestel.go
View file

@ -211,9 +211,9 @@ func (wb *Vestel) ChargedEnergy() (float64, error) {
return float64(binary.BigEndian.Uint32(b)) / 1e3, err
}
var _ api.MeterCurrent = (*Vestel)(nil)
var _ api.PhaseCurrents = (*Vestel)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *Vestel) Currents() (float64, float64, float64, error) {
var currents []float64
for _, regCurrent := range vestelRegCurrents {

4
charger/wallbe.go
View file

@ -41,7 +41,7 @@ func init() {
registry.Add("wallbe", NewWallbeFromConfig)
}
// go:generate go run ../cmd/tools/decorate.go -f decorateWallbe -b *Wallbe -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.ChargerEx,MaxCurrentMillis,func(current float64) error"
// go:generate go run ../cmd/tools/decorate.go -f decorateWallbe -b *Wallbe -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.ChargerEx,MaxCurrentMillis,func(current float64) error"
// NewWallbeFromConfig creates a Wallbe charger from generic config
func NewWallbeFromConfig(other map[string]interface{}) (api.Charger, error) {
@ -208,7 +208,7 @@ func (wb *Wallbe) totalEnergy() (float64, error) {
return res, nil
}
// currents implements the api.MeterCurrent interface
// currents implements the api.PhaseCurrents interface
func (wb *Wallbe) currents() (float64, float64, float64, error) {
var currents []float64
for _, regCurrent := range wbRegCurrents {

106
charger/wallbe_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error), chargerEx func(current float64) error) api.Charger {
func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error), chargerEx func(current float64) error) api.Charger {
switch {
case chargerEx == nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case chargerEx == nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.Meter
@ -22,7 +22,7 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.MeterEnergy
@ -33,7 +33,7 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.Meter
@ -48,67 +48,67 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx == nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.MeterCurrent
api.PhaseCurrents
}{
Wallbe: base,
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Wallbe: base,
Meter: &decorateWallbeMeterImpl{
meter: meter,
},
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Wallbe: base,
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx == nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Wallbe: base,
Meter: &decorateWallbeMeterImpl{
meter: meter,
},
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.ChargerEx
@ -119,7 +119,7 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case chargerEx != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.ChargerEx
@ -134,7 +134,7 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.ChargerEx
@ -149,7 +149,7 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case chargerEx != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Wallbe
api.ChargerEx
@ -168,27 +168,27 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
},
}
case chargerEx != nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.ChargerEx
api.MeterCurrent
api.PhaseCurrents
}{
Wallbe: base,
ChargerEx: &decorateWallbeChargerExImpl{
chargerEx: chargerEx,
},
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case chargerEx != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.ChargerEx
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Wallbe: base,
ChargerEx: &decorateWallbeChargerExImpl{
@ -197,37 +197,37 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
Meter: &decorateWallbeMeterImpl{
meter: meter,
},
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.ChargerEx
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Wallbe: base,
ChargerEx: &decorateWallbeChargerExImpl{
chargerEx: chargerEx,
},
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case chargerEx != nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case chargerEx != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Wallbe
api.ChargerEx
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Wallbe: base,
ChargerEx: &decorateWallbeChargerExImpl{
@ -236,12 +236,12 @@ func decorateWallbe(base *Wallbe, meter func() (float64, error), meterEnergy fun
Meter: &decorateWallbeMeterImpl{
meter: meter,
},
MeterCurrent: &decorateWallbeMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWallbeMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWallbePhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -264,14 +264,6 @@ func (impl *decorateWallbeMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateWallbeMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateWallbeMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateWallbeMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -279,3 +271,11 @@ type decorateWallbeMeterEnergyImpl struct {
func (impl *decorateWallbeMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateWallbePhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateWallbePhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

2
charger/warp.go
View file

@ -32,7 +32,7 @@ func init() {
registry.Add("warp", NewWarpFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateWarp -b *Warp -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateWarp -b *Warp -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewWarpFromConfig creates a new configurable charger
func NewWarpFromConfig(other map[string]interface{}) (api.Charger, error) {

2
charger/warp2.go
View file

@ -35,7 +35,7 @@ func init() {
registry.Add("warp-fw2", NewWarp2FromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateWarp2 -b *Warp2 -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.Identifier,Identify,func() (string, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateWarp2 -b *Warp2 -r api.Charger -t "api.Meter,CurrentPower,func() (float64, error)" -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.Identifier,Identify,func() (string, error)"
// NewWarpFromConfig creates a new configurable charger
func NewWarp2FromConfig(other map[string]interface{}) (api.Charger, error) {

106
charger/warp2_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error), identifier func() (string, error)) api.Charger {
func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error), identifier func() (string, error)) api.Charger {
switch {
case identifier == nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case identifier == nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Warp2
api.Meter
@ -22,7 +22,7 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
},
}
case identifier == nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Warp2
api.MeterEnergy
@ -33,7 +33,7 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
},
}
case identifier == nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Warp2
api.Meter
@ -48,67 +48,67 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
},
}
case identifier == nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case identifier == nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Warp2
api.MeterCurrent
api.PhaseCurrents
}{
Warp2: base,
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier == nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case identifier == nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Warp2
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Warp2: base,
Meter: &decorateWarp2MeterImpl{
meter: meter,
},
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier == nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case identifier == nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Warp2
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Warp2: base,
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWarp2MeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier == nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case identifier == nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Warp2
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Warp2: base,
Meter: &decorateWarp2MeterImpl{
meter: meter,
},
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWarp2MeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier != nil && meter == nil && meterCurrent == nil && meterEnergy == nil:
case identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Warp2
api.Identifier
@ -119,7 +119,7 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
},
}
case identifier != nil && meter != nil && meterCurrent == nil && meterEnergy == nil:
case identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Warp2
api.Identifier
@ -134,7 +134,7 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
},
}
case identifier != nil && meter == nil && meterCurrent == nil && meterEnergy != nil:
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Warp2
api.Identifier
@ -149,7 +149,7 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
},
}
case identifier != nil && meter != nil && meterCurrent == nil && meterEnergy != nil:
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Warp2
api.Identifier
@ -168,27 +168,27 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
},
}
case identifier != nil && meter == nil && meterCurrent != nil && meterEnergy == nil:
case identifier != nil && meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Warp2
api.Identifier
api.MeterCurrent
api.PhaseCurrents
}{
Warp2: base,
Identifier: &decorateWarp2IdentifierImpl{
identifier: identifier,
},
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier != nil && meter != nil && meterCurrent != nil && meterEnergy == nil:
case identifier != nil && meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Warp2
api.Identifier
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Warp2: base,
Identifier: &decorateWarp2IdentifierImpl{
@ -197,37 +197,37 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
Meter: &decorateWarp2MeterImpl{
meter: meter,
},
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier != nil && meter == nil && meterCurrent != nil && meterEnergy != nil:
case identifier != nil && meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Warp2
api.Identifier
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Warp2: base,
Identifier: &decorateWarp2IdentifierImpl{
identifier: identifier,
},
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWarp2MeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case identifier != nil && meter != nil && meterCurrent != nil && meterEnergy != nil:
case identifier != nil && meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Warp2
api.Identifier
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Warp2: base,
Identifier: &decorateWarp2IdentifierImpl{
@ -236,12 +236,12 @@ func decorateWarp2(base *Warp2, meter func() (float64, error), meterEnergy func(
Meter: &decorateWarp2MeterImpl{
meter: meter,
},
MeterCurrent: &decorateWarp2MeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWarp2MeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWarp2PhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -264,14 +264,6 @@ func (impl *decorateWarp2MeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateWarp2MeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateWarp2MeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateWarp2MeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -279,3 +271,11 @@ type decorateWarp2MeterEnergyImpl struct {
func (impl *decorateWarp2MeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateWarp2PhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateWarp2PhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

62
charger/warp_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateWarp(base *Warp, meter func() (float64, error), meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Charger {
func decorateWarp(base *Warp, meter func() (float64, error), meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Charger {
switch {
case meter == nil && meterCurrent == nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents == nil:
return base
case meter != nil && meterCurrent == nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents == nil:
return &struct {
*Warp
api.Meter
@ -22,7 +22,7 @@ func decorateWarp(base *Warp, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent == nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Warp
api.MeterEnergy
@ -33,7 +33,7 @@ func decorateWarp(base *Warp, meter func() (float64, error), meterEnergy func()
},
}
case meter != nil && meterCurrent == nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents == nil:
return &struct {
*Warp
api.Meter
@ -48,64 +48,64 @@ func decorateWarp(base *Warp, meter func() (float64, error), meterEnergy func()
},
}
case meter == nil && meterCurrent != nil && meterEnergy == nil:
case meter == nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Warp
api.MeterCurrent
api.PhaseCurrents
}{
Warp: base,
MeterCurrent: &decorateWarpMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWarpPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy == nil:
case meter != nil && meterEnergy == nil && phaseCurrents != nil:
return &struct {
*Warp
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Warp: base,
Meter: &decorateWarpMeterImpl{
meter: meter,
},
MeterCurrent: &decorateWarpMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateWarpPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter == nil && meterCurrent != nil && meterEnergy != nil:
case meter == nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Warp
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Warp: base,
MeterCurrent: &decorateWarpMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWarpMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWarpPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meter != nil && meterCurrent != nil && meterEnergy != nil:
case meter != nil && meterEnergy != nil && phaseCurrents != nil:
return &struct {
*Warp
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Warp: base,
Meter: &decorateWarpMeterImpl{
meter: meter,
},
MeterCurrent: &decorateWarpMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateWarpMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateWarpPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -120,14 +120,6 @@ func (impl *decorateWarpMeterImpl) CurrentPower() (float64, error) {
return impl.meter()
}
type decorateWarpMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateWarpMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateWarpMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -135,3 +127,11 @@ type decorateWarpMeterEnergyImpl struct {
func (impl *decorateWarpMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateWarpPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateWarpPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

4
charger/webasto-next.go
View file

@ -212,9 +212,9 @@ func (wb *WebastoNext) TotalEnergy() (float64, error) {
return float64(binary.BigEndian.Uint32(b)) / 1e3, nil
}
var _ api.MeterCurrent = (*WebastoNext)(nil)
var _ api.PhaseCurrents = (*WebastoNext)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (wb *WebastoNext) Currents() (float64, float64, float64, error) {
var curr [3]float64
for l := uint16(0); l < 3; l++ {

4
charger/zaptec.go
View file

@ -247,9 +247,9 @@ func (c *Zaptec) ChargedEnergy() (float64, error) {
return res.ObservationByID(zaptec.TotalChargePowerSession).Float64()
}
var _ api.MeterCurrent = (*Zaptec)(nil)
var _ api.PhaseCurrents = (*Zaptec)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (c *Zaptec) Currents() (float64, float64, float64, error) {
res, err := c.statusG()
if err != nil {

6
cmd/dumper.go
View file

@ -55,7 +55,7 @@ func (d *dumper) Dump(name string, v interface{}) {
}
}
if v, ok := v.(api.MeterCurrent); ok {
if v, ok := v.(api.PhaseCurrents); ok {
if i1, i2, i3, err := v.Currents(); err != nil {
fmt.Fprintf(w, "Current L1..L3:\t%v\n", err)
} else {
@ -63,7 +63,7 @@ func (d *dumper) Dump(name string, v interface{}) {
}
}
if v, ok := v.(api.MeterVoltage); ok {
if v, ok := v.(api.PhaseVoltages); ok {
if u1, u2, u3, err := v.Voltages(); err != nil {
fmt.Fprintf(w, "Voltage L1..L3:\t%v\n", err)
} else {
@ -71,7 +71,7 @@ func (d *dumper) Dump(name string, v interface{}) {
}
}
if v, ok := v.(api.MeterPower); ok {
if v, ok := v.(api.PhasePowers); ok {
if p1, p2, p3, err := v.Powers(); err != nil {
fmt.Fprintf(w, "Power L1..L3:\t%v\n", err)
} else {

8
core/loadpoint.go
View file

@ -1602,11 +1602,11 @@ func (lp *Loadpoint) UpdateChargePower() {
}
}
// updateChargeCurrents uses MeterCurrent interface to count phases with current >=1A
// updateChargeCurrents uses PhaseCurrents interface to count phases with current >=1A
func (lp *Loadpoint) updateChargeCurrents() {
lp.chargeCurrents = nil
phaseMeter, ok := lp.chargeMeter.(api.MeterCurrent)
phaseMeter, ok := lp.chargeMeter.(api.PhaseCurrents)
if !ok {
return // don't guess
}
@ -1645,9 +1645,9 @@ func (lp *Loadpoint) updateChargeCurrents() {
}
}
// updateChargeVoltages uses MeterVoltage interface to count phases with nominal grid voltage
// updateChargeVoltages uses PhaseVoltages interface to count phases with nominal grid voltage
func (lp *Loadpoint) updateChargeVoltages() {
phaseMeter, ok := lp.chargeMeter.(api.MeterVoltage)
phaseMeter, ok := lp.chargeMeter.(api.PhaseVoltages)
if !ok {
return // don't guess
}

8
core/site.go
View file

@ -229,7 +229,7 @@ func (site *Site) Loadpoints() []loadpoint.API {
func meterCapabilities(name string, meter interface{}) string {
_, power := meter.(api.Meter)
_, energy := meter.(api.MeterEnergy)
_, currents := meter.(api.MeterCurrent)
_, currents := meter.(api.PhaseCurrents)
name += ":"
return fmt.Sprintf(" %-10s power %s energy %s currents %s",
@ -301,7 +301,7 @@ func (site *Site) DumpConfig() {
_, power := lp.charger.(api.Meter)
_, energy := lp.charger.(api.MeterEnergy)
_, currents := lp.charger.(api.MeterCurrent)
_, currents := lp.charger.(api.PhaseCurrents)
_, phases := lp.charger.(api.PhaseSwitcher)
_, wakeup := lp.charger.(api.Resurrector)
@ -461,7 +461,7 @@ func (site *Site) updateMeters() error {
// powers
var p1, p2, p3 float64
if phaseMeter, ok := site.gridMeter.(api.MeterPower); err == nil && ok {
if phaseMeter, ok := site.gridMeter.(api.PhasePowers); err == nil && ok {
p1, p2, p3, err = phaseMeter.Powers()
if err == nil {
phases := []float64{p1, p2, p3}
@ -473,7 +473,7 @@ func (site *Site) updateMeters() error {
}
// currents
if phaseMeter, ok := site.gridMeter.(api.MeterCurrent); err == nil && ok {
if phaseMeter, ok := site.gridMeter.(api.PhaseCurrents); err == nil && ok {
var i1, i2, i3 float64
i1, i2, i3, err = phaseMeter.Currents()
if err == nil {

4
meter/_blueprint.go
View file

@ -56,9 +56,9 @@ func (m *Blueprint) TotalEnergy() (float64, error) {
return 0, api.ErrNotAvailable
}
var _ api.MeterCurrent = (*Blueprint)(nil)
var _ api.PhaseCurrents = (*Blueprint)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (m *Blueprint) Currents() (float64, float64, float64, error) {
return 0, 0, 0, api.ErrNotAvailable
}

4
meter/cfos.go
View file

@ -78,9 +78,9 @@ func (wb *CfosPowerBrain) TotalEnergy() (float64, error) {
return float64(binary.BigEndian.Uint64(b)) / 1e3, err
}
// var _ api.MeterCurrent = (*CfosPowerBrain)(nil)
// var _ api.PhaseCurrents = (*CfosPowerBrain)(nil)
// // Currents implements the api.MeterCurrent interface
// // Currents implements the api.PhaseCurrents interface
// func (wb *CfosPowerBrain) Currents() (float64, float64, float64, error) {
// var currents []float64
// for _, regCurrent := range cfosRegCurrents {

4
meter/dsmr.go
View file

@ -69,7 +69,7 @@ func init() {
registry.Add("dsmr", NewDsmrFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateDsmr -b api.Meter -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateDsmr -b api.Meter -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewDsmrFromConfig creates a DSMR meter from generic config
func NewDsmrFromConfig(other map[string]interface{}) (api.Meter, error) {
@ -251,7 +251,7 @@ func (m *Dsmr) totalEnergy() (float64, error) {
return m.get(m.energy)
}
// currents implements the api.MeterCurrent interface
// currents implements the api.PhaseCurrents interface
func (m *Dsmr) currents() (float64, float64, float64, error) {
var res [3]float64

40
meter/dsmr_decorators.go
View file

@ -6,12 +6,12 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateDsmr(base api.Meter, meterEnergy func() (float64, error), meterCurrent func() (float64, float64, float64, error)) api.Meter {
func decorateDsmr(base api.Meter, meterEnergy func() (float64, error), phaseCurrents func() (float64, float64, float64, error)) api.Meter {
switch {
case meterCurrent == nil && meterEnergy == nil:
case meterEnergy == nil && phaseCurrents == nil:
return base
case meterCurrent == nil && meterEnergy != nil:
case meterEnergy != nil && phaseCurrents == nil:
return &struct {
api.Meter
api.MeterEnergy
@ -22,44 +22,36 @@ func decorateDsmr(base api.Meter, meterEnergy func() (float64, error), meterCurr
},
}
case meterCurrent != nil && meterEnergy == nil:
case meterEnergy == nil && phaseCurrents != nil:
return &struct {
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Meter: base,
MeterCurrent: &decorateDsmrMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateDsmrPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
case meterCurrent != nil && meterEnergy != nil:
case meterEnergy != nil && phaseCurrents != nil:
return &struct {
api.Meter
api.MeterCurrent
api.MeterEnergy
api.PhaseCurrents
}{
Meter: base,
MeterCurrent: &decorateDsmrMeterCurrentImpl{
meterCurrent: meterCurrent,
},
MeterEnergy: &decorateDsmrMeterEnergyImpl{
meterEnergy: meterEnergy,
},
PhaseCurrents: &decorateDsmrPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
return nil
}
type decorateDsmrMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
}
func (impl *decorateDsmrMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
}
type decorateDsmrMeterEnergyImpl struct {
meterEnergy func() (float64, error)
}
@ -67,3 +59,11 @@ type decorateDsmrMeterEnergyImpl struct {
func (impl *decorateDsmrMeterEnergyImpl) TotalEnergy() (float64, error) {
return impl.meterEnergy()
}
type decorateDsmrPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateDsmrPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}

2
meter/meter.go
View file

@ -13,7 +13,7 @@ func init() {
registry.Add(api.Custom, NewConfigurableFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateMeter -b api.Meter -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.MeterVoltage,Voltages,func() (float64, float64, float64, error)" -t "api.MeterPower,Powers,func() (float64, float64, float64, error)" -t "api.Battery,Soc,func() (float64, error)" -t "api.BatteryCapacity,Capacity,func() float64"
//go:generate go run ../cmd/tools/decorate.go -f decorateMeter -b api.Meter -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.PhaseVoltages,Voltages,func() (float64, float64, float64, error)" -t "api.PhasePowers,Powers,func() (float64, float64, float64, error)" -t "api.Battery,Soc,func() (float64, error)" -t "api.BatteryCapacity,Capacity,func() float64"
// NewConfigurableFromConfig creates api.Meter from config
func NewConfigurableFromConfig(other map[string]interface{}) (api.Meter, error) {

6
meter/meter_average.go
View file

@ -52,19 +52,19 @@ func NewMovingAverageFromConfig(other map[string]interface{}) (api.Meter, error)
// decorate currents reading
var currents func() (float64, float64, float64, error)
if m, ok := m.(api.MeterCurrent); ok {
if m, ok := m.(api.PhaseCurrents); ok {
currents = m.Currents
}
// decorate voltages reading
var voltages func() (float64, float64, float64, error)
if m, ok := m.(api.MeterVoltage); ok {
if m, ok := m.(api.PhaseVoltages); ok {
voltages = m.Voltages
}
// decorate powers reading
var powers func() (float64, float64, float64, error)
if m, ok := m.(api.MeterPower); ok {
if m, ok := m.(api.PhasePowers); ok {
powers = m.Powers
}

1424
meter/meter_decorators.go
View file

File diff suppressed because it is too large Load diff

2
meter/modbus.go
View file

@ -26,7 +26,7 @@ func init() {
registry.Add("modbus", NewModbusFromConfig)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateModbus -b api.Meter -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)" -t "api.MeterVoltage,Voltages,func() (float64, float64, float64, error)" -t "api.MeterPower,Powers,func() (float64, float64, float64, error)" -t "api.Battery,Soc,func() (float64, error)" -t "api.BatteryCapacity,Capacity,func() float64"
//go:generate go run ../cmd/tools/decorate.go -f decorateModbus -b api.Meter -t "api.MeterEnergy,TotalEnergy,func() (float64, error)" -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)" -t "api.PhaseVoltages,Voltages,func() (float64, float64, float64, error)" -t "api.PhasePowers,Powers,func() (float64, float64, float64, error)" -t "api.Battery,Soc,func() (float64, error)" -t "api.BatteryCapacity,Capacity,func() float64"
// NewModbusFromConfig creates api.Meter from config
func NewModbusFromConfig(other map[string]interface{}) (api.Meter, error) {

1424
meter/modbus_decorators.go
View file

File diff suppressed because it is too large Load diff

12
meter/sma.go
View file

@ -112,9 +112,9 @@ func (sm *SMA) TotalEnergy() (float64, error) {
return sma.AsFloat(values[sunny.ActiveEnergyPlus]) / 3600000, err
}
var _ api.MeterCurrent = (*SMA)(nil)
var _ api.PhaseCurrents = (*SMA)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (sm *SMA) Currents() (float64, float64, float64, error) {
values, err := sm.device.Values()
@ -133,9 +133,9 @@ func (sm *SMA) Currents() (float64, float64, float64, error) {
return currents[0], currents[1], currents[2], err
}
var _ api.MeterVoltage = (*SMA)(nil)
var _ api.PhaseVoltages = (*SMA)(nil)
// Voltages implements the api.MeterVoltage interface
// Voltages implements the api.PhaseVoltages interface
func (sm *SMA) Voltages() (float64, float64, float64, error) {
values, err := sm.device.Values()
@ -147,9 +147,9 @@ func (sm *SMA) Voltages() (float64, float64, float64, error) {
return voltages[0], voltages[1], voltages[2], err
}
var _ api.MeterPower = (*SMA)(nil)
var _ api.PhasePowers = (*SMA)(nil)
// Powers implements the api.MeterPower interface
// Powers implements the api.PhasePowers interface
func (sm *SMA) Powers() (float64, float64, float64, error) {
values, err := sm.device.Values()

4
meter/tibber-pulse.go
View file

@ -140,9 +140,9 @@ func (t *Tibber) CurrentPower() (float64, error) {
return t.live.Power - t.live.PowerProduction, nil
}
var _ api.MeterCurrent = (*Tibber)(nil)
var _ api.PhaseCurrents = (*Tibber)(nil)
// Currents implements the api.MeterCurrent interface
// Currents implements the api.PhaseCurrents interface
func (t *Tibber) Currents() (float64, float64, float64, error) {
t.mu.Lock()
defer t.mu.Unlock()

2
meter/tq-em.go
View file

@ -55,7 +55,7 @@ type TqEm struct {
dataG func() (tqemData, error)
}
//go:generate go run ../cmd/tools/decorate.go -f decorateTqEm -b api.Meter -t "api.MeterCurrent,Currents,func() (float64, float64, float64, error)"
//go:generate go run ../cmd/tools/decorate.go -f decorateTqEm -b api.Meter -t "api.PhaseCurrents,Currents,func() (float64, float64, float64, error)"
// NewTqEmFromConfig creates a new configurable meter
func NewTqEmFromConfig(other map[string]interface{}) (api.Meter, error) {

2
meter/tq-em420.go
View file

@ -156,7 +156,7 @@ func (m *TqEM420) TotalEnergy() (float64, error) {
return res.SmartMeter.Values.ActiveEnergyP / 1e3, err
}
var _ api.MeterCurrent = (*TqEM420)(nil)
var _ api.PhaseCurrents = (*TqEM420)(nil)
func (m *TqEM420) Currents() (float64, float64, float64, error) {
res, err := m.dataG()

20
meter/tq-em_decorators.go
View file

@ -6,19 +6,19 @@ import (
"github.com/evcc-io/evcc/api"
)
func decorateTqEm(base api.Meter, meterCurrent func() (float64, float64, float64, error)) api.Meter {
func decorateTqEm(base api.Meter, phaseCurrents func() (float64, float64, float64, error)) api.Meter {
switch {
case meterCurrent == nil:
case phaseCurrents == nil:
return base
case meterCurrent != nil:
case phaseCurrents != nil:
return &struct {
api.Meter
api.MeterCurrent
api.PhaseCurrents
}{
Meter: base,
MeterCurrent: &decorateTqEmMeterCurrentImpl{
meterCurrent: meterCurrent,
PhaseCurrents: &decorateTqEmPhaseCurrentsImpl{
phaseCurrents: phaseCurrents,
},
}
}
@ -26,10 +26,10 @@ func decorateTqEm(base api.Meter, meterCurrent func() (float64, float64, float64
return nil
}
type decorateTqEmMeterCurrentImpl struct {
meterCurrent func() (float64, float64, float64, error)
type decorateTqEmPhaseCurrentsImpl struct {
phaseCurrents func() (float64, float64, float64, error)
}
func (impl *decorateTqEmMeterCurrentImpl) Currents() (float64, float64, float64, error) {
return impl.meterCurrent()
func (impl *decorateTqEmPhaseCurrentsImpl) Currents() (float64, float64, float64, error) {
return impl.phaseCurrents()
}