#include <trigger_central.h>

Inheritance diagram for TriggerCentral:

Collaboration diagram for TriggerCentral:

[legend]

Public Member Functions
	TriggerCentral ()

angle_t	syncAndReport (int divider, int remainder)

void	handleShaftSignal (trigger_event_e signal, efitick_t timestamp)

int	getHwEventCounter (int index) const

void	resetCounters ()

void	validateCamVvtCounters ()

void	updateWaveform ()

void	prepareTriggerShape ()

bool	checkIfTriggerConfigChanged ()

bool	isTriggerConfigChanged ()

bool	isTriggerDecoderError ()

expected< float >	getCurrentEnginePhase (efitick_t nowNt) const

float	getSecondsSinceTriggerEvent (efitick_t nowNt) const

bool	engineMovedRecently (efitick_t nowNt) const

bool	engineMovedRecently () const

angle_t	getVVTPosition (uint8_t bankIndex, uint8_t camIndex)

Data Fields
InstantRpmCalculator	instantRpm

bool	hwTriggerInputEnabled = true

cyclic_buffer< int >	triggerErrorDetection

bool	directSelfStimulation = false

PrimaryTriggerConfiguration	primaryTriggerConfiguration

VvtTriggerConfiguration	vvtTriggerConfiguration [CAMS_PER_BANK] = {{"VVT1 ", 0}}

LocalVersionHolder	triggerVersion

bool	isSpinningJustForWatchdog = false

float	mapCamPrevCycleValue = 0

int	prevChangeAtCycle = 0

uint32_t	engineCycleEventCount = 0

bool	triggerConfigChangedOnLastConfigurationChange = false

TriggerNoiseFilter	noiseFilter

int	vvtEventRiseCounter [CAM_INPUTS_COUNT]

int	vvtEventFallCounter [CAM_INPUTS_COUNT]

angle_t	currentVVTEventPosition [BANKS_COUNT][CAMS_PER_BANK]

angle_t	vvtPosition [BANKS_COUNT][CAMS_PER_BANK]

PrimaryTriggerDecoder	triggerState

TriggerWaveform	triggerShape

VvtTriggerDecoder	vvtState [BANKS_COUNT][CAMS_PER_BANK]

TriggerWaveform	vvtShape [CAMS_PER_BANK]

TriggerFormDetails	triggerFormDetails

Timer	m_lastEventTimer

bool	isEngineSnifferEnabled = false

Data Fields inherited from trigger_central_s
uint32_t	hwEventCounters [HW_EVENT_TYPES]

uint32_t	vvtCamCounter = (uint32_t)0

float	mapVvt_MAP_AT_SPECIAL_POINT = (float)0

float	mapVvt_MAP_AT_DIFF = (float)0

uint8_t	mapVvt_MAP_AT_CYCLE_COUNT = (uint8_t)0

uint8_t	mapVvt_map_peak = (uint8_t)0

uint8_t	alignmentFill_at_38 [2]

float	currentEngineDecodedPhase = (float)0

float	triggerToothAngleError = (float)0

uint8_t	triggerIgnoredToothCount = (uint8_t)0

uint8_t	alignmentFill_at_49 [3]

angle_t	mapCamPrevToothAngle = (angle_t)0

bool	isDecodingMapCam: 1 {}

bool	unusedBit_13_1: 1 {}

bool	unusedBit_13_2: 1 {}

bool	unusedBit_13_3: 1 {}

bool	unusedBit_13_4: 1 {}

bool	unusedBit_13_5: 1 {}

bool	unusedBit_13_6: 1 {}

bool	unusedBit_13_7: 1 {}

bool	unusedBit_13_8: 1 {}

bool	unusedBit_13_9: 1 {}

bool	unusedBit_13_10: 1 {}

bool	unusedBit_13_11: 1 {}

bool	unusedBit_13_12: 1 {}

bool	unusedBit_13_13: 1 {}

bool	unusedBit_13_14: 1 {}

bool	unusedBit_13_15: 1 {}

bool	unusedBit_13_16: 1 {}

bool	unusedBit_13_17: 1 {}

bool	unusedBit_13_18: 1 {}

bool	unusedBit_13_19: 1 {}

bool	unusedBit_13_20: 1 {}

bool	unusedBit_13_21: 1 {}

bool	unusedBit_13_22: 1 {}

bool	unusedBit_13_23: 1 {}

bool	unusedBit_13_24: 1 {}

bool	unusedBit_13_25: 1 {}

bool	unusedBit_13_26: 1 {}

bool	unusedBit_13_27: 1 {}

bool	unusedBit_13_28: 1 {}

bool	unusedBit_13_29: 1 {}

bool	unusedBit_13_30: 1 {}

bool	unusedBit_13_31: 1 {}

Private Member Functions
void	decodeMapCam (efitick_t nowNt, float currentPhase)

