TriggerDecoderBase Class Reference

#include <trigger_decoder.h>

Inheritance diagram for TriggerDecoderBase:

Collaboration diagram for TriggerDecoderBase:

Public Member Functions
	TriggerDecoderBase (const char *name)
void	printGaps (const char *prefix, const TriggerConfiguration &triggerConfiguration, const TriggerWaveform &triggerShape)
int	getCurrentIndex () const
int	getSynchronizationCounter () const
void	incrementShaftSynchronizationCounter ()
int64_t	getTotalEventCounter () const
expected< TriggerDecodeResult >	decodeTriggerEvent (const char *msg, const TriggerWaveform &triggerShape, TriggerStateListener *triggerStateListener, const TriggerConfiguration &triggerConfiguration, const trigger_event_e signal, const efitick_t nowNt)
	Trigger decoding happens here VR falls are filtered out and some VR noise detection happens prior to invoking this method, for Hall this method is invoked every time we have a fall or rise on one of the trigger sensors. This method changes the state of trigger_state_s data structure according to the trigger event.
void	onShaftSynchronization (bool wasSynchronized, const efitick_t nowNt, const TriggerWaveform &triggerShape)
bool	isValidIndex (const TriggerWaveform &triggerShape) const
virtual void	resetState ()
void	setShaftSynchronized (bool value)
bool	getShaftSynchronized () const
uint32_t	findTriggerZeroEventIndex (TriggerWaveform &shape, const TriggerConfiguration &triggerConfiguration)
bool	someSortOfTriggerError () const

Data Fields
float	gapRatio [PWM_PHASE_MAX_COUNT *6]
bool	shaft_is_synchronized = false
efitick_t	mostRecentSyncTime
Timer	previousEventTimer
uint32_t	toothDurations [GAP_TRACKING_LENGTH+1]
efitick_t	toothed_previous_time
current_cycle_state_s	currentCycle
const char *const	name
uint32_t	totalTriggerErrorCounter
uint32_t	orderingErrorCounter
efitick_t	startOfCycleNt
Data Fields inherited from trigger_state_s
uint32_t	synchronizationCounter = (uint32_t)0
uint32_t	vvtToothDurations0 = (uint32_t)0
float	vvtCurrentPosition = (float)0
float	vvtToothPosition [4] = {}
float	triggerSyncGapRatio = (float)0
uint8_t	triggerStateIndex = (uint8_t)0
int8_t	triggerCountersError = (int8_t)0
uint8_t	alignmentFill_at_34 [2] = {}

Protected Member Functions
virtual void	onTriggerError ()
virtual void	onNotEnoughTeeth (int, int)
virtual void	onTooManyTeeth (int, int)

Private Member Functions
void	setTriggerErrorState (int errorIncrement=1)
void	resetCurrentCycleState ()
bool	isSyncPoint (const TriggerWaveform &triggerShape, trigger_type_e triggerType) const
int	getEventCountersError (const TriggerWaveform &triggerShape) const

Private Attributes
trigger_event_e	prevSignal
int64_t	totalEventCountBase
bool	isFirstEvent
Timer	m_timeSinceDecodeError

Detailed Description

See also

TriggerWaveform for trigger wheel shape definition

Definition at line 85 of file trigger_decoder.h.

Constructor & Destructor Documentation

TriggerDecoderBase()

TriggerDecoderBase::TriggerDecoderBase

(

const char *

name

)

Definition at line 40 of file trigger_decoder.cpp.

    : name(p_name)
{
    TriggerDecoderBase::resetState();
}

Here is the call graph for this function:

Member Function Documentation

decodeTriggerEvent()

expected< TriggerDecodeResult > TriggerDecoderBase::decodeTriggerEvent	(	const char *	msg,
		const TriggerWaveform &	triggerShape,
		TriggerStateListener *	triggerStateListener,
		const TriggerConfiguration &	triggerConfiguration,
		const trigger_event_e	signal,
		const efitick_t	nowNt
	)

