#include <trigger_central.h>

Collaboration diagram for TriggerNoiseFilter:

Public Member Functions
void	resetAccumSignalData ()

bool	noiseFilter (efitick_t nowNt, TriggerDecoderBase *triggerState, trigger_event_e signal)

Data Fields
efitick_t	lastSignalTimes [HW_EVENT_TYPES]

efitick_t	accumSignalPeriods [HW_EVENT_TYPES]

efitick_t	accumSignalPrevPeriods [HW_EVENT_TYPES]

Detailed Description

Definition at line 32 of file trigger_central.h.

Member Function Documentation

◆ noiseFilter()

bool TriggerNoiseFilter::noiseFilter	(	efitick_t	nowNt,
		TriggerDecoderBase *	triggerState,
		trigger_event_e	signal
	)

This is used to filter noise spikes (interference) in trigger signal. See The basic idea is to use not just edges, but the average amount of time the signal stays in '0' or '1'. So we update 'accumulated periods' to track where the signal is. And then compare between the current period and previous, with some tolerance (allowing for the wheel speed change).

Returns: true if the signal is passed through.

Definition at line 592 of file trigger_central.cpp.

                                {
    // todo: find a better place for these defs
    static const trigger_event_e opposite[4] = { SHAFT_PRIMARY_RISING, SHAFT_PRIMARY_FALLING, SHAFT_SECONDARY_RISING, SHAFT_SECONDARY_FALLING };
    static const TriggerWheel triggerIdx[4] = { TriggerWheel::T_PRIMARY, TriggerWheel::T_PRIMARY, TriggerWheel::T_SECONDARY, TriggerWheel:: T_SECONDARY };
    // we process all trigger channels independently
    TriggerWheel ti = triggerIdx[signal];
    // falling is opposite to rising, and vise versa
    trigger_event_e os = opposite[signal];
 
    // todo: currently only primary channel is filtered, because there are some weird trigger types on other channels
    if (ti != TriggerWheel::T_PRIMARY)
        return true;
 
    // update period accumulator: for rising signal, we update '0' accumulator, and for falling - '1'
    if (lastSignalTimes[signal] != -1)
        accumSignalPeriods[signal] += nowNt - lastSignalTimes[signal];
    // save current time for this trigger channel
    lastSignalTimes[signal] = nowNt;
 
    // now we want to compare current accumulated period to the stored one
    efitick_t currentPeriod = accumSignalPeriods[signal];
    // the trick is to compare between different
    efitick_t allowedPeriod = accumSignalPrevPeriods[os];
 
    // but first check if we're expecting a gap
    bool isGapExpected = TRIGGER_WAVEFORM(isSynchronizationNeeded) && triggerState->getShaftSynchronized() &&
            (triggerState->currentCycle.eventCount[(int)ti] + 1) == TRIGGER_WAVEFORM(getExpectedEventCount(ti));
 
    if (isGapExpected) {
        // usually we need to extend the period for gaps, based on the trigger info
        allowedPeriod *= TRIGGER_WAVEFORM(syncRatioAvg);
    }
 
    // also we need some margin for rapidly changing trigger-wheel speed,
    // that's why we expect the period to be no less than 2/3 of the previous period (this is just an empirical 'magic' coef.)
    efitick_t minAllowedPeriod = 2 * allowedPeriod / 3;
    // but no longer than 5/4 of the previous 'normal' period
    efitick_t maxAllowedPeriod = 5 * allowedPeriod / 4;
 
    // above all, check if the signal comes not too early
    if (currentPeriod >= minAllowedPeriod) {
        // now we store this period as a reference for the next time,
        // BUT we store only 'normal' periods, and ignore too long periods (i.e. gaps)
        if (!isGapExpected && (maxAllowedPeriod == 0 || currentPeriod <= maxAllowedPeriod)) {
            accumSignalPrevPeriods[signal] = currentPeriod;
        }
        // reset accumulator
        accumSignalPeriods[signal] = 0;
        return true;
    }
    // all premature or extra-long events are ignored - treated as interference
    return false;
}

Referenced by TriggerCentral::handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetAccumSignalData()

void TriggerNoiseFilter::resetAccumSignalData ( )

Definition at line 48 of file trigger_central.cpp.

                                              {
    memset(lastSignalTimes, 0xff, sizeof(lastSignalTimes)); // = -1
    memset(accumSignalPeriods, 0, sizeof(accumSignalPeriods));
    memset(accumSignalPrevPeriods, 0, sizeof(accumSignalPrevPeriods));
}