bool	isToothExpectedNow (efitick_t timestamp)

Private Attributes
Timer	m_lastToothTimer

float	m_lastToothPhaseFromSyncPoint

expected< float >	expectedNextPhase = unexpected

Detailed Description

Maybe merge TriggerCentral and TriggerState classes into one class? Probably not: we have an instance of TriggerState which is used for trigger initialization, also composition probably better than inheritance here

Definition at line 49 of file trigger_central.h.

Constructor & Destructor Documentation

◆ TriggerCentral()

TriggerCentral::TriggerCentral ( )

Definition at line 43 of file trigger_central.cpp.

                                :
         vvtEventRiseCounter(),
         vvtEventFallCounter(),
         vvtPosition(),
         triggerState("TRG")
 {
     memset(&hwEventCounters, 0, sizeof(hwEventCounters));
     triggerState.resetState();
     noiseFilter.resetAccumSignalData();
 }

Here is the call graph for this function:

Member Function Documentation

◆ checkIfTriggerConfigChanged()

bool TriggerCentral::checkIfTriggerConfigChanged ( )

Returns: true if configuration just changed, and if that change has affected trigger

Definition at line 1194 of file trigger_central.cpp.

                                                  {
     // we want to make sure that configuration has changed AND that change has changed trigger specifically
     bool result = triggerVersion.isOld(engine->getGlobalConfigurationVersion()) && triggerConfigChangedOnLastConfigurationChange;
     triggerConfigChangedOnLastConfigurationChange = false; // whoever has called the method is supposed to react to changes
     return result;
 }

Here is the call graph for this function:

◆ decodeMapCam()

void TriggerCentral::decodeMapCam	(	efitick_t	nowNt,
		float	currentPhase
	)

private

Definition at line 644 of file trigger_central.cpp.

                                                                          {
     isDecodingMapCam = engineConfiguration->vvtMode[0] == VVT_MAP_V_TWIN &&
                                 Sensor::getOrZero(SensorType::Rpm) < engineConfiguration->cranking.rpm;
     if (isDecodingMapCam) {
         // we are trying to figure out which 360 half of the total 720 degree cycle is which, so we compare those in 360 degree sense.
         auto toothAngle360 = currentPhase;
         while (toothAngle360 >= 360) {
             toothAngle360 -= 360;
         }
  
         if (mapCamPrevToothAngle < engineConfiguration->mapCamDetectionAnglePosition && toothAngle360 > engineConfiguration->mapCamDetectionAnglePosition) {
             // we are somewhere close to 'mapCamDetectionAnglePosition'
  
             // warning: hack hack hack
             float map = engine->outputChannels.instantMAPValue;
  
             // Compute diff against the last time we were here
             float diff = map - mapCamPrevCycleValue;
             mapCamPrevCycleValue = map;
  
             if (diff > 0) {
                 mapVvt_map_peak++;
                 int revolutionCounter = getTriggerCentral()->triggerState.getCrankSynchronizationCounter();
                 mapVvt_MAP_AT_CYCLE_COUNT = revolutionCounter - prevChangeAtCycle;
                 prevChangeAtCycle = revolutionCounter;
  
                 hwHandleVvtCamSignal(TriggerValue::RISE, timestamp, /*index*/0);
                 hwHandleVvtCamSignal(TriggerValue::FALL, timestamp, /*index*/0);
 #if EFI_UNIT_TEST
                 // hack? feature? existing unit test relies on VVT phase available right away
                 // but current implementation which is based on periodicFastCallback would only make result available on NEXT tooth
                 getLimpManager()->onFastCallback();
 #endif // EFI_UNIT_TEST
             }
  
             mapVvt_MAP_AT_SPECIAL_POINT = map;
             mapVvt_MAP_AT_DIFF = diff;
         }
  
         mapCamPrevToothAngle = toothAngle360;
     }
 }

Referenced by handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ engineMovedRecently() [1/2]

bool TriggerCentral::engineMovedRecently ( ) const

inline

Definition at line 144 of file trigger_central.h.

                                      {
         return engineMovedRecently(getTimeNowNt());
     }

Here is the call graph for this function:

◆ engineMovedRecently() [2/2]

bool TriggerCentral::engineMovedRecently ( efitick_t nowNt ) const

inline

Definition at line 131 of file trigger_central.h.

                                                     {
         constexpr float oneRevolutionLimitInSeconds = 60.0 / RPM_LOW_THRESHOLD;
         auto maxAverageToothTime = oneRevolutionLimitInSeconds / triggerShape.getSize();
  
         // Some triggers may have long gaps (with many teeth), don't count that as stopped!
         auto maxAllowedGap = maxAverageToothTime * 10;
  
         // Clamp between 0.1 seconds ("instant" for a human) and worst case of one engine cycle on low tooth count wheel
         maxAllowedGap = clampF(0.1f, maxAllowedGap, oneRevolutionLimitInSeconds);
  
         return getSecondsSinceTriggerEvent(nowNt) < maxAllowedGap;
     }