Trigger decoding happens here VR falls are filtered out and some VR noise detection happens prior to invoking this method, for Hall this method is invoked every time we have a fall or rise on one of the trigger sensors. This method changes the state of trigger_state_s data structure according to the trigger event.

Parameters

signal	type of event which just happened
nowNt	current time

We are here if there is a time gap between now and previous shaft event - that means the engine is not running. That means we have lost synchronization since the engine is not running :)

For performance reasons, we want to work with 32 bit values. If there has been more then 10 seconds since previous trigger event we do not really care.

todo: technically we can afford detailed logging even with 60/2 as long as low RPM todo: figure out exact threshold as a function of RPM and tooth count? Open question what is 'triggerShape.getSize()' for 60/2 is it 58 or 58*2 or 58*4?

We are here in case of a wheel without synchronization - we just need to count events, synchronization point simply happens once we have the right number of events

in case of noise the counter could be above the expected number of events, that's why 'more or equals' and not just 'equals'

Definition at line 416 of file trigger_decoder.cpp.

                               {
    ScopePerf perf(PE::DecodeTriggerEvent);
 
#if EFI_PROD_CODE
  getTriggerCentral()->triggerElapsedUs = previousEventTimer.getElapsedUs();
#endif
 
    if (previousEventTimer.getElapsedSecondsAndReset(nowNt) > 1) {
        /**
         * We are here if there is a time gap between now and previous shaft event - that means the engine is not running.
         * That means we have lost synchronization since the engine is not running :)
         */
        setShaftSynchronized(false);
        if (triggerStateListener) {
            triggerStateListener->OnTriggerSynchronizationLost();
        }
    }
 
    bool useOnlyRisingEdgeForTrigger = triggerShape.useOnlyRisingEdges;
 
    efiAssert(ObdCode::CUSTOM_TRIGGER_UNEXPECTED, signal <= SHAFT_SECONDARY_RISING, "unexpected signal", unexpected);
 
    TriggerWheel triggerWheel = eventIndex[signal];
    TriggerValue type = eventType[signal];
 
    // Check that we didn't get the same edge twice in a row - that should be impossible
    if (!useOnlyRisingEdgeForTrigger && prevSignal == signal) {
        orderingErrorCounter++;
    }
 
    prevSignal = signal;
 
    currentCycle.eventCount[(int)triggerWheel]++;
 
    if (toothed_previous_time > nowNt) {
        firmwareError(ObdCode::CUSTOM_OBD_93, "[%s] toothed_previous_time after nowNt prev=%lu now=%lu", msg, (uint32_t)toothed_previous_time, (uint32_t)nowNt);
    }
 
    efidur_t currentDurationLong = isFirstEvent ? 0 : (nowNt - toothed_previous_time);
 
    /**
     * For performance reasons, we want to work with 32 bit values. If there has been more then
     * 10 seconds since previous trigger event we do not really care.
     */
    toothDurations[0] =
            currentDurationLong > 10 * NT_PER_SECOND ? 10 * NT_PER_SECOND : currentDurationLong;
 
    if (!shouldConsiderEdge(triggerShape, triggerWheel, type)) {
#if EFI_UNIT_TEST
        if (printTriggerTrace) {
            printf("%s isLessImportant %s now=%d index=%d\r\n",
                    getTrigger_type_e(triggerConfiguration.TriggerType.type),
                    getTrigger_event_e(signal),
                    (int)nowNt,
                    currentCycle.current_index);
        }
#endif /* EFI_UNIT_TEST */
 
        // For less important events we simply increment the index.
        nextTriggerEvent();
    } else {
#if !EFI_PROD_CODE
        if (printTriggerTrace) {
            printf("%s event %s %lld\r\n",
                    getTrigger_type_e(triggerConfiguration.TriggerType.type),
                    getTrigger_event_e(signal),
                    nowNt);
            printf("decodeTriggerEvent ratio %.2f: current=%d previous=%d\r\n", 1.0 * toothDurations[0] / toothDurations[1],
                    toothDurations[0], toothDurations[1]);
        }
#endif
 
        isFirstEvent = false;
        bool isSynchronizationPoint;
        bool wasSynchronized = getShaftSynchronized();
 
        if (triggerShape.isSynchronizationNeeded) {
            triggerSyncGapRatio = (float)toothDurations[0] / toothDurations[1];
 
            if (wasSynchronized && triggerSyncGapRatio > NOISE_RATIO_THRESHOLD) {
                setTriggerErrorState(100);
            }
 
            isSynchronizationPoint = isSyncPoint(triggerShape, triggerConfiguration.TriggerType.type);
            if (isSynchronizationPoint) {
                enginePins.debugTriggerSync.toggle();
            }
 
            /**
             * todo: technically we can afford detailed logging even with 60/2 as long as low RPM
             * todo: figure out exact threshold as a function of RPM and tooth count?
             * Open question what is 'triggerShape.getSize()' for 60/2 is it 58 or 58*2 or 58*4?
             */
            bool silentTriggerError = triggerShape.getSize() > 40 && engineConfiguration->silentTriggerError;
 
#if EFI_PROD_CODE || EFI_SIMULATOR
            bool verbose = getTriggerCentral()->isEngineSnifferEnabled && triggerConfiguration.VerboseTriggerSynchDetails;
 
            if (verbose || (someSortOfTriggerError() && !silentTriggerError)) {
                const char * prefix = verbose ? "[vrb]" : "[err]";
                printGaps(prefix, triggerConfiguration, triggerShape);
            }
#else
            if (printTriggerTrace) {
                for (int i = 0;i<triggerShape.gapTrackingLength;i++) {
                    float gap = 1.0 * toothDurations[i] / toothDurations[i + 1];
                    printf("%sindex=%d: gap=%.2f expected from %.2f to %.2f error=%s\r\n",
                            triggerConfiguration.PrintPrefix,
                            i,
                            gap,
                            triggerShape.synchronizationRatioFrom[i],
                            triggerShape.synchronizationRatioTo[i],
                            boolToString(someSortOfTriggerError()));
                }
            }
#endif /* EFI_PROD_CODE */
        } else {
            /**
             * We are here in case of a wheel without synchronization - we just need to count events,
             * synchronization point simply happens once we have the right number of events
             *
             * in case of noise the counter could be above the expected number of events, that's why 'more or equals' and not just 'equals'
             */
 
            unsigned int endOfCycleIndex = triggerShape.getSize() - (useOnlyRisingEdgeForTrigger ? 2 : 1);
 
            isSynchronizationPoint = !getShaftSynchronized() || (currentCycle.current_index >= endOfCycleIndex);
 
#if EFI_UNIT_TEST
            if (printTriggerTrace) {
                printf("decodeTriggerEvent sync=%d isSynchronizationPoint=%d index=%d size=%d\r\n",
                        getShaftSynchronized(),
                    isSynchronizationPoint,
                    currentCycle.current_index,
                    triggerShape.getSize());
            }
#endif /* EFI_UNIT_TEST */
        }
#if EFI_UNIT_TEST
        if (printTriggerTrace) {
            printf("decodeTriggerEvent gap %s isSynchronizationPoint=%d index=%d %s\r\n",
                    getTrigger_type_e(triggerConfiguration.TriggerType.type),
                    isSynchronizationPoint, currentCycle.current_index,
                    getTrigger_event_e(signal));
        }
#endif /* EFI_UNIT_TEST */
 
        if (isSynchronizationPoint) {
          triggerCountersError = getEventCountersError(triggerShape);
            bool isDecodingError = isTriggerCounterError(triggerCountersError);
 
            if (triggerStateListener) {
                triggerStateListener->OnTriggerSynchronization(wasSynchronized, isDecodingError);
            }
 
            // If we got a sync point, but the wrong number of events since the last sync point
            // One of two things has happened:
            //  - We missed a tooth, and this is the real sync point
            //  - Due to some mistake in timing, we found what looks like a sync point but actually isn't
            // In either case, we should wait for another sync point before doing anything to try and run an engine,
            // so we clear the synchronized flag.
            if (wasSynchronized && isDecodingError) {
                setTriggerErrorState();
                onNotEnoughTeeth(currentCycle.current_index, triggerShape.getSize());
 
                // Something wrong, no longer synchronized
                setShaftSynchronized(false);
 
                // This is a decoding error
                onTriggerError();
                printGaps("newerr", triggerConfiguration, triggerShape);
            } else {
                // If this was the first sync point OR no decode error, we're synchronized!
                setShaftSynchronized(true);
            }
 
            // this call would update duty cycle values
            nextTriggerEvent();
 
            onShaftSynchronization(wasSynchronized, nowNt, triggerShape);
        } else {    /* if (!isSynchronizationPoint) */
            nextTriggerEvent();
        }
 
        for (int i = triggerShape.gapTrackingLength; i > 0; i--) {
            toothDurations[i] = toothDurations[i - 1];
        }
 
        toothed_previous_time = nowNt;
 
#if EFI_UNIT_TEST
        if (wasSynchronized) {
            int uiGapIndex = (currentCycle.current_index) % triggerShape.getLength();
            gapRatio[uiGapIndex] = triggerSyncGapRatio;
        }
#endif // EFI_UNIT_TEST
    }
 
    if (getShaftSynchronized() && !isValidIndex(triggerShape)) {
        // We've had too many events since the last sync point, we should have seen a sync point by now.
        // This is a trigger error.
 
        // let's not show a warning if we are just starting to spin
        if (Sensor::getOrZero(SensorType::Rpm) != 0) {
            setTriggerErrorState();
            onTooManyTeeth(currentCycle.current_index, triggerShape.getSize());
        }
 
        onTriggerError();
 
        setShaftSynchronized(false);
 
        return unexpected;
    }
 
    triggerStateIndex = currentCycle.current_index;
 
    // Needed for early instant-RPM detection
    TriggerStateListener * l = triggerStateListener;
    while (l) {
        l->OnTriggerStateProperState(nowNt, triggerStateIndex);
        l = l->nextListener();
    }
 
    if (getShaftSynchronized()) {
        return TriggerDecodeResult{ currentCycle.current_index };
    } else {
        return unexpected;
    }
}

