fuel_math.h File Reference

Detailed Description

Date

May 27, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file fuel_math.h.

Functions
void	initFuelMap ()
	Initialize fuel map data structure. More...
float	getRunningFuel (float baseFuel)
float	getBaroCorrection ()
percent_t	getFuelALSCorrection (int rpm)
int	getNumberOfInjections (injection_mode_e mode)
angle_t	getInjectionOffset (float rpm, float load)
float	getIatFuelCorrection ()
float	getCltFuelCorrection ()
	Engine warm-up fuel correction. More...
angle_t	getCltTimingCorrection ()
float	getCrankingFuel (float baseFuel)
float	getCrankingFuel3 (float baseFuel, uint32_t revolutionCounterSinceStart)
float	getInjectionMass (int rpm)
percent_t	getInjectorDutyCycle (int rpm)
percent_t	getInjectorDutyCycleStage2 (int rpm)
float	getStage2InjectionFraction (int rpm, float fuelLoad)
float	getStandardAirCharge ()
float	getCylinderFuelTrim (size_t cylinderNumber, int rpm, float fuelLoad)
AirmassModelBase *	getAirmassModel (engine_load_mode_e mode)
float	getMaxAirflowAtMap (float map)

Function Documentation

getAirmassModel()

AirmassModelBase* getAirmassModel

(

engine_load_mode_e

mode

)

Definition at line 150 of file fuel_math.cpp.

                                                           {
    switch (mode) {
        case LM_SPEED_DENSITY: return &sdAirmass;
        case LM_REAL_MAF: return &mafAirmass;
        case LM_ALPHA_N: return &alphaNAirmass;
#if EFI_LUA
        case LM_LUA: return &(getLuaAirmassModel());
#endif
#if EFI_UNIT_TEST
        case LM_MOCK: return engine->mockAirmassModel;
#endif
        default:
            firmwareError(ObdCode::CUSTOM_ERR_ASSERT, "Invalid airmass mode %d", engineConfiguration->fuelAlgorithm);
            return nullptr;
    }
}

Referenced by getBaseFuelMass(), and lua_getAirmass().

Here is the call graph for this function:

Here is the caller graph for this function:

getBaroCorrection()

float getBaroCorrection

(

)

