Add soc: min setting to always force-charge to this value (#379)

Author: andig

assets/index.html

@@ -335,7 +335,8 @@ <h2 class="value">
 <div class="row">
   <div class="col-6 col-md-3 mt-3">
     <div class="mb-2 value">Leistung
-      <i class="text-primary fa fa-temperature-low ml-1" v-if="state.climater=='heating'"></i>
+      <i class="text-warning fas fa-battery-quarter ml-1" v-if="minSoCActive"></i>
+      <i class="text-primary fa fa-temperature-low ml-1" v-else-if="state.climater=='heating'"></i>
       <i class="text-primary fa fa-temperature-high ml-1" v-else-if="state.climater=='cooling'"></i>
       <i class="text-primary fa fa-thermometer-half ml-1" v-else-if="state.climater=='on'"></i>
     </div>
@@ -413,6 +414,7 @@ <h2 class="value">
         'progress-bar-animated': state.charging,
         'bg-light': !state.connected,
         'text-secondary': !state.connected,
+        'bg-warning': state.connected && minSoCActive,
       }" v-bind:style="{width: socChargeDisplayWidth+'%'}">{{socChargeDisplayValue}}</div>
   </div>
 </div>

assets/js/app.js

@@ -346,7 +346,12 @@ Vue.component("loadpoint", {
 Vue.component("loadpoint-details", {
   template: "#loadpoint-details-template",
   props: ["state"],
-  mixins: [formatter]
+  mixins: [formatter],
+  computed: {
+    minSoCActive: function () {
+      return this.state.minSoC > 0 && this.state.socCharge < this.state.minSoC;
+    }
+  }
 });
 
 Vue.component("vehicle", {
@@ -377,6 +382,9 @@ Vue.component("vehicle", {
         socCharge += "%";
       }
       return socCharge;
+    },
+    minSoCActive: function () {
+      return this.state.minSoC > 0 && this.state.socCharge < this.state.minSoC;
     }
   }
 });

cmd/setup.go

@@ -21,7 +21,7 @@ func init() {
 }
 
 // setup influx databases
-func configureDatabase(conf server.InfluxConfig, loadPoints []*core.LoadPoint, in <-chan util.Param) {
+func configureDatabase(conf server.InfluxConfig, loadPoints []core.LoadPointAPI, in <-chan util.Param) {
 	influx := server.NewInfluxClient(
 		conf.URL,
 		conf.Token,

core/loadpoint.go

@@ -29,6 +29,15 @@ const (
 	minActiveCurrent = 1.0 // minimum current at which a phase is treated as active
 )
 
+// SoCConfig defines soc settings, estimation and update behaviour
+type SoCConfig struct {
+	AlwaysUpdate bool  `mapstructure:"alwaysUpdate"`
+	Levels       []int `mapstructure:"levels"`
+	Estimate     bool  `mapstructure:"estimate"`
+	Min          int   `mapstructure:"min"`    // Default minimum SoC, guarded by mutex
+	Target       int   `mapstructure:"target"` // Default target SoC, guarded by mutex
+}
+
 // ThresholdConfig defines enable/disable hysteresis parameters
 type ThresholdConfig struct {
 	Delay     time.Duration
@@ -47,8 +56,7 @@ type LoadPoint struct {
 
 	// exposed public configuration
 	sync.Mutex                // guard status
-	Mode       api.ChargeMode `mapstructure:"mode"`      // Charge mode, guarded by mutex
-	TargetSoC  int            `mapstructure:"targetSoC"` // Target SoC, guarded by mutex
+	Mode       api.ChargeMode `mapstructure:"mode"` // Charge mode, guarded by mutex
 
 	Title      string `mapstructure:"title"`   // UI title
 	Phases     int64  `mapstructure:"phases"`  // Phases- required for converting power and current
@@ -57,11 +65,7 @@ type LoadPoint struct {
 	Meters     struct {
 		ChargeMeterRef string `mapstructure:"charge"` // Charge meter reference
 	}
-	SoC struct {
-		AlwaysUpdate bool  `mapstructure:"alwaysUpdate"`
-		Levels       []int `mapstructure:"levels"`
-		Estimate     bool  `mapstructure:"estimate"`
-	}
+	SoC          SoCConfig
 	OnDisconnect struct {
 		Mode      api.ChargeMode `mapstructure:"mode"`      // Charge mode to apply when car disconnected
 		TargetSoC int            `mapstructure:"targetSoC"` // Target SoC to apply when car disconnected
@@ -102,11 +106,14 @@ func NewLoadPointFromConfig(log *util.Logger, cp configProvider, other map[strin
 	lp.OnDisconnect.Mode = api.ChargeModeString(string(lp.OnDisconnect.Mode))
 
 	sort.Ints(lp.SoC.Levels)
-	if lp.TargetSoC == 0 {
-		lp.TargetSoC = 100
+	if lp.SoC.Target == 0 {
+		lp.SoC.Target = lp.OnDisconnect.TargetSoC // use disconnect value as default soc
+		if lp.SoC.Target == 0 {
+			lp.SoC.Target = 100
+		}
 
 		if len(lp.SoC.Levels) > 0 {
-			lp.TargetSoC = lp.SoC.Levels[len(lp.SoC.Levels)-1]
+			lp.SoC.Target = lp.SoC.Levels[len(lp.SoC.Levels)-1]
 		}
 	}
 
@@ -162,50 +169,6 @@ func NewLoadPoint(log *util.Logger) *LoadPoint {
 	return lp
 }
 
-// GetMode returns loadpoint charge mode
-func (lp *LoadPoint) GetMode() api.ChargeMode {
-	lp.Lock()
-	defer lp.Unlock()
-	return lp.Mode
-}
-
-// SetMode sets loadpoint charge mode
-func (lp *LoadPoint) SetMode(mode api.ChargeMode) {
-	lp.Lock()
-	defer lp.Unlock()
-
-	lp.log.INFO.Printf("set charge mode: %s", string(mode))
-
-	// apply immediately
-	if lp.Mode != mode {
-		lp.Mode = mode
-		lp.publish("mode", mode)
-		lp.requestUpdate()
-	}
-}
-
-// GetTargetSoC returns loadpoint charge targetSoC
-func (lp *LoadPoint) GetTargetSoC() int {
-	lp.Lock()
-	defer lp.Unlock()
-	return lp.TargetSoC
-}
-
-// SetTargetSoC sets loadpoint charge targetSoC
-func (lp *LoadPoint) SetTargetSoC(targetSoC int) {
-	lp.Lock()
-	defer lp.Unlock()
-
-	lp.log.INFO.Println("set target soc:", targetSoC)
-
-	// apply immediately
-	if lp.TargetSoC != targetSoC {
-		lp.TargetSoC = targetSoC
-		lp.publish("targetSoC", targetSoC)
-		lp.requestUpdate()
-	}
-}
-
 // requestUpdate requests site to update this loadpoint
 func (lp *LoadPoint) requestUpdate() {
 	select {
@@ -309,7 +272,7 @@ func (lp *LoadPoint) evVehicleDisconnectHandler() {
 		lp.SetMode(lp.OnDisconnect.Mode)
 	}
 	if lp.OnDisconnect.TargetSoC != 0 {
-		lp.SetTargetSoC(lp.OnDisconnect.TargetSoC)
+		_ = lp.SetTargetSoC(lp.OnDisconnect.TargetSoC)
 	}
 }
 
@@ -364,7 +327,8 @@ func (lp *LoadPoint) Prepare(uiChan chan<- util.Param, pushChan chan<- push.Even
 	// publish initial values
 	lp.Lock()
 	lp.publish("mode", lp.Mode)
-	lp.publish("targetSoC", lp.TargetSoC)
+	lp.publish("targetSoC", lp.SoC.Target)
+	lp.publish("minSoC", lp.SoC.Min)
 	lp.Unlock()
 
 	// prepare charger status
@@ -376,10 +340,20 @@ func (lp *LoadPoint) connected() bool {
 	return lp.status == api.StatusB || lp.status == api.StatusC
 }
 
-// targetSocReached checks if targetSoC configured and reached
-func (lp *LoadPoint) targetSocReached(socCharge, targetSoC float64) bool {
-	// check for vehicle != nil is not necessary as socCharge would be zero then
-	return targetSoC > 0 && targetSoC < 100 && socCharge >= targetSoC
+// targetSocReached checks if target is configured and reached.
+// If vehicle is not configured this will always return false
+func (lp *LoadPoint) targetSocReached() bool {
+	return lp.vehicle != nil &&
+		lp.SoC.Target > 0 &&
+		lp.socCharge >= float64(lp.SoC.Target)
+}
+
+// minSocNotReached checks if minimum is configured and not reached.
+// If vehicle is not configured this will always return true
+func (lp *LoadPoint) minSocNotReached() bool {
+	return lp.vehicle != nil &&
+		lp.SoC.Min > 0 &&
+		lp.socCharge < float64(lp.SoC.Min)
 }
 
 // climateActive checks if vehicle has active climate request
@@ -481,8 +455,13 @@ func (lp *LoadPoint) detectPhases() {
 	}
 }
 
-// maxCurrent calculates the maximum target current for PV mode
-func (lp *LoadPoint) maxCurrent(mode api.ChargeMode, sitePower float64) int64 {
+// pvDisableTimer puts the pv enable/disable timer into elapsed state
+func (lp *LoadPoint) pvDisableTimer() {
+	lp.pvTimer = time.Now().Add(-lp.Disable.Delay)
+}
+
+// pvMaxCurrent calculates the maximum target current for PV mode
+func (lp *LoadPoint) pvMaxCurrent(mode api.ChargeMode, sitePower float64) int64 {
 	// calculate target charge current from delta power and actual current
 	effectiveCurrent := lp.handler.TargetCurrent()
 	if lp.status != api.StatusC {
@@ -624,11 +603,11 @@ func (lp *LoadPoint) publishSoC() {
 
 			chargeEstimate := time.Duration(-1)
 			if lp.charging {
-				chargeEstimate = lp.socEstimator.RemainingChargeDuration(lp.chargePower, lp.TargetSoC)
+				chargeEstimate = lp.socEstimator.RemainingChargeDuration(lp.chargePower, lp.SoC.Target)
 			}
 			lp.publish("chargeEstimate", chargeEstimate)
 
-			chargeRemainingEnergy := 1e3 * lp.socEstimator.RemainingChargeEnergy(lp.TargetSoC)
+			chargeRemainingEnergy := 1e3 * lp.socEstimator.RemainingChargeEnergy(lp.SoC.Target)
 			lp.publish("chargeRemainingEnergy", chargeRemainingEnergy)
 
 			return
@@ -684,8 +663,8 @@ func (lp *LoadPoint) Update(sitePower float64) {
 		// https://github.com/andig/evcc/issues/105
 		err = lp.handler.Ramp(0)
 
-	case lp.targetSocReached(lp.socCharge, float64(lp.TargetSoC)):
-		var targetCurrent int64
+	case lp.targetSocReached():
+		var targetCurrent int64 // zero disables
 		if lp.climateActive() {
 			targetCurrent = lp.MinCurrent
 		}
@@ -694,11 +673,15 @@ func (lp *LoadPoint) Update(sitePower float64) {
 	case mode == api.ModeOff:
 		err = lp.handler.Ramp(0, true)
 
+	case lp.minSocNotReached():
+		err = lp.handler.Ramp(lp.MaxCurrent, true)
+		lp.pvDisableTimer() // let PV mode disable immediately afterwards
+
 	case mode == api.ModeNow:
 		err = lp.handler.Ramp(lp.MaxCurrent, true)
 
 	case mode == api.ModeMinPV || mode == api.ModePV:
-		targetCurrent := lp.maxCurrent(mode, sitePower)
+		targetCurrent := lp.pvMaxCurrent(mode, sitePower)
 		lp.log.DEBUG.Printf("target charge current: %dA", targetCurrent)
 
 		var required bool // false

core/loadpoint_api.go

@@ -0,0 +1,136 @@
+package core
+
+import (
+	"github.com/andig/evcc/api"
+	"github.com/andig/evcc/core/wrapper"
+)
+
+// LoadPointAPI is the external loadpoint API
+type LoadPointAPI interface {
+	Name() string
+	HasChargeMeter() bool
+	LoadPointSettingsAPI
+	LoadPointEnergyAPI
+}
+
+// LoadPointSettingsAPI is the getter/setter part of the external loadpoint API
+type LoadPointSettingsAPI interface {
+	GetMode() api.ChargeMode
+	SetMode(api.ChargeMode)
+	GetTargetSoC() int
+	SetTargetSoC(int) error
+	GetMinSoC() int
+	SetMinSoC(int) error
+}
+
+// LoadPointEnergyAPI is the external loadpoint API
+type LoadPointEnergyAPI interface {
+	GetMinCurrent() int64
+	GetMaxCurrent() int64
+	GetMinPower() int64
+	GetMaxPower() int64
+}
+
+// GetMode returns loadpoint charge mode
+func (lp *LoadPoint) GetMode() api.ChargeMode {
+	lp.Lock()
+	defer lp.Unlock()
+	return lp.Mode
+}
+
+// SetMode sets loadpoint charge mode
+func (lp *LoadPoint) SetMode(mode api.ChargeMode) {
+	lp.Lock()
+	defer lp.Unlock()
+
+	lp.log.INFO.Printf("set charge mode: %s", string(mode))
+
+	// apply immediately
+	if lp.Mode != mode {
+		lp.Mode = mode
+		lp.publish("mode", mode)
+		lp.requestUpdate()
+	}
+}
+
+// GetTargetSoC returns loadpoint charge target soc
+func (lp *LoadPoint) GetTargetSoC() int {
+	lp.Lock()
+	defer lp.Unlock()
+	return lp.SoC.Target
+}
+
+// SetTargetSoC sets loadpoint charge target soc
+func (lp *LoadPoint) SetTargetSoC(soc int) error {
+	if lp.vehicle == nil {
+		return api.ErrNotAvailable
+	}
+
+	lp.Lock()
+	defer lp.Unlock()
+
+	lp.log.INFO.Println("set target soc:", soc)
+
+	// apply immediately
+	if lp.SoC.Target != soc {
+		lp.SoC.Target = soc
+		lp.publish("targetSoC", soc)
+		lp.requestUpdate()
+	}
+
+	return nil
+}
+
+// GetMinSoC returns loadpoint charge minimum soc
+func (lp *LoadPoint) GetMinSoC() int {
+	lp.Lock()
+	defer lp.Unlock()
+	return lp.SoC.Min
+}
+
+// SetMinSoC sets loadpoint charge minimum soc
+func (lp *LoadPoint) SetMinSoC(soc int) error {
+	if lp.vehicle == nil {
+		return api.ErrNotAvailable
+	}
+
+	lp.Lock()
+	defer lp.Unlock()
+
+	lp.log.INFO.Println("set min soc:", soc)
+
+	// apply immediately
+	if lp.SoC.Min != soc {
+		lp.SoC.Min = soc
+		lp.publish("minSoC", soc)
+		lp.requestUpdate()
+	}
+
+	return nil
+}
+
+// HasChargeMeter determines if a physical charge meter is attached
+func (lp *LoadPoint) HasChargeMeter() bool {
+	_, isWrapped := lp.chargeMeter.(*wrapper.ChargeMeter)
+	return lp.chargeMeter != nil && !isWrapped
+}
+
+// GetMinCurrent returns the minimal loadpoint current
+func (lp *LoadPoint) GetMinCurrent() int64 {
+	return lp.MinCurrent
+}
+
+// GetMaxCurrent returns the minimal loadpoint current
+func (lp *LoadPoint) GetMaxCurrent() int64 {
+	return lp.MaxCurrent
+}
+
+// GetMinPower returns the minimal loadpoint power for a single phase
+func (lp *LoadPoint) GetMinPower() int64 {
+	return int64(Voltage) * lp.MinCurrent
+}
+
+// GetMaxPower returns the minimal loadpoint power taking active phases into account
+func (lp *LoadPoint) GetMaxPower() int64 {
+	return int64(Voltage) * lp.Phases * lp.MaxCurrent
+}