Referenced by TriggerCentral::handleShaftSignal(), and handleVvtCamSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

findTriggerZeroEventIndex()

uint32_t TriggerDecoderBase::findTriggerZeroEventIndex	(	TriggerWaveform &	shape,
		const TriggerConfiguration &	triggerConfiguration
	)

Trigger shape is defined in a way which is convenient for trigger shape definition On the other hand, trigger decoder indexing begins from synchronization event.

This function finds the index of synchronization event within TriggerWaveform

Definition at line 711 of file trigger_decoder.cpp.

                                                          {
#if EFI_PROD_CODE
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, hasLotsOfRemainingStack(), "findPos", -1);
#endif
 
 
    resetState();
 
    if (shape.shapeDefinitionError) {
        return 0;
    }
 
    expected<uint32_t> syncIndex = TriggerStimulatorHelper::findTriggerSyncPoint(shape,
            triggerConfiguration,
            *this);
    if (!syncIndex) {
        return EFI_ERROR_CODE;
    }
 
    // Assert that we found the sync point on the very first revolution
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, getSynchronizationCounter() == 0, "findZero_revCounter", EFI_ERROR_CODE);
 
#if EFI_UNIT_TEST
    if (printTriggerDebug) {
        printf("findTriggerZeroEventIndex: syncIndex located %lu!\r\n", syncIndex.Value);
    }
