LimpManager Class Reference

#include <limp_manager.h>

Inheritance diagram for LimpManager:

Collaboration diagram for LimpManager:

Public Types
using	interface_t = LimpManager

Public Member Functions
void	updateState (float rpm, efitick_t nowNt)
void	onFastCallback () override
void	onIgnitionStateChanged (bool ignitionOn) override
bool	allowElectronicThrottle () const
LimpState	allowInjection () const
LimpState	allowIgnition () const
float	getTimeSinceAnyCut () const
bool	allowTriggerInput () const
void	updateRevLimit (float rpm)
angle_t	getLimitingTimingRetard () const
float	getLimitingFuelCorrection () const
void	reportEtbProblem ()
void	fatalError ()
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	setDefaultConfiguration ()
virtual void	onConfigurationChange (engine_configuration_s const *)
virtual void	onSlowCallback ()
virtual void	onEngineStop ()
virtual bool	needsDelayedShutoff ()
virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)

Data Fields
ShutdownController	shutdownController
Timer	externalGdiCanBusComms

Private Member Functions
void	setFaultRevLimit (int limit, ClearReason rpmLimitReason)

Private Attributes
Hysteresis	m_revLimitHysteresis
MaxLimitWithHysteresis	m_boostCutHysteresis
Hysteresis	m_injectorDutyCutHysteresis
int32_t	m_faultRevLimit = INT32_MAX
Clearable	m_allowEtb
Clearable	m_allowInjection
Clearable	m_allowIgnition
Clearable	m_allowTriggerInput
Clearable	m_transientAllowInjection = true
Clearable	m_transientAllowIgnition = true
bool	m_hadOilPressureAfterStart = false
bool	m_ignitionOn = false
angle_t	m_timingRetard = 0
float	m_fuelCorrection = 1.0f
float	m_revLimit
ClearReason	m_rpmLimitReason = ClearReason::None
float	resumeRpm
Timer	m_lastCutTime
Timer	m_injectorDutySustainedTimer
Timer	m_lowOilPressureTimer
Timer	m_highOilPressureTimer

Detailed Description

Definition at line 90 of file limp_manager.h.

Member Typedef Documentation

interface_t

using LimpManager::interface_t = LimpManager

Definition at line 94 of file limp_manager.h.

Member Function Documentation

allowElectronicThrottle()

bool LimpManager::allowElectronicThrottle

(

)

const

Definition at line 295 of file limp_manager.cpp.

                                                {
    return m_allowEtb || engine->etbIgnoreJamProtection;
}

Referenced by EtbController::setOutput().

Here is the caller graph for this function:

allowIgnition()

LimpState LimpManager::allowIgnition

(

)

const

Definition at line 314 of file limp_manager.cpp.

                                           {
    if (!m_allowIgnition) {
        return {false, m_allowIgnition.clearReason};
    }
    if (!m_transientAllowIgnition) {
        return {false, m_transientAllowIgnition.clearReason};
    }
    return {true, ClearReason::None};
}

Referenced by onTriggerEventSparkLogic().

Here is the caller graph for this function:

allowInjection()

LimpState LimpManager::allowInjection

(

)

const

Definition at line 304 of file limp_manager.cpp.

                                            {
    if (!m_allowInjection) {
        return {false, m_allowInjection.clearReason};
    }
    if (!m_transientAllowInjection) {
        return {false, m_transientAllowInjection.clearReason};
    }
    return {true, ClearReason::None};
}

Referenced by handleFuel().

Here is the caller graph for this function:

allowTriggerInput()

bool LimpManager::allowTriggerInput

(

)

const

Definition at line 300 of file limp_manager.cpp.

                                          {
    return m_allowTriggerInput;
}

Referenced by handleShaftSignal().

Here is the caller graph for this function:

fatalError()

void LimpManager::fatalError

(

)

Definition at line 276 of file limp_manager.cpp.

                             {
    m_allowEtb.clear(ClearReason::Fatal);
    m_allowIgnition.clear(ClearReason::Fatal);
    m_allowInjection.clear(ClearReason::Fatal);
    m_allowTriggerInput.clear(ClearReason::Fatal);
 
    setFaultRevLimit(/*rpm*/0, ClearReason::FatalErrorRevLimit);
}

Referenced by firmwareErrorV().

Here is the call graph for this function:

Here is the caller graph for this function:

