WallFuelController Class Reference

#include <wall_fuel.h>

Inheritance diagram for WallFuelController:

Collaboration diagram for WallFuelController:

Public Types
using	interface_t = IWallFuelController

Public Member Functions
void	onFastCallback () override
bool	getEnable () const override
float	getAlpha () const override
float	getBeta () const override
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	setDefaultConfiguration ()
virtual void	onConfigurationChange (engine_configuration_s const *)
virtual void	onSlowCallback ()
virtual void	onEngineStop ()
virtual void	onIgnitionStateChanged (bool)
virtual bool	needsDelayedShutoff ()
virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)

Protected Member Functions
float	computeTau () const
float	computeBeta () const

Private Attributes
bool	m_enable = false
float	m_alpha = 0
float	m_beta = 0

Detailed Description

Definition at line 33 of file wall_fuel.h.

Member Typedef Documentation

interface_t

using WallFuelController::interface_t = IWallFuelController

Definition at line 35 of file wall_fuel.h.

Member Function Documentation

computeBeta()

float WallFuelController::computeBeta ( ) const

protected

Definition at line 105 of file wall_fuel.cpp.

                                            {
    if (!engineConfiguration->complexWallModel) {
        return engineConfiguration->wwaeBeta;
    }
 
    // Default to normal operating temperature in case of
    // CLT failure, this is not critical to get perfect
    float clt = Sensor::get(SensorType::Clt).value_or(90);
 
    float beta = interpolate2d(
        clt,
        config->wwCltBins,
        config->wwBetaCltValues
    );
 
    // If you have a MAP sensor, apply MAP correction
    if (Sensor::hasSensor(SensorType::Map)) {
        auto map = Sensor::get(SensorType::Map).value_or(60);
 
        beta *= interpolate2d(
            map,
            config->wwMapBins,
            config->wwBetaMapValues
        );
    }
 
    // Clamp to 0..1 (you can't have more than 100% of the fuel hit the wall!)
    return clampF(0, beta, 1);
}

Referenced by onFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

computeTau()

float WallFuelController::computeTau ( ) const

protected

Definition at line 76 of file wall_fuel.cpp.

                                           {
    if (!engineConfiguration->complexWallModel) {
        return engineConfiguration->wwaeTau;
    }
 
    // Default to normal operating temperature in case of
    // CLT failure, this is not critical to get perfect
    float clt = Sensor::get(SensorType::Clt).value_or(90);
 
    float tau = interpolate2d(
        clt,
        config->wwCltBins,
        config->wwTauCltValues
    );
 
    // If you have a MAP sensor, apply MAP correction
    if (Sensor::hasSensor(SensorType::Map)) {
        auto map = Sensor::get(SensorType::Map).value_or(60);
 
        tau *= interpolate2d(
            map,
            config->wwMapBins,
            config->wwTauMapValues
        );
    }
 
    return tau;
}

Referenced by onFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getAlpha()

float WallFuelController::getAlpha ( ) const

inlineoverridevirtual

Implements IWallFuelController.

Definition at line 43 of file wall_fuel.h.

                                    {
        return m_alpha;
    }

getBeta()

float WallFuelController::getBeta ( ) const

inlineoverridevirtual

Implements IWallFuelController.

Definition at line 47 of file wall_fuel.h.

                                   {
        return m_beta;
    }

getEnable()

bool WallFuelController::getEnable ( ) const

inlineoverridevirtual

Implements IWallFuelController.

Definition at line 39 of file wall_fuel.h.

                                    {
        return m_enable;
    }

Referenced by WallFuel::adjust().

Here is the caller graph for this function:

onFastCallback()

void WallFuelController::onFastCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 135 of file wall_fuel.cpp.

                                        {
    // disable wall wetting cranking
    // TODO: is this correct? Why not correct for cranking?
    if (engine->rpmCalculator.isCranking()) {
        m_enable = false;
        return;
    }
 
    float tau = computeTau();
    float beta = computeBeta();
 
    // if tau or beta is really small, we get div/0.
    // you probably meant to disable wwae.
    if (tau < 0.01f || beta < 0.01f) {
        m_enable = false;
        return;
    }
 
    auto rpm = Sensor::getOrZero(SensorType::Rpm);
 
    // Ignore low RPM
    if (rpm < 100) {
        m_enable = false;
        return;
    }
 
    float alpha = expf_taylor(-120 / (rpm * tau));
 
    // If beta is larger than alpha, the system is underdamped.
    // For reasonable values {tau, beta}, this should only be possible
    // at extremely low engine speeds (<300rpm ish)
    // Clamp beta to less than alpha.
    if (beta > alpha) {
        beta = alpha;
    }
 
    // Store parameters so the model can read them
    m_alpha = alpha;
    m_beta = beta;
    m_enable = true;
}

Here is the call graph for this function:

Field Documentation

m_alpha

float WallFuelController::m_alpha = 0

private

Definition at line 57 of file wall_fuel.h.

Referenced by getAlpha(), and onFastCallback().

m_beta

float WallFuelController::m_beta = 0

private

Definition at line 58 of file wall_fuel.h.

Referenced by getBeta(), and onFastCallback().

m_enable

bool WallFuelController::m_enable = false

private

Definition at line 56 of file wall_fuel.h.

Referenced by getEnable(), and onFastCallback().

---

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

• controllers/algo/wall_fuel.h
• controllers/algo/wall_fuel.cpp