EngineState Class Reference

#include <engine_state.h>

Inheritance diagram for EngineState:

Collaboration diagram for EngineState:

Public Member Functions
	EngineState ()
void	periodicFastCallback ()
void	updateTChargeK (float rpm, float tps)
void	updateSparkSkip ()

Data Fields
angle_t	engineCycle {getEngineCycle(FOUR_STROKE_CRANK_SENSOR)}
bool	useOddFireWastedSpark = false
float	injectionStage2Fraction = 0
Timer	crankingTimer {}
Timer	undervoltageCrankingTimer {}
WarningCodeState	warnings {}
float	airflowEstimate = 0
float	auxValveStart = 0
float	auxValveEnd = 0
angle_t	mapAveragingStart [MAX_CYLINDER_COUNT] {}
angle_t	mapAveragingDuration = 0
angle_t	timingAdvance [MAX_CYLINDER_COUNT] {}
angle_t	trailingSparkAngle = 0
Timer	timeSinceLastTChargeK {}
floatms_t	baseFuel = 0
floatms_t	tpsAccelEnrich = 0
floatms_t	injectionDuration = 0
floatms_t	injectionDurationStage2 = 0
angle_t	injectionOffset = 0
multispark_state	multispark {}
bool	shouldUpdateInjectionTiming = true
Data Fields inherited from engine_state_s
float	injectionMass [MAX_CYLINDER_COUNT] = {}
LuaAdjustments	lua
speed_density_s	sd
cranking_fuel_s	crankingFuel
float	baroCorrection = (float)0
int16_t	hellenBoardId = (int16_t)0
int8_t	clutchUpState = (int8_t)0
int8_t	brakePedalState = (int8_t)0
int8_t	startStopState = (int8_t)0
int8_t	smartChipState = (int8_t)0
int8_t	smartChipRestartCounter = (int8_t)0
int8_t	smartChipAliveCounter = (int8_t)0
bool	startStopPhysicalState: 1 {}
bool	acrActive: 1 {}
bool	acrEngineMovedRecently: 1 {}
bool	heaterControlEnabled: 1 {}
bool	luaDigitalState0: 1 {}
bool	luaDigitalState1: 1 {}
bool	luaDigitalState2: 1 {}
bool	luaDigitalState3: 1 {}
bool	clutchDownState: 1 {}
bool	unusedBit_21_9: 1 {}
bool	unusedBit_21_10: 1 {}
bool	unusedBit_21_11: 1 {}
bool	unusedBit_21_12: 1 {}
bool	unusedBit_21_13: 1 {}
bool	unusedBit_21_14: 1 {}
bool	unusedBit_21_15: 1 {}
bool	unusedBit_21_16: 1 {}
bool	unusedBit_21_17: 1 {}
bool	unusedBit_21_18: 1 {}
bool	unusedBit_21_19: 1 {}
bool	unusedBit_21_20: 1 {}
bool	unusedBit_21_21: 1 {}
bool	unusedBit_21_22: 1 {}
bool	unusedBit_21_23: 1 {}
bool	unusedBit_21_24: 1 {}
bool	unusedBit_21_25: 1 {}
bool	unusedBit_21_26: 1 {}
bool	unusedBit_21_27: 1 {}
bool	unusedBit_21_28: 1 {}
bool	unusedBit_21_29: 1 {}
bool	unusedBit_21_30: 1 {}
bool	unusedBit_21_31: 1 {}
uint32_t	startStopStateToggleCounter = (uint32_t)0
float	currentVe = (float)0
float	luaSoftSparkSkip = (float)0
float	luaHardSparkSkip = (float)0
float	tractionControlSparkSkip = (float)0
uint32_t	fuelInjectionCounter = (uint32_t)0
uint32_t	globalSparkCounter = (uint32_t)0
float	fuelingLoad = (float)0
float	ignitionLoad = (float)0
scaled_channel< uint16_t, 100, 1 >	veTableYAxis = (uint16_t)0
uint8_t	overDwellCounter = (uint8_t)0
uint8_t	overDwellNotScheduledCounter = (uint8_t)0
uint8_t	sparkOutOfOrderCounter = (uint8_t)0
uint8_t	alignmentFill_at_137 [3] = {}
float	stftCorrection [FT_BANK_COUNT] = {}

Detailed Description

Definition at line 15 of file engine_state.h.

Constructor & Destructor Documentation

EngineState()

EngineState::EngineState

(

)

Definition at line 133 of file engine2.cpp.

                         {
    timeSinceLastTChargeK.reset(getTimeNowNt());
}

Here is the call graph for this function:

Member Function Documentation

periodicFastCallback()

void EngineState::periodicFastCallback

(

)