#endif /* EFI_UNIT_TEST */
 
    TriggerStimulatorHelper::assertSyncPosition(triggerConfiguration,
            syncIndex.Value, *this, shape);
 
    return syncIndex.Value % shape.getSize();
}

Here is the call graph for this function:

getCurrentIndex()

int TriggerDecoderBase::getCurrentIndex

(

)

const

current trigger processing index, between zero and size

Definition at line 209 of file trigger_decoder.cpp.

                                              {
    return currentCycle.current_index;
}

getEventCountersError()

int TriggerDecoderBase::getEventCountersError ( const TriggerWaveform &  triggerShape ) const

private

Definition at line 308 of file trigger_decoder.cpp.

                                                                                       {
    // We can check if things are fine by comparing the number of events in a cycle with the expected number of event.
    int countersError = 0;
    for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) {
      countersError = currentCycle.eventCount[i] - triggerShape.getExpectedEventCount((TriggerWheel)i);
      if (countersError != 0) {
        break;
      }
    }
 
#if EFI_DETAILED_LOGGING
    printf("getEventCountersError: isDecodingError=%d\n", (countersError != 0));
    if (countersError != 0) {
        for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) {
            printf("  count: cur=%d exp=%d\n", currentCycle.eventCount[i],  triggerShape.getExpectedEventCount((TriggerWheel)i));
        }
    }
