#include <trigger_decoder.h>

Inheritance diagram for TriggerState:

Collaboration diagram for TriggerState:

[legend]

Public Member Functions
	TriggerState ()

int	getCurrentIndex () const

int	getTotalRevolutionCounter () const

void	incrementTotalEventCounter ()

efitime_t	getTotalEventCounter () const

void	decodeTriggerEvent (const char msg, const TriggerWaveform &triggerShape, const TriggerStateCallback triggerCycleCallback, TriggerStateListener triggerStateListener, const TriggerConfiguration &triggerConfiguration, const trigger_event_e signal, const efitime_t nowUs)
	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. More...

bool	validateEventCounters (const TriggerWaveform &triggerShape) const

void	onShaftSynchronization (const TriggerStateCallback triggerCycleCallback, bool wasSynchronized, const efitick_t nowNt, const TriggerWaveform &triggerShape)

bool	isValidIndex (const TriggerWaveform &triggerShape) const

void	setTriggerErrorState ()

virtual void	resetTriggerState ()

void	setShaftSynchronized (bool value)

bool	getShaftSynchronized ()

uint32_t	findTriggerZeroEventIndex (TriggerWaveform &shape, const TriggerConfiguration &triggerConfiguration, const trigger_config_s &triggerConfig)

Data Fields
bool	shaft_is_synchronized

efitick_t	mostRecentSyncTime

Timer	previousEventTimer

efitick_t	lastDecodingErrorTime

bool	someSortOfTriggerError

uint32_t	toothDurations [GAP_TRACKING_LENGTH+1]

efitick_t	toothed_previous_time

current_cycle_state_s	currentCycle

const char *	name = nullptr

int	expectedTotalTime [PWM_PHASE_MAX_WAVE_PER_PWM]

uint32_t	totalTriggerErrorCounter

uint32_t	orderingErrorCounter

efitick_t	startOfCycleNt

Data Fields inherited from trigger_state_s
uint32_t	totalRevolutionCounter = (uint32_t)0

scaled_channel< float, 1, 1 >	vvtSyncGapRatio = (float)0

scaled_channel< float, 1, 1 >	vvtCurrentPosition = (float)0

scaled_channel< float, 1, 1 >	triggerSyncGapRatio = (float)0

float	triggerActualSyncGapRatio = (float)0

uint8_t	triggerStateIndex = (uint8_t)0

uint8_t	vvtCounter = (uint8_t)0

uint8_t	vvtSyncCounter = (uint8_t)0

uint8_t	vvtStateIndex = (uint8_t)0

Private Member Functions
void	resetCurrentCycleState ()

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

Private Attributes
trigger_event_e	curSignal

trigger_event_e	prevSignal

int64_t	totalEventCountBase

bool	isFirstEvent

Detailed Description

See also: TriggerWaveform for trigger wheel shape definition

Definition at line 77 of file trigger_decoder.h.

Constructor & Destructor Documentation

◆ TriggerState()

TriggerState::TriggerState ( )

Definition at line 41 of file trigger_decoder.cpp.

                            {
     resetTriggerState();
 }

Here is the call graph for this function:

Member Function Documentation

◆ decodeTriggerEvent()

void TriggerState::decodeTriggerEvent	(	const char *	msg,
		const TriggerWaveform &	triggerShape,
		const TriggerStateCallback	triggerCycleCallback,
		TriggerStateListener *	triggerStateListener,
		const TriggerConfiguration &	triggerConfiguration,
		const trigger_event_e	signal,
		const efitime_t	nowUs
	)

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.