getLimitingFuelCorrection()

float LimpManager::getLimitingFuelCorrection

(

)

const

Definition at line 330 of file limp_manager.cpp.

                                                   {
    if (!engineConfiguration->cutFuelOnHardLimit)
        return 1.0f;    // no correction
    return m_fuelCorrection;
}

Referenced by getRunningFuel().

Here is the caller graph for this function:

getLimitingTimingRetard()

angle_t LimpManager::getLimitingTimingRetard

(

)

const

Definition at line 324 of file limp_manager.cpp.

                                                   {
    if (!engineConfiguration->cutSparkOnHardLimit)
        return 0;
    return m_timingRetard;
}

Referenced by EngineState::periodicFastCallback().

Here is the caller graph for this function:

getTimeSinceAnyCut()

float LimpManager::getTimeSinceAnyCut

(

)

const

Definition at line 336 of file limp_manager.cpp.

                                            {
    return m_lastCutTime.getElapsedSeconds();
}

onFastCallback()

void LimpManager::onFastCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 40 of file limp_manager.cpp.

                                 {
    updateState(Sensor::getOrZero(SensorType::Rpm), getTimeNowNt());
}

Referenced by TriggerCentral::decodeMapCam().

Here is the call graph for this function:

Here is the caller graph for this function:

onIgnitionStateChanged()

void LimpManager::onIgnitionStateChanged ( bool  ignitionOn )

overridevirtual

Reimplemented from EngineModule.

Definition at line 267 of file limp_manager.cpp.

                                                        {
    m_ignitionOn = ignitionOn;
}

reportEtbProblem()

void LimpManager::reportEtbProblem

(

)

Definition at line 271 of file limp_manager.cpp.

                                   {
    m_allowEtb.clear(ClearReason::EtbProblem);
    setFaultRevLimit(/*rpm*/1500, ClearReason::EtbFaultRevLimit);
}

Referenced by EtbController::checkJam().

Here is the call graph for this function:

Here is the caller graph for this function:

setFaultRevLimit()

void LimpManager::setFaultRevLimit ( int  limit, ClearReason  rpmLimitReason  )

private

Definition at line 285 of file limp_manager.cpp.

                                                                        {
    // Only allow decreasing the limit
    // aka uses the limit of the worst fault to yet occur
    if (limit < m_faultRevLimit) {
      m_faultRevLimit = limit;
      m_rpmLimitReason = rpmLimitReason;
    }
}

Referenced by fatalError(), and reportEtbProblem().

Here is the caller graph for this function:

updateRevLimit()

void LimpManager::updateRevLimit

(

float

rpm

)

Definition at line 44 of file limp_manager.cpp.

                                          {
    // User-configured hard RPM limit, either constant or CLT-lookup
    m_revLimit = engineConfiguration->useCltBasedRpmLimit
        ? interpolate2d(Sensor::getOrZero(SensorType::Clt), config->cltRevLimitRpmBins, config->cltRevLimitRpm)
        : (float)engineConfiguration->rpmHardLimit;
 
    // Require configurable rpm drop before resuming
    resumeRpm = m_revLimit - engineConfiguration->rpmHardLimitHyst;
 
    m_timingRetard = interpolateClamped(resumeRpm, 0, m_revLimit, engineConfiguration->rpmSoftLimitTimingRetard, rpm);
 
    percent_t fuelAdded = interpolateClamped(resumeRpm, 0, m_revLimit, engineConfiguration->rpmSoftLimitFuelAdded, rpm);
    m_fuelCorrection = 1.0f + fuelAdded / 100;
}

Referenced by EngineState::periodicFastCallback(), and updateState().

Here is the call graph for this function:

Here is the caller graph for this function:

updateState()

void LimpManager::updateState	(	float	rpm,
		efitick_t	nowNt
	)

todo: we need explicit clarification on why do we cut fuel but do not cut spark here!