Definition at line 380 of file fuel_math.cpp.

                          {
    if (Sensor::hasSensor(SensorType::BarometricPressure)) {
        // Default to 1atm if failed
        float pressure = Sensor::get(SensorType::BarometricPressure).value_or(101.325f);
 
        float correction = interpolate3d(
            config->baroCorrTable,
            config->baroCorrPressureBins, pressure,
            config->baroCorrRpmBins, Sensor::getOrZero(SensorType::Rpm)
        );
 
        if (cisnan(correction) || correction < 0.01) {
            warning(ObdCode::OBD_Barometric_Press_Circ_Range_Perf, "Invalid baro correction %f", correction);
            return 1;
        }
 
        return correction;
    } else {
        return 1;
    }
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getCltFuelCorrection()

float getCltFuelCorrection

(

)

Engine warm-up fuel correction.

Definition at line 353 of file fuel_math.cpp.

                             {
    const auto clt = Sensor::get(SensorType::Clt);
 
    if (!clt)
        return 1; // this error should be already reported somewhere else, let's just handle it
 
    return interpolate2d(clt.Value, config->cltFuelCorrBins, config->cltFuelCorr);
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getCltTimingCorrection()

angle_t getCltTimingCorrection

(

)

Definition at line 362 of file fuel_math.cpp.

                                 {
    const auto clt = Sensor::get(SensorType::Clt);
 
    if (!clt)
        return 0; // this error should be already reported somewhere else, let's just handle it
 
    return interpolate2d(clt.Value, config->cltTimingBins, config->cltTimingExtra);
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getCrankingFuel()

float getCrankingFuel

(

float

baseFuel

)

Returns

Duration of fuel injection while craning

Definition at line 423 of file fuel_math.cpp.

                                      {
    return getCrankingFuel3(baseFuel, engine->rpmCalculator.getRevolutionCounterSinceStart());
}

Referenced by getCycleFuelMass().

Here is the call graph for this function:

Here is the caller graph for this function:

getCrankingFuel3()

float getCrankingFuel3	(	float	baseFuel,
		uint32_t	revolutionCounterSinceStart
	)

Cranking fuel is different depending on engine coolant temperature If the sensor is failed, use 20 deg C

Definition at line 42 of file fuel_math.cpp.

                                                                             {
 
    float baseCrankingFuel;
    if (engineConfiguration->useRunningMathForCranking) {
        baseCrankingFuel = baseFuel;
    } else {
        // parameter is in milligrams, convert to grams
        baseCrankingFuel = engineConfiguration->cranking.baseFuel * 0.001f;
    }
 
    // Cranking fuel changes over time
    engine->engineState.crankingFuel.durationCoefficient = interpolate2d(revolutionCounterSinceStart, config->crankingCycleBins,
            config->crankingCycleCoef);
 
    /**
     * Cranking fuel is different depending on engine coolant temperature
     * If the sensor is failed, use 20 deg C
     */
    auto clt = Sensor::get(SensorType::Clt).value_or(20);
    auto e0Mult = interpolate2d(clt, config->crankingFuelBins, config->crankingFuelCoef);
 
    bool alreadyWarned = false;
    if (e0Mult <= 0.1f) {
        warning(ObdCode::CUSTOM_ERR_ZERO_E0_MULT, "zero e0 multiplier");
        alreadyWarned = true;
    }
 
    if (engineConfiguration->flexCranking && Sensor::hasSensor(SensorType::FuelEthanolPercent)) {
        auto e85Mult = interpolate2d(clt, config->crankingFuelBins, config->crankingFuelCoefE100);
 
        if (e85Mult <= 0.1f) {
            warning(ObdCode::CUSTOM_ERR_ZERO_E85_MULT, "zero e85 multiplier");
            alreadyWarned = true;
        }
 
        // If failed flex sensor, default to 50% E
        auto flex = Sensor::get(SensorType::FuelEthanolPercent).value_or(50);
 
        engine->engineState.crankingFuel.coolantTemperatureCoefficient =
            interpolateClamped(
                0, e0Mult,
                85, e85Mult,
                flex
            );
    } else {
        engine->engineState.crankingFuel.coolantTemperatureCoefficient = e0Mult;
    }
 
    auto tps = Sensor::get(SensorType::DriverThrottleIntent);
    engine->engineState.crankingFuel.tpsCoefficient =
        tps.Valid
        ? interpolate2d(tps.Value, config->crankingTpsBins, config->crankingTpsCoef)
        : 1; // in case of failed TPS, don't correct.
 
    floatms_t crankingFuel = baseCrankingFuel
            * engine->engineState.crankingFuel.durationCoefficient
            * engine->engineState.crankingFuel.coolantTemperatureCoefficient
            * engine->engineState.crankingFuel.tpsCoefficient;
 
    engine->engineState.crankingFuel.fuel = crankingFuel * 1000;
 
    // don't re-warn for zero fuel when we already warned for a more specific problem
    if (!alreadyWarned && crankingFuel <= 0) {
        warning(ObdCode::CUSTOM_ERR_ZERO_CRANKING_FUEL, "Cranking fuel value %f", crankingFuel);
    }
    return crankingFuel;
}

Referenced by getCrankingFuel().

Here is the call graph for this function:

Here is the caller graph for this function:

getCylinderFuelTrim()

float getCylinderFuelTrim	(	size_t	cylinderNumber,
		int	rpm,
		float	fuelLoad
	)

Definition at line 441 of file fuel_math.cpp.

                                                                          {
    auto trimPercent = interpolate3d(
        config->fuelTrims[cylinderNumber].table,
        config->fuelTrimLoadBins, fuelLoad,
        config->fuelTrimRpmBins, rpm
    );
 
    // Convert from percent +- to multiplier
    // 5% -> 1.05
    return (100 + trimPercent) / 100;
}

Referenced by EngineState::periodicFastCallback().

Here is the caller graph for this function:

getFuelALSCorrection()

percent_t getFuelALSCorrection

(

int

rpm

)

Definition at line 402 of file fuel_math.cpp.

                                        {
#if EFI_ANTILAG_SYSTEM
        if (engine->antilagController.isAntilagCondition) {
            float throttleIntent = Sensor::getOrZero(SensorType::DriverThrottleIntent);
            auto AlsFuelAdd = interpolate3d(
            config->ALSFuelAdjustment,
            config->alsFuelAdjustmentLoadBins, throttleIntent,
            config->alsFuelAdjustmentrpmBins, rpm
        );
        return AlsFuelAdd;
    } else
#endif /* EFI_ANTILAG_SYSTEM */
    {
        return 0;
    }
}

Referenced by AntilagSystemBase::update().

Here is the call graph for this function:

Here is the caller graph for this function:

getIatFuelCorrection()

float getIatFuelCorrection

(

)

Definition at line 371 of file fuel_math.cpp.

                             {
    const auto iat = Sensor::get(SensorType::Iat);
 
    if (!iat)
        return 1; // this error should be already reported somewhere else, let's just handle it
 
    return interpolate2d(iat.Value, config->iatFuelCorrBins, config->iatFuelCorr);
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getInjectionMass()

float getInjectionMass

(

int

rpm

)

Returns

Mass of each individual fuel injection, in grams in case of single point injection mode the amount of fuel into all cylinders, otherwise the amount for one cylinder

Definition at line 303 of file fuel_math.cpp.

                                {
    ScopePerf perf(PE::GetInjectionDuration);
 
    // Always update base fuel - some cranking modes use it
    float baseFuelMass = getBaseFuelMass(rpm);
 
    bool isCranking = engine->rpmCalculator.isCranking();
    float cycleFuelMass = getCycleFuelMass(isCranking, baseFuelMass);
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !cisnan(cycleFuelMass), "NaN cycleFuelMass", 0);
 
    if (engine->module<DfcoController>()->cutFuel()) {
        // If decel fuel cut, zero out fuel
        cycleFuelMass = 0;
    }
 
    float durationMultiplier = getInjectionModeDurationMultiplier();
    float injectionFuelMass = cycleFuelMass * durationMultiplier;
 
    // Prepare injector flow rate & deadtime
    engine->module<InjectorModelPrimary>()->prepare();
 
    if (engineConfiguration->enableStagedInjection) {
        engine->module<InjectorModelSecondary>()->prepare();
    }
 
    floatms_t tpsAccelEnrich = engine->tpsAccelEnrichment.getTpsEnrichment();
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !cisnan(tpsAccelEnrich), "NaN tpsAccelEnrich", 0);
    engine->engineState.tpsAccelEnrich = tpsAccelEnrich;
 
    // For legacy reasons, the TPS accel table is in units of milliseconds, so we have to convert BACK to mass
    float tpsAccelPerInjection = durationMultiplier * tpsAccelEnrich;
 
    float tpsFuelMass = engine->module<InjectorModelPrimary>()->getFuelMassForDuration(tpsAccelPerInjection);
 
    return injectionFuelMass + tpsFuelMass;
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getInjectionOffset()

angle_t getInjectionOffset	(	float	rpm,
		float	load
	)

Definition at line 208 of file fuel_math.cpp.

                                                  {
    if (cisnan(rpm)) {
        return 0; // error already reported
    }
 
    if (cisnan(load)) {
        return 0; // error already reported
    }
 
    angle_t value = interpolate3d(
        config->injectionPhase,
        config->injPhaseLoadBins, load,
        config->injPhaseRpmBins, rpm
    );
 
    if (cisnan(value)) {
        // we could be here while resetting configuration for example
        // huh? what? when do we have RPM while resetting configuration? is that CI edge case? shall we fix CI?
        warning(ObdCode::CUSTOM_ERR_6569, "phase map not ready");
        return 0;
    }
 
    angle_t result = value;
    wrapAngle(result, "inj offset#2", ObdCode::CUSTOM_ERR_6553);
    return result;
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getInjectorDutyCycle()

percent_t getInjectorDutyCycle

(

int

rpm

)

Definition at line 279 of file fuel_math.cpp.

                                        {
    floatms_t totalInjectiorAmountPerCycle = engine->engineState.injectionDuration * getNumberOfInjections(engineConfiguration->injectionMode);
    floatms_t engineCycleDuration = getEngineCycleDuration(rpm);
    return 100 * totalInjectiorAmountPerCycle / engineCycleDuration;
}

Referenced by canDashboardHaltech(), EngineState::periodicFastCallback(), populateFrame(), LimpManager::updateState(), and updateTunerStudioState().

Here is the call graph for this function:

Here is the caller graph for this function:

getInjectorDutyCycleStage2()

percent_t getInjectorDutyCycleStage2

(

int

rpm

)

Definition at line 285 of file fuel_math.cpp.

                                              {
    floatms_t totalInjectiorAmountPerCycle = engine->engineState.injectionDurationStage2 * getNumberOfInjections(engineConfiguration->injectionMode);
    floatms_t engineCycleDuration = getEngineCycleDuration(rpm);
    return 100 * totalInjectiorAmountPerCycle / engineCycleDuration;
}

Referenced by updateTunerStudioState().

Here is the call graph for this function:

Here is the caller graph for this function:

getMaxAirflowAtMap()

float getMaxAirflowAtMap

(

float

map

)

Definition at line 167 of file fuel_math.cpp.

                                    {
    return sdAirmass.getAirflow(Sensor::getOrZero(SensorType::Rpm), map, false);
}

Referenced by ThrottleModel::maxEngineFlow().

Here is the call graph for this function:

Here is the caller graph for this function:

getNumberOfInjections()

int getNumberOfInjections

(

injection_mode_e

mode

)

Number of injections using each injector per engine cycle

See also

getNumberOfSparks

Definition at line 239 of file fuel_math.cpp.

                                                 {
    switch (mode) {
    case IM_SIMULTANEOUS:
    case IM_SINGLE_POINT:
        return engineConfiguration->cylindersCount;
    case IM_BATCH:
        return 2;
    case IM_SEQUENTIAL:
        return 1;
    default:
        firmwareError(ObdCode::CUSTOM_ERR_INVALID_INJECTION_MODE, "Unexpected injection_mode_e %d", mode);
        return 1;
    }
}

Referenced by getInjectorDutyCycle(), getInjectorDutyCycleStage2(), and InjectionEvent::onTriggerTooth().

Here is the call graph for this function:

Here is the caller graph for this function:

getRunningFuel()

float getRunningFuel

(

float

baseFuel

)

Returns

baseFuel with CLT and IAT corrections

Definition at line 110 of file fuel_math.cpp.

                                     {
    ScopePerf perf(PE::GetRunningFuel);
 
    float iatCorrection = engine->fuelComputer.running.intakeTemperatureCoefficient;
    float cltCorrection = engine->fuelComputer.running.coolantTemperatureCoefficient;
    float postCrankingFuelCorrection = engine->fuelComputer.running.postCrankingFuelCorrection;
    float baroCorrection = engine->engineState.baroCorrection;
 
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !cisnan(iatCorrection), "NaN iatCorrection", 0);
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !cisnan(cltCorrection), "NaN cltCorrection", 0);
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !cisnan(postCrankingFuelCorrection), "NaN postCrankingFuelCorrection", 0);
 
    float correction = baroCorrection * iatCorrection * cltCorrection * postCrankingFuelCorrection;
 
#if EFI_ANTILAG_SYSTEM
    correction *= (1 + engine->antilagController.fuelALSCorrection / 100);
#endif /* EFI_ANTILAG_SYSTEM */
 
#if EFI_LAUNCH_CONTROL
    correction *= engine->launchController.getFuelCoefficient();
#endif
 
    correction *= getLimpManager()->getLimitingFuelCorrection();
 
    float runningFuel = baseFuel * correction;
 
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !cisnan(runningFuel), "NaN runningFuel", 0);
 
    // Publish output state
    engine->fuelComputer.running.baseFuel = baseFuel * 1000;
    engine->fuelComputer.totalFuelCorrection = correction;
    engine->fuelComputer.running.fuel = runningFuel * 1000;
 
    return runningFuel;
}