Referenced by applyIACposition(), RpmCalculator::checkIfSpinning(), EtbController::checkStatus(), Engine::efiWatchdog(), getAcrState(), RpmCalculator::onSlowCallback(), and FuelPumpController::onSlowCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCurrentEnginePhase()

expected< float > TriggerCentral::getCurrentEnginePhase ( efitick_t nowNt ) const

Returns: angle since trigger synchronization point, NOT angle since TDC.

Definition at line 75 of file trigger_central.cpp.

                                                                            {
     floatus_t oneDegreeUs = engine->rpmCalculator.oneDegreeUs;
  
     if (cisnan(oneDegreeUs)) {
         return unexpected;
     }
  
     float elapsed;
     float toothPhase;
  
     {
         // under lock to avoid mismatched tooth phase and time
         chibios_rt::CriticalSectionLocker csl;
  
         elapsed = m_lastToothTimer.getElapsedUs(nowNt);
         toothPhase = m_lastToothPhaseFromSyncPoint;
     }
  
     return toothPhase + elapsed / oneDegreeUs;
 }

Referenced by getAcrState(), handleVvtCamSignal(), isToothExpectedNow(), onFastAdcComplete(), and rpmShaftPositionCallback().

Here is the caller graph for this function:

◆ getHwEventCounter()

int TriggerCentral::getHwEventCounter ( int index ) const

Definition at line 60 of file trigger_central.cpp.

                                                      {
     return hwEventCounters[index];
 }

Referenced by canDashboardHaltech(), sendQcBenchEventCounters(), triggerInfo(), and updateTunerStudioState().

Here is the caller graph for this function:

◆ getSecondsSinceTriggerEvent()

float TriggerCentral::getSecondsSinceTriggerEvent ( efitick_t nowNt ) const

inline

Definition at line 127 of file trigger_central.h.

                                                              {
         return m_lastEventTimer.getElapsedSeconds(nowNt);
     }

Referenced by engineMovedRecently().

Here is the caller graph for this function:

◆ getVVTPosition()

angle_t TriggerCentral::getVVTPosition	(	uint8_t	bankIndex,
		uint8_t	camIndex
	)

Definition at line 65 of file trigger_central.cpp.

                                                                           {
     if (bankIndex >= BANKS_COUNT || camIndex >= CAMS_PER_BANK) {
         return NAN;
     }
     return vvtPosition[bankIndex][camIndex];
 }

Referenced by HpfpLobe::findNextLobe(), VvtController::observePlant(), populateFrame(), readGppwmChannel(), and updateVvtSensors().

Here is the caller graph for this function:

◆ handleShaftSignal()

void TriggerCentral::handleShaftSignal	(	trigger_event_e	signal,
		efitick_t	timestamp
	)

This method is NOT invoked for VR falls.

If we only have a crank position sensor with four stroke, here we are extending crank revolutions with a 360 degree cycle into a four stroke, 720 degrees cycle.