#endif /* EFI_UNIT_TEST */
 
    return countersError;
}

Referenced by decodeTriggerEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

getShaftSynchronized()

bool TriggerDecoderBase::getShaftSynchronized

(

)

const

Definition at line 46 of file trigger_decoder.cpp.

                                                    {
    return shaft_is_synchronized;
}

Referenced by decodeTriggerEvent(), handleVvtCamSignal(), TriggerNoiseFilter::noiseFilter(), SetNextCompositeEntry(), and RpmCalculator::setSpinningUp().

Here is the caller graph for this function:

getSynchronizationCounter()

int TriggerDecoderBase::getSynchronizationCounter

(

)

const

Definition at line 176 of file trigger_decoder.cpp.

                                                        {
    return synchronizationCounter;
}

Referenced by extIonCallback(), findTriggerZeroEventIndex(), getAcrState(), TriggerCentral::handleShaftSignal(), TriggerCentral::isMapCamSync(), PrimaryTriggerDecoder::syncEnginePhase(), triggerInfo(), and TriggerCentral::validateCamVvtCounters().

Here is the caller graph for this function:

getTotalEventCounter()

int64_t TriggerDecoderBase::getTotalEventCounter

(

)

const

Definition at line 172 of file trigger_decoder.cpp.

                                                       {
    return totalEventCountBase + currentCycle.current_index;
}

Referenced by updateDevConsoleState().

Here is the caller graph for this function:

incrementShaftSynchronizationCounter()

void TriggerDecoderBase::incrementShaftSynchronizationCounter

(

)

this is important for crank-based virtual trigger and VVT magic

Definition at line 238 of file trigger_decoder.cpp.

                                                              {
    synchronizationCounter++;
}

Referenced by onShaftSynchronization(), and PrimaryTriggerDecoder::syncEnginePhase().

Here is the caller graph for this function:

isSyncPoint()

bool TriggerDecoderBase::isSyncPoint ( const TriggerWaveform &  triggerShape, trigger_type_e  triggerType  ) const

private

