TpsAccelEnrichment Class Reference

#include <accel_enrichment.h>

Inheritance diagram for TpsAccelEnrichment:

Collaboration diagram for TpsAccelEnrichment:

Public Member Functions
	TpsAccelEnrichment ()
void	onConfigurationChange (engine_configuration_s const *previousConfig) override
bool	isAccelEventTriggered ()
int	getMaxDeltaIndex ()
float	getMaxDelta ()
void	setLength (int length)
void	onNewValue (float currentValue)
floatms_t	getTpsEnrichment ()
void	onEngineCycleTps ()
void	resetFractionValues ()
void	resetAE ()
float	getTimeSinceAcell () const
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	setDefaultConfiguration ()
virtual void	onSlowCallback ()
virtual void	onFastCallback ()
virtual void	onEngineStop ()
virtual void	onIgnitionStateChanged (bool)
virtual bool	needsDelayedShutoff ()
virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)

Data Fields
bool	m_accelEventJustOccurred = false
Timer	m_timeSinceAccel
cyclic_buffer< float >	cb
int	onUpdateInvocationCounter = 0
Data Fields inherited from tps_accel_state_s
percent_t	tpsFrom = (percent_t)0
percent_t	tpsTo = (percent_t)0
percent_t	deltaTps = (percent_t)0
floatms_t	extraFuel = (floatms_t)0
float	valueFromTable = (float)0
bool	isAboveAccelThreshold: 1 {}
bool	isBelowDecelThreshold: 1 {}
bool	isTimeToResetAccumulator: 1 {}
bool	isFractionalEnrichment: 1 {}
bool	belowEpsilon: 1 {}
bool	tooShort: 1 {}
bool	unusedBit_11_6: 1 {}
bool	unusedBit_11_7: 1 {}
bool	unusedBit_11_8: 1 {}
bool	unusedBit_11_9: 1 {}
bool	unusedBit_11_10: 1 {}
bool	unusedBit_11_11: 1 {}
bool	unusedBit_11_12: 1 {}
bool	unusedBit_11_13: 1 {}
bool	unusedBit_11_14: 1 {}
bool	unusedBit_11_15: 1 {}
bool	unusedBit_11_16: 1 {}
bool	unusedBit_11_17: 1 {}
bool	unusedBit_11_18: 1 {}
bool	unusedBit_11_19: 1 {}
bool	unusedBit_11_20: 1 {}
bool	unusedBit_11_21: 1 {}
bool	unusedBit_11_22: 1 {}
bool	unusedBit_11_23: 1 {}
bool	unusedBit_11_24: 1 {}
bool	unusedBit_11_25: 1 {}
bool	unusedBit_11_26: 1 {}
bool	unusedBit_11_27: 1 {}
bool	unusedBit_11_28: 1 {}
bool	unusedBit_11_29: 1 {}
bool	unusedBit_11_30: 1 {}
bool	unusedBit_11_31: 1 {}
float	fractionalInjFuel = (float)0
floatms_t	accumulatedValue = (floatms_t)0
floatms_t	maxExtraPerCycle = (floatms_t)0
floatms_t	maxExtraPerPeriod = (floatms_t)0
floatms_t	maxInjectedPerPeriod = (floatms_t)0
int	cycleCnt = (int)0

Detailed Description

Definition at line 19 of file accel_enrichment.h.

Constructor & Destructor Documentation

TpsAccelEnrichment()

TpsAccelEnrichment::TpsAccelEnrichment

(

)

Definition at line 209 of file accel_enrichment.cpp.

                                       {
    resetAE();
    cb.setSize(4);
}

Here is the call graph for this function:

Member Function Documentation

getMaxDelta()

float TpsAccelEnrichment::getMaxDelta

(

)

Definition at line 156 of file accel_enrichment.cpp.

                                      {
    int index = getMaxDeltaIndex();
 
    return (cb.get(index) - (cb.get(index - 1)));
}

Here is the call graph for this function:

getMaxDeltaIndex()

int TpsAccelEnrichment::getMaxDeltaIndex

(

)

Definition at line 132 of file accel_enrichment.cpp.

                                         {
    int len = minI(cb.getSize(), cb.getCount());
    tooShort = len < 2;
    if (tooShort) {
        return 0;
    }
    int ci = cb.currentIndex - 1;
    float maxValue = cb.get(ci) - cb.get(ci - 1);
    int resultIndex = ci;
 
    // todo: 'get' method is maybe a bit heavy because of the branching
    // todo: this could be optimized with some careful magic
 
    for (int i = 1; i<len - 1;i++) {
        float v = cb.get(ci - i) - cb.get(ci - i - 1);
        if (v > maxValue) {
            maxValue = v;
            resultIndex = ci - i;
        }
    }
 
    return resultIndex;
}