Definition at line 750 of file trigger_central.cpp.

                                                                                   {
     if (triggerShape.shapeDefinitionError) {
         // trigger is broken, we cannot do anything here
         warning(ObdCode::CUSTOM_ERR_UNEXPECTED_SHAFT_EVENT, "Shaft event while trigger is mis-configured");
         // magic value to indicate a problem
         hwEventCounters[0] = 155;
         return;
     }
  
     // This code gathers some statistics on signals and compares accumulated periods to filter interference
     if (engineConfiguration->useNoiselessTriggerDecoder) {
         if (!noiseFilter.noiseFilter(timestamp, &triggerState, signal)) {
             return;
         }
         if (!isUsefulSignal(signal, triggerShape)) {
             return;
         }
     }
  
     if (!isToothExpectedNow(timestamp)) {
         triggerIgnoredToothCount++;
         return;
     }
  
     isSpinningJustForWatchdog = true;
  
 #if EFI_HD_ACR
     bool firstEventInAWhile = m_lastEventTimer.hasElapsedSec(1);
     if (firstEventInAWhile) {
         // let's open that valve on first sign of movement
         engine->module<HarleyAcr>()->updateAcr();
     }
 #endif // EFI_HD_ACR
  
   if (boardAllowTriggerActions()) {
       m_lastEventTimer.reset(timestamp);
   }
  
     int eventIndex = (int) signal;
     efiAssertVoid(ObdCode::CUSTOM_TRIGGER_EVENT_TYPE, eventIndex >= 0 && eventIndex < HW_EVENT_TYPES, "signal type");
     hwEventCounters[eventIndex]++;
  
     // Decode the trigger!
     auto decodeResult = triggerState.decodeTriggerEvent(
             "trigger",
             triggerShape,
             engine,
             primaryTriggerConfiguration,
             signal, timestamp);
  
     // Don't propagate state if we don't know where we are
     if (decodeResult) {
         ScopePerf perf(PE::ShaftPositionListeners);
  
         /**
          * If we only have a crank position sensor with four stroke, here we are extending crank revolutions with a 360 degree
          * cycle into a four stroke, 720 degrees cycle.
          */
         int crankDivider = getCrankDivider(triggerShape.getWheelOperationMode());
         int crankInternalIndex = triggerState.getCrankSynchronizationCounter() % crankDivider;
         int triggerIndexForListeners = decodeResult.Value.CurrentIndex + (crankInternalIndex * triggerShape.getSize());
  
         reportEventToWaveChart(signal, triggerIndexForListeners, triggerShape.useOnlyRisingEdges);
  
         // Look up this tooth's angle from the sync point. If this tooth is the sync point, we'll get 0 here.
         auto currentPhaseFromSyncPoint = getTriggerCentral()->triggerFormDetails.eventAngles[triggerIndexForListeners];
  
         // Adjust so currentPhase is in engine-space angle, not trigger-space angle
         currentEngineDecodedPhase = wrapAngleMethod(currentPhaseFromSyncPoint - tdcPosition(), "currentEnginePhase", ObdCode::CUSTOM_ERR_6555);
  
         // Record precise time and phase of the engine. This is used for VVT decode, and to check that the
         // trigger pattern selected matches reality (ie, we check the next tooth is where we think it should be)
         {
             // under lock to avoid mismatched tooth phase and time
             chibios_rt::CriticalSectionLocker csl;
  
             m_lastToothTimer.reset(timestamp);
             m_lastToothPhaseFromSyncPoint = currentPhaseFromSyncPoint;
         }
  
 #if TRIGGER_EXTREME_LOGGING
     efiPrintf("trigger %d %d %d", triggerIndexForListeners, getRevolutionCounter(), (int)getTimeNowUs());
 #endif /* TRIGGER_EXTREME_LOGGING */
  
         // Update engine RPM
         rpmShaftPositionCallback(signal, triggerIndexForListeners, timestamp);
  
         // Schedule the TDC mark
         tdcMarkCallback(triggerIndexForListeners, timestamp);
  
 #if !EFI_UNIT_TEST
 #if EFI_MAP_AVERAGING
         mapAveragingTriggerCallback(triggerIndexForListeners, timestamp);
 #endif /* EFI_MAP_AVERAGING */
 #endif /* EFI_UNIT_TEST */
  
 #if EFI_LOGIC_ANALYZER
         waTriggerEventListener(signal, triggerIndexForListeners, timestamp);
 #endif
  
         // TODO: is this logic to compute next trigger tooth angle correct?
         auto nextToothIndex = triggerIndexForListeners;
         angle_t nextPhase = 0;
  
         int loopAllowance = 2 * engineCycleEventCount + 1000;
         do {
             // I don't love this.
             nextToothIndex = (nextToothIndex + 1) % engineCycleEventCount;
             nextPhase = getTriggerCentral()->triggerFormDetails.eventAngles[nextToothIndex] - tdcPosition();
             wrapAngle(nextPhase, "nextEnginePhase", ObdCode::CUSTOM_ERR_6555);
         } while (nextPhase == currentEngineDecodedPhase && --loopAllowance > 0);
         if (nextPhase != 0 && loopAllowance == 0) {
             firmwareError(ObdCode::CUSTOM_ERR_TRIGGER_ZERO, "handleShaftSignal unexpected loop end");
         }
  
         float expectNextPhase = nextPhase + tdcPosition();
         wrapAngle(expectNextPhase, "nextEnginePhase", ObdCode::CUSTOM_ERR_6555);
         expectedNextPhase = expectNextPhase;
  
 #if EFI_CDM_INTEGRATION
         if (trgEventIndex == 0 && isBrainPinValid(engineConfiguration->cdmInputPin)) {
             int cdmKnockValue = getCurrentCdmValue(getTriggerCentral()->triggerState.getCrankSynchronizationCounter());
             engine->knockLogic(cdmKnockValue);
         }
 #endif /* EFI_CDM_INTEGRATION */
  
         if (engine->rpmCalculator.getCachedRpm() > 0 && triggerIndexForListeners == 0) {
             engine->tpsAccelEnrichment.onEngineCycleTps();
         }
  
         // Handle ignition and injection
         mainTriggerCallback(triggerIndexForListeners, timestamp, currentEngineDecodedPhase, nextPhase);
  
         // Decode the MAP based "cam" sensor
         decodeMapCam(timestamp, currentEngineDecodedPhase);
     } else {
         // We don't have sync, but report to the wave chart anyway as index 0.
         reportEventToWaveChart(signal, 0, triggerShape.useOnlyRisingEdges);
  
         expectedNextPhase = unexpected;
     }
 }