Definition at line 653 of file trigger_decoder.cpp.

                                                                                                          {
    // Miata NB needs a special decoder.
    // The problem is that the crank wheel only has 4 teeth, also symmetrical, so the pattern
    // is long-short-long-short for one crank rotation.
    // A quick acceleration can result in two successive "short gaps", so we see
    // long-short-short-short-long instead of the correct long-short-long-short-long
    // This logic expands the lower bound on a "long" tooth, then compares the last
    // tooth to the current one.
 
    // Instead of detecting short/long, this logic first checks for "maybe short" and "maybe long",
    // then simply tests longer vs. shorter instead of absolute value.
    if (triggerType == trigger_type_e::TT_MIATA_VVT) {
        auto secondGap = (float)toothDurations[1] / toothDurations[2];
 
        bool currentGapOk = isInRange(triggerShape.synchronizationRatioFrom[0], (float)triggerSyncGapRatio, triggerShape.synchronizationRatioTo[0]);
        bool secondGapOk  = isInRange(triggerShape.synchronizationRatioFrom[1], secondGap,  triggerShape.synchronizationRatioTo[1]);
 
        // One or both teeth was impossible range, this is not the sync point
        if (!currentGapOk || !secondGapOk) {
            return false;
        }
 
        // If both teeth are in the range of possibility, return whether this gap is
        // shorter than the last or not.  If it is, this is the sync point.
        return triggerSyncGapRatio < secondGap;
    }
 
    for (int i = 0; i < triggerShape.gapTrackingLength; i++) {
        auto from = triggerShape.synchronizationRatioFrom[i];
        auto to = triggerShape.synchronizationRatioTo[i];
 
        if (std::isnan(from)) {
            // don't check this gap, skip it
            continue;
        }
 
        // This is transformed to avoid a division and use a cheaper multiply instead
        // toothDurations[i] / toothDurations[i+1] > from
        // is an equivalent comparison to
        // toothDurations[i] > toothDurations[i+1] * from
        bool isGapCondition =
              (toothDurations[i] > toothDurations[i + 1] * from
            && toothDurations[i] < toothDurations[i + 1] * to);
 
        if (!isGapCondition) {
            return false;
        }
    }
 
    return true;
}

Referenced by decodeTriggerEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

isValidIndex()

bool TriggerDecoderBase::isValidIndex

(

const TriggerWaveform &

triggerShape

)

const

Definition at line 187 of file trigger_decoder.cpp.

                                                                               {
    return currentCycle.current_index < triggerShape.getSize();
}

Referenced by decodeTriggerEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

onNotEnoughTeeth()

virtual void TriggerDecoderBase::onNotEnoughTeeth ( int  , int    )

inlineprotectedvirtual

Reimplemented in PrimaryTriggerDecoder, and VvtTriggerDecoder.

Definition at line 177 of file trigger_decoder.h.

{ }

Referenced by decodeTriggerEvent().

Here is the caller graph for this function:

onShaftSynchronization()

void TriggerDecoderBase::onShaftSynchronization	(	bool	wasSynchronized,
		const efitick_t	nowNt,
		const TriggerWaveform &	triggerShape
	)

Definition at line 330 of file trigger_decoder.cpp.

                                             {
    startOfCycleNt = nowNt;
    resetCurrentCycleState();
 
    if (wasSynchronized) {
        incrementShaftSynchronizationCounter();
    } else {
        // We have just synchronized, this is the zeroth revolution
        synchronizationCounter = 0;
    }
 
    totalEventCountBase += triggerShape.getSize();
 
#if EFI_UNIT_TEST
    if (printTriggerDebug) {
        printf("onShaftSynchronization index=%d %d\r\n",
                currentCycle.current_index,
                synchronizationCounter);
    }
#endif /* EFI_UNIT_TEST */
}

Referenced by decodeTriggerEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

onTooManyTeeth()

virtual void TriggerDecoderBase::onTooManyTeeth ( int  , int    )

inlineprotectedvirtual

Reimplemented in PrimaryTriggerDecoder, and VvtTriggerDecoder.

Definition at line 178 of file trigger_decoder.h.

{ }

Referenced by decodeTriggerEvent().

Here is the caller graph for this function:

onTriggerError()

virtual void TriggerDecoderBase::onTriggerError ( )

inlineprotectedvirtual

Reimplemented in PrimaryTriggerDecoder.

Definition at line 175 of file trigger_decoder.h.

{ }

Referenced by decodeTriggerEvent().

Here is the caller graph for this function:

printGaps()

void TriggerDecoderBase::printGaps	(	const char *	prefix,
		const TriggerConfiguration &	triggerConfiguration,
		const TriggerWaveform &	triggerShape
	)