Referenced by getMaxDelta(), and onNewValue().

Here is the caller graph for this function:

getTimeSinceAcell()

float TpsAccelEnrichment::getTimeSinceAcell

(

)

const

Definition at line 226 of file accel_enrichment.cpp.

                                                  {
    return m_timeSinceAccel.getElapsedSeconds();
}

getTpsEnrichment()

float TpsAccelEnrichment::getTpsEnrichment

(

)

Returns

Extra fuel squirt duration for TPS acceleration

Definition at line 30 of file accel_enrichment.cpp.

                                           {
    ScopePerf perf(PE::GetTpsEnrichment);
 
    // If predictive MAP mode is active, the old "adder" logic is disabled.
    if (engineConfiguration->accelEnrichmentMode == AE_MODE_PREDICTIVE_MAP) {
        return 0;
    }
 
    if (engineConfiguration->tpsAccelLookback == 0) {
        // If disabled, return 0.
        return 0;
    }
 
#if EFI_TUNER_STUDIO
    if (isTuningVeNow()) {
        return 0;
    }
#endif
 
    float rpm = Sensor::getOrZero(SensorType::Rpm);
    if (rpm < engineConfiguration->cranking.rpm) {
        return 0;
    }
 
    if (isAboveAccelThreshold) {
        valueFromTable = interpolate3d(config->tpsTpsAccelTable,
            config->tpsTpsAccelToRpmBins, tpsTo,
            config->tpsTpsAccelFromRpmBins, tpsFrom);
        extraFuel = valueFromTable;
        m_timeSinceAccel.reset();
    } else if (isBelowDecelThreshold) {
        extraFuel = deltaTps * engineConfiguration->tpsDecelEnleanmentMultiplier;
        m_timeSinceAccel.reset();
    } else {
        extraFuel = 0;
    }
 
    // Fractional enrichment (fuel portions are accumulated and split between several engine cycles.
    // This is a crude imitation of carburetor's acceleration pump.
    isFractionalEnrichment = engineConfiguration->tpsAccelFractionPeriod > 1 || engineConfiguration->tpsAccelFractionDivisor > 1.0f;
    if (isFractionalEnrichment) {
        // make sure both values are non-zero
        float periodF = std::max<int>(engineConfiguration->tpsAccelFractionPeriod, 1);
        float divisor = std::max(engineConfiguration->tpsAccelFractionDivisor, 1.0f);
 
        // if current extra fuel portion is not "strong" enough, then we keep up the "pump pressure" with the accumulated portion
        floatms_t maxExtraFuel = std::max(extraFuel, accumulatedValue);
        // use only a fixed fraction of the accumulated portion
        fractionalInjFuel = maxExtraFuel / divisor;
 
        // update max counters
        maxExtraPerCycle = std::max(extraFuel, maxExtraPerCycle);
        maxInjectedPerPeriod = std::max(fractionalInjFuel, maxInjectedPerPeriod);
 
        // evenly split it between several engine cycles
        extraFuel = fractionalInjFuel / periodF;
    } else {
        resetFractionValues();
    }
 
    float mult = interpolate2d(rpm, config->tpsTspCorrValuesBins,
                        config->tpsTspCorrValues);
    if (mult != 0 && (mult < 0.01 || mult > 100)) {
        mult = 1;
    }
 
    return extraFuel * mult;
}

Here is the call graph for this function:

isAccelEventTriggered()

bool TpsAccelEnrichment::isAccelEventTriggered

(

)

Definition at line 201 of file accel_enrichment.cpp.

                                               {
    // Read the flag
    bool result = m_accelEventJustOccurred;
    // Reset it so we only fire once per event
    m_accelEventJustOccurred = false;
    return result;
}

Referenced by SpeedDensityAirmass::getPredictiveMap().

Here is the caller graph for this function:

onConfigurationChange()

void TpsAccelEnrichment::onConfigurationChange ( engine_configuration_s const *  previousConfig )

overridevirtual

Reimplemented from EngineModule.

Definition at line 214 of file accel_enrichment.cpp.

                                                                              {
    constexpr float slowCallbackPeriodSecond = SLOW_CALLBACK_PERIOD_MS / 1000.0f;
    int length = engineConfiguration->tpsAccelLookback / slowCallbackPeriodSecond;
 
    if (length < 1) {
        efiPrintf("setTpsAccelLen: Length should be positive [%d]", length);
        return;
    }
 
    setLength(length);
}

