Add HLC no‑energy timeout and reuse power_available()

Signed-off-by: Piet Gömpel <pietgoempel@gmail.com>

Author: Pietfried

modules/EVSE/EvseManager/CMakeLists.txt

@@ -19,6 +19,7 @@ target_sources(${MODULE_NAME}
         ErrorHandling.cpp
         backtrace.cpp
         PersistentStore.cpp
+        over_voltage/OverVoltageMonitor.cpp
 )
 
 target_link_libraries(${MODULE_NAME}
@@ -56,7 +57,6 @@ target_sources(${MODULE_NAME}
         "token_provider/auth_token_providerImpl.cpp"
         "random_delay/uk_random_delayImpl.cpp"
         "dc_external_derate/dc_external_derateImpl.cpp"
-        "over_voltage/OverVoltageMonitor.cpp"
 )
 
 # ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1

modules/EVSE/EvseManager/Charger.cpp

@@ -307,7 +307,7 @@ void Charger::run_state_machine() {
             if (config_context.charge_mode == ChargeMode::DC) {
                 // Create a copy of the atomic struct
                 types::iso15118::DcEvseMaximumLimits evse_limit = shared_context.current_evse_max_limits;
-                if (not(evse_limit.evse_maximum_current_limit > 0 and evse_limit.evse_maximum_power_limit > 0)) {
+                if (not power_available()) {
 
                     // Wait some time here in this state to see if we get energy from the EnergyManager...
                     if (time_in_current_state < WAIT_FOR_ENERGY_IN_AUTHLOOP_TIMEOUT_MS) {
@@ -593,11 +593,12 @@ void Charger::run_state_machine() {
             if (initialize_state) {
                 signal_simple_event(types::evse_manager::SessionEventEnum::PrepareCharging);
                 bcb_toggle_reset();
+                internal_context.hlc_charge_loop_no_energy_timeout_running = false;
 
                 if (config_context.charge_mode == ChargeMode::DC) {
                     // Create a copy of the atomic struct
                     types::iso15118::DcEvseMaximumLimits evse_limit = shared_context.current_evse_max_limits;
-                    if (not(evse_limit.evse_maximum_current_limit > 0 and evse_limit.evse_maximum_power_limit > 0)) {
+                    if (not power_available()) {
                         signal_hlc_no_energy_available();
                     }
                 }
@@ -628,18 +629,17 @@ void Charger::run_state_machine() {
                 // used as the car can do BASIC and HLC charging any time. In AC HLC with 5 percent mode, we need to
                 // wait for both iec_allow and hlc_allow.
                 if (not power_available() and not hlc_use_5percent_current_session) {
-                    //For AC BC: it is ok to wait here.
-                    // For AC and DC ISO, continue in case we are in 5% mode. This allows us to go into
-                    // Charge loop and report 0A/0W to the EV
+                    // For AC BC: it is ok to wait here.
+                    //  For AC and DC ISO, continue in case we are in 5% mode. This allows us to go into
+                    //  Charge loop and report 0A/0W to the EV
                     break;
                 }
 
                 // Power is available or we are in HLC, PWM is already enabled. Check if we can go to charging
                 if ((shared_context.iec_allow_close_contactor and not hlc_use_5percent_current_session) or
                     (shared_context.iec_allow_close_contactor and shared_context.hlc_allow_close_contactor and
                      hlc_use_5percent_current_session)) {
-
-                    shared_context.current_state = EvseState::Charging;
+                    set_state(EvseState::Charging);
                 } else {
                     // We have power and PWM is on, but EV did not proceed to state C yet (and/or HLC is not
                     // ready)
@@ -661,6 +661,8 @@ void Charger::run_state_machine() {
                 }
             }
 
+            // For DC we go into charging when CurrentDemand started (notify_currentdemand_started)
+
             // if (charge_mode == ChargeMode::DC) {
             //  DC: wait until car requests power on CP (B->C/D).
             //  Then we close contactor and wait for instructions from HLC.
@@ -695,25 +697,54 @@ void Charger::run_state_machine() {
                 break;
             }
 
+            if (not power_available()) {
+                const bool hlc_session_active =
+                    shared_context.hlc_charging_active or hlc_use_5percent_current_session;
+                if (hlc_session_active) {
+                    if (config_context.hlc_charge_loop_without_energy_timeout_s > 0) {
+                        if (not internal_context.hlc_charge_loop_no_energy_timeout_running) {
+                            internal_context.hlc_charge_loop_no_energy_timeout_running = true;
+                            internal_context.iso_charge_loop_no_energy_timeout_started =
+                                std::chrono::steady_clock::now();
+                            session_log.evse(false, fmt::format("No energy available, starting ISO charge loop timeout of {} seconds",
+                                                                config_context.hlc_charge_loop_without_energy_timeout_s));
+                        } else {
+                            const auto no_energy_duration_ms =
+                                std::chrono::duration_cast<std::chrono::milliseconds>(
+                                    std::chrono::steady_clock::now() -
+                                    internal_context.iso_charge_loop_no_energy_timeout_started)
+                                    .count();
+                            if (no_energy_duration_ms >=
+                                config_context.hlc_charge_loop_without_energy_timeout_s * 1000) {
+                                session_log.evse(false,
+                                                 "No energy available, ISO charge loop timeout reached");
+                                internal_context.hlc_charge_loop_no_energy_timeout_running = false;
+                                set_state(EvseState::StoppingCharging);
+                                break;
+                            }
+                        }
+                    } else {
+                        session_log.evse(false, "No energy available, but no timeout configured, stopping charging immediately");
+                        set_state(EvseState::StoppingCharging);
+                        break;
+                    }
+                } else if (config_context.charge_mode == ChargeMode::AC) {
+                    EVLOG_info << "HLC charging not active";
+                    // Stop immediately in basic AC mode
+                    set_state(EvseState::StoppingCharging); // Proxy state to ChargingPausedEVSE
+                    break;
+                }
+            } else {
+                internal_context.hlc_charge_loop_no_energy_timeout_running = false;
+            }
+
             if (config_context.charge_mode == ChargeMode::DC) {
                 if (initialize_state) {
                     bsp->allow_power_on(true, types::evse_board_support::Reason::FullPowerCharging);
                 }
             } else {
                 check_soft_over_current();
 
-                if (not power_available()) {
-                    if (shared_context.hlc_charging_active or hlc_use_5percent_current_session) {
-                        // We are in HLC and have no energy
-                        // TODO: start timer to stop charging
-                    } else {
-                        EVLOG_info << "HLC charging not active";
-                        // Stop immediately in basic AC mode
-                        set_state(EvseState::StoppingCharging); // Proxy state to ChargingPausedEVSE 
-                        break;
-                    }
-                }
-
                 if (initialize_state) {
                     // Allow another wake-up sequence
                     shared_context.legacy_wakeup_done = false;
@@ -1406,7 +1437,8 @@ void Charger::setup(bool has_ventilation, const ChargeMode _charge_mode, bool _a
                     const int _switch_3ph1ph_delay_s, const std::string _switch_3ph1ph_cp_state,
                     const int _soft_over_current_timeout_ms, const int _state_F_after_fault_ms,
                     const bool fail_on_powermeter_errors, const bool raise_mrec9,
-                    const int sleep_before_enabling_pwm_hlc_mode_ms, const utils::SessionIdType session_id_type) {
+                    const int sleep_before_enabling_pwm_hlc_mode_ms, const utils::SessionIdType session_id_type,
+                    const int hlc_charge_loop_without_energy_timeout_s) {
     // set up board support package
     bsp->setup(has_ventilation);
 
@@ -1430,6 +1462,7 @@ void Charger::setup(bool has_ventilation, const ChargeMode _charge_mode, bool _a
     config_context.raise_mrec9 = raise_mrec9;
     config_context.sleep_before_enabling_pwm_hlc_mode_ms = sleep_before_enabling_pwm_hlc_mode_ms;
     config_context.session_id_type = session_id_type;
+    config_context.hlc_charge_loop_without_energy_timeout_s = hlc_charge_loop_without_energy_timeout_s;
 
     if (config_context.charge_mode == ChargeMode::AC and config_context.ac_hlc_enabled)
         EVLOG_info << "AC HLC mode enabled.";
@@ -1810,15 +1843,21 @@ void Charger::check_soft_over_current() {
 // returns whether power is actually available from EnergyManager
 // i.e. max_current is in valid range
 bool Charger::power_available() {
-    const auto overrun = duration_cast<seconds>(steady_clock::now() - shared_context.max_current_valid_until).count();
-    if (overrun > 0) {
-        EVLOG_warning << "Power budget expired, falling back to 0. Last update: " << overrun << " seconds ago";
-        if (shared_context.max_current > 0.) {
-            shared_context.max_current = 0.;
-            signal_max_current(shared_context.max_current);
+    if (config_context.charge_mode == ChargeMode::AC) {
+        const auto overrun =
+            duration_cast<seconds>(steady_clock::now() - shared_context.max_current_valid_until).count();
+        if (overrun > 0) {
+            EVLOG_warning << "Power budget expired, falling back to 0. Last update: " << overrun << " seconds ago";
+            if (shared_context.max_current > 0.) {
+                shared_context.max_current = 0.;
+                signal_max_current(shared_context.max_current);
+            }
         }
+        return get_max_current_internal() > 5.9;
+    } else {
+        const auto evse_limit = shared_context.current_evse_max_limits;
+        return evse_limit.evse_maximum_current_limit > 0 and evse_limit.evse_maximum_power_limit > 0;
     }
-    return get_max_current_internal() > 5.9;
 }
 
 void Charger::request_error_sequence() {

modules/EVSE/EvseManager/Charger.hpp

@@ -105,7 +105,8 @@ class Charger {
                float soft_over_current_measurement_noise_A, const int switch_3ph1ph_delay_s,
                const std::string switch_3ph1ph_cp_state, const int soft_over_current_timeout_ms,
                const int _state_F_after_fault_ms, const bool fail_on_powermeter_errors, const bool raise_mrec9,
-               const int sleep_before_enabling_pwm_hlc_mode_ms, const utils::SessionIdType session_id_type);
+               const int sleep_before_enabling_pwm_hlc_mode_ms, const utils::SessionIdType session_id_type,
+               const int hlc_charge_loop_without_energy_timeout_s);
 
     void enable_disable_initial_state_publish();
     bool enable_disable(int connector_id, const types::evse_manager::EnableDisableSource& source);
@@ -345,6 +346,8 @@ class Charger {
         int sleep_before_enabling_pwm_hlc_mode_ms{1000};
         // type used to generate session ids
         utils::SessionIdType session_id_type{utils::SessionIdType::UUID};
+        // Timeout in seconds that defines for how long the EVSE allows the ISO charge loop (AC: ChargingStatus, DC: CurrentDemand)
+        int hlc_charge_loop_without_energy_timeout_s{300};
     } config_context;
 
     // Used by different threads, but requires no complete state machine locking
@@ -390,6 +393,9 @@ class Charger {
         std::chrono::time_point<std::chrono::steady_clock> ac_x1_fallback_nominal_timeout_started;
         bool auth_received_printed{false};
 
+        bool hlc_charge_loop_no_energy_timeout_running{false};
+        std::chrono::time_point<std::chrono::steady_clock> iso_charge_loop_no_energy_timeout_started;
+
         std::chrono::time_point<std::chrono::steady_clock> fatal_error_became_active;
         bool fatal_error_timer_running{false};
 

modules/EVSE/EvseManager/EvseManager.cpp

@@ -1357,7 +1357,8 @@ void EvseManager::ready() {
                        config.switch_3ph1ph_delay_s, config.switch_3ph1ph_cp_state, config.soft_over_current_timeout_ms,
                        config.state_F_after_fault_ms, config.fail_on_powermeter_errors, config.raise_mrec9,
                        config.sleep_before_enabling_pwm_hlc_mode_ms,
-                       utils::get_session_id_type_from_string(config.session_id_type));
+                       utils::get_session_id_type_from_string(config.session_id_type),
+                       config.hlc_charge_loop_without_energy_timeout_s);
     }
 
     telemetryThreadHandle = std::thread([this]() {
@@ -1546,7 +1547,8 @@ void EvseManager::setup_fake_DC_mode() {
                    config.soft_over_current_measurement_noise_A, config.switch_3ph1ph_delay_s,
                    config.switch_3ph1ph_cp_state, config.soft_over_current_timeout_ms, config.state_F_after_fault_ms,
                    config.fail_on_powermeter_errors, config.raise_mrec9, config.sleep_before_enabling_pwm_hlc_mode_ms,
-                   utils::get_session_id_type_from_string(config.session_id_type));
+                   utils::get_session_id_type_from_string(config.session_id_type),
+                   config.hlc_charge_loop_without_energy_timeout_s);
 
     types::iso15118::EVSEID evseid = {config.evse_id, config.evse_id_din};
 
@@ -1587,7 +1589,7 @@ void EvseManager::setup_AC_mode() {
                    config.soft_over_current_measurement_noise_A, config.switch_3ph1ph_delay_s,
                    config.switch_3ph1ph_cp_state, config.soft_over_current_timeout_ms, config.state_F_after_fault_ms,
                    config.fail_on_powermeter_errors, config.raise_mrec9, config.sleep_before_enabling_pwm_hlc_mode_ms,
-                   utils::get_session_id_type_from_string(config.session_id_type));
+                   utils::get_session_id_type_from_string(config.session_id_type), config.hlc_charge_loop_without_energy_timeout_s);
 
     types::iso15118::EVSEID evseid = {config.evse_id, config.evse_id_din};
 

modules/EVSE/EvseManager/EvseManager.hpp

@@ -117,6 +117,7 @@ struct Conf {
     std::string bpt_channel;
     std::string bpt_generator_mode;
     std::string bpt_grid_code_island_method;
+    int hlc_charge_loop_without_energy_timeout_s;
 };
 
 class EvseManager : public Everest::ModuleBase {

modules/EVSE/EvseManager/manifest.yaml

@@ -379,6 +379,12 @@ config:
       - Active
       - Passive
     default: None
+  hlc_charge_loop_without_energy_timeout_s:
+    description: >-
+      Timeout (s) to allow HLC charge loop to continue without available energy; 
+      when exceeded, the HLC session is stopped and PWM is disabled until energy returns.
+    type: integer
+    default: 300
 provides:
   evse:
     interface: evse_manager