#include <trigger_central.h>

Inheritance diagram for TriggerCentral:

Collaboration diagram for TriggerCentral:

[legend]

Public Member Functions
	TriggerCentral ()

angle_t	syncEnginePhaseAndReport (int divider, int remainder)

void	handleShaftSignal (trigger_event_e signal, efitick_t timestamp)

int	getHwEventCounter (int index) const

void	resetCounters ()

void	validateCamVvtCounters ()

void	applyShapesConfiguration ()

angle_t	findNextTriggerToothAngle (int nextToothIndex)

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)

void	applyCamGapOverride ()

bool	isMapCamSync (efitick_t nowNt, float currentPhase)

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

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
uint16_t	hwEventCounters [HW_EVENT_TYPES] = {}

uint16_t	vvtEventRiseCounter [CAM_INPUTS_COUNT] = {}

uint16_t	vvtEventFallCounter [CAM_INPUTS_COUNT] = {}

uint16_t	vvtCamCounter = (uint16_t)0

uint8_t	alignmentFill_at_26 [2] = {}

float	mapVvt_MAP_AT_SPECIAL_POINT = (float)0

float	mapVvt_MAP_AT_DIFF = (float)0

int8_t	mapVvt_MAP_AT_CYCLE_COUNT = (int8_t)0

uint8_t	mapVvt_sync_counter = (uint8_t)0

uint8_t	mapVvt_min_point_counter = (uint8_t)0

uint8_t	alignmentFill_at_39 [1] = {}

uint32_t	temp_mapVvt_index = (uint32_t)0

float	mapVvt_CycleDelta = (float)0

float	currentEngineDecodedPhase = (float)0

float	triggerToothAngleError = (float)0

uint8_t	triggerIgnoredToothCount = (uint8_t)0

uint8_t	alignmentFill_at_57 [3] = {}

angle_t	mapCamPrevToothAngle = (angle_t)0

bool	isDecodingMapCam: 1 {}

bool	unusedBit_19_1: 1 {}

bool	unusedBit_19_2: 1 {}

bool	unusedBit_19_3: 1 {}

bool	unusedBit_19_4: 1 {}

bool	unusedBit_19_5: 1 {}

bool	unusedBit_19_6: 1 {}

bool	unusedBit_19_7: 1 {}

bool	unusedBit_19_8: 1 {}

bool	unusedBit_19_9: 1 {}

bool	unusedBit_19_10: 1 {}

bool	unusedBit_19_11: 1 {}

bool	unusedBit_19_12: 1 {}

bool	unusedBit_19_13: 1 {}

bool	unusedBit_19_14: 1 {}

bool	unusedBit_19_15: 1 {}

bool	unusedBit_19_16: 1 {}

bool	unusedBit_19_17: 1 {}

bool	unusedBit_19_18: 1 {}

bool	unusedBit_19_19: 1 {}

bool	unusedBit_19_20: 1 {}

bool	unusedBit_19_21: 1 {}

bool	unusedBit_19_22: 1 {}

bool	unusedBit_19_23: 1 {}

bool	unusedBit_19_24: 1 {}

bool	unusedBit_19_25: 1 {}

bool	unusedBit_19_26: 1 {}

bool	unusedBit_19_27: 1 {}

bool	unusedBit_19_28: 1 {}

bool	unusedBit_19_29: 1 {}

bool	unusedBit_19_30: 1 {}

bool	unusedBit_19_31: 1 {}

uint32_t	triggerElapsedUs = (uint32_t)0

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

void	applyTriggerGapOverride ()

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 39 of file trigger_central.cpp.

                               :
        vvtPosition(),
        triggerState("TRG")
{
    setArrayValues(hwEventCounters, 0);
    triggerState.resetState();
    noiseFilter.resetAccumSignalData();
}

Here is the call graph for this function:

Member Function Documentation

◆ applyCamGapOverride()

void TriggerCentral::applyCamGapOverride ( )

Definition at line 1182 of file trigger_central.cpp.

                                         {
    if (engineConfiguration->overrideVvtTriggerGaps) {
        int gapIndex = 0;
 
        TriggerWaveform *shape = &vvtShape[0];
        shape->gapTrackingLength = engineConfiguration->gapVvtTrackingLengthOverride;
 
        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;
        }
    }
}