Referenced by handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isToothExpectedNow()

bool TriggerCentral::isToothExpectedNow ( efitick_t timestamp )

private

Definition at line 687 of file trigger_central.cpp.

                                                            {
     // Check that the expected next phase (from the last tooth) is close to the actual current phase:
     // basically, check that the tooth width is correct
     auto estimatedCurrentPhase = getCurrentEnginePhase(timestamp);
     auto lastToothPhase = m_lastToothPhaseFromSyncPoint;
  
     if (expectedNextPhase && estimatedCurrentPhase) {
         float angleError = expectedNextPhase.Value - estimatedCurrentPhase.Value;
  
         // Wrap around correctly at the end of the cycle
         float cycle = getEngineState()->engineCycle;
         if (angleError < -cycle / 2) {
             angleError += cycle;
         }
  
         triggerToothAngleError = angleError;
  
         // Only perform checks if engine is spinning quickly
         // All kinds of garbage happens while cranking
         if (Sensor::getOrZero(SensorType::Rpm) > 1000) {
             // Now compute how close we are to the last tooth decoded
             float angleSinceLastTooth = estimatedCurrentPhase.Value - lastToothPhase;
             if (angleSinceLastTooth < 0.5f) {
                 // This tooth came impossibly early, ignore it
                 // This rejects things like doubled edges, for example:
                 //             |-| |----------------
                 //             | | |
                 // ____________| |_|
                 //             1   2
                 //     #1 will be decoded
                 //     #2 will be ignored
                 // We're not sure which edge was the "real" one, but they were close enough
                 // together that it doesn't really matter.
                 warning(ObdCode::CUSTOM_PRIMARY_DOUBLED_EDGE, "doubled trigger edge after %.2f deg at #%d", angleSinceLastTooth, triggerState.currentCycle.current_index);
  
                 return false;
             }
  
             // Absolute error from last tooth
             float absError = absF(angleError);
             float isRpmEnough = Sensor::getOrZero(SensorType::Rpm) > 1000;
             // TODO: configurable threshold
             if (isRpmEnough && absError > 10 && absError < 180) {
                 // This tooth came at a very unexpected time, ignore it
                 warning(ObdCode::CUSTOM_PRIMARY_BAD_TOOTH_TIMING, "tooth #%d error of %.1f", triggerState.currentCycle.current_index, angleError);
  
                 // TODO: this causes issues with some real engine logs, should it?
                 // return false;
             }
         }
     } else {
         triggerToothAngleError = 0;
     }
  
     // We aren't ready to reject unexpected teeth, so accept this tooth
     return true;
 }

Referenced by handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isTriggerConfigChanged()

bool TriggerCentral::isTriggerConfigChanged ( )

Definition at line 1202 of file trigger_central.cpp.

                                             {
     return triggerConfigChangedOnLastConfigurationChange;
 }

◆ isTriggerDecoderError()

bool TriggerCentral::isTriggerDecoderError ( )

Returns: TRUE is something is wrong with trigger decoding

Definition at line 1234 of file trigger_central.cpp.

                                            {
     return triggerErrorDetection.sum(6) > 4;
 }

Referenced by isTriggerErrorNow(), and triggerInfo().

Here is the caller graph for this function:

◆ prepareTriggerShape()

void TriggerCentral::prepareTriggerShape ( )

inline

Definition at line 61 of file trigger_central.h.

                                {
 #if EFI_ENGINE_CONTROL && EFI_SHAFT_POSITION_INPUT
         if (triggerShape.shapeDefinitionError) {
             // Nothing to do here if there's a problem with the trigger shape
             return;
         }
  
         triggerFormDetails.prepareEventAngles(&triggerShape);
 #endif
     }

Referenced by prepareOutputSignals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetCounters()

void TriggerCentral::resetCounters ( )

Definition at line 558 of file trigger_central.cpp.

                                    {
     memset(hwEventCounters, 0, sizeof(hwEventCounters));
 }

Referenced by resetRunningTriggerCounters().

Here is the caller graph for this function:

◆ syncAndReport()

angle_t TriggerCentral::syncAndReport	(	int	divider,
		int	remainder
	)

Definition at line 134 of file trigger_central.cpp.

                                                                 {
     angle_t engineCycle = getEngineCycle(getEngineRotationState()->getOperationMode());
  
     angle_t totalShift = triggerState.syncEnginePhase(divider, remainder, engineCycle);
     if (totalShift != 0) {
         // Reset instant RPM, since the engine phase has now changed, invalidating the tooth history buffer
         // maybe TODO: could/should we rotate the buffer around to re-align it instead? Is that worth it?
         instantRpm.resetInstantRpm();
     }
     return totalShift;
 }

Referenced by adjustCrankPhase().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateWaveform()

void TriggerCentral::updateWaveform ( )