Definition at line 374 of file trigger_decoder.cpp.

                                       {
                for (int i = 0;i<triggerShape.gapTrackingLength;i++) {
                    float ratioFrom = triggerShape.synchronizationRatioFrom[i];
                    if (std::isnan(ratioFrom)) {
                        // we do not track gap at this depth
                        continue;
                    }
 
                    float gap = 1.0 * toothDurations[i] / toothDurations[i + 1];
                    if (std::isnan(gap)) {
                        efiPrintf("%s index=%d NaN gap, you have noise issues?", prefix, i);
                    } else {
                        float ratioTo = triggerShape.synchronizationRatioTo[i];
 
                        bool gapOk = isInRange(ratioFrom, gap, ratioTo);
 
                        efiPrintf("%s %srpm=%d time=%d eventIndex=%lu gapIndex=%d: %s gap=%.3f expected from %.3f to %.3f error=%s",
                                prefix,
                                triggerConfiguration.PrintPrefix,
                                (int)Sensor::getOrZero(SensorType::Rpm),
                            /* cast is needed to make sure we do not put 64 bit value to stack*/ (int)getTimeNowS(),
                            currentCycle.current_index,
                            i,
                            gapOk ? "Y" : "n",
                            gap,
                            ratioFrom,
                            ratioTo,
                            boolToString(someSortOfTriggerError()));
                    }
                }
}

Referenced by decodeTriggerEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

resetCurrentCycleState()

void TriggerDecoderBase::resetCurrentCycleState ( )

private

Definition at line 95 of file trigger_decoder.cpp.

                                                {
    setArrayValues(currentCycle.eventCount, 0);
    currentCycle.current_index = 0;
}

Referenced by onShaftSynchronization(), and resetState().

Here is the call graph for this function:

Here is the caller graph for this function:

resetState()

void TriggerDecoderBase::resetState ( )

virtual

Reimplemented in PrimaryTriggerDecoder.

Definition at line 69 of file trigger_decoder.cpp.

                                    {
    setShaftSynchronized(false);
    toothed_previous_time = 0;
 
    setArrayValues(toothDurations, 0);
 
    synchronizationCounter = 0;
    totalTriggerErrorCounter = 0;
    orderingErrorCounter = 0;
    m_timeSinceDecodeError.init();
 
    prevSignal = SHAFT_PRIMARY_FALLING;
    startOfCycleNt = {};
 
    resetCurrentCycleState();
 
    totalEventCountBase = 0;
    isFirstEvent = true;
}

Referenced by findTriggerZeroEventIndex(), Engine::OnTriggerSynchronizationLost(), PrimaryTriggerDecoder::resetState(), and TriggerDecoderBase().

Here is the call graph for this function:

Here is the caller graph for this function:

setShaftSynchronized()

void TriggerDecoderBase::setShaftSynchronized

(

bool

value

)

Definition at line 50 of file trigger_decoder.cpp.

                                                        {
#if EFI_UNIT_TEST
    if (value != shaft_is_synchronized) {
        LogTriggerSync(value, getTimeNowNt());
    }
#endif
 
    if (value) {
        if (!shaft_is_synchronized) {
            // just got synchronized
            mostRecentSyncTime = getTimeNowNt();
        }
    } else {
        // sync loss
        mostRecentSyncTime = 0;
    }
    shaft_is_synchronized = value;
}

Referenced by decodeTriggerEvent(), and resetState().

Here is the call graph for this function:

Here is the caller graph for this function:

setTriggerErrorState()

void TriggerDecoderBase::setTriggerErrorState ( int  errorIncrement = 1 )

private

Definition at line 89 of file trigger_decoder.cpp.

                                                                {
    m_timeSinceDecodeError.reset();
    totalTriggerErrorCounter += errorIncrement;
    onTransitionEvent(TransitionEvent::TriggerError);
}

Referenced by decodeTriggerEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

someSortOfTriggerError()

bool TriggerDecoderBase::someSortOfTriggerError ( ) const

inline

Definition at line 166 of file trigger_decoder.h.

                                        {
        return !m_timeSinceDecodeError.hasElapsedSec(0.3);
    }

Referenced by decodeTriggerEvent(), isTriggerErrorNow(), Engine::OnTriggerSynchronization(), and printGaps().

Here is the caller graph for this function:

Field Documentation

currentCycle

current_cycle_state_s TriggerDecoderBase::currentCycle

Definition at line 142 of file trigger_decoder.h.

