Basic things working again

Signed-off-by: Cornelius Claussen <cc@pionix.de>

Author: corneliusclaussen

modules/EVSE/EvseManager/Charger.cpp

@@ -226,17 +226,6 @@ void Charger::run_state_machine() {
             break;
 
         case EvseState::WaitingForAuthentication:
-            if (not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in) {
-                // Wed did not start to charge yet, so go directly to finished.
-                set_state(EvseState::Finished);
-                break;
-            }
-
-            // Errors prevent charging? -> go to EVSE paused
-            if (stop_charging_on_fatal_error_internal()) {
-                set_state(EvseState::ChargingPausedEVSE);
-                break;
-            }
 
             // Explicitly do not allow to be powered on. This is important
             // to make sure control_pilot does not switch on relais even if
@@ -249,12 +238,12 @@ void Charger::run_state_machine() {
 
                 bsp->allow_power_on(false, types::evse_board_support::Reason::PowerOff);
 
-                    // First user interaction was plug in of car? Start session here.
-                    if (not shared_context.session_active) {
-                        start_session(false);
-                    }
-                    // External signal on MQTT
-                    signal_simple_event(types::evse_manager::SessionEventEnum::AuthRequired);
+                // First user interaction was plug in of car? Start session here.
+                if (not shared_context.session_active) {
+                    start_session(false);
+                }
+                // External signal on MQTT
+                signal_simple_event(types::evse_manager::SessionEventEnum::AuthRequired);
 
                 hlc_use_5percent_current_session = false;
 
@@ -288,6 +277,17 @@ void Charger::run_state_machine() {
                 }
             }
 
+            // Errors prevent charging? -> wait here, we cannot go to paused etc because we are not authorized yet
+            if (stop_charging_on_fatal_error_internal()) {
+                break;
+            }
+
+            if (not shared_context.flag_ev_plugged_in) {
+                // Wed did not start to charge yet, so go directly to finished.
+                set_state(EvseState::Finished);
+                break;
+            }
+
             // Read PP value in case of AC socket
             if (connector_type == types::evse_board_support::Connector_type::IEC62196Type2Socket and
                 shared_context.max_current_cable == 0) {
@@ -324,25 +324,7 @@ void Charger::run_state_machine() {
                 }
             }
 
-            // SLAC is running in the background trying to setup a PLC connection.
-
-            // we get Auth (maybe before SLAC matching or during matching)
-            // FIXME: getAuthorization needs to distinguish between EIM and PnC in Auth mananger
-
-            // FIXME: Note Fig 7. is not fully supported here yet (AC Auth before plugin - this overides PnC and always
-            // starts with nominal PWM). We need to support this as this is the only way a user can
-            // skip PnC if he does NOT want to use it for this charging session.
-
-            // FIXME: In case V2G is not successfull after all, it needs
-            // to send a dlink_error request, which then needs to:
-            // AC mode: fall back to nominal PWM charging etc (not
-            // implemented yet!), it can do so because it is already authorized.
-            // DC mode: go to error_hlc and give up
-
-            // FIXME: if slac reports a dlink_ready=false while we are still waiting for auth we should:
-            // in AC mode: go back to non HLC nominal PWM mode
-            // in DC mode: go to error_slac for this session
-
+            // EIM
             if (shared_context.flag_authorized and not shared_context.authorized_pnc) {
                 if (not internal_context.auth_received_printed) {
                     internal_context.auth_received_printed = true;
@@ -476,6 +458,7 @@ void Charger::run_state_machine() {
                     // unsupported charging mode, give up here.
                     error_handling->raise_internal_error("Unsupported charging mode.");
                 }
+                // Contract / Plug and Charge
             } else if (shared_context.flag_authorized and shared_context.authorized_pnc) {
 
                 if (not shared_context.flag_transaction_active) {
@@ -620,20 +603,10 @@ void Charger::run_state_machine() {
                 }
             }
 
-            if (not shared_context.flag_authorized) {
+            if (stop_charging_on_fatal_error_internal() or not shared_context.flag_authorized or
+                not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in) {
                 // We started to initialize charging already, so we need to stop via StoppingCharging
                 set_state(EvseState::StoppingCharging);
-            }
-
-            if (not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in) {
-                // We started to initialize charging already, so we need to stop via StoppingCharging
-                set_state(EvseState::StoppingCharging);
-            }
-
-            // Errors prevent charging? -> go to StoppingCharging
-            if (stop_charging_on_fatal_error_internal()) {
-                internal_context.current_state_started = now;
-                set_state(EvseState::StoppingCharging);
                 break;
             }
 
@@ -654,10 +627,13 @@ void Charger::run_state_machine() {
                 // In AC mode BASIC, iec_allow is sufficient.  The same is true for HLC mode when nominal PWM is
                 // 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()) {
-                    // TODO: start timer to stop charging
+                    // FIXME: For AC BC, it is ok to wait here. The behaviour we would like to have for AC ISO
+                    // when starting up with no power needs to be defined still. For DC it just continues here without
+                    // power.
+                    break;
                 }
+
                 // Power is available, 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
@@ -711,34 +687,14 @@ void Charger::run_state_machine() {
                 }
             }
 
-            // Errors prevent charging? -> go to StoppingCharging
-            if (stop_charging_on_fatal_error_internal()) {
+            // Stop charging on errors, user stops or pause requests
+            if (stop_charging_on_fatal_error_internal() or not shared_context.flag_authorized or
+                not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in or
+                shared_context.flag_paused_by_evse) {
                 set_state(EvseState::StoppingCharging);
                 break;
             }
 
-            if (not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in) {
-                set_state(EvseState::StoppingCharging);
-            }
-
-            if (shared_context.flag_paused_by_evse) {
-                set_state(EvseState::StoppingCharging);
-            }
-
-            if (config_context.state_F_after_fault_ms > 0 and not shared_context.hlc_charging_active) {
-                // First time we see that a fatal error became active, signal F for a short time.
-                // Only use in basic charging mode.
-                if (entered_fatal_error_state()) {
-                    pwm_F();
-                }
-
-                if (internal_context.pwm_F_active and
-                    time_in_fatal_error_state_ms() > config_context.state_F_after_fault_ms and
-                    shared_context.shutdown_type == ShutdownType::EmergencyShutdown) {
-                    pwm_off();
-                }
-            }
-
             if (config_context.charge_mode == ChargeMode::DC) {
                 if (initialize_state) {
                     bsp->allow_power_on(true, types::evse_board_support::Reason::FullPowerCharging);
@@ -787,9 +743,10 @@ void Charger::run_state_machine() {
                 signal_simple_event(types::evse_manager::SessionEventEnum::ChargingPausedEV);
             }
 
-            if (not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in) {
-                // Wed did not start to charge yet, so go directly to finished.
+            if (not shared_context.flag_transaction_active or not shared_context.flag_authorized or
+                not shared_context.flag_ev_plugged_in) {
                 set_state(EvseState::StoppingCharging);
+                break;
             }
 
             if (config_context.charge_mode == ChargeMode::AC) {
@@ -847,43 +804,61 @@ void Charger::run_state_machine() {
                 internal_context.last_charging_paused_evse_reasons = {};
             }
 
-            if (not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in) {
+            if (not shared_context.flag_transaction_active or not shared_context.flag_authorized or
+                not shared_context.flag_ev_plugged_in) {
                 set_state(EvseState::StoppingCharging);
-            }
-{
-            types::evse_manager::ChargingPausedEVSEReasons r;
-            if (stop_charging_on_fatal_error_internal()) {
-                r.reasons.push_back(types::evse_manager::PauseChargingEVSEReasonEnum::Error);
+                break;
             }
 
-            if (not power_available()) {
-                r.reasons.push_back(types::evse_manager::PauseChargingEVSEReasonEnum::NoEnergy);
-            }
+            if (config_context.state_F_after_fault_ms > 0 and not shared_context.hlc_charging_active) {
+                // First time we see that a fatal error became active, signal F for a short time.
+                // Only use in basic charging mode.
+                if (entered_fatal_error_state()) {
+                    pwm_F();
+                }
 
-            if (shared_context.flag_paused_by_evse) {
-                r.reasons.push_back(types::evse_manager::PauseChargingEVSEReasonEnum::UserPause);
+                if (internal_context.pwm_F_active and
+                    time_in_fatal_error_state_ms() > config_context.state_F_after_fault_ms and
+                    shared_context.shutdown_type == ShutdownType::EmergencyShutdown) {
+                    pwm_off();
+                }
             }
 
-            if (r.reasons.size() == 0) {
-                // resume charging
-                if (shared_context.hlc_charging_terminate_pause == HlcTerminatePause::Terminate) {
-                    signal_slac_start(); // wake up SLAC as well
+            {
+                types::evse_manager::ChargingPausedEVSEReasons r;
+                if (stop_charging_on_fatal_error_internal()) {
+                    r.reasons.push_back(types::evse_manager::PauseChargingEVSEReasonEnum::Error);
                 }
-                shared_context.current_state = EvseState::PrepareCharging;
-            } else {
-                if (internal_context.last_charging_paused_evse_reasons not_eq r) {
-                    signal_charging_paused_evse_event(r);
-                    internal_context.last_charging_paused_evse_reasons = r;
+
+                if (not power_available()) {
+                    r.reasons.push_back(types::evse_manager::PauseChargingEVSEReasonEnum::NoEnergy);
+                }
+
+                if (shared_context.flag_paused_by_evse) {
+                    r.reasons.push_back(types::evse_manager::PauseChargingEVSEReasonEnum::UserPause);
+                }
+
+                if (r.reasons.size() == 0) {
+                    // resume charging
+                    if (shared_context.hlc_charging_terminate_pause == HlcTerminatePause::Terminate) {
+                        signal_slac_start(); // wake up SLAC as well
+                    }
+                    shared_context.current_state = EvseState::PrepareCharging;
+                } else {
+                    if (internal_context.last_charging_paused_evse_reasons not_eq r) {
+                        signal_charging_paused_evse_event(r);
+                        internal_context.last_charging_paused_evse_reasons = r;
+                    }
                 }
             }
-        }
             break;
 
             /*
             Stopping Charging:
-            - stops an ongoing charging session actively from EVSE side if it is still ongoing
+            - stops an ongoing charging session actively from EVSE side if it is still ongoing (hard stop)
             - switch to this state to stop charging
-            - When EV stops charging, remain in Charging state unt
+            - DC: When EV stops charging, remain in Charging state until WeldingCheck etc is really done, otherwise PWM
+            will switch off too early
             - after charging is stopped, it switches to PausedEVSE or Finished depending on whether it may restart or
             not (only a short transitional state)
             */
@@ -912,20 +887,17 @@ void Charger::run_state_machine() {
                 bsp->allow_power_on(false, types::evse_board_support::Reason::PowerOff);
             }
 
-            // Errors prevent charging? -> go to StoppingCharging
-            if (stop_charging_on_fatal_error_internal()) {
-                set_state(EvseState::ChargingPausedEVSE);
-                break;
-            }
-
-            if (not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in) {
-                // Wed did not start to charge yet, so go directly to finished.
+            // Those are fatal, so we can not recover without replugging.
+            if (not shared_context.flag_transaction_active or not shared_context.flag_ev_plugged_in or
+                not shared_context.flag_authorized) {
                 set_state(EvseState::Finished);
+                break;
             }
 
-            if (shared_context.flag_paused_by_evse) {
+            if (shared_context.flag_paused_by_evse or stop_charging_on_fatal_error_internal()) {
                 // Paused was initiated by EVSE, continue to PausedEVSE
                 set_state(EvseState::ChargingPausedEVSE);
+                break;
             }
 
             break;
@@ -953,6 +925,8 @@ void Charger::run_state_machine() {
                 bsp->allow_power_on(false, types::evse_board_support::Reason::PowerOff);
             }
 
+            // FIXME: wait here for SLAC to become available again
+
             // If unplugged, proceed to Idle, otherwise wait here and do nothing
             if (not shared_context.flag_ev_plugged_in) {
                 shared_context.current_state = EvseState::Idle;
@@ -1013,7 +987,6 @@ void Charger::process_cp_events_state(CPEvent cp_event) {
 
     case EvseState::WaitingForAuthentication:
         if (cp_event == CPEvent::CarRequestedPower) {
-            session_log.car(false, "B->C transition before PWM is enabled at this stage violates IEC61851-1");
             shared_context.iec_allow_close_contactor = true;
         } else if (cp_event == CPEvent::CarRequestedStopPower) {
             shared_context.iec_allow_close_contactor = false;
@@ -1038,15 +1011,13 @@ void Charger::process_cp_events_state(CPEvent cp_event) {
             // if this is not the case, we have to do it here.
             if (shared_context.hlc_charging_active) {
                 signal_hlc_stop_charging();
-                session_log.evse(false, "CP state transition C->B at this stage violates ISO15118-2");
             }
         } else if (cp_event == CPEvent::BCDtoE) {
             shared_context.iec_allow_close_contactor = false;
             shared_context.current_state = EvseState::StoppingCharging;
             // Tell HLC stack to stop the session in case of an E event while charging.
             if (shared_context.hlc_charging_active) {
                 signal_hlc_stop_charging();
-                session_log.evse(false, "CP state transition C->E/F at this stage violates ISO15118-2");
             }
         }
         break;

modules/EVSE/EvseManager/energy_grid/energyImpl.cpp

@@ -493,7 +493,6 @@ void energyImpl::handle_enforce_limits(types::energy::EnforcedLimits& value) {
             }
         }
 
-
         mod->signalNrOfPhasesAvailable(mod->ac_nr_phases_active);
 
         if (mod->config.charge_mode == "DC") {