Definition at line 59 of file limp_manager.cpp.

                                                        {
    Clearable allowFuel = engineConfiguration->isInjectionEnabled;
    Clearable allowSpark = engineConfiguration->isIgnitionEnabled;
 
#if EFI_SHAFT_POSITION_INPUT && !EFI_UNIT_TEST
    if (!m_ignitionOn
    && !engine->triggerCentral.directSelfStimulation // useful to try things on real ECU even without ignition voltage
    ) {
        allowFuel.clear(ClearReason::IgnitionOff);
        allowSpark.clear(ClearReason::IgnitionOff);
    }
#endif
 
    if (isGdiEngine() && engineConfiguration->externalRusEfiGdiModule) {
        if (externalGdiCanBusComms.getElapsedSeconds() > 1) {
            allowFuel.clear(ClearReason::GdiComms);
        }
    }
 
    if (engine->engineState.lua.luaIgnCut) {
        allowSpark.clear(ClearReason::Lua);
    }
 
    if (engine->engineState.lua.luaFuelCut) {
        allowFuel.clear(ClearReason::Lua);
    }
 
    updateRevLimit(rpm);
    if (m_revLimitHysteresis.test(rpm, m_revLimit, resumeRpm)) {
        if (engineConfiguration->cutFuelOnHardLimit) {
            allowFuel.clear(ClearReason::HardLimit);
        }
 
        if (engineConfiguration->cutSparkOnHardLimit) {
            allowSpark.clear(ClearReason::HardLimit);
        }
    }
 
#if EFI_SHAFT_POSITION_INPUT
    if (engine->lambdaMonitor.isCut()) {
        allowFuel.clear(ClearReason::LambdaProtection);
    }
 
    if (noFiringUntilVvtSync()
            && !engine->triggerCentral.triggerState.hasSynchronizedPhase()) {
        // Any engine that requires cam-assistance for a full crank sync (symmetrical crank) can't schedule until we have cam sync
        // examples:
        // NB2, Nissan VQ/MR: symmetrical crank wheel and we need to make sure no spark happens out of sync
        // VTwin Harley: uneven firing order, so we need "cam" MAP sync to make sure no spark happens out of sync
        allowFuel.clear(ClearReason::EnginePhase);
        allowSpark.clear(ClearReason::EnginePhase);
    }
 
    // Force fuel limiting on the fault rev limit
    if (rpm > m_faultRevLimit) {
        allowFuel.clear(m_rpmLimitReason);
    }
 
    // Limit fuel only on boost pressure (limiting spark bends valves)
    float mapCut = engineConfiguration->boostCutPressure;
    if (mapCut != 0) {
        // require drop of 'boostCutPressureHyst' kPa to resume fuel
        if (m_boostCutHysteresis.checkIfLimitIsExceeded(Sensor::getOrZero(SensorType::Map), mapCut, engineConfiguration->boostCutPressureHyst)) {
            allowFuel.clear(ClearReason::BoostCut);
        }
    }
 
    if (engine->rpmCalculator.isRunning()) {
        bool hasOilpSensor = Sensor::hasSensor(SensorType::OilPressure);
        auto oilp = Sensor::get(SensorType::OilPressure);
        uint16_t minOilPressure = engineConfiguration->minOilPressureAfterStart;
 
        // Only check if the setting is enabled and you have an oil pressure sensor
        if (minOilPressure > 0 && hasOilpSensor) {
            // Has it been long enough we should have pressure?
            bool isTimedOut = engine->rpmCalculator.getSecondsSinceEngineStart(nowNt) > 5.0f;
 
            // Only check before timed out
            if (!isTimedOut) {
                if (oilp) {
                    // We had oil pressure! Set the flag.
                    if (oilp.Value > minOilPressure) {
                        m_hadOilPressureAfterStart = true;
                    }
                }
            }
 
            // If time is up, the sensor works, and no pressure, kill the engine.
            if (isTimedOut && !m_hadOilPressureAfterStart) {
                allowFuel.clear(ClearReason::OilPressure);
            }
        }
 
        if (oilp && engineConfiguration->enableOilPressureProtect) {
            float minPressure = interpolate2d(rpm, config->minimumOilPressureBins, config->minimumOilPressureValues);
            bool isPressureSufficient = oilp.Value > minPressure;
 
            if (isPressureSufficient) {
                m_lowOilPressureTimer.reset(nowNt);
            }
 
            if (m_lowOilPressureTimer.hasElapsedSec(engineConfiguration->minimumOilPressureTimeout)) {
                allowFuel.clear(ClearReason::OilPressure);
            }
        }
 
        // check the maximum oil pressure
        float maxOilPressure = interpolate2d(rpm, config->maximumOilPressureBins, config->maximumOilPressureValues);
        if (maxOilPressure > 0 && hasOilpSensor) {
            if (oilp.Value < maxOilPressure) {
                m_highOilPressureTimer.reset(nowNt);
            }
            if (m_highOilPressureTimer.hasElapsedSec(engineConfiguration->maxOilPressureTimeout)) {
                allowFuel.clear(ClearReason::OilPressure);
            }
        }
 
    } else {
        // reset state in case of stalled engine
        m_hadOilPressureAfterStart = false;
        m_lowOilPressureTimer.reset(nowNt);
    }
 
    // If we're in engine stop mode, inhibit fuel
    if (shutdownController.isEngineStop(nowNt)) {
        /**
         * todo: we need explicit clarification on why do we cut fuel but do not cut spark here!
         */
        allowFuel.clear(ClearReason::StopRequested);
    }
 
    {
        // todo: we need to add some tests of this?
        // If duty cycle is high, impose a fuel cut rev limiter.
        // This is safer than attempting to limp along with injectors or a pump that are out of flow.
        // Two conditions will trigger a cut:
        // - An instantaneous excursion above maxInjectorDutyInstant
        // - A sustained excursion above maxInjectorDutySustained for a duration of >= maxInjectorDutySustainedTimeout
        // Only reset once below 20% duty to force the driver to lift off the pedal
 
        auto injDutyCycle = getInjectorDutyCycle(rpm);
        bool isOverInstantDutyCycle = injDutyCycle > engineConfiguration->maxInjectorDutyInstant;
        bool isOverSustainedDutyCycle = injDutyCycle > engineConfiguration->maxInjectorDutySustained;
        bool isUnderLowDuty = injDutyCycle < 20;
 
        if (!isOverSustainedDutyCycle) {
            // Duty cycle is OK, reset timer.
            m_injectorDutySustainedTimer.reset(nowNt);
        }
 
        // True if isOverSustainedDutyCycle has been true for longer than the timeout
        bool sustainedLimitTimedOut = m_injectorDutySustainedTimer.hasElapsedSec(engineConfiguration->maxInjectorDutySustainedTimeout);
 
        bool someLimitTripped = isOverInstantDutyCycle || sustainedLimitTimedOut;
 
        if (m_injectorDutyCutHysteresis.test(someLimitTripped, isUnderLowDuty)) {
            allowFuel.clear(ClearReason::InjectorDutyCycle);
            warning(ObdCode::CUSTOM_TOO_LONG_FUEL_INJECTION, "Injector duty cycle cut %.1f", injDutyCycle);
        }
    }
 
    {
        // GDI Fuel cut
        bool isGDIDriverInjectorTimeTooLong = engine->engineState.injectionDuration > engineConfiguration->mc33_t_hold_tot;
 
        if (isGdiEngine() && isGDIDriverInjectorTimeTooLong) {
            allowFuel.clear(ClearReason::GdiLimits);
            warning(ObdCode::CUSTOM_TOO_LONG_FUEL_INJECTION, "Injection duration excess PT2001 limits time: %.4f", engine->engineState.injectionDuration);
        }
    }
 
    // If the pedal is pushed while not running, cut fuel to clear a flood condition.
    if (!engine->rpmCalculator.isRunning() &&
        engineConfiguration->isCylinderCleanupEnabled &&
        Sensor::getOrZero(SensorType::DriverThrottleIntent) > CLEANUP_MODE_TPS) {
        allowFuel.clear(ClearReason::FloodClear);
    }
#endif // EFI_SHAFT_POSITION_INPUT
 
    if (!engine->isMainRelayEnabled()) {
/*
todo AndreiKA this change breaks 22 unit tests?
        allowFuel.clear();
        allowSpark.clear();
*/
    }
 
#if EFI_LAUNCH_CONTROL
    // Fuel cut if launch control engaged
    if (engine->launchController.isLaunchFuelRpmRetardCondition()) {
        allowFuel.clear(ClearReason::LaunchCut);
    }
 
    // Spark cut if launch control engaged
    if (engine->launchController.isLaunchSparkRpmRetardCondition()) {
        allowSpark.clear(ClearReason::LaunchCut);
    }
#endif // EFI_LAUNCH_CONTROL
 
    m_transientAllowInjection = allowFuel;
    m_transientAllowIgnition = allowSpark;
 
    if (!m_transientAllowInjection || !m_transientAllowIgnition) {
        // Tracks the last time any cut happened
        m_lastCutTime.reset(nowNt);
    }
}

