FOME-Tech
/
fome-fw
mirror of https://github.com/FOME-Tech/fome-fw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

const ref-ify trigger (#1856) 

* const ref-ify

* tests
This commit is contained in:
Matthew Kennedy 2020-10-05 11:22:59 -07:00 committed by GitHub
parent 540fca8cc9
commit 060cfbd778
10 changed files with 168 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
firmware/controllers/algo/engine.cpp
View File

@ -109,8 +109,8 @@ void Engine::initializeTriggerWaveform(Logging *logger DECLARE_ENGINE_PARAMETER_
* 'initState' instance of TriggerState is used only to initialize 'this' TriggerWaveform instance * 'initState' instance of TriggerState is used only to initialize 'this' TriggerWaveform instance
* #192 BUG real hardware trigger events could be coming even while we are initializing trigger * #192 BUG real hardware trigger events could be coming even while we are initializing trigger
*/ */
calculateTriggerSynchPoint(&ENGINE(triggerCentral.triggerShape), calculateTriggerSynchPoint(ENGINE(triggerCentral.triggerShape),
&initState PASS_ENGINE_PARAMETER_SUFFIX); initState PASS_ENGINE_PARAMETER_SUFFIX);
engine->engineCycleEventCount = TRIGGER_WAVEFORM(getLength()); engine->engineCycleEventCount = TRIGGER_WAVEFORM(getLength());
} }
@ -124,9 +124,9 @@ void Engine::initializeTriggerWaveform(Logging *logger DECLARE_ENGINE_PARAMETER_
engineConfiguration->ambiguousOperationMode, engineConfiguration->ambiguousOperationMode,
engine->engineConfigurationPtr->vvtCamSensorUseRise, &config); engine->engineConfigurationPtr->vvtCamSensorUseRise, &config);
ENGINE(triggerCentral).vvtShape.initializeSyncPoint(&initState, ENGINE(triggerCentral).vvtShape.initializeSyncPoint(initState,
&engine->vvtTriggerConfiguration, engine->vvtTriggerConfiguration,
&config); config);
} }
if (!alreadyLocked) { if (!alreadyLocked) {
@ -370,7 +370,7 @@ void Engine::OnTriggerSyncronization(bool wasSynchronized) {
/** /**
* We can check if things are fine by comparing the number of events in a cycle with the expected number of event. * We can check if things are fine by comparing the number of events in a cycle with the expected number of event.
*/ */
bool isDecodingError = triggerCentral.triggerState.validateEventCounters(&triggerCentral.triggerShape); bool isDecodingError = triggerCentral.triggerState.validateEventCounters(triggerCentral.triggerShape);
enginePins.triggerDecoderErrorPin.setValue(isDecodingError); enginePins.triggerDecoderErrorPin.setValue(isDecodingError);

8
firmware/controllers/trigger/decoders/trigger_structure.h
View File

@ -256,9 +256,11 @@ public:
*/ */
int triggerShapeSynchPointIndex; int triggerShapeSynchPointIndex;
void initializeSyncPoint(TriggerState *state, void initializeSyncPoint(
const TriggerConfiguration * triggerConfiguration, TriggerState& state,
trigger_config_s const*triggerConfig); const TriggerConfiguration& triggerConfiguration,
const trigger_config_s& triggerConfig
);
private: private:
trigger_shape_helper h; trigger_shape_helper h;

17
firmware/controllers/trigger/trigger_central.cpp
View File

@ -157,10 +157,10 @@ void hwHandleVvtCamSignal(trigger_value_e front, efitick_t nowNt DECLARE_ENGINE_
} }
ENGINE(triggerCentral).vvtState.decodeTriggerEvent( ENGINE(triggerCentral).vvtState.decodeTriggerEvent(
&ENGINE(triggerCentral).vvtShape, ENGINE(triggerCentral).vvtShape,
nullptr, nullptr,
nullptr, nullptr,
&engine->vvtTriggerConfiguration, engine->vvtTriggerConfiguration,
front == TV_RISE ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING, nowNt); front == TV_RISE ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING, nowNt);
@ -292,8 +292,7 @@ void hwHandleShaftSignal(trigger_event_e signal, efitick_t timestamp) {
// for effective noise filtering, we need both signal edges, // for effective noise filtering, we need both signal edges,
// so we pass them to handleShaftSignal() and defer this test // so we pass them to handleShaftSignal() and defer this test
if (!CONFIG(useNoiselessTriggerDecoder)) { if (!CONFIG(useNoiselessTriggerDecoder)) {
const TriggerConfiguration * triggerConfiguration = &ENGINE(primaryTriggerConfiguration); if (!isUsefulSignal(signal, ENGINE(primaryTriggerConfiguration))) {
if (!isUsefulSignal(signal, triggerConfiguration)) {
/** /**
* no need to process VR falls further * no need to process VR falls further
*/ */
@ -434,9 +433,7 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal, efitick_t timesta
if (!noiseFilter.noiseFilter(timestamp, &triggerState, signal PASS_ENGINE_PARAMETER_SUFFIX)) { if (!noiseFilter.noiseFilter(timestamp, &triggerState, signal PASS_ENGINE_PARAMETER_SUFFIX)) {
return; return;
} }
const TriggerConfiguration* triggerConfiguration = &ENGINE(primaryTriggerConfiguration); if (!isUsefulSignal(signal, ENGINE(primaryTriggerConfiguration))) {
if (!isUsefulSignal(signal, triggerConfiguration)) {
return; return;
} }
} }
@ -451,10 +448,10 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal, efitick_t timesta
/** /**
* This invocation changes the state of triggerState * This invocation changes the state of triggerState
*/ */
triggerState.decodeTriggerEvent(&triggerShape, triggerState.decodeTriggerEvent(triggerShape,
nullptr, nullptr,
engine, engine,
&engine->primaryTriggerConfiguration, engine->primaryTriggerConfiguration,
signal, timestamp); signal, timestamp);
/** /**
@ -483,7 +480,7 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal, efitick_t timesta
return; return;
} }
if (triggerState.isValidIndex(&ENGINE(triggerCentral.triggerShape))) { if (triggerState.isValidIndex(ENGINE(triggerCentral.triggerShape))) {
ScopePerf perf(PE::ShaftPositionListeners); ScopePerf perf(PE::ShaftPositionListeners);
#if TRIGGER_EXTREME_LOGGING #if TRIGGER_EXTREME_LOGGING

116
firmware/controllers/trigger/trigger_decoder.cpp
View File

@ -114,38 +114,41 @@ float actualSynchGap;
static Logging * logger = nullptr; static Logging * logger = nullptr;
void TriggerWaveform::initializeSyncPoint(TriggerState *state, void TriggerWaveform::initializeSyncPoint(TriggerState& state,
const TriggerConfiguration * triggerConfiguration, const TriggerConfiguration& triggerConfiguration,
trigger_config_s const*triggerConfig) { const trigger_config_s& triggerConfig) {
triggerShapeSynchPointIndex = state->findTriggerZeroEventIndex(this, triggerShapeSynchPointIndex = state.findTriggerZeroEventIndex(*this,
triggerConfiguration, triggerConfig); triggerConfiguration, triggerConfig);
} }
/** /**
* Calculate 'shape.triggerShapeSynchPointIndex' value using 'TriggerState *state' * Calculate 'shape.triggerShapeSynchPointIndex' value using 'TriggerState *state'
*/ */
void calculateTriggerSynchPoint(TriggerWaveform *shape, void calculateTriggerSynchPoint(
TriggerState *state DECLARE_ENGINE_PARAMETER_SUFFIX) { TriggerWaveform& shape,
state->resetTriggerState(); TriggerState& state
DECLARE_ENGINE_PARAMETER_SUFFIX) {
state.resetTriggerState();
#if EFI_PROD_CODE #if EFI_PROD_CODE
efiAssertVoid(CUSTOM_TRIGGER_STACK, getCurrentRemainingStack() > EXPECTED_REMAINING_STACK, "calc s"); efiAssertVoid(CUSTOM_TRIGGER_STACK, getCurrentRemainingStack() > EXPECTED_REMAINING_STACK, "calc s");
#endif #endif
trigger_config_s const*triggerConfig = &engineConfiguration->trigger;
engine->triggerErrorDetection.clear(); engine->triggerErrorDetection.clear();
shape->initializeSyncPoint(state, shape.initializeSyncPoint(state,
&engine->primaryTriggerConfiguration, engine->primaryTriggerConfiguration,
triggerConfig); CONFIG(trigger));
int length = shape->getLength(); int length = shape.getLength();
engine->engineCycleEventCount = length; engine->engineCycleEventCount = length;
efiAssertVoid(CUSTOM_SHAPE_LEN_ZERO, length > 0, "shapeLength=0"); efiAssertVoid(CUSTOM_SHAPE_LEN_ZERO, length > 0, "shapeLength=0");
if (length >= PWM_PHASE_MAX_COUNT) { if (length >= PWM_PHASE_MAX_COUNT) {
firmwareError(CUSTOM_ERR_TRIGGER_WAVEFORM_TOO_LONG, "Trigger length above maximum: %d", length); firmwareError(CUSTOM_ERR_TRIGGER_WAVEFORM_TOO_LONG, "Trigger length above maximum: %d", length);
shape->setShapeDefinitionError(true); shape.setShapeDefinitionError(true);
return; return;
} }
if (shape->getSize() == 0) {
if (shape.getSize() == 0) {
firmwareError(CUSTOM_ERR_TRIGGER_ZERO, "triggerShape size is zero"); firmwareError(CUSTOM_ERR_TRIGGER_ZERO, "triggerShape size is zero");
} }
} }
@ -286,8 +289,8 @@ void TriggerStateWithRunningStatistics::runtimeStatistics(TriggerFormDetails *tr
} }
} }
bool TriggerState::isValidIndex(const TriggerWaveform *triggerShape) const { bool TriggerState::isValidIndex(const TriggerWaveform& triggerShape) const {
return currentCycle.current_index < triggerShape->getSize(); return currentCycle.current_index < triggerShape.getSize();
} }
static trigger_wheel_e eventIndex[6] = { T_PRIMARY, T_PRIMARY, T_SECONDARY, T_SECONDARY, T_CHANNEL_3, T_CHANNEL_3 }; static trigger_wheel_e eventIndex[6] = { T_PRIMARY, T_PRIMARY, T_SECONDARY, T_SECONDARY, T_CHANNEL_3, T_CHANNEL_3 };
@ -315,15 +318,15 @@ static trigger_value_e eventType[6] = { TV_FALL, TV_RISE, TV_FALL, TV_RISE, TV_F
/* odd event - start accumulation */ \ /* odd event - start accumulation */ \
currentCycle.timeOfPreviousEventNt[triggerWheel] = nowNt; \ currentCycle.timeOfPreviousEventNt[triggerWheel] = nowNt; \
} \ } \
if (triggerConfiguration->isUseOnlyRisingEdgeForTrigger()) {currentCycle.current_index++;} \ if (triggerConfiguration.isUseOnlyRisingEdgeForTrigger()) {currentCycle.current_index++;} \
currentCycle.current_index++; \ currentCycle.current_index++; \
PRINT_INC_INDEX; \ PRINT_INC_INDEX; \
} }
#define considerEventForGap() (!triggerShape->useOnlyPrimaryForSync || isPrimary) #define considerEventForGap() (!triggerShape.useOnlyPrimaryForSync || isPrimary)
#define needToSkipFall(type) ((!triggerShape->gapBothDirections) && (( triggerShape->useRiseEdge) && (type != TV_RISE))) #define needToSkipFall(type) ((!triggerShape.gapBothDirections) && (( triggerShape.useRiseEdge) && (type != TV_RISE)))
#define needToSkipRise(type) ((!triggerShape->gapBothDirections) && ((!triggerShape->useRiseEdge) && (type != TV_FALL))) #define needToSkipRise(type) ((!triggerShape.gapBothDirections) && ((!triggerShape.useRiseEdge) && (type != TV_FALL)))
int TriggerState::getCurrentIndex() const { int TriggerState::getCurrentIndex() const {
return currentCycle.current_index; return currentCycle.current_index;
@ -348,10 +351,10 @@ bool TriggerState::isEvenRevolution() const {
return totalRevolutionCounter & 1; return totalRevolutionCounter & 1;
} }
bool TriggerState::validateEventCounters(TriggerWaveform *triggerShape) const { bool TriggerState::validateEventCounters(const TriggerWaveform& triggerShape) const {
bool isDecodingError = false; bool isDecodingError = false;
for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) { for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) {
isDecodingError |= (currentCycle.eventCount[i] != triggerShape->expectedEventCount[i]); isDecodingError |= (currentCycle.eventCount[i] != triggerShape.expectedEventCount[i]);
} }
@ -359,7 +362,7 @@ bool TriggerState::validateEventCounters(TriggerWaveform *triggerShape) const {
printf("sync point: isDecodingError=%d\r\n", isDecodingError); printf("sync point: isDecodingError=%d\r\n", isDecodingError);
if (isDecodingError) { if (isDecodingError) {
for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) { for (int i = 0;i < PWM_PHASE_MAX_WAVE_PER_PWM;i++) {
printf("count: cur=%d exp=%d\r\n", currentCycle.eventCount[i], triggerShape->expectedEventCount[i]); printf("count: cur=%d exp=%d\r\n", currentCycle.eventCount[i], triggerShape.expectedEventCount[i]);
} }
} }
#endif /* EFI_UNIT_TEST */ #endif /* EFI_UNIT_TEST */
@ -370,7 +373,7 @@ bool TriggerState::validateEventCounters(TriggerWaveform *triggerShape) const {
void TriggerState::onShaftSynchronization( void TriggerState::onShaftSynchronization(
const TriggerStateCallback triggerCycleCallback, const TriggerStateCallback triggerCycleCallback,
const efitick_t nowNt, const efitick_t nowNt,
const TriggerWaveform *triggerShape) { const TriggerWaveform& triggerShape) {
if (triggerCycleCallback) { if (triggerCycleCallback) {
@ -380,7 +383,7 @@ void TriggerState::onShaftSynchronization(
startOfCycleNt = nowNt; startOfCycleNt = nowNt;
resetCurrentCycleState(); resetCurrentCycleState();
incrementTotalEventCounter(); incrementTotalEventCounter();
totalEventCountBase += triggerShape->getSize(); totalEventCountBase += triggerShape.getSize();
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
if (printTriggerDebug) { if (printTriggerDebug) {
@ -400,10 +403,10 @@ void TriggerState::onShaftSynchronization(
* @param nowNt current time * @param nowNt current time
*/ */
void TriggerState::decodeTriggerEvent( void TriggerState::decodeTriggerEvent(
const TriggerWaveform* const triggerShape, const TriggerWaveform& triggerShape,
const TriggerStateCallback triggerCycleCallback, const TriggerStateCallback triggerCycleCallback,
TriggerStateListener* triggerStateListener, TriggerStateListener* triggerStateListener,
const TriggerConfiguration* const triggerConfiguration, const TriggerConfiguration& triggerConfiguration,
const trigger_event_e signal, const trigger_event_e signal,
const efitick_t nowNt) { const efitick_t nowNt) {
ScopePerf perf(PE::DecodeTriggerEvent); ScopePerf perf(PE::DecodeTriggerEvent);
@ -421,7 +424,7 @@ void TriggerState::decodeTriggerEvent(
previousShaftEventTimeNt = nowNt; previousShaftEventTimeNt = nowNt;
bool useOnlyRisingEdgeForTrigger = triggerConfiguration->isUseOnlyRisingEdgeForTrigger(); bool useOnlyRisingEdgeForTrigger = triggerConfiguration.isUseOnlyRisingEdgeForTrigger();
efiAssertVoid(CUSTOM_TRIGGER_UNEXPECTED, signal <= SHAFT_3RD_RISING, "unexpected signal"); efiAssertVoid(CUSTOM_TRIGGER_UNEXPECTED, signal <= SHAFT_3RD_RISING, "unexpected signal");
@ -455,7 +458,7 @@ void TriggerState::decodeTriggerEvent(
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
if (printTriggerTrace) { if (printTriggerTrace) {
printf("%s isLessImportant %s now=%d index=%d\r\n", printf("%s isLessImportant %s now=%d index=%d\r\n",
getTrigger_type_e(triggerConfiguration->getType()), getTrigger_type_e(triggerConfiguration.getType()),
getTrigger_event_e(signal), getTrigger_event_e(signal),
(int)nowNt, (int)nowNt,
currentCycle.current_index); currentCycle.current_index);
@ -471,7 +474,7 @@ void TriggerState::decodeTriggerEvent(
#if !EFI_PROD_CODE #if !EFI_PROD_CODE
if (printTriggerTrace) { if (printTriggerTrace) {
printf("%s event %s %d\r\n", printf("%s event %s %d\r\n",
getTrigger_type_e(triggerConfiguration->getType()), getTrigger_type_e(triggerConfiguration.getType()),
getTrigger_event_e(signal), getTrigger_event_e(signal),
nowNt); nowNt);
printf("decodeTriggerEvent ratio %.2f: current=%d previous=%d\r\n", 1.0 * toothDurations[0] / toothDurations[1], printf("decodeTriggerEvent ratio %.2f: current=%d previous=%d\r\n", 1.0 * toothDurations[0] / toothDurations[1],
@ -509,7 +512,7 @@ void TriggerState::decodeTriggerEvent(
DISPLAY(DISPLAY_FIELD(vvtEventFallCounter)); DISPLAY(DISPLAY_FIELD(vvtEventFallCounter));
DISPLAY(DISPLAY_FIELD(vvtCamCounter)); DISPLAY(DISPLAY_FIELD(vvtCamCounter));
if (triggerShape->isSynchronizationNeeded) { if (triggerShape.isSynchronizationNeeded) {
currentGap = 1.0 * toothDurations[0] / toothDurations[1]; currentGap = 1.0 * toothDurations[0] / toothDurations[1];
if (CONFIG(debugMode) == DBG_TRIGGER_COUNTERS) { if (CONFIG(debugMode) == DBG_TRIGGER_COUNTERS) {
@ -520,9 +523,9 @@ void TriggerState::decodeTriggerEvent(
} }
bool isSync = true; bool isSync = true;
for (int i = 0; i < triggerShape->gapTrackingLength; i++) { for (int i = 0; i < triggerShape.gapTrackingLength; i++) {
bool isGapCondition = cisnan(triggerShape->syncronizationRatioFrom[i]) || (toothDurations[i] > toothDurations[i + 1] * triggerShape->syncronizationRatioFrom[i] bool isGapCondition = cisnan(triggerShape.syncronizationRatioFrom[i]) || (toothDurations[i] > toothDurations[i + 1] * triggerShape.syncronizationRatioFrom[i]
&& toothDurations[i] < toothDurations[i + 1] * triggerShape->syncronizationRatioTo[i]); && toothDurations[i] < toothDurations[i + 1] * triggerShape.syncronizationRatioTo[i]);
isSync &= isGapCondition; isSync &= isGapCondition;
} }
@ -535,18 +538,18 @@ void TriggerState::decodeTriggerEvent(
/** /**
* todo: technically we can afford detailed logging even with 60/2 as long as low RPM * 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? * 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? * Open question what is 'triggerShape.getSize()' for 60/2 is it 58 or 58*2 or 58*4?
*/ */
bool silentTriggerError = triggerShape->getSize() > 40 && CONFIG(silentTriggerError); bool silentTriggerError = triggerShape.getSize() > 40 && CONFIG(silentTriggerError);
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
actualSynchGap = 1.0 * toothDurations[0] / toothDurations[1]; actualSynchGap = 1.0 * toothDurations[0] / toothDurations[1];
#endif /* EFI_UNIT_TEST */ #endif /* EFI_UNIT_TEST */
#if EFI_PROD_CODE || EFI_SIMULATOR #if EFI_PROD_CODE || EFI_SIMULATOR
if (triggerConfiguration->isVerboseTriggerSynchDetails() || (someSortOfTriggerError && !silentTriggerError)) { if (triggerConfiguration.isVerboseTriggerSynchDetails() || (someSortOfTriggerError && !silentTriggerError)) {
for (int i = 0;i<triggerShape->gapTrackingLength;i++) { for (int i = 0;i<triggerShape.gapTrackingLength;i++) {
float ratioFrom = triggerShape->syncronizationRatioFrom[i]; float ratioFrom = triggerShape.syncronizationRatioFrom[i];
if (cisnan(ratioFrom)) { if (cisnan(ratioFrom)) {
// we do not track gap at this depth // we do not track gap at this depth
continue; continue;
@ -558,13 +561,13 @@ void TriggerState::decodeTriggerEvent(
i); i);
} else { } else {
scheduleMsg(logger, "%s rpm=%d time=%d index=%d: gap=%.3f expected from %.3f to %.3f error=%s", scheduleMsg(logger, "%s rpm=%d time=%d index=%d: gap=%.3f expected from %.3f to %.3f error=%s",
triggerConfiguration->getPrintPrefix(), triggerConfiguration.getPrintPrefix(),
GET_RPM(), GET_RPM(),
/* cast is needed to make sure we do not put 64 bit value to stack*/ (int)getTimeNowSeconds(), /* cast is needed to make sure we do not put 64 bit value to stack*/ (int)getTimeNowSeconds(),
i, i,
gap, gap,
ratioFrom, ratioFrom,
triggerShape->syncronizationRatioTo[i], triggerShape.syncronizationRatioTo[i],
boolToString(someSortOfTriggerError)); boolToString(someSortOfTriggerError));
} }
} }
@ -572,13 +575,13 @@ void TriggerState::decodeTriggerEvent(
#else #else
if (printTriggerTrace) { if (printTriggerTrace) {
float gap = 1.0 * toothDurations[0] / toothDurations[1]; float gap = 1.0 * toothDurations[0] / toothDurations[1];
for (int i = 0;i<triggerShape->gapTrackingLength;i++) { for (int i = 0;i<triggerShape.gapTrackingLength;i++) {
float gap = 1.0 * toothDurations[i] / toothDurations[i + 1]; float gap = 1.0 * toothDurations[i] / toothDurations[i + 1];
print("index=%d: gap=%.2f expected from %.2f to %.2f error=%s\r\n", print("index=%d: gap=%.2f expected from %.2f to %.2f error=%s\r\n",
i, i,
gap, gap,
triggerShape->syncronizationRatioFrom[i], triggerShape.syncronizationRatioFrom[i],
triggerShape->syncronizationRatioTo[i], triggerShape.syncronizationRatioTo[i],
boolToString(someSortOfTriggerError)); boolToString(someSortOfTriggerError));
} }
} }
@ -591,7 +594,7 @@ void TriggerState::decodeTriggerEvent(
* in case of noise the counter could be above the expected number of events, that's why 'more or equals' and not just 'equals' * 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->isUseOnlyRisingEdgeForTrigger() ? 2 : 1); unsigned int endOfCycleIndex = triggerShape.getSize() - (triggerConfiguration.isUseOnlyRisingEdgeForTrigger() ? 2 : 1);
isSynchronizationPoint = !shaft_is_synchronized || (currentCycle.current_index >= endOfCycleIndex); isSynchronizationPoint = !shaft_is_synchronized || (currentCycle.current_index >= endOfCycleIndex);
@ -601,14 +604,14 @@ void TriggerState::decodeTriggerEvent(
shaft_is_synchronized, shaft_is_synchronized,
isSynchronizationPoint, isSynchronizationPoint,
currentCycle.current_index, currentCycle.current_index,
triggerShape->getSize()); triggerShape.getSize());
} }
#endif /* EFI_UNIT_TEST */ #endif /* EFI_UNIT_TEST */
} }
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
if (printTriggerTrace) { if (printTriggerTrace) {
printf("decodeTriggerEvent %s isSynchronizationPoint=%d index=%d %s\r\n", printf("decodeTriggerEvent %s isSynchronizationPoint=%d index=%d %s\r\n",
getTrigger_type_e(triggerConfiguration->getType()), getTrigger_type_e(triggerConfiguration.getType()),
isSynchronizationPoint, currentCycle.current_index, isSynchronizationPoint, currentCycle.current_index,
getTrigger_event_e(signal)); getTrigger_event_e(signal));
} }
@ -631,7 +634,7 @@ void TriggerState::decodeTriggerEvent(
; ;
} }
for (int i = triggerShape->gapTrackingLength; i > 0; i--) { for (int i = triggerShape.gapTrackingLength; i > 0; i--) {
toothDurations[i] = toothDurations[i - 1]; toothDurations[i] = toothDurations[i - 1];
} }
@ -667,9 +670,10 @@ static void onFindIndexCallback(TriggerState *state) {
* *
* This function finds the index of synchronization event within TriggerWaveform * This function finds the index of synchronization event within TriggerWaveform
*/ */
uint32_t TriggerState::findTriggerZeroEventIndex(TriggerWaveform * shape, uint32_t TriggerState::findTriggerZeroEventIndex(
const TriggerConfiguration * triggerConfiguration, TriggerWaveform& shape,
trigger_config_s const*triggerConfig) { const TriggerConfiguration& triggerConfiguration,
const trigger_config_s& triggerConfig) {
UNUSED(triggerConfig); UNUSED(triggerConfig);
#if EFI_PROD_CODE #if EFI_PROD_CODE
efiAssert(CUSTOM_ERR_ASSERT, getCurrentRemainingStack() > 128, "findPos", -1); efiAssert(CUSTOM_ERR_ASSERT, getCurrentRemainingStack() > 128, "findPos", -1);
@ -678,7 +682,7 @@ uint32_t TriggerState::findTriggerZeroEventIndex(TriggerWaveform * shape,
resetTriggerState(); resetTriggerState();
if (shape->shapeDefinitionError) { if (shape.shapeDefinitionError) {
return 0; return 0;
} }
@ -688,7 +692,7 @@ uint32_t TriggerState::findTriggerZeroEventIndex(TriggerWaveform * shape,
uint32_t syncIndex = helper.findTriggerSyncPoint(shape, uint32_t syncIndex = helper.findTriggerSyncPoint(shape,
triggerConfiguration, triggerConfiguration,
this); *this);
if (syncIndex == EFI_ERROR_CODE) { if (syncIndex == EFI_ERROR_CODE) {
return syncIndex; return syncIndex;
} }
@ -708,9 +712,9 @@ uint32_t TriggerState::findTriggerZeroEventIndex(TriggerWaveform * shape,
*/ */
helper.assertSyncPositionAndSetDutyCycle(onFindIndexCallback, triggerConfiguration, helper.assertSyncPositionAndSetDutyCycle(onFindIndexCallback, triggerConfiguration,
syncIndex, this, shape); syncIndex, *this, shape);
return syncIndex % shape->getSize(); return syncIndex % shape.getSize();
} }
void initTriggerDecoderLogger(Logging *sharedLogger) { void initTriggerDecoderLogger(Logging *sharedLogger) {

25
firmware/controllers/trigger/trigger_decoder.h
View File

@ -81,20 +81,20 @@ public:
efitime_t getTotalEventCounter() const; efitime_t getTotalEventCounter() const;
void decodeTriggerEvent( void decodeTriggerEvent(
const TriggerWaveform *triggerShape, const TriggerWaveform& triggerShape,
const TriggerStateCallback triggerCycleCallback, const TriggerStateCallback triggerCycleCallback,
TriggerStateListener * triggerStateListener, TriggerStateListener* triggerStateListener,
const TriggerConfiguration * triggerConfiguration, const TriggerConfiguration& triggerConfiguration,
const trigger_event_e signal, const trigger_event_e signal,
const efitime_t nowUs); const efitime_t nowUs);
bool validateEventCounters(TriggerWaveform *triggerShape) const; bool validateEventCounters(const TriggerWaveform& triggerShape) const;
void onShaftSynchronization( void onShaftSynchronization(
const TriggerStateCallback triggerCycleCallback, const TriggerStateCallback triggerCycleCallback,
const efitick_t nowNt, const efitick_t nowNt,
const TriggerWaveform *triggerShape); const TriggerWaveform& triggerShape);
bool isValidIndex(const TriggerWaveform *triggerShape) const; bool isValidIndex(const TriggerWaveform& triggerShape) const;
/** /**
* TRUE if we know where we are * TRUE if we know where we are
@ -135,9 +135,10 @@ public:
*/ */
efitick_t startOfCycleNt; efitick_t startOfCycleNt;
uint32_t findTriggerZeroEventIndex(TriggerWaveform * shape, uint32_t findTriggerZeroEventIndex(
const TriggerConfiguration * triggerConfiguration, TriggerWaveform& shape,
trigger_config_s const*triggerConfig const TriggerConfiguration& triggerConfiguration,
const trigger_config_s& triggerConfig
); );
private: private:
@ -195,7 +196,9 @@ class Engine;
void initTriggerDecoderLogger(Logging *sharedLogger); void initTriggerDecoderLogger(Logging *sharedLogger);
void calculateTriggerSynchPoint(TriggerWaveform *shape, void calculateTriggerSynchPoint(
TriggerState *state DECLARE_ENGINE_PARAMETER_SUFFIX); TriggerWaveform& shape,
TriggerState& state
DECLARE_ENGINE_PARAMETER_SUFFIX);
void prepareEventAngles(TriggerWaveform *shape, TriggerFormDetails *details DECLARE_ENGINE_PARAMETER_SUFFIX); void prepareEventAngles(TriggerWaveform *shape, TriggerFormDetails *details DECLARE_ENGINE_PARAMETER_SUFFIX);

9
firmware/controllers/trigger/trigger_emulator_algo.cpp
View File

@ -21,10 +21,11 @@ int getPreviousIndex(const int currentIndex, const int size) {
return (currentIndex + size - 1) % size; return (currentIndex + size - 1) % size;
} }
bool needEvent(const int currentIndex, const int size, MultiChannelStateSequence *multiChannelStateSequence, int channelIndex) { bool needEvent(const int currentIndex, const int size, const MultiChannelStateSequence& mcss, int channelIndex) {
int prevIndex = getPreviousIndex(currentIndex, size); int prevIndex = getPreviousIndex(currentIndex, size);
pin_state_t previousValue = multiChannelStateSequence->getChannelState(channelIndex, /*phaseIndex*/prevIndex); pin_state_t previousValue = mcss.getChannelState(channelIndex, /*phaseIndex*/prevIndex);
pin_state_t currentValue = multiChannelStateSequence->getChannelState(channelIndex, /*phaseIndex*/currentIndex); pin_state_t currentValue = mcss.getChannelState(channelIndex, /*phaseIndex*/currentIndex);
return previousValue != currentValue; return previousValue != currentValue;
} }
@ -53,7 +54,7 @@ void TriggerEmulatorHelper::handleEmulatorCallback(PwmConfig *state, int stateIn
for (size_t i = 0; i < efi::size(emulatorOutputs); i++) for (size_t i = 0; i < efi::size(emulatorOutputs); i++)
{ {
if (needEvent(stateIndex, state->phaseCount, &state->multiChannelStateSequence, i)) { if (needEvent(stateIndex, state->phaseCount, state->multiChannelStateSequence, i)) {
pin_state_t currentValue = multiChannelStateSequence->getChannelState(/*phaseIndex*/i, stateIndex); pin_state_t currentValue = multiChannelStateSequence->getChannelState(/*phaseIndex*/i, stateIndex);
constexpr trigger_event_e riseEvents[] = { SHAFT_PRIMARY_RISING, SHAFT_SECONDARY_RISING, SHAFT_3RD_RISING }; constexpr trigger_event_e riseEvents[] = { SHAFT_PRIMARY_RISING, SHAFT_SECONDARY_RISING, SHAFT_3RD_RISING };

2
firmware/controllers/trigger/trigger_emulator_algo.h
View File

@ -27,5 +27,5 @@ public:
void initTriggerEmulatorLogic(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX); void initTriggerEmulatorLogic(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX);
int getPreviousIndex(const int currentIndex, const int size); int getPreviousIndex(const int currentIndex, const int size);
bool needEvent(const int currentIndex, const int size, MultiChannelStateSequence *multiChannelStateSequence, int channelIndex); bool needEvent(const int currentIndex, const int size, const MultiChannelStateSequence& mcss, int channelIndex);

79
firmware/controllers/trigger/trigger_simulator.cpp
View File

@ -21,36 +21,39 @@ static const bool isRisingEdge[HW_EVENT_TYPES] = { false, true, false, true, fal
* todo: should this method be invoked somewhere deeper? at the moment we have too many usages too high * todo: should this method be invoked somewhere deeper? at the moment we have too many usages too high
* @return true if front should be decoded further, false if we are not interested * @return true if front should be decoded further, false if we are not interested
*/ */
bool isUsefulSignal(trigger_event_e signal, const TriggerConfiguration * triggerConfiguration) { bool isUsefulSignal(trigger_event_e signal, const TriggerConfiguration& triggerConfiguration) {
return !triggerConfiguration->isUseOnlyRisingEdgeForTrigger() || isRisingEdge[(int) signal]; return !triggerConfiguration.isUseOnlyRisingEdgeForTrigger() || isRisingEdge[(int) signal];
} }
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
extern bool printTriggerDebug; extern bool printTriggerDebug;
#endif /* ! EFI_UNIT_TEST */ #endif /* ! EFI_UNIT_TEST */
void TriggerStimulatorHelper::feedSimulatedEvent(const TriggerStateCallback triggerCycleCallback, void TriggerStimulatorHelper::feedSimulatedEvent(
const TriggerConfiguration * triggerConfiguration, const TriggerStateCallback triggerCycleCallback,
TriggerState *state, TriggerWaveform * shape, int i const TriggerConfiguration& triggerConfiguration,
TriggerState& state,
const TriggerWaveform& shape,
int i
) { ) {
efiAssertVoid(CUSTOM_ERR_6593, shape->getSize() > 0, "size not zero"); efiAssertVoid(CUSTOM_ERR_6593, shape.getSize() > 0, "size not zero");
int stateIndex = i % shape->getSize(); int stateIndex = i % shape.getSize();
int size = shape->getSize(); int size = shape.getSize();
int loopIndex = i / shape->getSize(); int loopIndex = i / shape.getSize();
int time = (int) (SIMULATION_CYCLE_PERIOD * (loopIndex + shape->wave.getSwitchTime(stateIndex))); int time = (int) (SIMULATION_CYCLE_PERIOD * (loopIndex + shape.wave.getSwitchTime(stateIndex)));
MultiChannelStateSequence *multiChannelStateSequence = &shape->wave; const MultiChannelStateSequence& multiChannelStateSequence = shape.wave;
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
int prevIndex = getPreviousIndex(stateIndex, shape->getSize()); int prevIndex = getPreviousIndex(stateIndex, shape.getSize());
pin_state_t primaryWheelState = multiChannelStateSequence->getChannelState(0, prevIndex); pin_state_t primaryWheelState = multiChannelStateSequence.getChannelState(0, prevIndex);
pin_state_t newPrimaryWheelState = multiChannelStateSequence->getChannelState(0, stateIndex); pin_state_t newPrimaryWheelState = multiChannelStateSequence.getChannelState(0, stateIndex);
pin_state_t secondaryWheelState = multiChannelStateSequence->getChannelState(1, prevIndex); pin_state_t secondaryWheelState = multiChannelStateSequence.getChannelState(1, prevIndex);
pin_state_t newSecondaryWheelState = multiChannelStateSequence->getChannelState(1, stateIndex); pin_state_t newSecondaryWheelState = multiChannelStateSequence.getChannelState(1, stateIndex);
// pin_state_t thirdWheelState = multiChannelStateSequence->getChannelState(2, prevIndex); // pin_state_t thirdWheelState = multiChannelStateSequence->getChannelState(2, prevIndex);
// pin_state_t new3rdWheelState = multiChannelStateSequence->getChannelState(2, stateIndex); // pin_state_t new3rdWheelState = multiChannelStateSequence->getChannelState(2, stateIndex);
@ -65,10 +68,10 @@ void TriggerStimulatorHelper::feedSimulatedEvent(const TriggerStateCallback trig
// todo: code duplication with TriggerEmulatorHelper::handleEmulatorCallback? // todo: code duplication with TriggerEmulatorHelper::handleEmulatorCallback?
if (needEvent(stateIndex, size, multiChannelStateSequence, 0)) { if (needEvent(stateIndex, size, multiChannelStateSequence, 0)) {
pin_state_t currentValue = multiChannelStateSequence->getChannelState(/*phaseIndex*/0, stateIndex); pin_state_t currentValue = multiChannelStateSequence.getChannelState(/*phaseIndex*/0, stateIndex);
trigger_event_e event = currentValue ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING; trigger_event_e event = currentValue ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING;
if (isUsefulSignal(event, triggerConfiguration)) { if (isUsefulSignal(event, triggerConfiguration)) {
state->decodeTriggerEvent(shape, state.decodeTriggerEvent(shape,
triggerCycleCallback, triggerCycleCallback,
/* override */ nullptr, /* override */ nullptr,
triggerConfiguration, triggerConfiguration,
@ -77,10 +80,10 @@ void TriggerStimulatorHelper::feedSimulatedEvent(const TriggerStateCallback trig
} }
if (needEvent(stateIndex, size, multiChannelStateSequence, 1)) { if (needEvent(stateIndex, size, multiChannelStateSequence, 1)) {
pin_state_t currentValue = multiChannelStateSequence->getChannelState(/*phaseIndex*/1, stateIndex); pin_state_t currentValue = multiChannelStateSequence.getChannelState(/*phaseIndex*/1, stateIndex);
trigger_event_e event = currentValue ? SHAFT_SECONDARY_RISING : SHAFT_SECONDARY_FALLING; trigger_event_e event = currentValue ? SHAFT_SECONDARY_RISING : SHAFT_SECONDARY_FALLING;
if (isUsefulSignal(event, triggerConfiguration)) { if (isUsefulSignal(event, triggerConfiguration)) {
state->decodeTriggerEvent(shape, state.decodeTriggerEvent(shape,
triggerCycleCallback, triggerCycleCallback,
/* override */ nullptr, /* override */ nullptr,
triggerConfiguration, triggerConfiguration,
@ -89,10 +92,10 @@ void TriggerStimulatorHelper::feedSimulatedEvent(const TriggerStateCallback trig
} }
if (needEvent(stateIndex, size, multiChannelStateSequence, 2)) { if (needEvent(stateIndex, size, multiChannelStateSequence, 2)) {
pin_state_t currentValue = multiChannelStateSequence->getChannelState(/*phaseIndex*/2, stateIndex); pin_state_t currentValue = multiChannelStateSequence.getChannelState(/*phaseIndex*/2, stateIndex);
trigger_event_e event = currentValue ? SHAFT_3RD_RISING : SHAFT_3RD_FALLING; trigger_event_e event = currentValue ? SHAFT_3RD_RISING : SHAFT_3RD_FALLING;
if (isUsefulSignal(event, triggerConfiguration)) { if (isUsefulSignal(event, triggerConfiguration)) {
state->decodeTriggerEvent(shape, state.decodeTriggerEvent(shape,
triggerCycleCallback, triggerCycleCallback,
/* override */ nullptr, /* override */ nullptr,
triggerConfiguration, triggerConfiguration,
@ -101,48 +104,52 @@ void TriggerStimulatorHelper::feedSimulatedEvent(const TriggerStateCallback trig
} }
} }
void TriggerStimulatorHelper::assertSyncPositionAndSetDutyCycle(const TriggerStateCallback triggerCycleCallback, void TriggerStimulatorHelper::assertSyncPositionAndSetDutyCycle(
const TriggerConfiguration * triggerConfiguration, const TriggerStateCallback triggerCycleCallback,
const uint32_t syncIndex, TriggerState *state, TriggerWaveform * shape const TriggerConfiguration& triggerConfiguration,
const uint32_t syncIndex,
TriggerState& state,
TriggerWaveform& shape
) { ) {
/** /**
* let's feed two more cycles to validate shape definition * let's feed two more cycles to validate shape definition
*/ */
for (uint32_t i = syncIndex + 1; i <= syncIndex + GAP_TRACKING_LENGTH * shape->getSize(); i++) { for (uint32_t i = syncIndex + 1; i <= syncIndex + GAP_TRACKING_LENGTH * shape.getSize(); i++) {
feedSimulatedEvent(triggerCycleCallback, feedSimulatedEvent(triggerCycleCallback,
triggerConfiguration, triggerConfiguration,
state, shape, i); state, shape, i);
} }
int revolutionCounter = state->getTotalRevolutionCounter(); int revolutionCounter = state.getTotalRevolutionCounter();
if (revolutionCounter != GAP_TRACKING_LENGTH + 1) { if (revolutionCounter != GAP_TRACKING_LENGTH + 1) {
warning(CUSTOM_OBD_TRIGGER_WAVEFORM, "sync failed/wrong gap parameters trigger=%s rc=%d", getTrigger_type_e(triggerConfiguration->getType()), revolutionCounter); warning(CUSTOM_OBD_TRIGGER_WAVEFORM, "sync failed/wrong gap parameters trigger=%s rc=%d", getTrigger_type_e(triggerConfiguration.getType()), revolutionCounter);
shape->setShapeDefinitionError(true); shape.setShapeDefinitionError(true);
return; return;
} }
shape->shapeDefinitionError = false; shape.shapeDefinitionError = false;
for (int i = 0; i < PWM_PHASE_MAX_WAVE_PER_PWM; i++) { for (int i = 0; i < PWM_PHASE_MAX_WAVE_PER_PWM; i++) {
shape->expectedDutyCycle[i] = 1.0 * state->expectedTotalTime[i] / SIMULATION_CYCLE_PERIOD; shape.expectedDutyCycle[i] = 1.0 * state.expectedTotalTime[i] / SIMULATION_CYCLE_PERIOD;
} }
} }
/** /**
* @return trigger synchronization point index, or error code if not found * @return trigger synchronization point index, or error code if not found
*/ */
uint32_t TriggerStimulatorHelper::findTriggerSyncPoint(TriggerWaveform * shape, uint32_t TriggerStimulatorHelper::findTriggerSyncPoint(
const TriggerConfiguration * triggerConfiguration, TriggerWaveform& shape,
TriggerState *state) { const TriggerConfiguration& triggerConfiguration,
TriggerState& state) {
for (int i = 0; i < 4 * PWM_PHASE_MAX_COUNT; i++) { for (int i = 0; i < 4 * PWM_PHASE_MAX_COUNT; i++) {
feedSimulatedEvent(nullptr, feedSimulatedEvent(nullptr,
triggerConfiguration, triggerConfiguration,
state, shape, i); state, shape, i);
if (state->shaft_is_synchronized) { if (state.shaft_is_synchronized) {
return i; return i;
} }
} }
shape->setShapeDefinitionError(true); shape.setShapeDefinitionError(true);
warning(CUSTOM_ERR_TRIGGER_SYNC, "findTriggerZeroEventIndex() failed"); warning(CUSTOM_ERR_TRIGGER_SYNC, "findTriggerZeroEventIndex() failed");
return EFI_ERROR_CODE; return EFI_ERROR_CODE;
} }

25
firmware/controllers/trigger/trigger_simulator.h
View File

@ -13,21 +13,26 @@
class TriggerStimulatorHelper { class TriggerStimulatorHelper {
public: public:
uint32_t findTriggerSyncPoint(TriggerWaveform * shape, uint32_t findTriggerSyncPoint(
const TriggerConfiguration * triggerConfiguration, TriggerWaveform& shape,
TriggerState *state); const TriggerConfiguration& triggerConfiguration,
TriggerState& state);
void assertSyncPositionAndSetDutyCycle(const TriggerStateCallback triggerCycleCallback, void assertSyncPositionAndSetDutyCycle(
const TriggerConfiguration * triggerConfiguration, const TriggerStateCallback triggerCycleCallback,
const uint32_t index, TriggerState *state, TriggerWaveform * shape const TriggerConfiguration& triggerConfiguration,
const uint32_t index,
TriggerState& state,
TriggerWaveform& shape
); );
private: private:
// send next event so that we can see how state reacts // send next event so that we can see how state reacts
void feedSimulatedEvent(const TriggerStateCallback triggerCycleCallback, void feedSimulatedEvent(const TriggerStateCallback triggerCycleCallback,
const TriggerConfiguration * triggerConfiguration, const TriggerConfiguration& triggerConfiguration,
TriggerState *state, TriggerState& state,
TriggerWaveform * shape, int i); const TriggerWaveform& shape,
int i);
}; };
bool isUsefulSignal(trigger_event_e signal, const TriggerConfiguration * triggerConfiguration); bool isUsefulSignal(trigger_event_e signal, const TriggerConfiguration& triggerConfiguration);

29
unit_tests/tests/trigger/test_trigger_decoder.cpp
View File

@ -42,11 +42,11 @@ static int getTriggerZeroEventIndex(engine_type_e engineType) {
initDataStructures(PASS_ENGINE_PARAMETER_SIGNATURE); initDataStructures(PASS_ENGINE_PARAMETER_SIGNATURE);
const TriggerConfiguration * triggerConfiguration = &engine->primaryTriggerConfiguration; const auto& triggerConfiguration = engine->primaryTriggerConfiguration;
TriggerWaveform * shape = &eth.engine.triggerCentral.triggerShape; TriggerWaveform& shape = eth.engine.triggerCentral.triggerShape;
return eth.engine.triggerCentral.triggerState.findTriggerZeroEventIndex(shape, triggerConfiguration, return eth.engine.triggerCentral.triggerState.findTriggerZeroEventIndex(shape, triggerConfiguration,
&engineConfiguration->trigger); engineConfiguration->trigger);
} }
TEST(misc, testSkipped2_0) { TEST(misc, testSkipped2_0) {
@ -113,47 +113,42 @@ static void assertTriggerPosition(event_trigger_position_s *position, int eventI
} }
TEST(misc, testSomethingWeird) { TEST(misc, testSomethingWeird) {
printf("*************************************************** testSomethingWeird\r\n");
WITH_ENGINE_TEST_HELPER(FORD_INLINE_6_1995); WITH_ENGINE_TEST_HELPER(FORD_INLINE_6_1995);
TriggerState state_; TriggerState state_;
TriggerState *sta = &state_; TriggerState *sta = &state_;
const TriggerConfiguration * triggerConfiguration = &engine->primaryTriggerConfiguration; const auto& triggerConfiguration = engine->primaryTriggerConfiguration;
ASSERT_FALSE(sta->shaft_is_synchronized) << "shaft_is_synchronized"; ASSERT_FALSE(sta->shaft_is_synchronized) << "shaft_is_synchronized";
int r = 10; int r = 10;
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r);
ASSERT_FALSE(sta->shaft_is_synchronized) << "shaft_is_synchronized"; // still no synchronization ASSERT_FALSE(sta->shaft_is_synchronized) << "shaft_is_synchronized"; // still no synchronization
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, ++r); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, ++r);
ASSERT_TRUE(sta->shaft_is_synchronized); // first signal rise synchronize ASSERT_TRUE(sta->shaft_is_synchronized); // first signal rise synchronize
ASSERT_EQ(0, sta->getCurrentIndex()); ASSERT_EQ(0, sta->getCurrentIndex());
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r++); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r++);
ASSERT_EQ(1, sta->getCurrentIndex()); ASSERT_EQ(1, sta->getCurrentIndex());
for (int i = 2; i < 10;) { for (int i = 2; i < 10;) {
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, r++); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, r++);
assertEqualsM("even", i++, sta->getCurrentIndex()); assertEqualsM("even", i++, sta->getCurrentIndex());
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r++); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r++);
assertEqualsM("odd", i++, sta->getCurrentIndex()); assertEqualsM("odd", i++, sta->getCurrentIndex());
} }
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, r++); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, r++);
ASSERT_EQ(10, sta->getCurrentIndex()); ASSERT_EQ(10, sta->getCurrentIndex());
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r++); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_FALLING, r++);
ASSERT_EQ(11, sta->getCurrentIndex()); ASSERT_EQ(11, sta->getCurrentIndex());
sta->decodeTriggerEvent(&ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, r++); sta->decodeTriggerEvent(ENGINE(triggerCentral.triggerShape), nullptr, /* override */ nullptr, triggerConfiguration, SHAFT_PRIMARY_RISING, r++);
ASSERT_EQ(0, sta->getCurrentIndex()); // new revolution ASSERT_EQ(0, sta->getCurrentIndex()); // new revolution
} }
TEST(misc, test1995FordInline6TriggerDecoder) { TEST(misc, test1995FordInline6TriggerDecoder) {
printf("*************************************************** test1995FordInline6TriggerDecoder\r\n");
ASSERT_EQ( 0, getTriggerZeroEventIndex(FORD_INLINE_6_1995)) << "triggerIndex "; ASSERT_EQ( 0, getTriggerZeroEventIndex(FORD_INLINE_6_1995)) << "triggerIndex ";
WITH_ENGINE_TEST_HELPER(FORD_INLINE_6_1995); WITH_ENGINE_TEST_HELPER(FORD_INLINE_6_1995);