fix(EvseManager): Apply EVSE limits on DC target values if EV doesnt update its target values (#1893)

Pietfried · web-flow · commit cd96d4d14d90 · 2026-02-27T14:26:58.000Z
* fix(EvseManager):Apply EVSE limits on DC target values if EV doesnt update its target values

The ISO15118 stack may only publish EV target voltage/current on change,
so updated EVSE limits from energy management or BSP caps were never enforced when
the EV kept requesting the same values.

Store the raw EV targets as atomics and extract the clamping logic into
process_dc_ev_target_voltage_current(). The Charger state machine now
now calls process_dc_ev_target_voltage_current via signal_dc_enforce_target_limits
to re-clamp against current EVSE limits, in case apply_new_target_voltage_current
has no been called for 5 seconds

Signed-off-by: Piet Gömpel &lt;pietgoempel@gmail.com&gt;

* Only update power supply targets if values changed compared to last values

Signed-off-by: Piet Gömpel &lt;pietgoempel@gmail.com&gt;

---------

Signed-off-by: Piet Gömpel &lt;pietgoempel@gmail.com&gt;
diff --git a/modules/EVSE/EvseManager/Charger.cpp b/modules/EVSE/EvseManager/Charger.cpp
@@ -734,6 +734,14 @@ void Charger::run_state_machine() {
                 if (initialize_state) {
                     bsp->allow_power_on(true, types::evse_board_support::Reason::FullPowerCharging);
                 }
+                // Enforce EVSE target limits so that energy management
+                // changes are applied even when the EV does not send new targets
+                const auto now = std::chrono::steady_clock::now();
+                if (now - last_dc_enforce_target_limits.load() >=
+                    std::chrono::milliseconds(DC_ENFORCE_TARGET_LIMITS_INTERVAL_MS)) {
+                    last_dc_enforce_target_limits = now;
+                    signal_dc_enforce_target_limits(shared_context.current_evse_max_limits);
+                }
             } else {
                 check_soft_over_current();
 
@@ -1933,6 +1941,10 @@ void Charger::set_matching_started(bool m) {
     shared_context.matching_started = m;
 }
 
+void Charger::reset_dc_enforce_target_limits_timer() {
+    last_dc_enforce_target_limits = std::chrono::steady_clock::now();
+}
+
 void Charger::notify_currentdemand_started() {
     Everest::scoped_lock_timeout lock(state_machine_mutex,
                                       Everest::MutexDescription::Charger_notify_currentdemand_started);
diff --git a/modules/EVSE/EvseManager/Charger.hpp b/modules/EVSE/EvseManager/Charger.hpp
@@ -162,6 +162,7 @@ class Charger {
     sigslot::signal<> signal_ac_with_soc_timeout;
 
     sigslot::signal<> signal_dc_supply_off;
+    sigslot::signal<types::iso15118::DcEvseMaximumLimits> signal_dc_enforce_target_limits;
     sigslot::signal<> signal_slac_reset;
     sigslot::signal<> signal_slac_start;
 
@@ -179,6 +180,7 @@ class Charger {
     void set_matching_started(bool m);
 
     void notify_currentdemand_started();
+    void reset_dc_enforce_target_limits_timer();
 
     std::string evse_state_to_string(EvseState s);
 
@@ -398,12 +400,15 @@ class Charger {
 
         std::chrono::time_point<std::chrono::steady_clock> fatal_error_became_active;
         bool fatal_error_timer_running{false};
+
     } internal_context;
 
     // main Charger thread
     Everest::Thread main_thread_handle;
     Everest::Thread error_thread_handle;
 
+    std::atomic<std::chrono::steady_clock::time_point> last_dc_enforce_target_limits{};
+
     const std::unique_ptr<IECStateMachine>& bsp;
     const std::unique_ptr<ErrorHandling>& error_handling;
     const std::vector<std::unique_ptr<powermeterIntf>>& r_powermeter_billing;
@@ -440,6 +445,12 @@ class Charger {
     static constexpr int STAY_IN_X1_AFTER_TSTEP_EF_MS = 750;
     static constexpr int WAIT_FOR_ENERGY_IN_AUTHLOOP_TIMEOUT_MS = 5000;
     static constexpr int AC_X1_FALLBACK_TO_NOMINAL_TIMEOUT_MS = 3000;
+    // Ensures apply_new_target_voltage_current() is called at least every DC_ENFORCE_TARGET_LIMITS_INTERVAL_MS
+    // during DC charging. This re-applies EVSE limits to the power supply even when the EV does not send
+    // new target values or ignores updated limits from energy management.
+    // The timer is reset whenever apply_new_target_voltage_current() is called from any source
+    // (subscribe callback, energy manager, or this periodic signal).
+    static constexpr int DC_ENFORCE_TARGET_LIMITS_INTERVAL_MS = 5000;
 
     types::evse_manager::EnableDisableSource active_enable_disable_source{
         types::evse_manager::Enable_source::Unspecified, types::evse_manager::Enable_state::Unassigned, 10000};
diff --git a/modules/EVSE/EvseManager/EvseManager.cpp b/modules/EVSE/EvseManager/EvseManager.cpp
@@ -719,69 +719,16 @@ void EvseManager::ready() {
                 });
             }
 
-            // Car requests a target voltage and current limit
-            r_hlc[0]->subscribe_dc_ev_target_voltage_current(
-                [this](types::iso15118::DcEvTargetValues v) {
-                    bool target_changed = false;
-
-                    // Hack for Skoda Enyaq that should be fixed in a different way
-                    if (config.hack_skoda_enyaq and (v.dc_ev_target_voltage < 300 or v.dc_ev_target_current < 0))
-                        return;
-
-                    // Limit voltage/current for broken EV implementations
-                    const auto ev = get_ev_info();
-                    if (ev.maximum_current_limit.has_value() and
-                        v.dc_ev_target_current > ev.maximum_current_limit.value()) {
-                        v.dc_ev_target_current = ev.maximum_current_limit.value();
-                    }
-
-                    if (ev.maximum_voltage_limit.has_value() and
-                        v.dc_ev_target_voltage > ev.maximum_voltage_limit.value()) {
-                        v.dc_ev_target_voltage = ev.maximum_voltage_limit.value();
-                    }
-
-                    bool car_breaks_limit{false};
-                    const auto hlc_limits = charger->get_evse_max_hlc_limits();
-                    if (v.dc_ev_target_current > hlc_limits.evse_maximum_current_limit) {
-                        v.dc_ev_target_current = hlc_limits.evse_maximum_current_limit;
-                        car_breaks_limit = true;
-                    }
-
-                    const auto actual_voltage =
-                        ev_info.present_voltage.has_value() ? ev_info.present_voltage.value() : v.dc_ev_target_voltage;
-
-                    const auto target_power = v.dc_ev_target_current * actual_voltage;
-                    if (target_power > hlc_limits.evse_maximum_power_limit) {
-                        v.dc_ev_target_current = hlc_limits.evse_maximum_power_limit / actual_voltage;
-                        car_breaks_limit = true;
-                    }
-
-                    if (v.dc_ev_target_voltage not_eq latest_target_voltage or
-                        v.dc_ev_target_current not_eq latest_target_current) {
-                        latest_target_voltage = v.dc_ev_target_voltage;
-                        latest_target_current = v.dc_ev_target_current;
-                        target_changed = true;
-                    }
-
-                    if (target_changed) {
-                        apply_new_target_voltage_current();
-                        if (not contactor_open) {
-                            powersupply_DC_on();
-                        }
-                        if (car_breaks_limit) {
-                            EVLOG_warning
-                                << "EV ignores new EVSE max limits. Setting target current to new EVSE max limits";
-                        }
-
-                        {
-                            Everest::scoped_lock_timeout lock(ev_info_mutex,
-                                                              Everest::MutexDescription::EVSE_publish_ev_info);
-                            ev_info.target_voltage = latest_target_voltage;
-                            ev_info.target_current = latest_target_current;
-                            p_evse->publish_ev_info(ev_info);
-                        }
-                    }
-                });
+            // Car requests a target voltage and current limit.
+            // Store raw EV values and immediately clamp against EVSE limits.
+            // Clamping is also re-applied by the Charger state machine
+            // (signal_dc_enforce_target_limits) in case the EV doesnt respect the
+            // limits or does not change the target values for some time.
+            r_hlc[0]->subscribe_dc_ev_target_voltage_current([this](types::iso15118::DcEvTargetValues v) {
+                raw_ev_target_voltage = v.dc_ev_target_voltage;
+                raw_ev_target_current = v.dc_ev_target_current;
+                process_dc_ev_target_voltage_current(charger->get_evse_max_hlc_limits());
+            });
 
             r_hlc[0]->subscribe_d20_dc_dynamic_charge_mode([this](types::iso15118::DcChargeDynamicModeValues values) {
                 static bool last_is_actually_exporting_to_grid{false};
@@ -899,6 +846,11 @@ void EvseManager::ready() {
                 imd_stop();
             });
 
+            // Re-evaluate DC target limits so that updated EVSE
+            // limits are enforced even when the EV does not send new target values
+            charger->signal_dc_enforce_target_limits.connect(
+                [this](types::iso15118::DcEvseMaximumLimits limits) { process_dc_ev_target_voltage_current(limits); });
+
             // Current demand has finished - switch off DC supply
             r_hlc[0]->subscribe_current_demand_finished([this] { powersupply_DC_off(); });
 
@@ -2338,6 +2290,10 @@ void EvseManager::powersupply_DC_on() {
 // input voltage/current is what the evse/car would like to set.
 // if it is more then what the energymanager gave us, we can limit it here.
 bool EvseManager::powersupply_DC_set(double _voltage, double _current) {
+    if (last_power_supply_voltage == _voltage and last_power_supply_current == _current) {
+        return true;
+    }
+
     double voltage = _voltage;
     double current = _current;
     static bool last_is_actually_exporting_to_grid{false};
@@ -2392,6 +2348,8 @@ bool EvseManager::powersupply_DC_set(double _voltage, double _current) {
 
             // set the new limits for the DC output
             r_powersupply_DC[0]->call_setImportVoltageCurrent(voltage, current);
+            last_power_supply_voltage = voltage;
+            last_power_supply_current = current;
             return true;
         }
         EVLOG_critical << fmt::format("DC voltage/current out of limits requested: Voltage {:.2f} Current {:.2f}.",
@@ -2426,6 +2384,8 @@ bool EvseManager::powersupply_DC_set(double _voltage, double _current) {
 
         // set the new limits for the DC output
         r_powersupply_DC[0]->call_setExportVoltageCurrent(voltage, current);
+        last_power_supply_voltage = voltage;
+        last_power_supply_current = current;
         return true;
     }
     EVLOG_critical << fmt::format("DC voltage/current out of limits requested: Voltage {:.2f} Current {:.2f}.", voltage,
@@ -2577,10 +2537,75 @@ types::evse_manager::EVInfo EvseManager::get_ev_info() {
     return ev_info;
 }
 
+void EvseManager::process_dc_ev_target_voltage_current(const types::iso15118::DcEvseMaximumLimits& hlc_limits) {
+    double clamped_voltage = raw_ev_target_voltage.load();
+    double clamped_current = raw_ev_target_current.load();
+
+    // Hack for Skoda Enyaq that should be fixed in a different way
+    if (config.hack_skoda_enyaq and (clamped_voltage < 300 or clamped_current < 0)) {
+        return;
+    }
+
+    // Limit voltage/current for broken EV implementations
+    const auto ev_info_snapshot = get_ev_info();
+    if (ev_info_snapshot.maximum_current_limit.has_value() and
+        clamped_current > ev_info_snapshot.maximum_current_limit.value()) {
+        clamped_current = ev_info_snapshot.maximum_current_limit.value();
+    }
+    if (ev_info_snapshot.maximum_voltage_limit.has_value() and
+        clamped_voltage > ev_info_snapshot.maximum_voltage_limit.value()) {
+        clamped_voltage = ev_info_snapshot.maximum_voltage_limit.value();
+    }
+
+    bool car_breaks_limit{false};
+    if (clamped_current > hlc_limits.evse_maximum_current_limit) {
+        clamped_current = hlc_limits.evse_maximum_current_limit;
+        car_breaks_limit = true;
+    }
+
+    const auto actual_voltage =
+        ev_info_snapshot.present_voltage.has_value() ? ev_info_snapshot.present_voltage.value() : clamped_voltage;
+
+    const auto target_power = clamped_current * actual_voltage;
+    if (target_power > hlc_limits.evse_maximum_power_limit) {
+        clamped_current = hlc_limits.evse_maximum_power_limit / actual_voltage;
+        car_breaks_limit = true;
+    }
+
+    bool target_changed = false;
+    if (clamped_voltage not_eq latest_target_voltage or clamped_current not_eq latest_target_current) {
+        latest_target_voltage = clamped_voltage;
+        latest_target_current = clamped_current;
+        target_changed = true;
+    }
+
+    apply_new_target_voltage_current();
+
+    if (target_changed) {
+        if (not contactor_open) {
+            powersupply_DC_on();
+        }
+        if (car_breaks_limit) {
+            EVLOG_warning << "EV ignores new EVSE max limits. Setting target current to new EVSE max limits";
+        }
+
+        {
+            Everest::scoped_lock_timeout lock(ev_info_mutex, Everest::MutexDescription::EVSE_publish_ev_info);
+            ev_info.target_voltage = latest_target_voltage;
+            ev_info.target_current = latest_target_current;
+            p_evse->publish_ev_info(ev_info);
+        }
+    }
+}
+
 void EvseManager::apply_new_target_voltage_current() {
     if (latest_target_voltage > 0) {
         powersupply_DC_set(latest_target_voltage, latest_target_current);
     }
+
+    // We allow the EV to adjust the voltage/current for a few seconds
+    // so we reset the timer on every new target value received.
+    charger->reset_dc_enforce_target_limits_timer();
 }
 
 bool EvseManager::session_is_iso_d20_ac_bpt() {
diff --git a/modules/EVSE/EvseManager/EvseManager.hpp b/modules/EVSE/EvseManager/EvseManager.hpp
@@ -232,6 +232,7 @@ class EvseManager : public Everest::ModuleBase {
 
     types::evse_manager::EVInfo get_ev_info();
     void apply_new_target_voltage_current();
+    void process_dc_ev_target_voltage_current(const types::iso15118::DcEvseMaximumLimits& hlc_limits);
 
     std::string selected_protocol = "Unknown";
 
@@ -339,8 +340,14 @@ class EvseManager : public Everest::ModuleBase {
     static constexpr std::chrono::seconds MIN_TIME_BETWEEN_FIRST_AND_LAST_FAILURE{2};
     static constexpr int REQUIRED_CONSECUTIVE_FAILURES{2};
 
-    double latest_target_voltage;
-    double latest_target_current;
+    std::atomic<double> latest_target_voltage{0.};
+    std::atomic<double> latest_target_current{0.};
+    std::atomic<double> last_power_supply_voltage{0.};
+    std::atomic<double> last_power_supply_current{0.};
+
+    // Raw EV target values as received from ISO15118 stack
+    std::atomic<double> raw_ev_target_voltage{0.};
+    std::atomic<double> raw_ev_target_current{0.};
 
     types::authorization::ProvidedIdToken autocharge_token;
 