Referenced by onFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

externalGdiCanBusComms

Timer LimpManager::externalGdiCanBusComms

Definition at line 119 of file limp_manager.h.

Referenced by processCanRxMessage(), and updateState().

m_allowEtb

Clearable LimpManager::m_allowEtb

private

Definition at line 131 of file limp_manager.h.

Referenced by allowElectronicThrottle(), fatalError(), and reportEtbProblem().

m_allowIgnition

Clearable LimpManager::m_allowIgnition

private

Definition at line 133 of file limp_manager.h.

Referenced by allowIgnition(), and fatalError().

m_allowInjection

Clearable LimpManager::m_allowInjection

private

Definition at line 132 of file limp_manager.h.

Referenced by allowInjection(), and fatalError().

m_allowTriggerInput

Clearable LimpManager::m_allowTriggerInput

private

Definition at line 134 of file limp_manager.h.

Referenced by allowTriggerInput(), and fatalError().

m_boostCutHysteresis

MaxLimitWithHysteresis LimpManager::m_boostCutHysteresis

private

Definition at line 125 of file limp_manager.h.

Referenced by updateState().

m_faultRevLimit

int32_t LimpManager::m_faultRevLimit = INT32_MAX

private

Definition at line 129 of file limp_manager.h.

Referenced by setFaultRevLimit(), and updateState().

