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.
float	getRunningFuel (float baseFuel)
float	getBaroCorrection ()
percent_t	getFuelALSCorrection (float rpm)
int	getNumberOfInjections (injection_mode_e mode)
angle_t	getInjectionOffset (float rpm, float load)
float	getIatFuelCorrection ()
float	getPostCrankingFuelCorrection ()
float	getCltFuelCorrection ()
	Engine warm-up fuel correction.
angle_t	getCltTimingCorrection ()
float	getCrankingFuel (float baseFuel)
float	getCrankingFuel3 (float baseFuel, uint32_t revolutionCounterSinceStart)
float	getInjectionMass (float rpm)
percent_t	getInjectorDutyCycle (float rpm)
percent_t	getInjectorDutyCycleStage2 (float rpm)
float	getStage2InjectionFraction (float rpm, float fuelLoad)
float	getStandardAirCharge ()
float	getCylinderFuelTrim (size_t cylinderNumber, float rpm, float fuelLoad)
AirmassModelBase *	getAirmassModel (engine_load_mode_e mode)
float	getMaxAirflowAtMap (float map)
float	getCycleFuelMass (bool isCranking, float baseFuelMass)

Function Documentation

getAirmassModel()

AirmassModelBase * getAirmassModel

(

engine_load_mode_e

mode

)