Referenced by applyShapesConfiguration(), and initVvtShape().

Here is the caller graph for this function:

◆ applyShapesConfiguration()

void TriggerCentral::applyShapesConfiguration ( )

'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 1203 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);
 
  applyTriggerGapOverride();
 
    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);
    }
 
  applyCamGapOverride();
 
    for (int camIndex = 0; camIndex < CAMS_PER_BANK; camIndex++) {
        // todo: should 'vvtWithRealDecoder' be used here?
        if (engineConfiguration->vvtMode[camIndex] != VVT_INACTIVE) {
            initVvtShape(
              camIndex,
                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::updateTriggerConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyTriggerGapOverride()

void TriggerCentral::applyTriggerGapOverride ( )

private

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

Definition at line 1157 of file trigger_central.cpp.

                                             {
    /**
     * this is only useful while troubleshooting a new trigger shape in the field
     * in very VERY rare circumstances
     */
    if (engineConfiguration->overrideTriggerGaps) {
        int gapIndex = 0;
 
        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];
            triggerShape.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;
        }
    }
}

Referenced by applyShapesConfiguration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkIfTriggerConfigChanged()

bool TriggerCentral::checkIfTriggerConfigChanged ( )

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

Definition at line 1253 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	(	int	triggerIndexForListeners,
		efitick_t	nowNt,
		float	currentPhase
	)

private

Definition at line 694 of file trigger_central.cpp.

                                                                                                     {
    UNUSED(toothIndexForListeners);
 
    isDecodingMapCam = engineConfiguration->vvtMode[0] == VVT_MAP_V_TWIN &&
                                Sensor::getOrZero(SensorType::Rpm) < engineConfiguration->cranking.rpm;
    if (isDecodingMapCam) {
 
 
#ifdef TEMP_V_TWIN
  mapAtAngle[toothIndexForListeners] = engine->outputChannels.instantMAPValue;
 
  if (toothIndexForListeners > 2) {
    if (mapAtAngle[toothIndexForListeners - 2] > mapAtAngle[toothIndexForListeners - 1] &&
      mapAtAngle[toothIndexForListeners - 1] < mapAtAngle[toothIndexForListeners - 0]) {
        mapVvt_min_point_counter++;
      }
 
  }
#endif
 
 
      if (isMapCamSync(timestamp, currentPhase)) {
                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
      }
    }
}

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 156 of file trigger_central.h.

                                     {
        return engineMovedRecently(getTimeNowNt());
    }

Referenced by engineMovedRecently().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ engineMovedRecently() [2/2]

bool TriggerCentral::engineMovedRecently ( efitick_t nowNt ) const

inline

Definition at line 138 of file trigger_central.h.

                                                    {
        // todo: this user-defined property is a quick solution, proper fix https://github.com/rusefi/rusefi/issues/6593 is needed
        if (engineConfiguration->triggerEventsTimeoutMs != 0 && m_lastEventTimer.hasElapsedMs(engineConfiguration->triggerEventsTimeoutMs)) {
            return false;
        }
 
        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) || directSelfStimulation;
    }

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:

◆ findNextTriggerToothAngle()

angle_t TriggerCentral::findNextTriggerToothAngle ( int nextToothIndex )

Definition at line 787 of file trigger_central.cpp.

                                                                         {
  int currentToothIndex = p_currentToothIndex;
        // TODO: is this logic to compute next trigger tooth angle correct?
        angle_t nextToothAngle = 0;
 
        int loopAllowance = 2 * engineCycleEventCount + 1000;
        do {
            // I don't love this.
            currentToothIndex = (currentToothIndex + 1) % engineCycleEventCount;
            nextToothAngle = getTriggerCentral()->triggerFormDetails.eventAngles[currentToothIndex] - tdcPosition();
            wrapAngle(nextToothAngle, "nextEnginePhase", ObdCode::CUSTOM_ERR_6555);
        } while (nextToothAngle == currentEngineDecodedPhase && --loopAllowance > 0); // '==' for float works here since both values come from 'eventAngles' array
        if (nextToothAngle != 0 && loopAllowance == 0) {
          // HW CI fails here, looks like we sometimes change trigger while still handling it?
            firmwareError(ObdCode::CUSTOM_ERR_TRIGGER_ZERO, "handleShaftSignal unexpected loop end %d %d %f %f", p_currentToothIndex, engineCycleEventCount, nextToothAngle, currentEngineDecodedPhase);
        }
        return nextToothAngle;
}