this is only useful while troubleshooting a new trigger shape in the field in very VERY rare circumstances

'initState' instance of TriggerDecoderBase is used only to initialize 'this' TriggerWaveform instance #192 BUG real hardware trigger events could be coming even while we are initializing trigger

Definition at line 1108 of file trigger_central.cpp.

                                     {
     // Re-read config in case it's changed
     primaryTriggerConfiguration.update();
     for (int camIndex = 0;camIndex < CAMS_PER_BANK;camIndex++) {
         vvtTriggerConfiguration[camIndex].update();
     }
  
     triggerShape.initializeTriggerWaveform(lookupOperationMode(), primaryTriggerConfiguration.TriggerType);
  
     /**
      * this is only useful while troubleshooting a new trigger shape in the field
      * in very VERY rare circumstances
      */
     if (engineConfiguration->overrideTriggerGaps) {
         int gapIndex = 0;
  
         engine->triggerCentral.triggerShape.gapTrackingLength = engineConfiguration->gapTrackingLengthOverride;
  
         // copy however many the user wants
         for (; gapIndex < engineConfiguration->gapTrackingLengthOverride; gapIndex++) {
             float gapOverrideFrom = engineConfiguration->triggerGapOverrideFrom[gapIndex];
             float gapOverrideTo = engineConfiguration->triggerGapOverrideTo[gapIndex];
             TRIGGER_WAVEFORM(setTriggerSynchronizationGap3(/*gapIndex*/gapIndex, gapOverrideFrom, gapOverrideTo));
         }
  
         // fill the remainder with the default gaps
         for (; gapIndex < GAP_TRACKING_LENGTH; gapIndex++) {
             triggerShape.synchronizationRatioFrom[gapIndex] = NAN;
             triggerShape.synchronizationRatioTo[gapIndex] = NAN;
         }
     }
  
     if (!triggerShape.shapeDefinitionError) {
         int length = triggerShape.getLength();
         engineCycleEventCount = length;
  
         efiAssertVoid(ObdCode::CUSTOM_SHAPE_LEN_ZERO, length > 0, "shapeLength=0");
  
         triggerErrorDetection.clear();
  
         /**
          * 'initState' instance of TriggerDecoderBase is used only to initialize 'this' TriggerWaveform instance
          * #192 BUG real hardware trigger events could be coming even while we are initializing trigger
          */
         calculateTriggerSynchPoint(primaryTriggerConfiguration,
                 triggerShape,
                 initState);
     }
  
     if (engineConfiguration->overrideVvtTriggerGaps) {
         int gapIndex = 0;
  
         TriggerWaveform *shape = &vvtShape[0];
  
         for (; gapIndex < engineConfiguration->gapVvtTrackingLengthOverride; gapIndex++) {
             float gapOverrideFrom = engineConfiguration->triggerVVTGapOverrideFrom[gapIndex];
             float gapOverrideTo = engineConfiguration->triggerVVTGapOverrideTo[gapIndex];
             shape->synchronizationRatioFrom[gapIndex] = gapOverrideFrom;
             shape->synchronizationRatioTo[gapIndex] = gapOverrideTo;
         }
         // fill the remainder with the default gaps
         for (; gapIndex < VVT_TRACKING_LENGTH; gapIndex++) {
             shape->synchronizationRatioFrom[gapIndex] = NAN;
             shape->synchronizationRatioTo[gapIndex] = NAN;
         }
     }
  
     for (int camIndex = 0; camIndex < CAMS_PER_BANK; camIndex++) {
         // todo: should 'vvtWithRealDecoder' be used here?
         if (engineConfiguration->vvtMode[camIndex] != VVT_INACTIVE) {
             initVvtShape(
                 vvtShape[camIndex],
                 vvtTriggerConfiguration[camIndex],
                 initState
             );
         }
     }
  
     // This is not the right place for this, but further refactoring has to happen before it can get moved.
     triggerState.setNeedsDisambiguation(engine->triggerCentral.triggerShape.needsDisambiguation());
  
 }

Referenced by Engine::updateTriggerWaveform().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validateCamVvtCounters()

void TriggerCentral::validateCamVvtCounters ( )

Definition at line 1070 of file trigger_central.cpp.

                                             {
     // micro-optimized 'crankSynchronizationCounter % 256'
     int camVvtValidationIndex = triggerState.getCrankSynchronizationCounter() & 0xFF;
     if (camVvtValidationIndex == 0) {
         vvtCamCounter = 0;
     } else if (camVvtValidationIndex == 0xFE && vvtCamCounter < 60) {
         // magic logic: we expect at least 60 CAM/VVT events for each 256 trigger cycles, otherwise throw a code
         warning(ObdCode::OBD_Camshaft_Position_Sensor_Circuit_Range_Performance, "No Camshaft Position Sensor signals");
     }
 }

Referenced by rpmShaftPositionCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ currentVVTEventPosition

