LimpManager Class Reference

#include <limp_manager.h>

Inheritance diagram for LimpManager:

Collaboration diagram for LimpManager:

Public Member Functions
void	updateState (int 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 (int rpm)
angle_t	getLimitingTimingRetard () const
float	getLimitingFuelCorrection () const
void	fatalError ()
Public Member Functions inherited from EngineModule
virtual void	onConfigurationChange (engine_configuration_s const *)
virtual void	onSlowCallback ()
virtual bool	needsDelayedShutoff ()

Data Fields
ShutdownController	shutdownController
Timer	gdiComms

Private Member Functions
void	setFaultRevLimit (int limit)

Private Attributes
Hysteresis	m_revLimitHysteresis
Hysteresis	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
float	resumeRpm
Timer	m_lastCutTime
Timer	m_injectorDutySustainedTimer

Detailed Description

Definition at line 106 of file limp_manager.h.

Member Function Documentation

allowElectronicThrottle()

bool LimpManager::allowElectronicThrottle

(

)

const

Definition at line 265 of file limp_manager.cpp.

                                                {
    return m_allowEtb;
}

allowIgnition()

LimpState LimpManager::allowIgnition

(

)

const

Definition at line 283 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 273 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 269 of file limp_manager.cpp.

                                          {
    return m_allowTriggerInput;
}

fatalError()

void LimpManager::fatalError

(

)

Definition at line 250 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);
}

Referenced by firmwareError().

Here is the call graph for this function:

Here is the caller graph for this function:

getLimitingFuelCorrection()

float LimpManager::getLimitingFuelCorrection

(

)

const

Definition at line 299 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 293 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 305 of file limp_manager.cpp.

                                            {
    return m_lastCutTime.getElapsedSeconds();
}

onFastCallback()

void LimpManager::onFastCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 46 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 239 of file limp_manager.cpp.

                                                        {
    m_ignitionOn = ignitionOn;
}

setFaultRevLimit()

void LimpManager::setFaultRevLimit ( int  limit )

private

Definition at line 259 of file limp_manager.cpp.

                                            {
    // Only allow decreasing the limit
    // aka uses the limit of the worst fault to yet occur
    m_faultRevLimit = minI(m_faultRevLimit, limit);
}

Referenced by fatalError().

Here is the caller graph for this function:

updateRevLimit()

void LimpManager::updateRevLimit

(

int

rpm

)

Definition at line 50 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	(	int	rpm,
		efitick_t	nowNt
	)

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

Definition at line 65 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()) {
        if (gdiComms.getElapsedSeconds() > 1) {
            allowFuel.clear(ClearReason::GdiComms);
        }
    }
 
    if (engine->engineState.lua.luaIgnCut) {
        allowSpark.clear(ClearReason::Lua);
    }
 
#if EFI_HD_ACR
    // Don't inject fuel during Harley compression release - it sprays fuel everywhere
    if (engine->module<HarleyAcr>()->isActive() && engineConfiguration->cutFuelInAcr) {
        allowFuel.clear(ClearReason::ACR);
    }
#endif // EFI_HD_ACR
 
    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(engineConfiguration->vvtMode[0])
            && !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(ClearReason::FaultRevLimit);
    }
 
    // 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.test(Sensor::getOrZero(SensorType::Map), mapCut, mapCut - engineConfiguration->boostCutPressureHyst)) {
            allowFuel.clear(ClearReason::BoostCut);
        }
    }
 
    if (engine->rpmCalculator.isRunning()) {
        uint16_t minOilPressure = engineConfiguration->minOilPressureAfterStart;
 
        // Only check if the setting is enabled and you have an oil pressure sensor
        if (minOilPressure > 0 && Sensor::hasSensor(SensorType::OilPressure)) {
            // Has it been long enough we should have pressure?
            bool isTimedOut = engine->rpmCalculator.getSecondsSinceEngineStart(nowNt) > 5.0f;
 
            // Only check before timed out
            if (!isTimedOut) {
                auto oilp = Sensor::get(SensorType::OilPressure);
 
                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);
            }
        }
    } else {
        // reset state in case of stalled engine
        m_hadOilPressureAfterStart = false;
    }
 
    // 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);
    }
 
    {
        // 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);
        }
    }
 
    // 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