Referenced by handleShaftSignal().

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 68 of file trigger_central.cpp.

                                                                           {
    floatus_t oneDegreeUs = engine->rpmCalculator.oneDegreeUs;
 
    if (std::isnan(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(), HpfpController::pinTurnOff(), and HpfpController::pinTurnOn().

Here is the caller graph for this function:

◆ getHwEventCounter()

int TriggerCentral::getHwEventCounter ( int index ) const

Definition at line 54 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 134 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 58 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 809 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");
        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.getSynchronizationCounter() % 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(), time2print(getTimeNowUs()));
#endif /* TRIGGER_EXTREME_LOGGING */
 
        // Update engine RPM
        rpmShaftPositionCallback(signal, triggerIndexForListeners, timestamp);
 
        // Schedule the TDC mark
        tdcMarkCallback(triggerIndexForListeners, timestamp);
 
#if EFI_LOGIC_ANALYZER
        waTriggerEventListener(signal, triggerIndexForListeners, timestamp);
#endif
 
        angle_t nextPhase = findNextTriggerToothAngle(triggerIndexForListeners);
 
        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.getSynchronizationCounter());
            engine->knockLogic(cdmKnockValue);
        }
#endif /* EFI_CDM_INTEGRATION */
 
        if (engine->rpmCalculator.getCachedRpm() > 0 && triggerIndexForListeners == 0) {
            engine->module<TpsAccelEnrichment>()->onEngineCycleTps();
        }
 
        // Handle ignition and injection
        mainTriggerCallback(triggerIndexForListeners, timestamp, currentEngineDecodedPhase, nextPhase);
 
    temp_mapVvt_index = triggerIndexForListeners / 2;
 
        // Decode the MAP based "cam" sensor
        decodeMapCam(temp_mapVvt_index, timestamp, currentEngineDecodedPhase);
 
        boardTriggerCallback(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:

◆ isMapCamSync()

bool TriggerCentral::isMapCamSync	(	efitick_t	nowNt,
		float	currentPhase
	)

Definition at line 648 of file trigger_central.cpp.

                                                                         {
    UNUSED(timestamp);
 
        // 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;
        }
 
    bool result;
        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 instantMapDiffBetweenReadoutAngles = map - mapCamPrevCycleValue;
            mapCamPrevCycleValue = map;
 
            if (instantMapDiffBetweenReadoutAngles > engineConfiguration->mapSyncThreshold) {
                mapVvt_sync_counter++;
                int revolutionCounter = getTriggerCentral()->triggerState.getSynchronizationCounter();
                mapVvt_MAP_AT_CYCLE_COUNT = revolutionCounter - prevChangeAtCycle;
                prevChangeAtCycle = revolutionCounter;
                result = true;
            } else {
                result = false;
            }
 
            mapVvt_MAP_AT_SPECIAL_POINT = map;
            mapVvt_MAP_AT_DIFF = instantMapDiffBetweenReadoutAngles;
        } else {
            result = false;
        }
 
        mapCamPrevToothAngle = toothAngle360;
        return result;
}

Referenced by decodeMapCam().

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 727 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 1261 of file trigger_central.cpp.

                                            {
    return triggerConfigChangedOnLastConfigurationChange;
}

◆ isTriggerDecoderError()

bool TriggerCentral::isTriggerDecoderError ( )

Returns: TRUE is something is wrong with trigger decoding

Definition at line 1293 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 68 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 563 of file trigger_central.cpp.

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

Referenced by resetRunningTriggerCounters().

Here is the caller graph for this function:

◆ syncEnginePhaseAndReport()

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

we have two kinds of sync: this method is about detecting of exact engine phase with 720 degree precision usually based on cam wheel decoding not to be confused with a totally different trigger wheel sync which could be either crank wheel sync or cam wheel sync

Definition at line 136 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:

◆ validateCamVvtCounters()

void TriggerCentral::validateCamVvtCounters ( )

