266 lines
6.5 KiB
Go
266 lines
6.5 KiB
Go
package charger
|
|
|
|
// LICENSE
|
|
|
|
// Copyright (c) evcc.io (andig, naltatis, premultiply)
|
|
|
|
// This module is NOT covered by the MIT license. All rights reserved.
|
|
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"math"
|
|
|
|
"github.com/evcc-io/evcc/api"
|
|
"github.com/evcc-io/evcc/util"
|
|
"github.com/evcc-io/evcc/util/modbus"
|
|
"github.com/evcc-io/evcc/util/sponsor"
|
|
"github.com/volkszaehler/mbmd/encoding"
|
|
)
|
|
|
|
// https://github.com/RustyDust/sonnen-charger/blob/main/Etrel%20INCH%20SmartHome%20Modbus%20TCPRegisters.xlsx
|
|
|
|
const (
|
|
// input, read-only
|
|
etrelRegChargeStatus = 0
|
|
etrelRegTargetCurrent = 4
|
|
etrelRegCurrents = 14 // 16, 18
|
|
etrelRegPower = 26
|
|
etrelRegSerial = 990
|
|
etrelRegModel = 1000
|
|
etrelRegHWVersion = 1010
|
|
etrelRegSWVersion = 1015
|
|
|
|
// Always zero, see https://github.com/evcc-io/evcc/issues/5346
|
|
// etrelRegSessionEnergy = 30
|
|
// etrelRegChargeTime = 32
|
|
|
|
// holding, write-only!
|
|
etrelRegMaxCurrent = 8
|
|
)
|
|
|
|
// Etrel is an api.Charger implementation for Etrel/Sonnen wallboxes
|
|
type Etrel struct {
|
|
log *util.Logger
|
|
conn *modbus.Connection
|
|
base uint16
|
|
current float32
|
|
}
|
|
|
|
func init() {
|
|
registry.AddCtx("etrel", NewEtrelFromConfig)
|
|
}
|
|
|
|
// NewEtrelFromConfig creates a Etrel charger from generic config
|
|
func NewEtrelFromConfig(ctx context.Context, other map[string]interface{}) (api.Charger, error) {
|
|
cc := struct {
|
|
Connector int
|
|
modbus.TcpSettings `mapstructure:",squash"`
|
|
}{
|
|
Connector: 1,
|
|
TcpSettings: modbus.TcpSettings{
|
|
ID: 1,
|
|
},
|
|
}
|
|
|
|
if err := util.DecodeOther(other, &cc); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return NewEtrel(ctx, cc.URI, cc.ID, cc.Connector)
|
|
}
|
|
|
|
// NewEtrel creates a Etrel charger
|
|
func NewEtrel(ctx context.Context, uri string, id uint8, connector int) (*Etrel, error) {
|
|
conn, err := modbus.NewConnection(ctx, uri, "", "", 0, modbus.Tcp, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !sponsor.IsAuthorized() {
|
|
return nil, api.ErrSponsorRequired
|
|
}
|
|
|
|
log := util.NewLogger("etrel")
|
|
conn.Logger(log.TRACE)
|
|
|
|
wb := &Etrel{
|
|
log: log,
|
|
conn: conn,
|
|
current: 6,
|
|
}
|
|
|
|
if connector == 2 {
|
|
wb.base = 100
|
|
}
|
|
|
|
return wb, nil
|
|
}
|
|
|
|
// Status implements the api.Charger interface
|
|
func (wb *Etrel) Status() (api.ChargeStatus, error) {
|
|
b, err := wb.conn.ReadInputRegisters(wb.base+etrelRegChargeStatus, 1)
|
|
if err != nil {
|
|
return api.StatusNone, err
|
|
}
|
|
|
|
// 0 Unknown
|
|
// 1 SocketAvailable
|
|
// 2 WaitingForVehicleToBeConnected
|
|
// 3 WaitingForVehicleToStart
|
|
// 4 Charging
|
|
// 5 ChargingPausedByEv
|
|
// 6 ChargingPausedByEvse
|
|
// 7 ChargingEnded
|
|
// 8 ChargingFault
|
|
// 9 UnpausingCharging
|
|
// 10 Unavailable
|
|
|
|
switch u := binary.BigEndian.Uint16(b); u {
|
|
case 0, 1, 2:
|
|
return api.StatusA, nil
|
|
case 3, 5, 6, 7, 9:
|
|
return api.StatusB, nil
|
|
case 4:
|
|
return api.StatusC, nil
|
|
default:
|
|
return api.StatusNone, fmt.Errorf("invalid status: %d", u)
|
|
}
|
|
}
|
|
|
|
// Enabled implements the api.Charger interface
|
|
func (wb *Etrel) Enabled() (bool, error) {
|
|
b, err := wb.conn.ReadInputRegisters(wb.base+etrelRegTargetCurrent, 2)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return encoding.Float32(b) > 0, nil
|
|
}
|
|
|
|
// Enable implements the api.Charger interface
|
|
func (wb *Etrel) Enable(enable bool) error {
|
|
var current float32
|
|
if enable {
|
|
current = wb.current
|
|
}
|
|
|
|
return wb.setCurrent(current)
|
|
}
|
|
|
|
func (wb *Etrel) setCurrent(current float32) error {
|
|
b := make([]byte, 4)
|
|
binary.BigEndian.PutUint32(b, math.Float32bits(current))
|
|
|
|
_, err := wb.conn.WriteMultipleRegisters(wb.base+etrelRegMaxCurrent, 2, b)
|
|
return err
|
|
}
|
|
|
|
// MaxCurrent implements the api.Charger interface
|
|
func (wb *Etrel) MaxCurrent(current int64) error {
|
|
return wb.MaxCurrentMillis(float64(current))
|
|
}
|
|
|
|
var _ api.ChargerEx = (*Etrel)(nil)
|
|
|
|
// MaxCurrentMillis implements the api.ChargerEx interface
|
|
func (wb *Etrel) MaxCurrentMillis(current float64) error {
|
|
if current < 6 {
|
|
return fmt.Errorf("invalid current %.1f", current)
|
|
}
|
|
|
|
curr := float32(current)
|
|
|
|
err := wb.setCurrent(curr)
|
|
if err == nil {
|
|
wb.current = curr
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// removed due to https://github.com/evcc-io/evcc/issues/14507
|
|
// var _ api.CurrentGetter = (*Etrel)(nil)
|
|
|
|
var _ api.Meter = (*Etrel)(nil)
|
|
|
|
// CurrentPower implements the api.Meter interface
|
|
func (wb *Etrel) CurrentPower() (float64, error) {
|
|
b, err := wb.conn.ReadInputRegisters(wb.base+etrelRegPower, 2)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return float64(encoding.Float32(b) * 1e3), err
|
|
}
|
|
|
|
var _ api.PhaseCurrents = (*Etrel)(nil)
|
|
|
|
// Currents implements the api.PhaseCurrents interface
|
|
func (wb *Etrel) Currents() (float64, float64, float64, error) {
|
|
b, err := wb.conn.ReadInputRegisters(etrelRegCurrents, 6)
|
|
if err != nil {
|
|
return 0, 0, 0, err
|
|
}
|
|
|
|
var res [3]float64
|
|
for i := range res {
|
|
res[i] = float64(encoding.Float32(b[4*i:]))
|
|
}
|
|
|
|
return res[0], res[1], res[2], nil
|
|
}
|
|
|
|
// var _ api.ChargeTimer = (*Etrel)(nil)
|
|
//
|
|
// // ChargeDuration implements the api.ChargeTimer interface
|
|
// func (wb *Etrel) ChargeDuration() (time.Duration, error) {
|
|
// b, err := wb.conn.ReadInputRegisters(wb.base+etrelRegChargeTime, 4)
|
|
// if err != nil {
|
|
// return 0, err
|
|
// }
|
|
//
|
|
// return time.Duration(int64(binary.BigEndian.Uint64(b))) * time.Second, nil
|
|
// }
|
|
|
|
// var _ api.ChargeRater = (*Etrel)(nil)
|
|
//
|
|
// // ChargedEnergy implements the api.ChargeRater interface
|
|
// func (wb *Etrel) ChargedEnergy() (float64, error) {
|
|
// b, err := wb.conn.ReadInputRegisters(wb.base+etrelRegSessionEnergy, 2)
|
|
// if err != nil {
|
|
// return 0, err
|
|
// }
|
|
//
|
|
// return float64(encoding.Float32(b)), err
|
|
// }
|
|
|
|
var _ api.Diagnosis = (*Etrel)(nil)
|
|
|
|
// Diagnose implements the api.Diagnosis interface
|
|
func (wb *Etrel) Diagnose() {
|
|
if b, err := wb.conn.ReadInputRegisters(etrelRegModel, 10); err == nil {
|
|
fmt.Printf("Model:\t%s\n", b)
|
|
}
|
|
if b, err := wb.conn.ReadInputRegisters(etrelRegSerial, 10); err == nil {
|
|
fmt.Printf("Serial:\t%s\n", b)
|
|
}
|
|
if b, err := wb.conn.ReadInputRegisters(etrelRegHWVersion, 5); err == nil {
|
|
fmt.Printf("Hardware:\t%s\n", b)
|
|
}
|
|
if b, err := wb.conn.ReadInputRegisters(etrelRegSWVersion, 5); err == nil {
|
|
fmt.Printf("Software:\t%s\n", b)
|
|
}
|
|
}
|