gdiComms

Timer LimpManager::gdiComms

Definition at line 133 of file limp_manager.h.

Referenced by processCanRxMessage(), and updateState().

m_allowEtb

Clearable LimpManager::m_allowEtb

private

Definition at line 145 of file limp_manager.h.

Referenced by allowElectronicThrottle(), and fatalError().

m_allowIgnition

Clearable LimpManager::m_allowIgnition

private

Definition at line 147 of file limp_manager.h.

Referenced by allowIgnition(), and fatalError().

m_allowInjection

Clearable LimpManager::m_allowInjection

private

Definition at line 146 of file limp_manager.h.

Referenced by allowInjection(), and fatalError().

m_allowTriggerInput

Clearable LimpManager::m_allowTriggerInput

private

Definition at line 148 of file limp_manager.h.

Referenced by allowTriggerInput(), and fatalError().

m_boostCutHysteresis

Hysteresis LimpManager::m_boostCutHysteresis

private

Definition at line 139 of file limp_manager.h.

Referenced by updateState().

m_faultRevLimit

int32_t LimpManager::m_faultRevLimit = INT32_MAX

private

Definition at line 143 of file limp_manager.h.

Referenced by setFaultRevLimit(), and updateState().

m_fuelCorrection

float LimpManager::m_fuelCorrection = 1.0f

private

Definition at line 159 of file limp_manager.h.

Referenced by getLimitingFuelCorrection(), and updateRevLimit().

m_hadOilPressureAfterStart

bool LimpManager::m_hadOilPressureAfterStart = false

private

Definition at line 153 of file limp_manager.h.

Referenced by updateState().

m_ignitionOn

bool LimpManager::m_ignitionOn = false

private

Definition at line 156 of file limp_manager.h.

Referenced by onIgnitionStateChanged(), and updateState().

m_injectorDutyCutHysteresis

Hysteresis LimpManager::m_injectorDutyCutHysteresis

private

Definition at line 140 of file limp_manager.h.

Referenced by updateState().

m_injectorDutySustainedTimer

Timer LimpManager::m_injectorDutySustainedTimer

private

Definition at line 169 of file limp_manager.h.

Referenced by updateState().

m_lastCutTime

Timer LimpManager::m_lastCutTime

private

Definition at line 166 of file limp_manager.h.

Referenced by getTimeSinceAnyCut(), and updateState().

m_revLimit

float LimpManager::m_revLimit

private

Definition at line 162 of file limp_manager.h.

Referenced by updateRevLimit(), and updateState().

m_revLimitHysteresis

Hysteresis LimpManager::m_revLimitHysteresis

private

Definition at line 138 of file limp_manager.h.

Referenced by updateState().

m_timingRetard

angle_t LimpManager::m_timingRetard = 0

private

Definition at line 158 of file limp_manager.h.

Referenced by getLimitingTimingRetard(), and updateRevLimit().

m_transientAllowIgnition

Clearable LimpManager::m_transientAllowIgnition = true

private

Definition at line 151 of file limp_manager.h.

Referenced by allowIgnition(), and updateState().

m_transientAllowInjection

Clearable LimpManager::m_transientAllowInjection = true

private

Definition at line 150 of file limp_manager.h.

Referenced by allowInjection(), and updateState().

resumeRpm

float LimpManager::resumeRpm

private

Definition at line 163 of file limp_manager.h.

Referenced by updateRevLimit(), and updateState().

shutdownController

ShutdownController LimpManager::shutdownController

Definition at line 108 of file limp_manager.h.

Referenced by doScheduleStopEngine(), and updateState().

---

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

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