angle_t TriggerCentral::currentVVTEventPosition[BANKS_COUNT][CAMS_PER_BANK]

Definition at line 157 of file trigger_central.h.

Referenced by handleVvtCamSignal().

◆ directSelfStimulation

bool TriggerCentral::directSelfStimulation = false

◆ engineCycleEventCount

uint32_t TriggerCentral::engineCycleEventCount = 0

value of 'triggerShape.getLength()' pre-calculating this value is a performance optimization

Definition at line 111 of file trigger_central.h.

Referenced by handleShaftSignal(), and updateWaveform().

◆ expectedNextPhase

expected<float> TriggerCentral::expectedNextPhase = unexpected

private

Definition at line 210 of file trigger_central.h.

Referenced by handleShaftSignal(), and isToothExpectedNow().

◆ hwTriggerInputEnabled

bool TriggerCentral::hwTriggerInputEnabled = true

Definition at line 74 of file trigger_central.h.

Referenced by enableOrDisable(), hwHandleShaftSignal(), hwHandleVvtCamSignal(), and triggerInfo().

◆ instantRpm

InstantRpmCalculator TriggerCentral::instantRpm

Definition at line 59 of file trigger_central.h.

Referenced by getAdvanceCorrections(), IdleController::onSlowCallback(), PrimaryTriggerDecoder::onTriggerError(), Engine::OnTriggerSynchronizationLost(), rpmShaftPositionCallback(), RpmCalculator::setSpinningUp(), syncAndReport(), and updateTunerStudioState().

◆ isEngineSnifferEnabled

bool TriggerCentral::isEngineSnifferEnabled = false

this is based on engineSnifferRpmThreshold settings and current RPM

Definition at line 196 of file trigger_central.h.

Referenced by TriggerDecoderBase::decodeTriggerEvent(), and Engine::updateSlowSensors().

◆ isSpinningJustForWatchdog

bool TriggerCentral::isSpinningJustForWatchdog = false

By the way: 'cranking' means engine is not stopped and the rpm are below crankingRpm 'running' means RPM are above crankingRpm 'spinning' means the engine is not stopped this is set to true each time we register a trigger tooth signal

Definition at line 102 of file trigger_central.h.

Referenced by Engine::efiWatchdog(), and handleShaftSignal().

◆ m_lastEventTimer

Timer TriggerCentral::m_lastEventTimer

Definition at line 191 of file trigger_central.h.

Referenced by configureRusefiLuaHooks(), getSecondsSinceTriggerEvent(), and handleShaftSignal().

◆ m_lastToothPhaseFromSyncPoint

float TriggerCentral::m_lastToothPhaseFromSyncPoint

private

Definition at line 206 of file trigger_central.h.

Referenced by getCurrentEnginePhase(), handleShaftSignal(), and isToothExpectedNow().

◆ m_lastToothTimer

Timer TriggerCentral::m_lastToothTimer

private

Definition at line 204 of file trigger_central.h.

Referenced by getCurrentEnginePhase(), and handleShaftSignal().

◆ mapCamPrevCycleValue

float TriggerCentral::mapCamPrevCycleValue = 0

Definition at line 104 of file trigger_central.h.

Referenced by decodeMapCam().

◆ noiseFilter

TriggerNoiseFilter TriggerCentral::noiseFilter

Definition at line 148 of file trigger_central.h.

Referenced by handleShaftSignal(), onConfigurationChangeTriggerCallback(), RpmCalculator::setStopped(), and TriggerCentral().

◆ prevChangeAtCycle

int TriggerCentral::prevChangeAtCycle = 0

Definition at line 105 of file trigger_central.h.

Referenced by decodeMapCam().

◆ primaryTriggerConfiguration

PrimaryTriggerConfiguration TriggerCentral::primaryTriggerConfiguration

Definition at line 83 of file trigger_central.h.

Referenced by handleShaftSignal(), Engine::injectEngineReferences(), Engine::periodicSlowCallback(), and updateWaveform().

◆ triggerConfigChangedOnLastConfigurationChange

bool TriggerCentral::triggerConfigChangedOnLastConfigurationChange = false

true if a recent configuration change has changed any of the trigger settings which we have not adjusted for yet

Definition at line 116 of file trigger_central.h.

Referenced by checkIfTriggerConfigChanged(), isTriggerConfigChanged(), and onConfigurationChangeTriggerCallback().

◆ triggerErrorDetection

cyclic_buffer<int> TriggerCentral::triggerErrorDetection

Definition at line 76 of file trigger_central.h.

Referenced by isTriggerDecoderError(), Engine::OnTriggerSynchronization(), and updateWaveform().

◆ triggerFormDetails

TriggerFormDetails TriggerCentral::triggerFormDetails

Definition at line 188 of file trigger_central.h.

