#include <fuel_computer.h>

Inheritance diagram for IFuelComputer:

[legend]

Collaboration diagram for IFuelComputer:

[legend]

Public Member Functions
virtual mass_t	getCycleFuel (mass_t airmass, float rpm, float load)=0

temperature_t	getTCharge (float rpm, float tps)

float	getLoadOverride (float defaultLoad, load_override_e overrideMode) const

Private Member Functions
float	getTChargeCoefficient (float rpm, float tps)

Additional Inherited Members
Data Fields inherited from fuel_computer_s
float	totalFuelCorrection = (float)0

running_fuel_s	running

scaled_channel< uint16_t, 100, 1 >	afrTableYAxis = (uint16_t)0

scaled_channel< uint16_t, 10000, 1 >	targetLambda = (uint16_t)0

scaled_channel< uint16_t, 1000, 1 >	targetAFR = (uint16_t)0

scaled_channel< uint16_t, 1000, 1 >	stoichiometricRatio = (uint16_t)0

float	sdTcharge_coff = (float)0

float	sdAirMassInOneCylinder = (float)0

float	normalizedCylinderFilling = (float)0

uint8_t	brokenInjector = (uint8_t)0

uint8_t	unused88 = (uint8_t)0

uint16_t	idealEngineTorque = (uint16_t)0

bool	injectorHwIssue: 1 {}

bool	unusedBit_13_1: 1 {}

bool	unusedBit_13_2: 1 {}

bool	unusedBit_13_3: 1 {}

bool	unusedBit_13_4: 1 {}

bool	unusedBit_13_5: 1 {}

bool	unusedBit_13_6: 1 {}

bool	unusedBit_13_7: 1 {}

bool	unusedBit_13_8: 1 {}

bool	unusedBit_13_9: 1 {}

bool	unusedBit_13_10: 1 {}

bool	unusedBit_13_11: 1 {}

bool	unusedBit_13_12: 1 {}

bool	unusedBit_13_13: 1 {}

bool	unusedBit_13_14: 1 {}

bool	unusedBit_13_15: 1 {}

bool	unusedBit_13_16: 1 {}

bool	unusedBit_13_17: 1 {}

bool	unusedBit_13_18: 1 {}

bool	unusedBit_13_19: 1 {}

bool	unusedBit_13_20: 1 {}

bool	unusedBit_13_21: 1 {}

bool	unusedBit_13_22: 1 {}

bool	unusedBit_13_23: 1 {}

bool	unusedBit_13_24: 1 {}

bool	unusedBit_13_25: 1 {}

bool	unusedBit_13_26: 1 {}

bool	unusedBit_13_27: 1 {}

bool	unusedBit_13_28: 1 {}

bool	unusedBit_13_29: 1 {}

bool	unusedBit_13_30: 1 {}

bool	unusedBit_13_31: 1 {}

Detailed Description

Definition at line 12 of file fuel_computer.h.

Member Function Documentation

◆ getCycleFuel()

virtual mass_t IFuelComputer::getCycleFuel	(	mass_t	airmass,
		float	rpm,
		float	load
	)

pure virtual

Implemented in FuelComputerBase.

◆ getLoadOverride()

float IFuelComputer::getLoadOverride	(	float	defaultLoad,
		load_override_e	overrideMode
	)		const

Definition at line 86 of file fuel_computer.cpp.

                                                                                          {
    switch(overrideMode) {
        case AFR_None: return defaultLoad;
        // MAP default to 200kpa - failed MAP goes rich
        case AFR_MAP: return Sensor::get(SensorType::Map).value_or(200);
        // TPS/pedal default to 100% - failed TPS goes rich
        case AFR_Tps: return Sensor::get(SensorType::Tps1).value_or(100);
        case AFR_AccPedal: return Sensor::get(SensorType::AcceleratorPedal).value_or(100);
        case AFR_CylFilling: return normalizedCylinderFilling;
        default: return 0;
    }
}

Referenced by getBaseFuelMass(), and FuelComputer::getTargetLambdaLoadAxis().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTCharge()

temperature_t IFuelComputer::getTCharge	(	float	rpm,
		float	tps
	)