Definition at line 154 of file engine2.cpp.

                                       {
    ScopePerf perf(PE::EngineStatePeriodicFastCallback);
 
#if EFI_SHAFT_POSITION_INPUT
    if (!engine->slowCallBackWasInvoked) {
        warning(ObdCode::CUSTOM_SLOW_NOT_INVOKED, "Slow not invoked yet");
    }
 
    efitick_t nowNt = getTimeNowNt();
    bool isCranking = engine->rpmCalculator.isCranking();
    float rpm = Sensor::getOrZero(SensorType::Rpm);
 
    if (isCranking) {
        crankingTimer.reset(nowNt);
    }
 
    engine->fuelComputer.running.timeSinceCrankingInSecs = crankingTimer.getElapsedSeconds(nowNt);
 
#if EFI_AUX_VALVES
    recalculateAuxValveTiming();
#endif //EFI_AUX_VALVES
 
    engine->ignitionState.updateDwell(rpm, isCranking);
 
    // todo: move this into slow callback, no reason for IAT corr to be here
    engine->fuelComputer.running.intakeTemperatureCoefficient = getIatFuelCorrection();
    // todo: move this into slow callback, no reason for CLT corr to be here
    engine->fuelComputer.running.coolantTemperatureCoefficient = getCltFuelCorrection();
 
    engine->module<DfcoController>()->update();
    // should be called before getInjectionMass() and getLimitingTimingRetard()
    getLimpManager()->updateRevLimit(rpm);
 
    engine->fuelComputer.running.postCrankingFuelCorrection = getPostCrankingFuelCorrection();
 
    baroCorrection = getBaroCorrection();
 
    auto tps = Sensor::get(SensorType::Tps1);
    updateTChargeK(rpm, tps.value_or(0));
 
    float untrimmedInjectionMass = getInjectionMass(rpm) * engine->engineState.lua.fuelMult + engine->engineState.lua.fuelAdd;
    float fuelLoad = getFuelingLoad();
 
    auto clResult = engine->module<ShortTermFuelTrim>()->getCorrection(rpm, fuelLoad);
 
    engine->module<LongTermFuelTrim>()->learn(clResult, rpm, fuelLoad);
 
    auto ltftResult = engine->module<LongTermFuelTrim>()->getTrims(rpm, fuelLoad);
 
    injectionStage2Fraction = getStage2InjectionFraction(rpm, engine->fuelComputer.afrTableYAxis);
    float stage2InjectionMass = untrimmedInjectionMass * injectionStage2Fraction;
    float stage1InjectionMass = untrimmedInjectionMass - stage2InjectionMass;
 
    // Store the pre-wall wetting injection duration for scheduling purposes only, not the actual injection duration
    engine->engineState.injectionDuration = engine->module<InjectorModelPrimary>()->getInjectionDuration(stage1InjectionMass);
    engine->engineState.injectionDurationStage2 =
        engineConfiguration->enableStagedInjection
        ? engine->module<InjectorModelSecondary>()->getInjectionDuration(stage2InjectionMass)
        : 0;
 
    injectionOffset = getInjectionOffset(rpm, fuelLoad);
    engine->lambdaMonitor.update(rpm, fuelLoad);
 
#if EFI_LAUNCH_CONTROL
    engine->launchController.update();
    engine->shiftTorqueReductionController.update();
#endif //EFI_LAUNCH_CONTROL
 
    float l_ignitionLoad = getIgnitionLoad();
    engine->ignitionState.updateAdvanceCorrections(l_ignitionLoad);
    float baseAdvance = engine->ignitionState.getWrappedAdvance(rpm, l_ignitionLoad);
    float corrections = engineConfiguration->timingMode == TM_DYNAMIC ?
            // Pull any extra timing for knock retard
            - engine->module<KnockController>()->getKnockRetard()
            // Degrees of timing REMOVED from actual timing during soft RPM limit window
            - getLimpManager()->getLimitingTimingRetard() :
            0;
    float correctedIgnitionAdvance = baseAdvance + corrections;
    // these fields are scaled_channel so let's only use for observability, with a local variables holding value while it matters locally
    engine->ignitionState.baseIgnitionAdvance = MAKE_HUMAN_READABLE_ADVANCE(baseAdvance);
    engine->ignitionState.correctedIgnitionAdvance = MAKE_HUMAN_READABLE_ADVANCE(correctedIgnitionAdvance);
 
    // compute per-bank fueling
    for (size_t bankIndex = 0; bankIndex < FT_BANK_COUNT; bankIndex++) {
        engine->engineState.stftCorrection[bankIndex] = clResult.banks[bankIndex];
    }
 
    // Now apply that to per-cylinder fueling and timing
    for (size_t cylinderIndex = 0; cylinderIndex < engineConfiguration->cylindersCount; cylinderIndex++) {
        uint8_t bankIndex = engineConfiguration->cylinderBankSelect[cylinderIndex];
        /* TODO: add LTFT trims when ready */
        auto bankTrim = clResult.banks[bankIndex] * ltftResult.banks[bankIndex];
        auto cylinderTrim = getCylinderFuelTrim(cylinderIndex, rpm, fuelLoad);
        auto knockTrim = engine->module<KnockController>()->getFuelTrimMultiplier();
 
        // Apply both per-bank and per-cylinder trims
        engine->engineState.injectionMass[cylinderIndex] = untrimmedInjectionMass * bankTrim * cylinderTrim * knockTrim;
 
        angle_t cylinderIgnitionAdvance = correctedIgnitionAdvance
                                    + getCylinderIgnitionTrim(cylinderIndex, rpm, l_ignitionLoad)
                                    // spark hardware latency correction, for implementation details see:
                                    // https://github.com/rusefi/rusefi/issues/6832:
                                    + engine->ignitionState.getSparkHardwareLatencyCorrection();
        wrapAngle(cylinderIgnitionAdvance, "EngineState::periodicFastCallback", ObdCode::CUSTOM_ERR_ADCANCE_CALC_ANGLE);
        // todo: is it OK to apply cylinder trim with FIXED timing?
        timingAdvance[cylinderIndex] = cylinderIgnitionAdvance;
    }
 
    shouldUpdateInjectionTiming = getInjectorDutyCycle(rpm) < 90;
 
    engine->ignitionState.trailingSparkAngle = engine->ignitionState.getTrailingSparkAngle(rpm, l_ignitionLoad);
 
    multispark.count = getMultiSparkCount(rpm);
 
#if EFI_ANTILAG_SYSTEM
    engine->antilagController.update();
#endif //EFI_ANTILAG_SYSTEM
#endif // EFI_SHAFT_POSITION_INPUT
}