Definition at line 1119 of file trigger_central.cpp.

                                            {
    // micro-optimized 'synchronizationCounter % 256'
    int camVvtValidationIndex = triggerState.getSynchronizationCounter() & 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 166 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 118 of file trigger_central.h.

Referenced by applyShapesConfiguration(), and findNextTriggerToothAngle().

◆ expectedNextPhase

expected<float> TriggerCentral::expectedNextPhase = unexpected

private

Definition at line 222 of file trigger_central.h.

Referenced by handleShaftSignal(), and isToothExpectedNow().

◆ hwTriggerInputEnabled

bool TriggerCentral::hwTriggerInputEnabled = true

Definition at line 81 of file trigger_central.h.

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

◆ instantRpm

InstantRpmCalculator TriggerCentral::instantRpm

Definition at line 66 of file trigger_central.h.

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

◆ isEngineSnifferEnabled

bool TriggerCentral::isEngineSnifferEnabled = false

this is based on engineSnifferRpmThreshold settings and current RPM

Definition at line 205 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 109 of file trigger_central.h.

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

◆ m_lastEventTimer

Timer TriggerCentral::m_lastEventTimer

Definition at line 200 of file trigger_central.h.

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

◆ m_lastToothPhaseFromSyncPoint

float TriggerCentral::m_lastToothPhaseFromSyncPoint

private

Definition at line 218 of file trigger_central.h.

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

◆ m_lastToothTimer

Timer TriggerCentral::m_lastToothTimer

private

Definition at line 216 of file trigger_central.h.

Referenced by getCurrentEnginePhase(), and handleShaftSignal().

◆ mapCamPrevCycleValue

float TriggerCentral::mapCamPrevCycleValue = 0

Definition at line 111 of file trigger_central.h.

Referenced by isMapCamSync().

◆ noiseFilter

TriggerNoiseFilter TriggerCentral::noiseFilter

Definition at line 160 of file trigger_central.h.

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

◆ prevChangeAtCycle

int TriggerCentral::prevChangeAtCycle = 0

Definition at line 112 of file trigger_central.h.

Referenced by isMapCamSync().

◆ primaryTriggerConfiguration

PrimaryTriggerConfiguration TriggerCentral::primaryTriggerConfiguration

Definition at line 90 of file trigger_central.h.

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

◆ 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 123 of file trigger_central.h.

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

◆ triggerErrorDetection

cyclic_buffer<int> TriggerCentral::triggerErrorDetection

Definition at line 83 of file trigger_central.h.

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

◆ triggerFormDetails

TriggerFormDetails TriggerCentral::triggerFormDetails

Definition at line 197 of file trigger_central.h.

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

◆ triggerShape

◆ triggerState

◆ triggerVersion

LocalVersionHolder TriggerCentral::triggerVersion

Definition at line 97 of file trigger_central.h.

Referenced by checkIfTriggerConfigChanged().

◆ vvtPosition

angle_t TriggerCentral::vvtPosition[BANKS_COUNT][CAMS_PER_BANK]

Definition at line 170 of file trigger_central.h.

Referenced by getVVTPosition(), and handleVvtCamSignal().

◆ vvtShape

TriggerWaveform TriggerCentral::vvtShape[CAMS_PER_BANK]

Definition at line 195 of file trigger_central.h.

Referenced by applyCamGapOverride(), applyShapesConfiguration(), handleVvtCamSignal(), and startSimulatedTriggerSignal().

◆ 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 178 of file trigger_central.h.

                                                             {
        {
            "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
    };

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

◆ vvtTriggerConfiguration

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

Definition at line 92 of file trigger_central.h.

92{{"VVT1 ", 0}};

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

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

◆ applyCamGapOverride()

◆ applyShapesConfiguration()

◆ applyTriggerGapOverride()

◆ checkIfTriggerConfigChanged()

◆ decodeMapCam()

◆ engineMovedRecently() [1/2]

◆ engineMovedRecently() [2/2]

◆ findNextTriggerToothAngle()

◆ getCurrentEnginePhase()

◆ getHwEventCounter()

◆ getSecondsSinceTriggerEvent()

◆ getVVTPosition()

◆ handleShaftSignal()

◆ isMapCamSync()

◆ isToothExpectedNow()

◆ isTriggerConfigChanged()

◆ isTriggerDecoderError()

◆ prepareTriggerShape()

◆ resetCounters()

◆ syncEnginePhaseAndReport()

◆ 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

◆ vvtPosition

◆ vvtShape

◆ vvtState

◆ vvtTriggerConfiguration