Repeating plans: improve overrun behavior

core/loadpoint.go

@@ -159,11 +159,13 @@ type Loadpoint struct {
 	socEstimator   *soc.Estimator
 
 	// charge planning
-	planner     *planner.Planner
-	planTime    time.Time // time goal
-	planEnergy  float64   // Plan charge energy in kWh (dumb vehicles)
-	planSlotEnd time.Time // current plan slot end time
-	planActive  bool      // charge plan exists and has a currently active slot
+	planner        *planner.Planner
+	planTime       time.Time // time goal
+	planEnergy     float64   // Plan charge energy in kWh (dumb vehicles)
+	planSlotEnd    time.Time // current plan slot end time
+	planActive     bool      // charge plan exists and has a currently active slot
+	planActiveTime time.Time // needed to calculate the EffectivePlanTime if loading exceeds the target time
+	planActiveSoc  float64   // needed to calculate the EffectivePlanSoc if loading exceeds the target time
 
 	// cached state
 	status         api.ChargeStatus       // Charger status

core/loadpoint_effective.go

@@ -76,7 +76,12 @@ func (lp *Loadpoint) nextVehiclePlan() (time.Time, int, int) {
 
 // EffectivePlanSoc returns the soc target for the current plan
 func (lp *Loadpoint) EffectivePlanSoc() int {
+	if lp.planActive {
+		return int(lp.planActiveSoc)
+	}
+
 	_, soc, _ := lp.nextVehiclePlan()
+
 	return soc
 }
 
@@ -95,12 +100,18 @@ func (lp *Loadpoint) EffectivePlanId() int {
 
 // EffectivePlanTime returns the effective plan time
 func (lp *Loadpoint) EffectivePlanTime() time.Time {
+	if lp.planActive {
+		return lp.planActiveTime
+	}
+
+	var ts time.Time
+
 	if lp.socBasedPlanning() {
-		ts, _, _ := lp.nextVehiclePlan()
-		return ts
+		ts, _, _ = lp.nextVehiclePlan()
+	} else {
+		ts, _ = lp.GetPlanEnergy()
 	}
 
-	ts, _ := lp.GetPlanEnergy()
 	return ts
 }
 

core/loadpoint_plan.go

@@ -21,6 +21,8 @@ const (
 func (lp *Loadpoint) setPlanActive(active bool) {
 	if !active {
 		lp.planSlotEnd = time.Time{}
+		lp.planActiveTime = time.Time{}
+		lp.planActiveSoc = 0.0
 	}
 	if lp.planActive != active {
 		lp.planActive = active
@@ -37,6 +39,7 @@ func (lp *Loadpoint) finishPlan() {
 	} else if v := lp.GetVehicle(); v != nil {
 		vehicle.Settings(lp.log, v).SetPlanSoc(time.Time{}, 0)
 	}
+	lp.log.DEBUG.Println("plan: deleting expired plan")
 }
 
 // remainingPlanEnergy returns missing energy amount in kWh
@@ -85,32 +88,36 @@ func (lp *Loadpoint) GetPlan(targetTime time.Time, requiredDuration time.Duratio
 
 // plannerActive checks if the charging plan has a currently active slot
 func (lp *Loadpoint) plannerActive() (active bool) {
-	defer func() {
-		lp.setPlanActive(active)
-	}()
-
 	var planStart, planEnd time.Time
 	var planOverrun time.Duration
-
-	defer func() {
-		lp.publish(keys.PlanProjectedStart, planStart)
-		lp.publish(keys.PlanProjectedEnd, planEnd)
-		lp.publish(keys.PlanOverrun, planOverrun)
-	}()
-
 	planTime := lp.EffectivePlanTime()
 	if planTime.IsZero() {
 		return false
 	}
 
 	// keep overrunning plans as long as a vehicle is connected
 	if lp.clock.Until(planTime) < 0 && (!lp.planActive || !lp.connected()) {
-		lp.log.DEBUG.Println("plan: deleting expired plan")
 		lp.finishPlan()
 		return false
 	}
 
 	goal, isSocBased := lp.GetPlanGoal()
+
+	defer func() {
+		if active {
+			lp.planActiveTime = planTime
+			if isSocBased {
+				lp.planActiveSoc = goal
+			}
+		}
+
+		lp.setPlanActive(active)
+
+		lp.publish(keys.PlanProjectedStart, planStart)
+		lp.publish(keys.PlanProjectedEnd, planEnd)
+		lp.publish(keys.PlanOverrun, planOverrun)
+	}()
+
 	maxPower := lp.EffectiveMaxPower()
 	requiredDuration := lp.GetPlanRequiredDuration(goal, maxPower)
 	if requiredDuration <= 0 {
@@ -157,8 +164,8 @@ func (lp *Loadpoint) plannerActive() (active bool) {
 		}
 
 		// remember last active plan's end time
-		lp.setPlanActive(true)
 		lp.planSlotEnd = activeSlot.End
+		return true
 	} else if lp.planActive {
 		// planner was active (any slot, not necessarily previous slot) and charge goal has not yet been met
 		switch {
@@ -180,5 +187,5 @@ func (lp *Loadpoint) plannerActive() (active bool) {
 		}
 	}
 
-	return active
+	return false
 }