DfcoController Class Reference

#include <dfco.h>

Inheritance diagram for DfcoController:

Collaboration diagram for DfcoController:

Public Member Functions
void	update ()
bool	cutFuel () const
float	getTimingRetard () const
float	getTimeSinceCut () const
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	setDefaultConfiguration ()
virtual void	onConfigurationChange (engine_configuration_s const *)
virtual void	onSlowCallback ()
virtual void	onFastCallback ()
virtual void	onEngineStop ()
virtual void	onIgnitionStateChanged (bool)
virtual bool	needsDelayedShutoff ()
virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)

Private Member Functions
bool	getState () const

Private Attributes
bool	m_isDfco = false
Hysteresis	m_mapHysteresis
Timer	m_timeSinceCut
Timer	m_timeSinceNoCut

Detailed Description

Definition at line 11 of file dfco.h.

Member Function Documentation

cutFuel()

bool DfcoController::cutFuel

(

)

const

Definition at line 81 of file dfco.cpp.

                                   {
    float cutDelay = engineConfiguration->dfcoDelay;
 
    // 0 delay means cut immediately, aka timer has always expired
    bool hasBeenDelay = (cutDelay == 0) || m_timeSinceNoCut.hasElapsedSec(cutDelay);
 
    return m_isDfco && hasBeenDelay;
}

Referenced by getInjectionMass().

Here is the caller graph for this function:

getState()

bool DfcoController::getState ( ) const

private

Definition at line 8 of file dfco.cpp.

                                    {
    if (!engineConfiguration->coastingFuelCutEnabled) {
        return false;
    }
 
    if (checkIfTuningVeNow()) {
      return false;
    }
 
    const auto tps = Sensor::get(SensorType::DriverThrottleIntent);
    const auto clt = Sensor::get(SensorType::Clt);
    const auto map = Sensor::get(SensorType::Map);
 
    // If some sensor is broken, inhibit DFCO
    if (!tps || !clt) {
        return false;
    }
 
    // MAP sensor is optional, only inhibit if the sensor is present but broken
    bool hasMap = Sensor::hasSensor(SensorType::Map);
    if (hasMap && !map) {
        return false;
    }
    if (engine->engineState.lua.disableDecelerationFuelCutOff) {
      // Lua might have reasons to disable
        return false;
    }
 
    float rpm = Sensor::getOrZero(SensorType::Rpm);
    float vss = Sensor::getOrZero(SensorType::VehicleSpeed);
 
    bool mapActivate = !hasMap || !m_mapHysteresis.test(map.value_or(0), engineConfiguration->coastingFuelCutMap + 1, engineConfiguration->coastingFuelCutMap - 1);
    bool tpsActivate = tps.Value < engineConfiguration->coastingFuelCutTps;
    bool cltActivate = clt.Value > engineConfiguration->coastingFuelCutClt;
    // True if throttle, MAP, and CLT are all acceptable for DFCO to occur
    bool dfcoAllowed = mapActivate && tpsActivate && cltActivate;
 
    bool rpmActivate = (rpm > engineConfiguration->coastingFuelCutRpmHigh);
    bool rpmDeactivate = (rpm < engineConfiguration->coastingFuelCutRpmLow);
 
    // greater than or equal so that it works if both config params are set to 0
    bool vssActivate = (vss >= engineConfiguration->coastingFuelCutVssHigh);
    bool vssDeactivate = (vss < engineConfiguration->coastingFuelCutVssLow);
 
    // RPM is high enough, VSS high enough, and DFCO allowed
    if (dfcoAllowed && rpmActivate && vssActivate) {
        return true;
    }
 
    // RPM too low, VSS too low, or DFCO not allowed
    if (!dfcoAllowed || rpmDeactivate || vssDeactivate) {
        return false;
    }
 
    // No conditions hit, no change to state (provides hysteresis)
    return m_isDfco;
}

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

getTimeSinceCut()

float DfcoController::getTimeSinceCut

(

)

const

Definition at line 90 of file dfco.cpp.

                                            {
    return m_timeSinceCut.getElapsedSeconds();
}

getTimingRetard()

float DfcoController::getTimingRetard

(

)

const

Definition at line 94 of file dfco.cpp.

                                            {
    float cutTiming = clampF(0, engineConfiguration->dfcoRetardDeg, 30);
 
    if (m_isDfco) {
        // While cut, always retard timing
        return cutTiming;
    } else {
        float timeSinceCut = m_timeSinceCut.getElapsedSeconds();
        float rampInTime = engineConfiguration->dfcoRetardRampInTime;
 
        if (timeSinceCut > rampInTime) {
            // Normal operation, no retard
            return 0;
        } else {
            return interpolateClamped(0, cutTiming, 0.5, 0, timeSinceCut);
        }
    }
}

Here is the call graph for this function:

update()

void DfcoController::update

(

)

Definition at line 66 of file dfco.cpp.

                            {
    // Run state machine
    bool newState = getState();
 
    // If fuel is cut, reset the timer
    if (newState) {
        m_timeSinceCut.reset();
    } else {
        // If fuel is not cut, reset the not-cut timer
        m_timeSinceNoCut.reset();
    }
 
    m_isDfco = newState;
}

Here is the call graph for this function:

Field Documentation

m_isDfco

bool DfcoController::m_isDfco = false

private

Definition at line 24 of file dfco.h.

Referenced by cutFuel(), getState(), getTimingRetard(), and update().

m_mapHysteresis

Hysteresis DfcoController::m_mapHysteresis

mutableprivate

Definition at line 26 of file dfco.h.

Referenced by getState().

m_timeSinceCut

Timer DfcoController::m_timeSinceCut

private

Definition at line 28 of file dfco.h.

Referenced by getTimeSinceCut(), getTimingRetard(), and update().

m_timeSinceNoCut

Timer DfcoController::m_timeSinceNoCut

private

Definition at line 29 of file dfco.h.

Referenced by cutFuel(), and update().

---

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

• controllers/algo/fuel/dfco.h
• controllers/algo/fuel/dfco.cpp