m_fuelCorrection

float LimpManager::m_fuelCorrection = 1.0f

private

Definition at line 145 of file limp_manager.h.

Referenced by getLimitingFuelCorrection(), and updateRevLimit().

m_hadOilPressureAfterStart

bool LimpManager::m_hadOilPressureAfterStart = false

private

Definition at line 139 of file limp_manager.h.

Referenced by updateState().

m_highOilPressureTimer

Timer LimpManager::m_highOilPressureTimer

private

Definition at line 160 of file limp_manager.h.

Referenced by updateState().

m_ignitionOn

bool LimpManager::m_ignitionOn = false

private

Definition at line 142 of file limp_manager.h.

Referenced by onIgnitionStateChanged(), and updateState().

m_injectorDutyCutHysteresis

Hysteresis LimpManager::m_injectorDutyCutHysteresis

private

Definition at line 126 of file limp_manager.h.

Referenced by updateState().

m_injectorDutySustainedTimer

Timer LimpManager::m_injectorDutySustainedTimer

private

Definition at line 156 of file limp_manager.h.

Referenced by updateState().

m_lastCutTime

Timer LimpManager::m_lastCutTime

private

Definition at line 153 of file limp_manager.h.

Referenced by getTimeSinceAnyCut(), and updateState().

m_lowOilPressureTimer

Timer LimpManager::m_lowOilPressureTimer

private

Definition at line 159 of file limp_manager.h.

Referenced by updateState().

m_revLimit

float LimpManager::m_revLimit

private

Definition at line 148 of file limp_manager.h.

Referenced by updateRevLimit(), and updateState().

m_revLimitHysteresis

Hysteresis LimpManager::m_revLimitHysteresis

private

Definition at line 124 of file limp_manager.h.

Referenced by updateState().

m_rpmLimitReason

ClearReason LimpManager::m_rpmLimitReason = ClearReason::None

private

Definition at line 149 of file limp_manager.h.

Referenced by setFaultRevLimit(), and updateState().

m_timingRetard

angle_t LimpManager::m_timingRetard = 0

private

Definition at line 144 of file limp_manager.h.

Referenced by getLimitingTimingRetard(), and updateRevLimit().

m_transientAllowIgnition

Clearable LimpManager::m_transientAllowIgnition = true

private

Definition at line 137 of file limp_manager.h.

Referenced by allowIgnition(), and updateState().

m_transientAllowInjection

Clearable LimpManager::m_transientAllowInjection = true

private

Definition at line 136 of file limp_manager.h.

Referenced by allowInjection(), and updateState().

resumeRpm

float LimpManager::resumeRpm

private

Definition at line 150 of file limp_manager.h.

Referenced by updateRevLimit(), and updateState().

shutdownController

ShutdownController LimpManager::shutdownController

Definition at line 92 of file limp_manager.h.

Referenced by configureRusefiLuaHooks(), doScheduleStopEngine(), and updateState().

---

The documentation for this class was generated from the following files:

• controllers/limp_manager.h
• controllers/limp_manager.cpp