#include <engine_state.h>

Inheritance diagram for EngineState:

Collaboration diagram for EngineState:

[legend]

Public Member Functions
	EngineState ()

void	periodicFastCallback ()

void	updateSlowSensors ()

void	updateTChargeK (int rpm, float tps)

void	updateSparkSkip ()

Data Fields
angle_t	engineCycle

sensor_chart_e	sensorChartMode = SC_OFF

float	injectionMass [MAX_CYLINDER_COUNT] = {0}

float	injectionStage2Fraction = 0

Timer	crankingTimer

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] = {0}

angle_t	trailingSparkAngle = 0

Timer	timeSinceLastTChargeK

float	currentVe = 0

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
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	clutchDownState = (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

uint8_t	alignmentFill_at_49 [3]

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	unusedBit_21_8: 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	luaSoftSparkSkip = (float)0

float	luaHardSparkSkip = (float)0

float	tractionControlSparkSkip = (float)0

int16_t	desiredRpmLimit = (int16_t)0

uint8_t	alignmentFill_at_74 [2]

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_97 [3]

Detailed Description

Definition at line 15 of file engine_state.h.

Constructor & Destructor Documentation

◆ EngineState()

EngineState::EngineState ( )

Definition at line 84 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 100 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();
  
     if (engine->rpmCalculator.isCranking()) {
         crankingTimer.reset(nowNt);
     }
  
     engine->fuelComputer.running.timeSinceCrankingInSecs = crankingTimer.getElapsedSeconds(nowNt);
  
     recalculateAuxValveTiming();
  
     int rpm = Sensor::getOrZero(SensorType::Rpm);
     engine->ignitionState.sparkDwell = engine->ignitionState.getSparkDwell(rpm);
     engine->ignitionState.dwellDurationAngle = cisnan(rpm) ? NAN :  engine->ignitionState.sparkDwell / getOneDegreeTimeMs(rpm);
  
     // 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);
  
     // post-cranking fuel enrichment.
     float m_postCrankingFactor = interpolate3d(
         engineConfiguration->postCrankingFactor,
         engineConfiguration->postCrankingCLTBins, Sensor::getOrZero(SensorType::Clt),
         engineConfiguration->postCrankingDurationBins, engine->rpmCalculator.getRevolutionCounterSinceStart()
     );
     // for compatibility reasons, apply only if the factor is greater than unity (only allow adding fuel)
     // if the engine run time is past the last bin, disable ASE in case the table is filled with values more than 1.0, helps with compatibility
     if ((m_postCrankingFactor < 1.0f) || (engine->rpmCalculator.getRevolutionCounterSinceStart() > engineConfiguration->postCrankingDurationBins[efi::size(engineConfiguration->postCrankingDurationBins)-1])) {
         m_postCrankingFactor = 1.0f;
     }
     engine->fuelComputer.running.postCrankingFuelCorrection = m_postCrankingFactor;
  
     engine->ignitionState.cltTimingCorrection = getCltTimingCorrection();
  
     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;
     auto clResult = fuelClosedLoopCorrection();
  
     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;
  
     float fuelLoad = getFuelingLoad();
     injectionOffset = getInjectionOffset(rpm, fuelLoad);
     engine->lambdaMonitor.update(rpm, fuelLoad);
  
     float l_ignitionLoad = getIgnitionLoad();
     float baseAdvance = getAdvance(rpm, l_ignitionLoad) * engine->ignitionState.luaTimingMult + engine->ignitionState.luaTimingAdd;
     float correctedIgnitionAdvance = baseAdvance
             // 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();
     // 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 i = 0; i < STFT_BANK_COUNT; i++) {
         float corr = clResult.banks[i];
         engine->stftCorrection[i] = corr;
     }
  
     // Now apply that to per-cylinder fueling and timing
     for (size_t i = 0; i < engineConfiguration->cylindersCount; i++) {
         uint8_t bankIndex = engineConfiguration->cylinderBankSelect[i];
         auto bankTrim = engine->stftCorrection[bankIndex];
         auto cylinderTrim = getCylinderFuelTrim(i, rpm, fuelLoad);
  
         // Apply both per-bank and per-cylinder trims
         engine->engineState.injectionMass[i] = untrimmedInjectionMass * bankTrim * cylinderTrim;
  
         timingAdvance[i] = correctedIgnitionAdvance + getCylinderIgnitionTrim(i, rpm, l_ignitionLoad);
     }
  
     shouldUpdateInjectionTiming = getInjectorDutyCycle(rpm) < 90;
  
     // TODO: calculate me from a table!
     trailingSparkAngle = engineConfiguration->trailingSparkAngle;
  
     multispark.count = getMultiSparkCount(rpm);
  
 #if EFI_LAUNCH_CONTROL
     engine->launchController.update();
 #endif //EFI_LAUNCH_CONTROL
  
 #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:

◆ updateSlowSensors()

void EngineState::updateSlowSensors ( )

Definition at line 88 of file engine2.cpp.

88 {

89 }

Referenced by Engine::updateSlowSensors().

Here is the caller graph for this function:

◆ updateSparkSkip()

void EngineState::updateSparkSkip ( )

Definition at line 91 of file engine2.cpp.

                                   {
 #if EFI_LAUNCH_CONTROL
         engine->softSparkLimiter.setTargetSkipRatio(luaSoftSparkSkip + engineConfiguration->useHardSkipInTraction ? 0 : tractionControlSparkSkip);
         engine->hardSparkLimiter.setTargetSkipRatio(luaHardSparkSkip + engineConfiguration->useHardSkipInTraction ? tractionControlSparkSkip : 0);
 #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	(	int	rpm,
		float	tps
	)

Definition at line 216 of file engine2.cpp.

                                                    {
     float newTCharge = engine->fuelComputer.getTCharge(rpm, tps);
     if (!cisnan(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 44 of file engine_state.h.

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

◆ auxValveEnd

float EngineState::auxValveEnd = 0

Definition at line 47 of file engine_state.h.

Referenced by auxPlainPinTurnOn(), and recalculateAuxValveTiming().

◆ auxValveStart

float EngineState::auxValveStart = 0

Definition at line 46 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 70 of file engine_state.h.

Referenced by getBaseFuelMass().

◆ crankingTimer

Timer EngineState::crankingTimer

Definition at line 39 of file engine_state.h.

Referenced by periodicFastCallback().

◆ currentVe

float EngineState::currentVe = 0

Definition at line 65 of file engine_state.h.

Referenced by AirmassVeModelBase::getVe(), and updateFuelInfo().

◆ engineCycle

angle_t EngineState::engineCycle

always 360 or 720, never zero

Definition at line 27 of file engine_state.h.

Referenced by AngleBasedEvent::getAngleFromNow(), getPerCylinderFiringOrderOffset(), TriggerCentral::isToothExpectedNow(), InjectionEvent::onTriggerTooth(), prepareOutputSignals(), Engine::reset(), scheduleSparkEvent(), 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