MafAirmass Class Reference

#include <maf_airmass.h>

Inheritance diagram for MafAirmass:

Collaboration diagram for MafAirmass:

Public Member Functions
	MafAirmass (const ValueProvider3D &veTable)
AirmassResult	getAirmass (float rpm, bool postState) override
AirmassResult	getAirmassImpl (float massAirFlow, float rpm, bool postState) const
Public Member Functions inherited from AirmassVeModelBase
	AirmassVeModelBase (const ValueProvider3D &veTable)
float	getVe (float rpm, percent_t load, bool postState) const

Private Member Functions
float	getMaf () const

Detailed Description

Definition at line 5 of file maf_airmass.h.

Constructor & Destructor Documentation

MafAirmass()

MafAirmass::MafAirmass ( const ValueProvider3D &  veTable )

inlineexplicit

Definition at line 7 of file maf_airmass.h.

: AirmassVeModelBase(veTable) {}

Member Function Documentation

getAirmass()

AirmassResult MafAirmass::getAirmass ( float  rpm, bool  postState  )

overridevirtual

Implements AirmassModelBase.

Definition at line 31 of file maf_airmass.cpp.

                                                              {
    float maf = getMaf();
 
    return getAirmassImpl(maf, rpm, postState);
}

Here is the call graph for this function:

getAirmassImpl()

AirmassResult MafAirmass::getAirmassImpl	(	float	massAirFlow,
		float	rpm,
		bool	postState
	)		const

Function block now works to create a standardised load from the cylinder filling as well as tune fuel via VE table.

Returns

total duration of fuel injection per engine cycle, in milliseconds

Definition at line 41 of file maf_airmass.cpp.

                                                                                           {
    // If the engine is stopped, MAF is meaningless
    if (rpm == 0) {
        return {};
    }
 
    // kg/hr -> g/s
    float gramPerSecond = massAirFlow * 1000 / 3600;
 
    // 1/min -> 1/s
    float revsPerSecond = rpm / 60.0f;
    mass_t airPerRevolution = gramPerSecond / revsPerSecond;
 
    // Now we have to divide among cylinders - on a 4 stroke, half of the cylinders happen every revolution
    // This math is floating point to work properly on engines with odd cylinder count
    float halfCylCount = engineConfiguration->cylindersCount / 2.0f;
 
    mass_t cylinderAirmass = airPerRevolution / halfCylCount;
 
    //Create % load for fuel table using relative naturally aspirated cylinder filling
    float airChargeLoad = 100 * cylinderAirmass / getStandardAirCharge();
    
    //Correct air mass by VE table
    mass_t correctedAirmass = cylinderAirmass * getVe(rpm, airChargeLoad, postState);
 
    return {
        correctedAirmass,
        airChargeLoad, // AFR/VE/ignition table Y axis
    };
}

Referenced by getAirmass().

Here is the call graph for this function:

Here is the caller graph for this function:

getMaf()

float MafAirmass::getMaf ( ) const

private

Definition at line 7 of file maf_airmass.cpp.

                               {
    auto maf = Sensor::get(SensorType::Maf);
 
    if (Sensor::hasSensor(SensorType::Maf2)) {
        auto maf2 = Sensor::get(SensorType::Maf2);
 
        if (maf && maf2) {
            // Both MAFs work, return the sum
            return maf.Value + maf2.Value;
        } else if (maf) {
            // MAF 1 works, but not MAF 2, so double the value from #1
            return 2 * maf.Value;
        } else if (maf2) {
            // MAF 2 works, but not MAF 1, so double the value from #2
            return 2 * maf2.Value;
        } else {
            // Both MAFs are broken, give up.
            return 0;
        }
    } else {
        return maf.value_or(0);
    }
}

Referenced by getAirmass().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• controllers/algo/airmass/maf_airmass.h
• controllers/algo/airmass/maf_airmass.cpp