Referenced by getCycleFuelMass().

Here is the call graph for this function:

Here is the caller graph for this function:

getStage2InjectionFraction()

float getStage2InjectionFraction	(	int	rpm,
		float	fuelLoad
	)

Definition at line 455 of file fuel_math.cpp.

                                                      {
    if (!engineConfiguration->enableStagedInjection) {
        return 0;
    }
 
    float frac = 0.01f * interpolate3d(
        config->injectorStagingTable,
        config->injectorStagingLoadBins, load,
        config->injectorStagingRpmBins, rpm
    );
 
    // don't allow very small fraction, with some hysteresis
    if (!stage2Hysteresis.test(frac, 0.1, 0.03)) {
        return 0;
    }
 
    // Clamp to 90%
    if (frac > 0.9) {
        frac = 0.9;
    }
 
    return frac;
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getStandardAirCharge()

float getStandardAirCharge

(

)

Standard cylinder air charge - 100% VE at standard temperature, grams per cylinder

Should we bother caching 'getStandardAirCharge' result or can we afford to run the math every time we calculate fuel?

Definition at line 432 of file fuel_math.cpp.

                             {
    float totalDisplacement = engineConfiguration->displacement;
    float cylDisplacement = totalDisplacement / engineConfiguration->cylindersCount;
 
    // Calculation of 100% VE air mass in g/cyl - 1 cylinder filling at 1.204/L
    // 101.325kpa, 20C
    return idealGasLaw(cylDisplacement, 101.325f, 273.15f + 20.0f);
}

Referenced by MafAirmass::getAirmassImpl(), and getBaseFuelMass().

Here is the call graph for this function:

Here is the caller graph for this function:

initFuelMap()

void initFuelMap

(

)

Initialize fuel map data structure.

Note

this method has nothing to do with fuel map VALUES - it's job is to prepare the fuel map data structure for 3d interpolation

Definition at line 346 of file fuel_math.cpp.

                   {
    mapEstimationTable.initTable(config->mapEstimateTable, config->mapEstimateRpmBins, config->mapEstimateTpsBins);
}

Referenced by initDataStructures().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.