Definition at line 156 of file fuel_math.cpp.

                                                           {
#if EFI_UNIT_TEST
    if (mode == engine_load_mode_e::UNSUPPORTED_ENUM_VALUE) {
        return engine->mockAirmassModel;
    }
#endif
 
    switch (mode) {
    case engine_load_mode_e::LM_SPEED_DENSITY: return &sdAirmass;
    case engine_load_mode_e::LM_REAL_MAF: return &mafAirmass;
    case engine_load_mode_e::LM_ALPHA_N: return &alphaNAirmass;
#if EFI_LUA
    case engine_load_mode_e::LM_LUA: return &(getLuaAirmassModel());
#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 429 of file fuel_math.cpp.

                          {
    if (Sensor::hasSensor(SensorType::BarometricPressure)) {
        // Default to 1atm if failed
        float pressure = Sensor::get(SensorType::BarometricPressure).value_or(STD_ATMOSPHERE);
 
        float correction = interpolate3d(
            config->baroCorrTable,
            config->baroCorrPressureBins, pressure,
            config->baroCorrRpmBins, Sensor::getOrZero(SensorType::Rpm)
        );
 
        if (std::isnan(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 386 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

(

)

Referenced by IgnitionState::updateAdvanceCorrections().

Here is the caller graph for this function:

getCrankingFuel()

float getCrankingFuel

(

float

baseFuel

)

Returns

Duration of fuel injection while craning

Definition at line 472 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 {
        // Cranking fuel changes over time
        baseCrankingFuel = interpolate3d(
              config->crankingCycleBaseFuel,
              config->crankingCycleFuelCltBins, Sensor::getOrZero(SensorType::Clt),
              config->crankingCycleBins, revolutionCounterSinceStart
          ) * 0.001f; // parameter is in milligrams, convert to grams
    }
 
    engine->engineState.crankingFuel.baseFuel = baseCrankingFuel * 1000; // convert to mg
 
    /**
     * 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.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:

getCycleFuelMass()

float getCycleFuelMass	(	bool	isCranking,
		float	baseFuelMass
	)

Definition at line 300 of file fuel_math.cpp.

                                                            {
    if (isCranking) {
        return getCrankingFuel(baseFuelMass);
    } else {
        return getRunningFuel(baseFuelMass);
    }
}

Referenced by getInjectionMass().

Here is the call graph for this function:

Here is the caller graph for this function:

getCylinderFuelTrim()

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

Definition at line 491 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
    // possible optimization: remove division by moving this scaling to TS level
    return (100 + trimPercent) / 100;
}

Referenced by EngineState::periodicFastCallback().

Here is the caller graph for this function:

getFuelALSCorrection()

percent_t getFuelALSCorrection

(

float

rpm

)

Definition at line 451 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 395 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

(

float

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 312 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, !std::isnan(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();
    }
 
    // This variable will hold the extra fuel mass from legacy AE modes
    float tpsFuelMass = 0;
 
    // Get the AE value (it will be 0 if predictive mode is active)
    float tpsAccelEnrich = engine->module<TpsAccelEnrichment>()->getTpsEnrichment();
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !std::isnan(tpsAccelEnrich), "NaN tpsAccelEnrich", 0);
    engine->engineState.tpsAccelEnrich = tpsAccelEnrich;
 
    float tpsAccelPerInjection = durationMultiplier * tpsAccelEnrich;
 
    // Use a switch to handle all AE modes
    switch ((accel_enrichment_mode_e)engineConfiguration->accelEnrichmentMode) {
        case AE_MODE_PERCENT_ADDER:
            // Treat the tpsAccelEnrich value as a percentage
            tpsFuelMass = injectionFuelMass * tpsAccelPerInjection;
            break;
 
        case AE_MODE_MS_ADDER:
            // For legacy reasons, the TPS accel table is in units of milliseconds,
            // so we have to convert BACK to mass
            tpsFuelMass = engine->module<InjectorModelPrimary>()->getFuelMassForDuration(tpsAccelPerInjection);
            break;
 
        case AE_MODE_PREDICTIVE_MAP:
            // Do nothing here. Fuel correction has already been handled by providing a
            // corrected MAP value to the getBaseFuelMass() calculation.
            break;
 
        default:
            criticalError("Invalid accelEnrichmentMode %d", engineConfiguration->accelEnrichmentMode);
            break;
    }
 
    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 217 of file fuel_math.cpp.

                                                  {
    if (std::isnan(rpm)) {
        return 0; // error already reported
    }
 
    if (std::isnan(load)) {
        return 0; // error already reported
    }
 
    angle_t value = interpolate3d(
        config->injectionPhase,
        config->injPhaseLoadBins, load,
        config->injPhaseRpmBins, rpm
    );
 
    if (std::isnan(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

(

float

rpm

)

Definition at line 288 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

(

float

rpm

)

Definition at line 294 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 176 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 248 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:

getPostCrankingFuelCorrection()

float getPostCrankingFuelCorrection

(

)

Definition at line 404 of file fuel_math.cpp.

                                      {
    const auto revolutionCounter = engine->rpmCalculator.getRevolutionCounterSinceStart();
    // if the engine run time is past the last bin, disable ASE in case the table is filled with values more than 1.0, helps with compatibility
    if (revolutionCounter > config->postCrankingDurationBins[efi::size(config->postCrankingDurationBins) - 1])
        return 1;
 
    // TODO:
    //const auto clt = Sensor::get(SensorType::Clt);
    //if (!clt)
    //  return 1; // this error should be already reported somewhere else, let's just handle it
 
    // post-cranking fuel enrichment.
    float postCrankingFactor = interpolate3d(
        config->postCrankingFactor,
        config->postCrankingCLTBins, Sensor::getOrZero(SensorType::Clt),
        config->postCrankingDurationBins, revolutionCounter
    );
 
    // for compatibility reasons, apply only if the factor is greater than unity (only allow adding fuel)
    if (postCrankingFactor < 1.0f)
        postCrankingFactor = 1.0f;
 
    return postCrankingFactor;
}

Referenced by EngineState::periodicFastCallback().

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 111 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, !std::isnan(iatCorrection), "NaN iatCorrection", 0);
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !std::isnan(cltCorrection), "NaN cltCorrection", 0);
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !std::isnan(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();
    correction *= engine->module<NitrousController>().unmock().getFuelCoefficient();
#endif
 
#ifdef MODULE_VVL_CONTROLLER
    correction *= engine->module<VvlController>().unmock().getFuelCoefficient();
#endif /* MODULE_VVL_CONTROLLER */
 
    correction *= getLimpManager()->getLimitingFuelCorrection();
 
    float runningFuel = baseFuel * correction;
 
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !std::isnan(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	(	float	rpm,
		float	fuelLoad
	)

Definition at line 506 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 481 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, STD_ATMOSPHERE, C_K_OFFSET + STD_IAT);
}

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 379 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.