Referenced by handleShaftSignal(), prepareTriggerShape(), refreshMapAveragingPreCalc(), rpmShaftPositionCallback(), and triggerShapeInfo().

◆ triggerShape

TriggerWaveform TriggerCentral::triggerShape

Definition at line 167 of file trigger_central.h.

Referenced by engineMovedRecently(), RpmCalculator::getOperationMode(), handleShaftSignal(), handleShaftSignal(), InstantRpmCalculator::movePreSynchTimestamps(), HpfpController::onFastCallback(), Engine::OnTriggerSynchronization(), prepareTriggerShape(), rpmShaftPositionCallback(), InstantRpmCalculator::setLastEventTimeForInstantRpm(), startSimulatedTriggerSignal(), startTriggerInputPins(), triggerInfo(), triggerShapeInfo(), Engine::updateTriggerWaveform(), and updateWaveform().

◆ triggerState

◆ triggerVersion

LocalVersionHolder TriggerCentral::triggerVersion

Definition at line 90 of file trigger_central.h.

Referenced by checkIfTriggerConfigChanged().

◆ vvtEventFallCounter

int TriggerCentral::vvtEventFallCounter[CAM_INPUTS_COUNT]

Definition at line 151 of file trigger_central.h.

Referenced by handleVvtCamSignal(), sendQcBenchEventCounters(), triggerInfo(), and updateTunerStudioState().

◆ vvtEventRiseCounter

int TriggerCentral::vvtEventRiseCounter[CAM_INPUTS_COUNT]

Definition at line 150 of file trigger_central.h.

Referenced by handleVvtCamSignal(), sendQcBenchEventCounters(), triggerInfo(), and updateTunerStudioState().

◆ vvtPosition

angle_t TriggerCentral::vvtPosition[BANKS_COUNT][CAMS_PER_BANK]

Definition at line 161 of file trigger_central.h.

Referenced by getVVTPosition(), and handleVvtCamSignal().

◆ vvtShape

TriggerWaveform TriggerCentral::vvtShape[CAMS_PER_BANK]

Definition at line 186 of file trigger_central.h.

Referenced by handleVvtCamSignal(), startSimulatedTriggerSignal(), and updateWaveform().

◆ vvtState

VvtTriggerDecoder TriggerCentral::vvtState[BANKS_COUNT][CAMS_PER_BANK]

Initial value:

= {
        {
            "VVT B1 Int",
#if CAMS_PER_BANK >= 2
            "VVT B1 Exh"
#endif
        },
#if BANKS_COUNT >= 2
        {
            "VVT B2 Int",
#if CAMS_PER_BANK >= 2
            "VVT B1 Exh"
#endif
        }
#endif
    }

Definition at line 169 of file trigger_central.h.

Referenced by handleVvtCamSignal(), and Engine::OnTriggerSynchronizationLost().

◆ vvtTriggerConfiguration

VvtTriggerConfiguration TriggerCentral::vvtTriggerConfiguration = {{"VVT1 ", 0}}

Definition at line 85 of file trigger_central.h.

Referenced by handleVvtCamSignal(), Engine::injectEngineReferences(), Engine::periodicSlowCallback(), and updateWaveform().

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

controllers/trigger/trigger_central.h
controllers/trigger/trigger_central.cpp

Public Member Functions

Data Fields

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TriggerCentral()

Member Function Documentation

◆ checkIfTriggerConfigChanged()

◆ decodeMapCam()

◆ engineMovedRecently() [1/2]

◆ engineMovedRecently() [2/2]

◆ getCurrentEnginePhase()

◆ getHwEventCounter()

◆ getSecondsSinceTriggerEvent()

◆ getVVTPosition()

◆ handleShaftSignal()

◆ isToothExpectedNow()

◆ isTriggerConfigChanged()

◆ isTriggerDecoderError()

◆ prepareTriggerShape()

◆ resetCounters()

◆ syncAndReport()

◆ updateWaveform()

◆ validateCamVvtCounters()

Field Documentation

◆ currentVVTEventPosition

◆ directSelfStimulation

◆ engineCycleEventCount

◆ expectedNextPhase

◆ hwTriggerInputEnabled

◆ instantRpm

◆ isEngineSnifferEnabled

◆ isSpinningJustForWatchdog

◆ m_lastEventTimer

◆ m_lastToothPhaseFromSyncPoint

◆ m_lastToothTimer

◆ mapCamPrevCycleValue

◆ noiseFilter

◆ prevChangeAtCycle

◆ primaryTriggerConfiguration

◆ triggerConfigChangedOnLastConfigurationChange

◆ triggerErrorDetection

◆ triggerFormDetails

◆ triggerShape

◆ triggerState

◆ triggerVersion

◆ vvtEventFallCounter

◆ vvtEventRiseCounter

◆ vvtPosition

◆ vvtShape

◆ vvtState

◆ vvtTriggerConfiguration