Definition at line 65 of file speed_density.cpp.

                                                            {
    const auto clt = Sensor::get(SensorType::Clt);
    const auto iat = Sensor::get(SensorType::Iat);
 
    float airTemp;
 
    // Without either valid, return 0C.  It's wrong, but it'll pretend to be nice and dense, so at least you won't go lean.
    if (!iat && !clt) {
        return 0;
    } else if (!clt && iat) {
        // Intake temperature will almost always be colder (richer) than CLT - use that
        return iat.Value;
    } else if (!iat && clt) {
        // Without valid intake temperature, assume intake temp is 0C, and interpolate anyway
        airTemp = 0;
    } else {
        // All is well - use real air temp
        airTemp = iat.Value;
    }
 
    float coolantTemp = clt.Value;
 
    sdTcharge_coff = getTChargeCoefficient(rpm, tps);
 
    if (std::isnan(sdTcharge_coff)) {
        warning(ObdCode::CUSTOM_ERR_T2_CHARGE, "t2-getTCharge NaN");
        return coolantTemp;
    }
 
    // Interpolate between CLT and IAT:
    // 0.0 coefficient -> use CLT (full heat transfer)
    // 1.0 coefficient -> use IAT (no heat transfer)
    float Tcharge = interpolateClamped(0.0f, coolantTemp, 1.0f, airTemp, sdTcharge_coff);
 
    if (std::isnan(Tcharge)) {
        // we can probably end up here while resetting engine state - interpolation would fail
        warning(ObdCode::CUSTOM_ERR_TCHARGE_NOT_READY, "getTCharge NaN");
        return coolantTemp;
    }
 
    return Tcharge;
}

Referenced by EngineState::updateTChargeK().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTChargeCoefficient()

float IFuelComputer::getTChargeCoefficient	(	float	rpm,
		float	tps
	)

private

Definition at line 24 of file speed_density.cpp.

                                                               {
    // First, do TPS mode since it doesn't need any of the airflow math.
    if (engineConfiguration->tChargeMode == TCHARGE_MODE_RPM_TPS) {
        float minRpmKcurrentTPS = interpolateMsg("minRpm", tpMin,
                engineConfiguration->tChargeMinRpmMinTps, tpMax,
                engineConfiguration->tChargeMinRpmMaxTps, tps);
        float maxRpmKcurrentTPS = interpolateMsg("maxRpm", tpMin,
                engineConfiguration->tChargeMaxRpmMinTps, tpMax,
                engineConfiguration->tChargeMaxRpmMaxTps, tps);
 
        return interpolateMsg("Kcurr", rpmMin, minRpmKcurrentTPS, rpmMax, maxRpmKcurrentTPS, rpm);
    }
 
    constexpr floatms_t gramsPerMsToKgPerHour = (3600.0f * 1000.0f) / 1000.0f;
    // We're actually using an 'old' airMass calculated for the previous cycle, but it's ok, we're not having any self-excitaton issues
    floatms_t airMassForEngine = sdAirMassInOneCylinder * engineConfiguration->cylindersCount;
    // airMass is in grams per 1 cycle for 1 cyl. Convert it to airFlow in kg/h for the engine.
    // And if the engine is stopped (0 rpm), then airFlow is also zero (avoiding NaN division)
    floatms_t airFlow = (rpm == 0) ? 0 : airMassForEngine * gramsPerMsToKgPerHour / getEngineCycleDuration(rpm);
 
    if (engineConfiguration->tChargeMode == TCHARGE_MODE_AIR_INTERP) {
        // just interpolate between user-specified min and max coefs, based on the max airFlow value
        return interpolateClamped(
            0.0, engineConfiguration->tChargeAirCoefMin,
            engineConfiguration->tChargeAirFlowMax, engineConfiguration->tChargeAirCoefMax,
            airFlow
        );
    } else if (engineConfiguration->tChargeMode == TCHARGE_MODE_AIR_INTERP_TABLE) {
        return interpolate2d(
            airFlow,
            engineConfiguration->tchargeBins,
            engineConfiguration->tchargeValues
        );
    } else {
        criticalError("Unexpected tChargeMode: %d", engineConfiguration->tChargeMode);
        return 0;
    }
}

Referenced by getTCharge().

Here is the call graph for this function:

Here is the caller graph for this function:

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

controllers/algo/fuel/fuel_computer.h
controllers/algo/fuel/fuel_computer.cpp
controllers/math/speed_density.cpp

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ getCycleFuel()

◆ getLoadOverride()

◆ getTCharge()

◆ getTChargeCoefficient()