TriggerCentral Class Reference

#include <trigger_central.h>

Inheritance diagram for TriggerCentral:

Collaboration diagram for TriggerCentral:

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	updateWaveform ()
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)

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 {}
uint32_t	triggerElapsedUs = (uint32_t)0

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 1205 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 646 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 156 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 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;
    }

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 749 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 75 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(), 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 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 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 771 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(), time2print(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
 
        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.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 689 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 1213 of file trigger_central.cpp.

                                            {
    return triggerConfigChangedOnLastConfigurationChange;
}

isTriggerDecoderError()

bool TriggerCentral::isTriggerDecoderError

(

)

Returns

TRUE is something is wrong with trigger decoding

Definition at line 1245 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 560 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 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 1118 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;
 
        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;
        }
    }
 
    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];
        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;
        }
    }
 
    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 1080 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 169 of file trigger_central.h.

Referenced by handleVvtCamSignal().

directSelfStimulation

bool TriggerCentral::directSelfStimulation = false

See also triggerSimulatorRpm

Definition at line 88 of file trigger_central.h.

Referenced by configureRusefiLuaHooks(), disableTriggerStimulator(), doPeriodicSlowCallback(), emulatorApplyPinState(), enableExternalTriggerStimulator(), enableTriggerStimulator(), hwHandleShaftSignal(), hwHandleVvtCamSignal(), triggerInfo(), and LimpManager::updateState().

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 findNextTriggerToothAngle(), and updateWaveform().

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::onSlowCallback(), 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 208 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 203 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 decodeMapCam().

noiseFilter

TriggerNoiseFilter TriggerCentral::noiseFilter

Definition at line 160 of file trigger_central.h.

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

prevChangeAtCycle

int TriggerCentral::prevChangeAtCycle = 0

Definition at line 112 of file trigger_central.h.

Referenced by decodeMapCam().

primaryTriggerConfiguration

PrimaryTriggerConfiguration TriggerCentral::primaryTriggerConfiguration

Definition at line 90 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 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 isTriggerDecoderError(), Engine::OnTriggerSynchronization(), and updateWaveform().

triggerFormDetails

TriggerFormDetails TriggerCentral::triggerFormDetails

Definition at line 200 of file trigger_central.h.

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

triggerShape

TriggerWaveform TriggerCentral::triggerShape

Definition at line 179 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

PrimaryTriggerDecoder TriggerCentral::triggerState

Definition at line 176 of file trigger_central.h.

Referenced by canDashboardHaltech(), decodeMapCam(), extIonCallback(), getAcrState(), getCurrentIgnitionMode(), handleShaftSignal(), handleVvtCamSignal(), isToothExpectedNow(), isTriggerErrorNow(), Engine::OnTriggerSynchronization(), Engine::OnTriggerSynchronizationLost(), rpmShaftPositionCallback(), SetNextCompositeEntry(), RpmCalculator::setSpinningUp(), syncEnginePhaseAndReport(), TriggerCentral(), triggerInfo(), updateDevConsoleState(), LimpManager::updateState(), updateTunerStudioState(), updateWaveform(), and validateCamVvtCounters().

triggerVersion

LocalVersionHolder TriggerCentral::triggerVersion

Definition at line 97 of file trigger_central.h.

Referenced by checkIfTriggerConfigChanged().

vvtEventFallCounter

int TriggerCentral::vvtEventFallCounter[CAM_INPUTS_COUNT]

Definition at line 163 of file trigger_central.h.

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

vvtEventRiseCounter

int TriggerCentral::vvtEventRiseCounter[CAM_INPUTS_COUNT]

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

Referenced by getVVTPosition(), and handleVvtCamSignal().

vvtShape

TriggerWaveform TriggerCentral::vvtShape[CAMS_PER_BANK]

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

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

vvtTriggerConfiguration

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

Definition at line 92 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