ShortTermFuelTrim Class Reference

#include <closed_loop_fuel.h>

Inheritance diagram for ShortTermFuelTrim:

Collaboration diagram for ShortTermFuelTrim:

Public Member Functions
void	init (stft_s *stftCfg)
void	onSlowCallback () override
bool	needsDelayedShutoff () override
ClosedLoopFuelResult	getCorrection (float rpm, float fuelLoad)
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	setDefaultConfiguration ()
virtual void	onConfigurationChange (engine_configuration_s const *)
virtual void	onFastCallback ()
virtual void	onEngineStop ()
virtual void	onIgnitionStateChanged (bool)
virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)

Private Member Functions
SensorType	getSensorForBankIndex (size_t index)
size_t	computeStftBin (float rpm, float load, stft_s &cfg)
stft_state_e	getCorrectionState ()
stft_state_e	getLearningState (SensorType sensor)

Private Attributes
FuelingBank	banks [FT_BANK_COUNT]
Deadband< 25 >	idleDeadband
Deadband< 2 >	overrunDeadband
Deadband< 2 >	loadDeadband

Additional Inherited Members
Data Fields inherited from short_term_fuel_trim_state_s
uint8_t	stftCorrectionBinIdx = (uint8_t)0
uint8_t	stftLearningBinIdx = (uint8_t)0
stft_state_e	stftCorrectionState
stft_state_e	stftLearningState [FT_BANK_COUNT] = {}
uint8_t	alignmentFill_at_5 [3] = {}
float	stftInputError [FT_BANK_COUNT] = {}

Detailed Description

Definition at line 26 of file closed_loop_fuel.h.

Member Function Documentation

computeStftBin()

size_t ShortTermFuelTrim::computeStftBin ( float  rpm, float  load, stft_s &  cfg  )

private

Definition at line 16 of file closed_loop_fuel.cpp.

                                                                           {
    // Low RPM -> idle
    if (idleDeadband.lt(rpm, cfg.maxIdleRegionRpm))
    {
        return 0;
    }
 
    // Low load -> overrun
    if (overrunDeadband.lt(load, cfg.maxOverrunLoad))
    {
        return 1;
    }
 
    // High load -> power
    if (loadDeadband.gt(load, cfg.minPowerLoad))
    {
        return 2;
    }
 
    // Default -> normal "in the middle" cell
    return 3;
}

Referenced by getCorrection().

Here is the call graph for this function:

Here is the caller graph for this function:

getCorrection()

ClosedLoopFuelResult ShortTermFuelTrim::getCorrection	(	float	rpm,
		float	fuelLoad
	)

Definition at line 118 of file closed_loop_fuel.cpp.

                                                                               {
    stftCorrectionState = getCorrectionState();
    if (stftCorrectionState != stftEnabled) {
        // Learning is also prohibited
        for (size_t bank = 0; bank < FT_BANK_COUNT; bank++) {
            stftLearningState[bank] = stftCorrectionState;
        }
        return {};
    }
 
    stftCorrectionBinIdx = computeStftBin(rpm, fuelLoad, engineConfiguration->stft);
 
    ClosedLoopFuelResult result;
 
    for (size_t bank = 0; bank < FT_BANK_COUNT; bank++) {
        auto& cell = banks[bank].cells[stftCorrectionBinIdx];
 
        SensorType sensor = getSensorForBankIndex(bank);
 
        stftLearningState[bank] = getLearningState(sensor);
        if (stftLearningState[bank] == stftEnabled) {
            stftInputError[bank] = cell.getLambdaError();
            cell.update(engineConfiguration->stft.deadband * 0.01f, engineConfiguration->stftIgnoreErrorMagnitude);
            stftLearningBinIdx = stftCorrectionBinIdx;
        }
 
        result.banks[bank] = cell.getAdjustment();
    }
 
    return result;
}

Here is the call graph for this function:

getCorrectionState()

stft_state_e ShortTermFuelTrim::getCorrectionState ( )

private

Definition at line 39 of file closed_loop_fuel.cpp.

                                                   {
    const auto& cfg = engineConfiguration->stft;
 
    // User disable bit
    if (!engineConfiguration->fuelClosedLoopCorrectionEnabled) {
        return stftDisabledSettings;
    }
 
    // Don't correct if tuning seems to be happening
    if (checkIfTuningVeNow()) {
        return stftDisabledTuning;
    }
 
    // Don't correct if not running
    if (!engine->rpmCalculator.isRunning()) {
        return stftDisabledRPM;
    }
 
    // Startup delay - allow O2 sensor to warm up, etc
    if (cfg.startupDelay > engine->fuelComputer.running.timeSinceCrankingInSecs) {
        return stftDisabledCrankingDelay;
    }
 
    // Check that the engine is hot enough (and clt not failed)
    auto clt = Sensor::get(SensorType::Clt);
    if (!clt.Valid || clt.Value < cfg.minClt) {
        return stftDisabledClt;
    }
 
    // If all was well, then we're enabled!
    return stftEnabled;
}