Here is the call graph for this function:

onEngineCycleTps()

void TpsAccelEnrichment::onEngineCycleTps

(

)

Definition at line 99 of file accel_enrichment.cpp.

                                          {
    // we update values in handleFuel() directly by calling onNewValue()
 
    onUpdateInvocationCounter++;
 
    // we used some extra fuel during the current cycle, so we "charge" our "acceleration pump" with it
    accumulatedValue -= maxExtraPerPeriod;
    maxExtraPerPeriod = std::max(maxExtraPerCycle, maxExtraPerPeriod);
    maxExtraPerCycle = 0;
    accumulatedValue += maxExtraPerPeriod;
 
    // update the accumulated value every 'Period' engine cycles
    isTimeToResetAccumulator = --cycleCnt <= 0;
    if (isTimeToResetAccumulator) {
        maxExtraPerPeriod = 0;
 
        // we've injected this portion during the cycle, so we set what's left for the next cycle
        accumulatedValue -= maxInjectedPerPeriod;
        maxInjectedPerPeriod = 0;
 
        // it's an infinitely convergent series, so we set a limit at some point
        // (also make sure that accumulatedValue is positive, for safety)
        static const floatms_t smallEpsilon = 0.001f;
        belowEpsilon = accumulatedValue < smallEpsilon;
        if (belowEpsilon) {
            accumulatedValue = 0;
        }
 
        // reset the counter
        cycleCnt = engineConfiguration->tpsAccelFractionPeriod;
    }
}

onNewValue()

void TpsAccelEnrichment::onNewValue

(

float

currentValue

)

Definition at line 179 of file accel_enrichment.cpp.

                                                      {
    // Push new value in to the history buffer
    cb.add(currentValue);
 
    // Update deltas
    int maxDeltaIndex = getMaxDeltaIndex();
    tpsFrom = cb.get(maxDeltaIndex - 1);
    tpsTo = cb.get(maxDeltaIndex);
    deltaTps = tpsTo - tpsFrom;
 
    // Update threshold detection
    isAboveAccelThreshold = deltaTps > engineConfiguration->tpsAccelEnrichmentThreshold;
 
    // If an acceleration event just happened, latch the flag so it can be read once.
    if (isAboveAccelThreshold) {
        m_accelEventJustOccurred = true;
    }
 
    // TODO: can deltaTps actually be negative? Will this ever trigger?
    isBelowDecelThreshold = deltaTps < -engineConfiguration->tpsDecelEnleanmentThreshold;
}

Here is the call graph for this function:

resetAE()

void TpsAccelEnrichment::resetAE

(

)

Definition at line 162 of file accel_enrichment.cpp.

                                 {
    cb.clear();
    resetFractionValues();
}

Referenced by TpsAccelEnrichment().

Here is the call graph for this function:

Here is the caller graph for this function:

resetFractionValues()

void TpsAccelEnrichment::resetFractionValues

(

)

Definition at line 167 of file accel_enrichment.cpp.

                                             {
    accumulatedValue = 0;
    maxExtraPerCycle = 0;
    maxExtraPerPeriod = 0;
    maxInjectedPerPeriod = 0;
    cycleCnt = 0;
}

Referenced by getTpsEnrichment(), and resetAE().

Here is the caller graph for this function:

setLength()

void TpsAccelEnrichment::setLength

(

int

length

)

Definition at line 175 of file accel_enrichment.cpp.

                                             {
    cb.setSize(length);
}

Referenced by onConfigurationChange().

Here is the caller graph for this function:

Field Documentation

cb

cyclic_buffer<float> TpsAccelEnrichment::cb

Definition at line 39 of file accel_enrichment.h.

Referenced by getMaxDelta(), getMaxDeltaIndex(), onNewValue(), resetAE(), setLength(), and TpsAccelEnrichment().

m_accelEventJustOccurred

bool TpsAccelEnrichment::m_accelEventJustOccurred = false

Definition at line 25 of file accel_enrichment.h.

Referenced by isAccelEventTriggered(), and onNewValue().

m_timeSinceAccel

Timer TpsAccelEnrichment::m_timeSinceAccel

Definition at line 31 of file accel_enrichment.h.

Referenced by getTimeSinceAcell(), and getTpsEnrichment().

onUpdateInvocationCounter

int TpsAccelEnrichment::onUpdateInvocationCounter = 0

Definition at line 41 of file accel_enrichment.h.

Referenced by onEngineCycleTps().

---

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

• controllers/algo/accel_enrichment.h
• controllers/algo/accel_enrichment.cpp