Referenced by Engine::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

updateSparkSkip()

void EngineState::updateSparkSkip

(

)

Definition at line 137 of file engine2.cpp.

                                  {
#if EFI_LAUNCH_CONTROL
        engine->softSparkLimiter.updateTargetSkipRatio(luaSoftSparkSkip, tractionControlSparkSkip);
        engine->hardSparkLimiter.updateTargetSkipRatio(
            luaHardSparkSkip,
            tractionControlSparkSkip,
            /*
             * We are applying launch controller spark skip ratio only for hard skip limiter (see
             * https://github.com/rusefi/rusefi/issues/6566#issuecomment-2153149902).
             */
            engine->launchController.getSparkSkipRatio() + engine->shiftTorqueReductionController.getSparkSkipRatio()
        );
#endif // EFI_LAUNCH_CONTROL
}

Referenced by configureRusefiLuaHooks(), and getRunningAdvance().

Here is the call graph for this function:

Here is the caller graph for this function:

updateTChargeK()

void EngineState::updateTChargeK	(	float	rpm,
		float	tps
	)

Definition at line 275 of file engine2.cpp.

                                                     {
    float newTCharge = engine->fuelComputer.getTCharge(rpm, tps);
    if (!std::isnan(newTCharge)) {
        // control the rate of change or just fill with the initial value
        efitick_t nowNt = getTimeNowNt();
        float secsPassed = timeSinceLastTChargeK.getElapsedSeconds(nowNt);
        sd.tCharge = (sd.tChargeK == 0) ? newTCharge : limitRateOfChange(newTCharge, sd.tCharge, engineConfiguration->tChargeAirIncrLimit, engineConfiguration->tChargeAirDecrLimit, secsPassed);
        sd.tChargeK = convertCelsiusToKelvin(sd.tCharge);
        timeSinceLastTChargeK.reset(nowNt);
    }
}

Referenced by periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

airflowEstimate

float EngineState::airflowEstimate = 0

Definition at line 39 of file engine_state.h.

Referenced by getBaseFuelMass(), populateFrame(), Generic4TransmissionController::setPcState(), and updateTunerStudioState().

auxValveEnd

float EngineState::auxValveEnd = 0

Definition at line 42 of file engine_state.h.

Referenced by auxPlainPinTurnOn(), and recalculateAuxValveTiming().

auxValveStart

float EngineState::auxValveStart = 0

Definition at line 41 of file engine_state.h.

Referenced by auxPlainPinTurnOn(), recalculateAuxValveTiming(), and scheduleOpen().

baseFuel

floatms_t EngineState::baseFuel = 0

Raw fuel injection duration produced by current fuel algorithm, without any correction

Definition at line 63 of file engine_state.h.

Referenced by getBaseFuelMass().

crankingTimer

Timer EngineState::crankingTimer {}

Definition at line 33 of file engine_state.h.

{};

Referenced by periodicFastCallback().

engineCycle

