Add battery grid charging

core/keys/site.go

@@ -43,6 +43,10 @@ const (
 	BufferStartSoc                    = "bufferStartSoc"
 	MaxGridSupplyWhileBatteryCharging = "maxGridSupplyWhileBatteryCharging"
 
+	// battery charging
+	GridChargeLimit  = "gridChargeLimit"
+	GridChargeActive = "gridChargeActive"
+
 	// battery status
 	Battery       = "battery"
 	BatteryEnergy = "batteryEnergy"

core/loadpoint.go

@@ -120,12 +120,12 @@ type Loadpoint struct {
 	MinCurrent_       float64       `mapstructure:"minCurrent"`
 	MaxCurrent_       float64       `mapstructure:"maxCurrent"`
 
-	minCurrent       float64 // PV mode: start current	Min+PV mode: min current
-	maxCurrent       float64 // Max allowed current. Physically ensured by the charger
-	configuredPhases int     // Charger configured phase mode 0/1/3
-	limitSoc         int     // Session limit for soc
-	limitEnergy      float64 // Session limit for energy
-	smartCostLimit   float64 // always charge if cost is below this value
+	minCurrent       float64  // PV mode: start current	Min+PV mode: min current
+	maxCurrent       float64  // Max allowed current. Physically ensured by the charger
+	configuredPhases int      // Charger configured phase mode 0/1/3
+	limitSoc         int      // Session limit for soc
+	limitEnergy      float64  // Session limit for energy
+	smartCostLimit   *float64 // always charge if cost is below this value
 
 	mode                api.ChargeMode
 	enabled             bool      // Charger enabled state
@@ -335,9 +335,15 @@ func (lp *Loadpoint) restoreSettings() {
 	if v, err := lp.settings.Float(keys.LimitEnergy); err == nil && v > 0 {
 		lp.setLimitEnergy(v)
 	}
-	if v, err := lp.settings.Float(keys.SmartCostLimit); err == nil {
-		lp.SetSmartCostLimit(v)
+
+	if v, err := lp.settings.String(keys.SmartCostLimit); err == nil {
+		if v == "" {
+			lp.SetSmartCostLimit(nil)
+		} else if v, err := lp.settings.Float(keys.SmartCostLimit); err == nil {
+			lp.SetSmartCostLimit(&v)
+		}
 	}
+
 	t, err1 := lp.settings.Time(keys.PlanTime)
 	v, err2 := lp.settings.Float(keys.PlanEnergy)
 	if err1 == nil && err2 == nil {

core/loadpoint/api.go

@@ -110,9 +110,9 @@ type API interface {
 	//
 
 	// GetSmartChargingActive determines if smart charging is active
-	GetSmartCostLimit() float64
+	GetSmartCostLimit() *float64
 	// SetSmartCostLimit sets the smart cost limit
-	SetSmartCostLimit(limit float64)
+	SetSmartCostLimit(limit *float64)
 
 	//
 	// power and energy

core/loadpoint_api.go

@@ -9,6 +9,7 @@ import (
 	"github.com/evcc-io/evcc/core/keys"
 	"github.com/evcc-io/evcc/core/loadpoint"
 	"github.com/evcc-io/evcc/core/wrapper"
+	"github.com/evcc-io/evcc/server/db/settings"
 )
 
 var _ loadpoint.API = (*Loadpoint)(nil)
@@ -489,23 +490,29 @@ func (lp *Loadpoint) StartVehicleDetection() {
 }
 
 // GetSmartCostLimit gets the smart cost limit
-func (lp *Loadpoint) GetSmartCostLimit() float64 {
+func (lp *Loadpoint) GetSmartCostLimit() *float64 {
 	lp.RLock()
 	defer lp.RUnlock()
 	return lp.smartCostLimit
 }
 
 // SetSmartCostLimit sets the smart cost limit
-func (lp *Loadpoint) SetSmartCostLimit(val float64) {
+func (lp *Loadpoint) SetSmartCostLimit(val *float64) {
 	lp.Lock()
 	defer lp.Unlock()
 
 	lp.log.DEBUG.Println("set smart cost limit:", val)
 
 	if lp.smartCostLimit != val {
 		lp.smartCostLimit = val
-		lp.settings.SetFloat(keys.SmartCostLimit, lp.smartCostLimit)
-		lp.publish(keys.SmartCostLimit, lp.smartCostLimit)
+
+		if val == nil {
+			settings.SetString(keys.SmartCostLimit, "")
+			lp.publish(keys.SmartCostLimit, "")
+		} else {
+			settings.SetFloat(keys.SmartCostLimit, *val)
+			lp.publish(keys.SmartCostLimit, *val)
+		}
 	}
 }
 

core/site.go

@@ -82,10 +82,11 @@
 	auxMeters     []api.Meter // Auxiliary meters
 
 	// battery settings
-	prioritySoc             float64 // prefer battery up to this Soc
-	bufferSoc               float64 // continue charging on battery above this Soc
-	bufferStartSoc          float64 // start charging on battery above this Soc
-	batteryDischargeControl bool    // prevent battery discharge for fast and planned charging
+	prioritySoc             float64  // prefer battery up to this Soc
+	bufferSoc               float64  // continue charging on battery above this Soc
+	bufferStartSoc          float64  // start charging on battery above this Soc
+	batteryDischargeControl bool     // prevent battery discharge for fast and planned charging
+	gridChargeLimit         *float64 // grid charging limit
 
 	loadpoints  []*Loadpoint             // Loadpoints
 	tariffs     *tariff.Tariffs          // Tariffs
@@ -295,6 +296,15 @@
 			return err
 		}
 	}
+
+	if v, err := settings.String(keys.GridChargeLimit); err == nil {
+		if v == "" {
+			site.SetGridChargeLimit(nil)
+		} else if v, err := settings.Float(keys.GridChargeLimit); err == nil {
+			site.SetGridChargeLimit(&v)
+		}
+	}
+
 	return nil
 }
 
@@ -792,8 +802,18 @@
 	var smartCostActive bool
 	if rate, err := site.plannerRate(); err == nil {
 		smartCostActive = site.smartCostActive(lp, rate)
+
+		gridChargeActive := site.gridChargeActive(rate)
+		site.publish(keys.GridChargeActive, gridChargeActive)
+
+		if gridChargeActive {
+			site.SetBatteryMode(api.BatteryCharge)
+		} else if mode := site.GetBatteryMode(); mode != api.BatteryNormal {
+			site.SetBatteryMode(api.BatteryNormal)
+		}
+
 	} else {
-		site.log.WARN.Println("smartCostActive:", err)
+		site.log.WARN.Println("smartCost:", err)
 	}
 
 	var smartCostNextStart time.Time

core/site/api.go

@@ -39,6 +39,11 @@ type API interface {
 	GetMaxGridSupplyWhileBatteryCharging() float64
 	SetMaxGridSupplyWhileBatteryCharging(float64) error
 
+	// GetGridChargeLimit get the grid charge limit
+	GetGridChargeLimit() *float64
+	// SetGridChargeLimit sets the grid charge limit
+	SetGridChargeLimit(limit *float64)
+
 	//
 	// power and energy
 	//

core/site_api.go

@@ -356,3 +356,28 @@ func (site *Site) SetBatteryDischargeControl(val bool) error {
 
 	return nil
 }
+
+func (site *Site) GetGridChargeLimit() *float64 {
+	site.RLock()
+	defer site.RUnlock()
+	return site.gridChargeLimit
+}
+
+func (site *Site) SetGridChargeLimit(val *float64) {
+	site.log.DEBUG.Println("set smart cost limit:", val)
+
+	site.Lock()
+	defer site.Unlock()
+
+	if site.gridChargeLimit != val {
+		site.gridChargeLimit = val
+
+		if val == nil {
+			settings.SetString(keys.GridChargeLimit, "")
+			site.publish(keys.GridChargeLimit, "")
+		} else {
+			settings.SetFloat(keys.GridChargeLimit, *val)
+			site.publish(keys.GridChargeLimit, *val)
+		}
+	}
+}

core/site_battery.go

@@ -80,25 +80,30 @@ func (site *Site) plannerRate() (*api.Rate, error) {
 
 func (site *Site) smartCostActive(lp loadpoint.API, rate *api.Rate) bool {
 	limit := lp.GetSmartCostLimit()
-	return limit != 0 && rate != nil && rate.Price <= limit
+	return limit != nil && rate != nil && rate.Price <= *limit
 }
 
 func (site *Site) smartCostNextStart(lp loadpoint.API, rate api.Rates) time.Time {
 	limit := lp.GetSmartCostLimit()
-	if limit == 0 || rate == nil {
+	if limit == nil || rate == nil {
 		return time.Time{}
 	}
 
 	now := time.Now()
 	for _, slot := range rate {
-		if slot.Start.After(now) && slot.Price <= limit {
+		if slot.Start.After(now) && slot.Price <= *limit {
 			return slot.Start
 		}
 	}
 
 	return time.Time{}
 }
 
+func (site *Site) gridChargeActive(rate *api.Rate) bool {
+	limit := site.GetGridChargeLimit()
+	return limit != nil && rate != nil && rate.Price <= *limit
+}
+
 func (site *Site) updateBatteryMode() {
 	mode := api.BatteryNormal
 

server/http.go

@@ -108,7 +108,10 @@ func (s *HTTPd) RegisterSiteHandlers(site site.API, valueChan chan<- util.Param)
 		"maxgridsupply":           {"POST", "/maxgridsupply/{value:[0-9.]+}", floatHandler(site.SetMaxGridSupplyWhileBatteryCharging, site.GetMaxGridSupplyWhileBatteryCharging)},
 		"prioritysoc":             {"POST", "/prioritysoc/{value:[0-9.]+}", floatHandler(site.SetPrioritySoc, site.GetPrioritySoc)},
 		"residualpower":           {"POST", "/residualpower/{value:-?[0-9.]+}", floatHandler(site.SetResidualPower, site.GetResidualPower)},
-		"smartcost":               {"POST", "/smartcostlimit/{value:-?[0-9.]+}", updateSmartCostLimit(site)},
+		"smartcost":               {"POST", "/smartcostlimit/{value:-?[0-9.]+}", updateGlobalSmartCostLimit(site)},
+		"smartcostdelete":         {"DELETE", "/smartcostlimit/{value:-?[0-9.]+}", updateGlobalSmartCostLimit(site)},
+		"gridcharge":              {"POST", "/gridchargelimit/{value:-?[0-9.]+}", updateGridChargeLimit(site)},
+		"gridchargedelete":        {"DELETE", "/gridchargelimit", updateGridChargeLimit(site)},
 		"tariff":                  {"GET", "/tariff/{tariff:[a-z]+}", tariffHandler(site)},
 		"sessions":                {"GET", "/sessions", sessionHandler},
 		"updatesession":           {"PUT", "/session/{id:[0-9]+}", updateSessionHandler},
@@ -173,7 +176,8 @@ func (s *HTTPd) RegisterSiteHandlers(site site.API, valueChan chan<- util.Param)
 			"remotedemand":     {"POST", "/remotedemand/{demand:[a-z]+}/{source:[0-9a-zA-Z_-]+}", remoteDemandHandler(lp)},
 			"enableThreshold":  {"POST", "/enable/threshold/{value:-?[0-9.]+}", floatHandler(pass(lp.SetEnableThreshold), lp.GetEnableThreshold)},
 			"disableThreshold": {"POST", "/disable/threshold/{value:-?[0-9.]+}", floatHandler(pass(lp.SetDisableThreshold), lp.GetDisableThreshold)},
-			"smartCostLimit":   {"POST", "/smartcostlimit/{value:-?[0-9.]+}", floatHandler(pass(lp.SetSmartCostLimit), lp.GetSmartCostLimit)},
+			"smartCost":        {"POST", "/smartcostlimit/{value:-?[0-9.]+}", updateSmartCostLimit(lp)},
+			"smartCostDelete":  {"DELETE", "/smartcostlimit", updateSmartCostLimit(lp)},
 			// "priority":         {"POST", "/priority/{value:[0-9.]+}", floatHandler(pass(lp.SetPriority), lp.GetPriority)},
 		}
 

server/http_loadpoint_handler.go

@@ -216,3 +216,26 @@ func vehicleDetectHandler(lp loadpoint.API) http.HandlerFunc {
 		jsonResult(w, res)
 	}
 }
+
+// updateSmartCostLimit sets the smart cost limit
+func updateSmartCostLimit(lp loadpoint.API) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var valP *float64
+
+		if r.Method != http.MethodDelete {
+			vars := mux.Vars(r)
+
+			val, err := parseFloat(vars["value"])
+			if err != nil {
+				jsonError(w, http.StatusBadRequest, err)
+				return
+			}
+
+			valP = &val
+		}
+
+		lp.SetSmartCostLimit(valP)
+
+		jsonResult(w, valP)
+	}
+}

server/http_site_handler.go

@@ -148,22 +148,51 @@ func boolGetHandler(get func() bool) http.HandlerFunc {
 	}
 }
 
-// updateSmartCostLimit sets the smart cost limit globally
-func updateSmartCostLimit(site site.API) http.HandlerFunc {
+// updateGlobalSmartCostLimit sets the smart cost limit globally
+func updateGlobalSmartCostLimit(site site.API) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		vars := mux.Vars(r)
+		var valP *float64
 
-		val, err := parseFloat(vars["value"])
-		if err != nil {
-			jsonError(w, http.StatusBadRequest, err)
-			return
+		if r.Method != http.MethodDelete {
+			vars := mux.Vars(r)
+
+			val, err := parseFloat(vars["value"])
+			if err != nil {
+				jsonError(w, http.StatusBadRequest, err)
+				return
+			}
+
+			valP = &val
 		}
 
 		for _, lp := range site.Loadpoints() {
-			lp.SetSmartCostLimit(val)
+			lp.SetSmartCostLimit(valP)
+		}
+
+		jsonResult(w, valP)
+	}
+}
+
+// updateGridChargeLimit sets the smart cost limit globally
+func updateGridChargeLimit(site site.API) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var valP *float64
+
+		if r.Method != http.MethodDelete {
+			vars := mux.Vars(r)
+
+			val, err := parseFloat(vars["value"])
+			if err != nil {
+				jsonError(w, http.StatusBadRequest, err)
+				return
+			}
+
+			valP = &val
 		}
 
-		jsonResult(w, val)
+		site.SetGridChargeLimit(valP)
+
+		jsonResult(w, valP)
 	}
 }
 

server/mqtt.go

@@ -178,12 +178,14 @@ func (m *MQTT) listenSiteSetters(topic string, site site.API) error {
 		{"/batteryDischargeControl", boolSetter(site.SetBatteryDischargeControl)},
 		{"/prioritySoc", floatSetter(site.SetPrioritySoc)},
 		{"/residualPower", floatSetter(site.SetResidualPower)},
-		{"/smartCostLimit", floatSetter(func(limit float64) error {
+		{"/smartCostLimit", floatPtrSetter(pass(func(limit *float64) {
 			for _, lp := range site.Loadpoints() {
 				lp.SetSmartCostLimit(limit)
 			}
-			return nil
-		})},
+		}))},
+		{"/gridChargeLimit", floatPtrSetter(pass(func(limit *float64) {
+			site.SetGridChargeLimit(limit)
+		}))},
 	} {
 		if err := m.Handler.ListenSetter(topic+s.topic, s.fun); err != nil {
 			return err
@@ -203,7 +205,7 @@ func (m *MQTT) listenLoadpointSetters(topic string, site site.API, lp loadpoint.
 		{"/limitEnergy", floatSetter(pass(lp.SetLimitEnergy))},
 		{"/enableThreshold", floatSetter(pass(lp.SetEnableThreshold))},
 		{"/disableThreshold", floatSetter(pass(lp.SetDisableThreshold))},
-		{"/smartCostLimit", floatSetter(pass(lp.SetSmartCostLimit))},
+		{"/smartCostLimit", floatPtrSetter(pass(lp.SetSmartCostLimit))},
 		{"/planEnergy", func(payload string) error {
 			var plan struct {
 				Time  time.Time `json:"time"`