Referenced by decodeTriggerEvent(), getCurrentIndex(), getEventCountersError(), getTotalEventCounter(), handleVvtCamSignal(), TriggerCentral::isToothExpectedNow(), isValidIndex(), TriggerNoiseFilter::noiseFilter(), PrimaryTriggerDecoder::onNotEnoughTeeth(), onShaftSynchronization(), PrimaryTriggerDecoder::onTooManyTeeth(), Engine::OnTriggerSynchronization(), printGaps(), resetCurrentCycleState(), and rpmShaftPositionCallback().

gapRatio

float TriggerDecoderBase::gapRatio[PWM_PHASE_MAX_COUNT *6]

used only for trigger export

Definition at line 107 of file trigger_decoder.h.

Referenced by decodeTriggerEvent().

isFirstEvent

bool TriggerDecoderBase::isFirstEvent

private

Definition at line 190 of file trigger_decoder.h.

Referenced by decodeTriggerEvent(), and resetState().

m_timeSinceDecodeError

Timer TriggerDecoderBase::m_timeSinceDecodeError

private

Definition at line 192 of file trigger_decoder.h.

Referenced by resetState(), setTriggerErrorState(), and someSortOfTriggerError().

mostRecentSyncTime

efitick_t TriggerDecoderBase::mostRecentSyncTime

Definition at line 131 of file trigger_decoder.h.

Referenced by setShaftSynchronized().

name

const char* const TriggerDecoderBase::name

Definition at line 143 of file trigger_decoder.h.

Referenced by VvtTriggerDecoder::onNotEnoughTeeth(), and VvtTriggerDecoder::onTooManyTeeth().

orderingErrorCounter

uint32_t TriggerDecoderBase::orderingErrorCounter

Definition at line 149 of file trigger_decoder.h.

Referenced by decodeTriggerEvent(), resetState(), triggerInfo(), and updateTunerStudioState().

previousEventTimer

Timer TriggerDecoderBase::previousEventTimer

Definition at line 133 of file trigger_decoder.h.

Referenced by decodeTriggerEvent().

prevSignal

trigger_event_e TriggerDecoderBase::prevSignal

private

Definition at line 187 of file trigger_decoder.h.

Referenced by decodeTriggerEvent(), and resetState().

shaft_is_synchronized

bool TriggerDecoderBase::shaft_is_synchronized = false

TRUE if we know where we are

Definition at line 130 of file trigger_decoder.h.

Referenced by getShaftSynchronized(), and setShaftSynchronized().

startOfCycleNt

efitick_t TriggerDecoderBase::startOfCycleNt

this is start of real trigger cycle for virtual double trigger see timeAtVirtualZeroNt

Definition at line 159 of file trigger_decoder.h.

Referenced by onShaftSynchronization(), and resetState().

toothDurations

uint32_t TriggerDecoderBase::toothDurations[GAP_TRACKING_LENGTH+1]

current duration at index zero and previous durations are following

Definition at line 138 of file trigger_decoder.h.

Referenced by decodeTriggerEvent(), handleVvtCamSignal(), isSyncPoint(), printGaps(), and resetState().

toothed_previous_time

efitick_t TriggerDecoderBase::toothed_previous_time

Definition at line 140 of file trigger_decoder.h.

Referenced by decodeTriggerEvent(), and resetState().

totalEventCountBase

int64_t TriggerDecoderBase::totalEventCountBase

private

Definition at line 188 of file trigger_decoder.h.

Referenced by getTotalEventCounter(), onShaftSynchronization(), and resetState().

totalTriggerErrorCounter

uint32_t TriggerDecoderBase::totalTriggerErrorCounter

how many times since ECU reboot we had unexpected number of teeth in trigger cycle

Definition at line 148 of file trigger_decoder.h.

Referenced by canDashboardHaltech(), resetState(), setTriggerErrorState(), triggerInfo(), and updateTunerStudioState().

---

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

• controllers/trigger/trigger_decoder.h
• controllers/trigger/trigger_decoder.cpp