angle_t EngineState::engineCycle {getEngineCycle(FOUR_STROKE_CRANK_SENSOR)}

it's important for wrapAngle() that engineCycle field never has zero always 360 or 720, never zero

Definition at line 27 of file engine_state.h.

{getEngineCycle(FOUR_STROKE_CRANK_SENSOR)};

Referenced by AngleBasedEvent::getAngleFromNow(), getPerCylinderFiringOrderOffset(), TriggerCentral::isToothExpectedNow(), MapAveragingModule::onEnginePhase(), MapAveragingModule::onFastCallback(), InjectionEvent::onTriggerTooth(), prepareOutputSignals(), Engine::reset(), scheduleSparkEvent(), OneCylinder::updateCylinderNumber(), and wrapAngle().

injectionDuration

floatms_t EngineState::injectionDuration = 0

Each individual fuel injection duration for current engine cycle, without wall wetting including everything including injector lag, both cranking and running

See also

getInjectionDuration()

Definition at line 75 of file engine_state.h.

Referenced by InjectionEvent::computeInjectionAngle(), getInjectorDutyCycle(), periodicFastCallback(), populateFrame(), populateFrame(), and LimpManager::updateState().

injectionDurationStage2

floatms_t EngineState::injectionDurationStage2 = 0

Definition at line 76 of file engine_state.h.

Referenced by getInjectorDutyCycleStage2(), and periodicFastCallback().

injectionOffset

angle_t EngineState::injectionOffset = 0

Definition at line 78 of file engine_state.h.

Referenced by InjectionEvent::computeInjectionAngle(), and periodicFastCallback().

injectionStage2Fraction

float EngineState::injectionStage2Fraction = 0

Definition at line 31 of file engine_state.h.

Referenced by InjectionEvent::onTriggerTooth(), and periodicFastCallback().

mapAveragingDuration

angle_t EngineState::mapAveragingDuration = 0

Definition at line 48 of file engine_state.h.

Referenced by MapAveragingModule::onFastCallback(), and startAveraging().

mapAveragingStart

angle_t EngineState::mapAveragingStart[MAX_CYLINDER_COUNT] {}

MAP averaging angle start, in relation to '0' trigger index index

Definition at line 47 of file engine_state.h.

{};

Referenced by MapAveragingModule::onEnginePhase(), and MapAveragingModule::onFastCallback().

multispark

multispark_state EngineState::multispark {}

Definition at line 80 of file engine_state.h.

{};

Referenced by fireSparkAndPrepareNextSchedule(), getAdvanceCorrections(), getMultiSparkCount(), periodicFastCallback(), and scheduleSparkEvent().

shouldUpdateInjectionTiming

bool EngineState::shouldUpdateInjectionTiming = true

Definition at line 82 of file engine_state.h.

Referenced by periodicFastCallback().

timeSinceLastTChargeK

Timer EngineState::timeSinceLastTChargeK {}

Definition at line 58 of file engine_state.h.

{};

Referenced by EngineState(), and updateTChargeK().

timingAdvance

angle_t EngineState::timingAdvance[MAX_CYLINDER_COUNT] {}

timing advance is angle distance before Top Dead Center (TDP), i.e. "10 degree timing advance" means "happens 10 degrees before TDC"

Definition at line 53 of file engine_state.h.

{};

Referenced by canDashboardHaltech(), handleGetDataRequest(), initializeIgnitionActions(), KnockControllerBase::onKnockSenseCompleted(), periodicFastCallback(), populateFrame(), populateFrame(), and prepareCylinderIgnitionSchedule().

tpsAccelEnrich

floatms_t EngineState::tpsAccelEnrich = 0

TPS acceleration: extra fuel amount

Definition at line 68 of file engine_state.h.

Referenced by getInjectionMass(), and updateTunerStudioState().

trailingSparkAngle

angle_t EngineState::trailingSparkAngle = 0

Definition at line 56 of file engine_state.h.

undervoltageCrankingTimer

Timer EngineState::undervoltageCrankingTimer {}

Definition at line 34 of file engine_state.h.

{};

Referenced by Engine::periodicSlowCallback().

useOddFireWastedSpark

bool EngineState::useOddFireWastedSpark = false

Definition at line 29 of file engine_state.h.

Referenced by onTriggerEventSparkLogic(), prepareCylinderIgnitionSchedule(), and prepareOutputSignals().

warnings

WarningCodeState EngineState::warnings {}

Definition at line 36 of file engine_state.h.

{};

Referenced by firmwareErrorV(), handleGetConfigErorr(), handleTestCommand(), obdOnCanPacketRx(), populateFrame(), WarningCodeState::refreshTs(), updateTunerStudioState(), and warningVA().

---

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

• controllers/algo/engine_state.h
• controllers/algo/engine2.cpp