For less important events we simply increment the index.

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 483 of file trigger_decoder.cpp.

                                {
     ScopePerf perf(PE::DecodeTriggerEvent);
     
     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 = triggerConfiguration.UseOnlyRisingEdgeForTrigger;
  
     efiAssertVoid(CUSTOM_TRIGGER_UNEXPECTED, signal <= SHAFT_3RD_RISING, "unexpected signal");
  
     trigger_wheel_e triggerWheel = eventIndex[signal];
     trigger_value_e type = eventType[signal];
  
     if (!useOnlyRisingEdgeForTrigger && curSignal == prevSignal) {
         orderingErrorCounter++;
     }
  
     prevSignal = curSignal;
     curSignal = signal;
  
     currentCycle.eventCount[triggerWheel]++;
  
     if (toothed_previous_time > nowNt) {
         firmwareError(CUSTOM_OBD_93, "[%s] toothed_previous_time after nowNt prev=%d now=%d", msg, toothed_previous_time, nowNt);
     }
  
     efitick_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;
  
     bool isPrimary = triggerWheel == T_PRIMARY;
  
     if (needToSkipFall(type) || needToSkipRise(type) || (!considerEventForGap())) {
 #if EFI_UNIT_TEST
         if (printTriggerTrace) {
             printf("%s isLessImportant %s now=%d index=%d\r\n",
                     getTrigger_type_e(triggerConfiguration.TriggerType),
                     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 %d\r\n",
                     getTrigger_type_e(triggerConfiguration.TriggerType),
                     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];
  
             isSynchronizationPoint = isSyncPoint(triggerShape, triggerConfiguration.TriggerType);
             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_UNIT_TEST
             actualSynchGap = triggerSyncGapRatio;
 #endif /* EFI_UNIT_TEST */
  
 #if EFI_PROD_CODE || EFI_SIMULATOR
             if (triggerConfiguration.VerboseTriggerSynchDetails || (someSortOfTriggerError && !silentTriggerError)) {
  
                 int rpm = Sensor::getOrZero(SensorType::Rpm);
                 floatms_t engineCycleDuration = getEngineCycleDuration(rpm);
                 if (!engineConfiguration->useOnlyRisingEdgeForTrigger) {
                     int time = currentCycle.totalTimeNt[0];
                     efiPrintf("%s duty %f %d",
                         name,
                         time / engineCycleDuration,
                         time
                         );
                 }
  
                 for (int i = 0;i<triggerShape.gapTrackingLength;i++) {
                     float ratioFrom = triggerShape.syncronizationRatioFrom[i];
                     if (cisnan(ratioFrom)) {
                         // we do not track gap at this depth
                         continue;
                     }
  
                     float gap = 1.0 * toothDurations[i] / toothDurations[i + 1];
                     if (cisnan(gap)) {
                         efiPrintf("index=%d NaN gap, you have noise issues?",
                                 i);
                     } else {
                         efiPrintf("%srpm=%d time=%d eventIndex=%d gapIndex=%d: gap=%.3f expected from %.3f to %.3f error=%s",
                                 triggerConfiguration.PrintPrefix,
                                 (int)Sensor::getOrZero(SensorType::Rpm),
                             /* cast is needed to make sure we do not put 64 bit value to stack*/ (int)getTimeNowSeconds(),
                             currentCycle.current_index,
                             i,
                             gap,
                             ratioFrom,
                             triggerShape.syncronizationRatioTo[i],
                             boolToString(someSortOfTriggerError));
                     }
                 }
             }
 #else
             if (printTriggerTrace) {
                 float gap = 1.0 * toothDurations[0] / toothDurations[1];
                 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.syncronizationRatioFrom[i],
                             triggerShape.syncronizationRatioTo[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() - (triggerConfiguration.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 %s isSynchronizationPoint=%d index=%d %s\r\n",
                     getTrigger_type_e(triggerConfiguration.TriggerType),
                     isSynchronizationPoint, currentCycle.current_index,
                     getTrigger_event_e(signal));
         }
 #endif /* EFI_UNIT_TEST */
  
         if (isSynchronizationPoint) {
             if (triggerStateListener) {
                 triggerStateListener->OnTriggerSyncronization(wasSynchronized);
             }
  
             setShaftSynchronized(true);
             // this call would update duty cycle values
             nextTriggerEvent()
             ;
  
             onShaftSynchronization(triggerCycleCallback, 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 (getShaftSynchronized() && !isValidIndex(triggerShape) && triggerStateListener) {
         triggerStateListener->OnTriggerInvalidIndex(currentCycle.current_index);
         return;
     }
     if (someSortOfTriggerError) {
         if (getTimeNowNt() - lastDecodingErrorTime > NT_PER_SECOND) {
             someSortOfTriggerError = false;
         }
     }
  
  
     // Needed for early instant-RPM detection
     if (triggerStateListener) {
         triggerStateListener->OnTriggerStateProperState(nowNt);
     }
 }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findTriggerZeroEventIndex()

uint32_t TriggerState::findTriggerZeroEventIndex	(	TriggerWaveform &	shape,
		const TriggerConfiguration &	triggerConfiguration,
		const trigger_config_s &	triggerConfig
	)

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

Now that we have just located the synch point, we can simulate the whole cycle in order to calculate expected duty cycle

todo: add a comment why are we doing '2 * shape->getSize()' here?

Definition at line 776 of file trigger_decoder.cpp.

                                                {
     UNUSED(triggerConfig);
 #if EFI_PROD_CODE
     efiAssert(CUSTOM_ERR_ASSERT, getCurrentRemainingStack() > 128, "findPos", -1);
 #endif
  
  
     resetTriggerState();
  
     if (shape.shapeDefinitionError) {
         return 0;
     }
  
     TriggerStimulatorHelper helper;
  
     uint32_t syncIndex = helper.findTriggerSyncPoint(shape,
             triggerConfiguration,
             *this);
     if (syncIndex == EFI_ERROR_CODE) {
         return syncIndex;
     }
  
     // Assert that we found the sync point on the very first revolution
     efiAssert(CUSTOM_ERR_ASSERT, getTotalRevolutionCounter() == 0, "findZero_revCounter", EFI_ERROR_CODE);
  
 #if EFI_UNIT_TEST
     if (printTriggerDebug) {
         printf("findTriggerZeroEventIndex: syncIndex located %d!\r\n", syncIndex);
     }
 #endif /* EFI_UNIT_TEST */
  
     /**
      * Now that we have just located the synch point, we can simulate the whole cycle
      * in order to calculate expected duty cycle
      *
      * todo: add a comment why are we doing '2 * shape->getSize()' here?
      */
  
     helper.assertSyncPositionAndSetDutyCycle(onFindIndexCallback, triggerConfiguration,
             syncIndex, *this, shape);
  
     return syncIndex % shape.getSize();
 }

Here is the call graph for this function:

◆ getCurrentIndex()

int TriggerState::getCurrentIndex ( ) const

current trigger processing index, between zero and size

Definition at line 382 of file trigger_decoder.cpp.

                                         {
     return currentCycle.current_index;
 }

Referenced by TriggerCentral::handleShaftSignal().

Here is the caller graph for this function:

◆ getShaftSynchronized()

bool TriggerState::getShaftSynchronized ( )

Definition at line 45 of file trigger_decoder.cpp.

                                         {
     return shaft_is_synchronized;
 }

Referenced by decodeTriggerEvent(), TriggerCentral::handleShaftSignal(), hwHandleVvtCamSignal(), TriggerNoiseFilter::noiseFilter(), TriggerStateWithRunningStatistics::setLastEventTimeForInstantRpm(), and SetNextCompositeEntry().

Here is the caller graph for this function:

◆ getTotalEventCounter()

int64_t TriggerState::getTotalEventCounter ( ) const

Definition at line 212 of file trigger_decoder.cpp.

                                                  {
     return totalEventCountBase + currentCycle.current_index;
 }

Referenced by updateDevConsoleState().

Here is the caller graph for this function:

◆ getTotalRevolutionCounter()

int TriggerState::getTotalRevolutionCounter ( ) const

Definition at line 216 of file trigger_decoder.cpp.

                                                   {
     return totalRevolutionCounter;
 }

Referenced by extIonCallback(), findTriggerZeroEventIndex(), TriggerCentral::handleShaftSignal(), mainTriggerCallback(), TriggerStateWithRunningStatistics::syncEnginePhase(), triggerInfo(), and TriggerCentral::validateCamVvtCounters().

Here is the caller graph for this function:

◆ incrementTotalEventCounter()

void TriggerState::incrementTotalEventCounter ( )

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

Definition at line 420 of file trigger_decoder.cpp.

                                               {
     totalRevolutionCounter++;
 }

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

Here is the caller graph for this function:

◆ isSyncPoint()

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

private

Definition at line 711 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 == TT_MIATA_VVT) {
         auto secondGap = (float)toothDurations[1] / toothDurations[2];
  
         bool currentGapOk = isInRange(triggerShape.syncronizationRatioFrom[0], (float)triggerSyncGapRatio, triggerShape.syncronizationRatioTo[0]);
         bool secondGapOk  = isInRange(triggerShape.syncronizationRatioFrom[1], secondGap,  triggerShape.syncronizationRatioTo[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.syncronizationRatioFrom[i];
         auto to = triggerShape.syncronizationRatioTo[i];
  
         if (cisnan(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 TriggerState::isValidIndex ( const TriggerWaveform & triggerShape ) const

Definition at line 346 of file trigger_decoder.cpp.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ onShaftSynchronization()

void TriggerState::onShaftSynchronization	(	const TriggerStateCallback	triggerCycleCallback,
		bool	wasSynchronized,
		const efitick_t	nowNt,
		const TriggerWaveform &	triggerShape
	)

Definition at line 443 of file trigger_decoder.cpp.

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

Referenced by decodeTriggerEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetCurrentCycleState()

void TriggerState::resetCurrentCycleState ( )

private

Definition at line 90 of file trigger_decoder.cpp.

                                           {
     memset(currentCycle.eventCount, 0, sizeof(currentCycle.eventCount));
     memset(currentCycle.timeOfPreviousEventNt, 0, sizeof(currentCycle.timeOfPreviousEventNt));
 #if EFI_UNIT_TEST
     memcpy(currentCycle.totalTimeNtCopy, currentCycle.totalTimeNt, sizeof(currentCycle.totalTimeNt));
 #endif
     memset(currentCycle.totalTimeNt, 0, sizeof(currentCycle.totalTimeNt));
     currentCycle.current_index = 0;
 }

Referenced by onShaftSynchronization(), and resetTriggerState().

Here is the caller graph for this function:

◆ resetTriggerState()

void TriggerState::resetTriggerState ( )

virtual

Reimplemented in TriggerStateWithRunningStatistics.

Definition at line 62 of file trigger_decoder.cpp.

                                      {
     setShaftSynchronized(false);
     toothed_previous_time = 0;
  
     memset(toothDurations, 0, sizeof(toothDurations));
  
     totalRevolutionCounter = 0;
     totalTriggerErrorCounter = 0;
     orderingErrorCounter = 0;
     lastDecodingErrorTime = US2NT(-10000000LL);
     someSortOfTriggerError = false;
  
     curSignal = SHAFT_PRIMARY_FALLING;
     prevSignal = SHAFT_PRIMARY_FALLING;
     startOfCycleNt = 0;
  
     resetCurrentCycleState();
     memset(expectedTotalTime, 0, sizeof(expectedTotalTime));
  
     totalEventCountBase = 0;
     isFirstEvent = true;
 }

Referenced by findTriggerZeroEventIndex(), Engine::OnTriggerSynchronizationLost(), TriggerStateWithRunningStatistics::resetTriggerState(), and TriggerState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setShaftSynchronized()

void TriggerState::setShaftSynchronized ( bool value )

Definition at line 49 of file trigger_decoder.cpp.

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

Referenced by decodeTriggerEvent(), and resetTriggerState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setTriggerErrorState()

void TriggerState::setTriggerErrorState ( )

Definition at line 85 of file trigger_decoder.cpp.

                                         {
     lastDecodingErrorTime = getTimeNowNt();
     someSortOfTriggerError = true;
 }

Referenced by Engine::OnTriggerInvalidIndex(), and Engine::OnTriggerStateDecodingError().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validateEventCounters()

bool TriggerState::validateEventCounters ( const TriggerWaveform & triggerShape ) const

Definition at line 424 of file trigger_decoder.cpp.

                                                                                   {
     bool isDecodingError = false;
     for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) {
         isDecodingError |= (currentCycle.eventCount[i] != triggerShape.getExpectedEventCount(i));
     }
  
  
 #if EFI_UNIT_TEST
             printf("sync point: isDecodingError=%d\r\n", isDecodingError);
             if (isDecodingError) {
                 for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) {
                     printf("count: cur=%d exp=%d\r\n", currentCycle.eventCount[i],  triggerShape.getExpectedEventCount(i));
                 }
             }
 #endif /* EFI_UNIT_TEST */
  
     return isDecodingError;
 }