Referenced by getCorrection().

Here is the call graph for this function:

Here is the caller graph for this function:

getLearningState()

stft_state_e ShortTermFuelTrim::getLearningState ( SensorType  sensor )

private

Definition at line 72 of file closed_loop_fuel.cpp.

                                                                  {
    const auto& cfg = engineConfiguration->stft;
 
    // TODO: add check for stftLearningDisabledSettings
 
    // Pause (but don't reset) correction if the AFR is off scale.
    // It's probably a transient and poorly tuned transient correction
    // TODO: use getStoichiometricRatio() instead of STOICH_RATIO
    auto afr = Sensor::getOrZero(sensor) * STOICH_RATIO;
    if (!afr || afr < cfg.minAfr || afr > cfg.maxAfr) {
        return stftDisabledAfrOurOfRange;
    }
 
    // Pause correction if DFCO was active recently
    auto timeSinceDfco = engine->module<DfcoController>()->getTimeSinceCut();
    if (timeSinceDfco < engineConfiguration->noFuelTrimAfterDfcoTime) {
        return stftDisabledDFCO;
    }
 
    // Pause correction if Accel enrichment was active recently
    auto timeSinceAccel = engine->module<TpsAccelEnrichment>()->getTimeSinceAcell();
    if (timeSinceAccel < engineConfiguration->noFuelTrimAfterAccelTime) {
        return stftDisabledTpsAccel;
    }
 
    // Pause if some other cut was active recently
    auto timeSinceFuelCut = engine->module<LimpManager>()->getTimeSinceAnyCut();
    // TODO: should duration this be configurable?
    if (timeSinceFuelCut < 2) {
        return stftDisabledFuelCut;
    }
 
    return stftEnabled;
}

Referenced by getCorrection().

Here is the call graph for this function:

Here is the caller graph for this function:

getSensorForBankIndex()

SensorType ShortTermFuelTrim::getSensorForBankIndex ( size_t  index )

private

Definition at line 8 of file closed_loop_fuel.cpp.

                                                                {
    switch (index) {
        case 0: return SensorType::Lambda1;
        case 1: return SensorType::Lambda2;
        default: return SensorType::Invalid;
    }
}

Referenced by getCorrection(), and init().

Here is the caller graph for this function:

init()

void ShortTermFuelTrim::init

(

stft_s *

stftCfg

)

Definition at line 107 of file closed_loop_fuel.cpp.

                                            {
    for (size_t bank = 0; bank < FT_BANK_COUNT; bank++) {
        for (size_t bin = 0; bin < STFT_CELL_COUNT; bin++) {
            auto& cell = banks[bank].cells[bin];
            SensorType sensor = getSensorForBankIndex(bank);
 
            cell.configure(&stftCfg->cellCfgs[bin], sensor);
        }
    }
}

Here is the call graph for this function:

needsDelayedShutoff()

bool ShortTermFuelTrim::needsDelayedShutoff ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 154 of file closed_loop_fuel.cpp.

                                            {
    return false;
}

onSlowCallback()

void ShortTermFuelTrim::onSlowCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 150 of file closed_loop_fuel.cpp.

                                       {
    // Do some magic math here?
}

Field Documentation

banks

FuelingBank ShortTermFuelTrim::banks[FT_BANK_COUNT]

private

Definition at line 38 of file closed_loop_fuel.h.

Referenced by getCorrection(), and init().

idleDeadband

Deadband<25> ShortTermFuelTrim::idleDeadband

private

Definition at line 40 of file closed_loop_fuel.h.

Referenced by computeStftBin().

loadDeadband

Deadband<2> ShortTermFuelTrim::loadDeadband

private

Definition at line 42 of file closed_loop_fuel.h.

Referenced by computeStftBin().

overrunDeadband

Deadband<2> ShortTermFuelTrim::overrunDeadband

private

Definition at line 41 of file closed_loop_fuel.h.

Referenced by computeStftBin().

---

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

• controllers/math/closed_loop_fuel.h
• controllers/math/closed_loop_fuel.cpp