trigger_central.h File Reference

Data Structures
class	TriggerNoiseFilter
class	TriggerCentral

Typedefs
typedef void(*	ShaftPositionListener) (trigger_event_e signal, uint32_t index, efitick_t edgeTimestamp)

Functions
void	triggerInfo (void)
void	hwHandleShaftSignal (int signalIndex, bool isRising, efitick_t timestamp)
void	handleShaftSignal (int signalIndex, bool isRising, efitick_t timestamp)
void	hwHandleVvtCamSignal (TriggerValue front, efitick_t timestamp, int index)
void	hwHandleVvtCamSignal (bool isRising, efitick_t timestamp, int index)
void	handleVvtCamSignal (TriggerValue front, efitick_t timestamp, int index)
void	validateTriggerInputs ()
void	initTriggerCentral ()
int	isSignalDecoderError (void)
void	onConfigurationChangeTriggerCallback ()
TriggerCentral *	getTriggerCentral ()
int	getCrankDivider (operation_mode_e operationMode)
constexpr bool	isTriggerUpEvent (trigger_event_e event)

Typedef Documentation

ShaftPositionListener

typedef void(* ShaftPositionListener) (trigger_event_e signal, uint32_t index, efitick_t edgeTimestamp)

Definition at line 28 of file trigger_central.h.

Function Documentation

getCrankDivider()

int getCrankDivider

(

operation_mode_e

operationMode

)

todo: why is this method NOT reciprocal to getRpmMultiplier?!

wow even while we explicitly handle all enumerations in the switch above we still need a return statement due to https://stackoverflow.com/questions/34112483/gcc-how-best-to-handle-warning-about-unreachable-end-of-function-after-switch

Definition at line 92 of file trigger_central.cpp.

                                                    {
    switch (operationMode) {
    case FOUR_STROKE_CRANK_SENSOR:
        return 2;
    case FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR:
        return SYMMETRICAL_CRANK_SENSOR_DIVIDER;
    case FOUR_STROKE_THREE_TIMES_CRANK_SENSOR:
        return SYMMETRICAL_THREE_TIMES_CRANK_SENSOR_DIVIDER;
    case FOUR_STROKE_SIX_TIMES_CRANK_SENSOR:
        return SYMMETRICAL_SIX_TIMES_CRANK_SENSOR_DIVIDER;
    case FOUR_STROKE_TWELVE_TIMES_CRANK_SENSOR:
        return SYMMETRICAL_TWELVE_TIMES_CRANK_SENSOR_DIVIDER;
    case OM_NONE:
    case FOUR_STROKE_CAM_SENSOR:
    case TWO_STROKE:
        // That's easy - trigger cycle matches engine cycle
        return 1;
    /* let's NOT handle default in order to benefit from -Werror=switch */
    }
    /**
     wow even while we explicitly handle all enumerations in the switch above we still need a return statement due to
     https://stackoverflow.com/questions/34112483/gcc-how-best-to-handle-warning-about-unreachable-end-of-function-after-switch
     */
    criticalError("unreachable getCrankDivider");
    return 1;
}

Referenced by adjustCrankPhase(), getRpmMultiplier(), and TriggerCentral::handleShaftSignal().

Here is the caller graph for this function:

getTriggerCentral()

TriggerCentral * getTriggerCentral

(

)

Definition at line 590 of file engine.cpp.

                                     {
    return &engine->triggerCentral;
}

Referenced by WaveChart::addEvent3(), adjustCrankPhase(), TriggerDecoderBase::decodeTriggerEvent(), enableOrDisable(), TriggerCentral::findNextTriggerToothAngle(), getAcrState(), getValue(), handleShaftSignal(), TriggerCentral::handleShaftSignal(), handleVvtCamSignal(), hwHandleShaftSignal(), hwHandleVvtCamSignal(), initVvtShape(), TriggerCentral::isMapCamSync(), LogTriggerTooth(), mainTriggerCallback(), InstantRpmCalculator::movePreSynchTimestamps(), onConfigurationChangeTriggerCallback(), PrimaryTriggerDecoder::onNotEnoughTeeth(), PrimaryTriggerDecoder::onTooManyTeeth(), HpfpController::pinTurnOff(), HpfpController::pinTurnOn(), TriggerFormDetails::prepareEventAngles(), printStatus(), WaveChart::publish(), reportEventToWaveChart(), resetRunningTriggerCounters(), InstantRpmCalculator::setLastEventTimeForInstantRpm(), tdcMarkCallback(), triggerInfo(), and triggerShapeInfo().

Here is the caller graph for this function:

handleShaftSignal()

void handleShaftSignal	(	int	signalIndex,
		bool	isRising,
		efitick_t	timestamp
	)

no need to process VR falls further

Definition at line 485 of file trigger_central.cpp.

                                                                            {
    bool isPrimary = signalIndex == 0;
    if (!isPrimary && !TRIGGER_WAVEFORM(needSecondTriggerInput)) {
        return;
    }
 
    trigger_event_e signal;
    // todo: add support for 3rd channel
    if (isRising) {
        signal = isPrimary ?
                    (engineConfiguration->invertPrimaryTriggerSignal ? SHAFT_PRIMARY_FALLING : SHAFT_PRIMARY_RISING) :
                    (engineConfiguration->invertSecondaryTriggerSignal ? SHAFT_SECONDARY_FALLING : SHAFT_SECONDARY_RISING);
    } else {
        signal = isPrimary ?
                    (engineConfiguration->invertPrimaryTriggerSignal ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING) :
                    (engineConfiguration->invertSecondaryTriggerSignal ? SHAFT_SECONDARY_RISING : SHAFT_SECONDARY_FALLING);
    }
    if (isPrimary) {
        engine->outputChannels.triggerChannel1 = signal == SHAFT_PRIMARY_RISING;
    } else {
        engine->outputChannels.triggerChannel2 = signal == SHAFT_SECONDARY_RISING;
    }
 
    // Don't accept trigger input in case of some problems
    if (!getLimpManager()->allowTriggerInput()) {
        return;
    }
 
#if EFI_TOOTH_LOGGER
    // Log to the Tunerstudio tooth logger
    // We want to do this before anything else as we
    // actually want to capture any noise/jitter that may be occurring
 
    bool logLogicState = engineConfiguration->displayLogicLevelsInEngineSniffer && getTriggerCentral()->triggerShape.useOnlyRisingEdges;
 
    if (!logLogicState) {
        // we log physical state even if displayLogicLevelsInEngineSniffer if both fronts are used by decoder
        LogTriggerTooth(signal, timestamp);
    }
 
#endif /* EFI_TOOTH_LOGGER */
 
    // for effective noise filtering, we need both signal edges,
    // so we pass them to handleShaftSignal() and defer this test
    if (!engineConfiguration->useNoiselessTriggerDecoder) {
        if (!isUsefulSignal(signal, getTriggerCentral()->triggerShape)) {
            /**
             * no need to process VR falls further
             */
            return;
        }
    }
 
#if EFI_TOOTH_LOGGER
    if (logLogicState) {
        // first log rising normally
        LogTriggerTooth(signal, timestamp);
        // in 'logLogicState' mode we log opposite front right after logical rising away
        if (signal == SHAFT_PRIMARY_RISING) {
            LogTriggerTooth(SHAFT_PRIMARY_FALLING, timestamp);
        } else {
            LogTriggerTooth(SHAFT_SECONDARY_FALLING, timestamp);
        }
    }
#endif /* EFI_TOOTH_LOGGER */
 
    uint32_t triggerHandlerEntryTime = getTimeNowLowerNt();
    if (triggerReentrant > maxTriggerReentrant)
        maxTriggerReentrant = triggerReentrant;
    triggerReentrant++;
 
    getTriggerCentral()->handleShaftSignal(signal, timestamp);
 
    triggerReentrant--;
    triggerDuration = getTimeNowLowerNt() - triggerHandlerEntryTime;
    triggerMaxDuration = maxI(triggerMaxDuration, triggerDuration);
}

Referenced by TriggerEmulatorHelper::handleEmulatorCallback(), and hwHandleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

handleVvtCamSignal()

void handleVvtCamSignal	(	TriggerValue	front,
		efitick_t	timestamp,
		int	index
	)

we prefer not to have VVT sync right at trigger sync so that we do not have phase detection error if things happen a bit in wrong order due to belt flex or else https://github.com/rusefi/rusefi/issues/3269

Definition at line 323 of file trigger_central.cpp.

                                                                        {
    TriggerCentral *tc = getTriggerCentral();
    if (index == 0) {
        engine->outputChannels.vvtChannel1 = front == TriggerValue::RISE;
    } else if (index == 1) {
        engine->outputChannels.vvtChannel2 = front == TriggerValue::RISE;
    } else if (index == 2) {
        engine->outputChannels.vvtChannel3 = front == TriggerValue::RISE;
    } else if (index == 3) {
        engine->outputChannels.vvtChannel4 = front == TriggerValue::RISE;
    }
 
    int bankIndex = BANK_BY_INDEX(index);
    int camIndex = CAM_BY_INDEX(index);
    if (front == TriggerValue::RISE) {
        tc->vvtEventRiseCounter[index]++;
    } else {
        tc->vvtEventFallCounter[index]++;
    }
    if (engineConfiguration->vvtMode[camIndex] == VVT_INACTIVE) {
        warning(ObdCode::CUSTOM_VVT_MODE_NOT_SELECTED, "VVT: event on %d but no mode", camIndex);
    }
 
    const auto& vvtShape = tc->vvtShape[camIndex];
 
    bool isVvtWithRealDecoder = vvtWithRealDecoder(engineConfiguration->vvtMode[camIndex]);
 
    // Non real decoders only use the rising edge
    bool vvtUseOnlyRise = !isVvtWithRealDecoder || vvtShape.useOnlyRisingEdges;
    bool isImportantFront = !vvtUseOnlyRise || (front == TriggerValue::RISE);
 
    logVvtFront(vvtUseOnlyRise, isImportantFront, front, nowNt, index);
 
    if (!isImportantFront) {
        // This edge is unimportant, ignore it.
        return;
    }
 
    // If the main trigger is not synchronized, don't decode VVT yet
    if (!tc->triggerState.getShaftSynchronized()) {
        return;
    }
 
    TriggerDecoderBase& vvtDecoder = tc->vvtState[bankIndex][camIndex];
 
    if (isVvtWithRealDecoder) {
        vvtDecoder.decodeTriggerEvent(
                "vvt",
            vvtShape,
            nullptr,
            tc->vvtTriggerConfiguration[camIndex],
            front == TriggerValue::RISE ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING, nowNt);
        vvtDecoder.vvtToothDurations0 = (uint32_t)NT2US(vvtDecoder.toothDurations[0]);
    }
 
    // here we count all cams together
    tc->vvtCamCounter++;
 
    auto currentPhase = tc->getCurrentEnginePhase(nowNt);
    if (!currentPhase) {
        // If we couldn't resolve engine speed (yet primary trigger is sync'd), this
        // probably means that we have partial crank sync, but not RPM information yet
        return;
    }
 
    angle_t angleFromPrimarySyncPoint = currentPhase.Value;
    // convert trigger cycle angle into engine cycle angle
    angle_t currentPosition = angleFromPrimarySyncPoint - tdcPosition();
    // https://github.com/rusefi/rusefi/issues/1713 currentPosition could be negative that's expected
 
#if EFI_UNIT_TEST
    tc->currentVVTEventPosition[bankIndex][camIndex] = currentPosition;
#endif // EFI_UNIT_TEST
 
    tc->triggerState.vvtCurrentPosition = currentPosition;
 
    if (isVvtWithRealDecoder && vvtDecoder.currentCycle.current_index != 0) {
        // this is not sync tooth - exiting
        return;
    }
 
    auto vvtPosition = engineConfiguration->vvtOffsets[bankIndex * CAMS_PER_BANK + camIndex] - currentPosition;
    tc->triggerState.vvtToothPosition[index] = vvtPosition;
 
  bool skipTooth = skipToothSpecialShape(index, engineConfiguration->vvtMode[camIndex], currentPosition);
  if (skipTooth) {
            return;
  }
 
    // this could be just an 'if' but let's have it expandable for future use :)
    switch(engineConfiguration->vvtMode[camIndex]) {
    case VVT_HONDA_K_INTAKE:
        // honda K has four tooth in VVT intake trigger, so we just wrap each of those to 720 / 4
        vvtPosition = wrapVvt(vvtPosition, 180);
        break;
    default:
        // else, do nothing
        break;
    }
 
#if EFI_PROD_CODE
  if (!isBrainPinValid(engineConfiguration->camInputs[engineConfiguration->engineSyncCam]) &&
      engineConfiguration->vvtMode[engineConfiguration->engineSyncCam] != VVT_MAP_V_TWIN) {
    criticalError("Selected engine sync input not configured: %d", engineConfiguration->engineSyncCam);
  }
#endif // EFI_PROD_CODE
 
    // Only do engine sync using one cam, other cams just provide VVT position.
    if (index == engineConfiguration->engineSyncCam) {
        angle_t crankOffset = adjustCrankPhase(camIndex);
        // vvtPosition was calculated against wrong crank zero position. Now that we have adjusted crank position we
        // shall adjust vvt position as well
        vvtPosition -= crankOffset;
        vvtPosition = wrapVvt(vvtPosition, FOUR_STROKE_CYCLE_DURATION);
 
        if (absF(angleFromPrimarySyncPoint) < 7) {
            /**
             * we prefer not to have VVT sync right at trigger sync so that we do not have phase detection error if things happen a bit in
             * wrong order due to belt flex or else
             * https://github.com/rusefi/rusefi/issues/3269
             */
            warning(ObdCode::CUSTOM_VVT_SYNC_POSITION, "VVT sync position too close to trigger sync");
        }
    } else {
        // Not using this cam for engine sync, just wrap the value in to the reasonable range
        vvtPosition = wrapVvt(vvtPosition, FOUR_STROKE_CYCLE_DURATION);
    }
 
    // Only record VVT position if we have full engine sync - may be bogus before that point
    if (tc->triggerState.hasSynchronizedPhase()) {
        tc->vvtPosition[bankIndex][camIndex] = vvtPosition;
    } else {
        tc->vvtPosition[bankIndex][camIndex] = 0;
    }
}

Referenced by TriggerEmulatorHelper::handleEmulatorCallback(), and hwHandleVvtCamSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

hwHandleShaftSignal()

void hwHandleShaftSignal	(	int	signalIndex,
		bool	isRising,
		efitick_t	timestamp
	)

This function is called by all "hardware" trigger inputs:

• Hardware triggers
• Trigger replay from CSV (unit tests)

Definition at line 469 of file trigger_central.cpp.

                                                                              {
  if (tooSoonToHandleSignal()) {
    return;
  }
    TriggerCentral *tc = getTriggerCentral();
    ScopePerf perf(PE::HandleShaftSignal);
 
    if (tc->directSelfStimulation || !tc->hwTriggerInputEnabled) {
        // sensor noise + self-stim = loss of trigger sync
        return;
    }
 
    handleShaftSignal(signalIndex, isRising, timestamp);
}

Referenced by comp_shaft_callback(), onTriggerChanged(), and shaft_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

hwHandleVvtCamSignal() [1/2]

void hwHandleVvtCamSignal	(	bool	isRising,
		efitick_t	nowNt,
		int	index
	)

This function is called by all "hardware" trigger inputs:

• Hardware triggers
• Trigger replay from CSV (unit tests)

Definition at line 272 of file trigger_central.cpp.

                                                                     {
    int camIndex = CAM_BY_INDEX(index);
    bool invertSetting = camIndex == 0 ? engineConfiguration->invertCamVVTSignal : engineConfiguration->invertExhaustCamVVTSignal;
 
    if (isRising ^ invertSetting) {
        hwHandleVvtCamSignal(TriggerValue::RISE, nowNt, index);
    } else {
        hwHandleVvtCamSignal(TriggerValue::FALL, nowNt, index);
    }
}

Referenced by cam_callback(), comp_cam_callback(), and hwHandleVvtCamSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

hwHandleVvtCamSignal() [2/2]

void hwHandleVvtCamSignal	(	TriggerValue	front,
		efitick_t	timestamp,
		int	index
	)

Definition at line 284 of file trigger_central.cpp.

                                                                          {
  if (tooSoonToHandleSignal()) {
    return;
  }
    TriggerCentral *tc = getTriggerCentral();
    if (tc->directSelfStimulation || !tc->hwTriggerInputEnabled) {
        // sensor noise + self-stim = loss of trigger sync
        return;
    }
    handleVvtCamSignal(front, nowNt, index);
}

Referenced by TriggerCentral::decodeMapCam().

Here is the call graph for this function:

Here is the caller graph for this function:

initTriggerCentral()

void initTriggerCentral

(

)

Definition at line 1276 of file trigger_central.cpp.

                          {
 
#if EFI_ENGINE_SNIFFER
    initWaveChart(&waveChart);
#endif /* EFI_ENGINE_SNIFFER */
 
#if EFI_PROD_CODE || EFI_SIMULATOR
    addConsoleAction(CMD_TRIGGERINFO, triggerInfo);
    addConsoleAction("trigger_shape_info", triggerShapeInfo);
    addConsoleAction("reset_trigger", resetRunningTriggerCounters);
#endif // EFI_PROD_CODE || EFI_SIMULATOR
 
}

Referenced by commonEarlyInit().

Here is the call graph for this function:

Here is the caller graph for this function:

isSignalDecoderError()

int isSignalDecoderError

(

void

)

isTriggerUpEvent()

constexpr bool isTriggerUpEvent ( trigger_event_e  event )

constexpr

Definition at line 248 of file trigger_central.h.

                                                       {
    switch (event) {
        case SHAFT_PRIMARY_FALLING:
        case SHAFT_SECONDARY_FALLING:
            return false;
        case SHAFT_PRIMARY_RISING:
        case SHAFT_SECONDARY_RISING:
            return true;
    }
 
    return false;
}

Referenced by isUsefulSignal(), and reportEventToWaveChart().

Here is the caller graph for this function:

onConfigurationChangeTriggerCallback()

void onConfigurationChangeTriggerCallback

(

)

Definition at line 1057 of file trigger_central.cpp.

                                            {
    bool changed = false;
    // todo: how do we static_assert here?
    criticalAssertVoid(efi::size(engineConfiguration->camInputs) == efi::size(engineConfiguration->vvtOffsets), "sizes");
 
    for (size_t camIndex = 0; camIndex < efi::size(engineConfiguration->camInputs); camIndex++) {
        changed |= isConfigurationChanged(camInputs[camIndex]);
        changed |= isConfigurationChanged(vvtOffsets[camIndex]);
    }
 
    for (size_t i = 0; i < efi::size(engineConfiguration->triggerGapOverrideFrom); i++) {
        changed |= isConfigurationChanged(triggerGapOverrideFrom[i]);
        changed |= isConfigurationChanged(triggerGapOverrideTo[i]);
    }
 
    for (size_t i = 0; i < efi::size(engineConfiguration->triggerInputPins); i++) {
        changed |= isConfigurationChanged(triggerInputPins[i]);
        Gpio pin = engineConfiguration->camInputs[i];
        if (engineConfiguration->vvtMode[0] == VVT_MAP_V_TWIN && isBrainPinValid(pin)) {
            criticalError("Please no physical sensors in CAM by MAP mode index=%d %s", i, hwPortname(pin));
        }
    }
 
    for (size_t i = 0; i < efi::size(engineConfiguration->vvtMode); i++) {
        changed |= isConfigurationChanged(vvtMode[i]);
    }
 
    changed |= isConfigurationChanged(trigger.type);
    changed |= isConfigurationChanged(skippedWheelOnCam);
    changed |= isConfigurationChanged(twoStroke);
    changed |= isConfigurationChanged(globalTriggerAngleOffset);
    changed |= isConfigurationChanged(trigger.customTotalToothCount);
    changed |= isConfigurationChanged(trigger.customSkippedToothCount);
    changed |= isConfigurationChanged(overrideTriggerGaps);
    changed |= isConfigurationChanged(gapTrackingLengthOverride);
    changed |= isConfigurationChanged(overrideVvtTriggerGaps);
    changed |= isConfigurationChanged(gapVvtTrackingLengthOverride);
 
    if (changed) {
    #if EFI_ENGINE_CONTROL
        engine->updateTriggerConfiguration();
        getTriggerCentral()->noiseFilter.resetAccumSignalData();
    #endif
    }
#if EFI_DETAILED_LOGGING
    efiPrintf("isTriggerConfigChanged=%d", triggerConfigChanged);
#endif /* EFI_DETAILED_LOGGING */
 
    // we do not want to miss two updates in a row
    getTriggerCentral()->triggerConfigChangedOnLastConfigurationChange = getTriggerCentral()->triggerConfigChangedOnLastConfigurationChange || changed;
}

Referenced by incrementGlobalConfigurationVersion().

Here is the call graph for this function:

Here is the caller graph for this function:

triggerInfo()

void triggerInfo

(

void

)

Definition at line 952 of file trigger_central.cpp.

                       {
#if EFI_PROD_CODE || EFI_SIMULATOR
 
    TriggerCentral *tc = getTriggerCentral();
    TriggerWaveform *ts = &tc->triggerShape;
 
 
#if (HAL_TRIGGER_USE_PAL == TRUE) && (PAL_USE_CALLBACKS == TRUE)
        efiPrintf("trigger PAL mode %d", tc->hwTriggerInputEnabled);
#else
 
#endif /* HAL_TRIGGER_USE_PAL */
 
    efiPrintf("Template %s (%d) trigger %s (%d) syncEdge=%s tdcOffset=%.2f",
            getEngine_type_e(engineConfiguration->engineType),
            (int)engineConfiguration->engineType,
            getTrigger_type_e(engineConfiguration->trigger.type),
            (int)engineConfiguration->trigger.type,
            getSyncEdge(TRIGGER_WAVEFORM(syncEdge)), TRIGGER_WAVEFORM(tdcPosition));
 
    if (engineConfiguration->trigger.type == trigger_type_e::TT_TOOTHED_WHEEL) {
        efiPrintf("total %d/skipped %d", engineConfiguration->trigger.customTotalToothCount,
                engineConfiguration->trigger.customSkippedToothCount);
    }
 
 
    efiPrintf("trigger#1 event counters up=%d/down=%d", tc->getHwEventCounter(0),
            tc->getHwEventCounter(1));
 
    if (ts->needSecondTriggerInput) {
        efiPrintf("trigger#2 event counters up=%d/down=%d", tc->getHwEventCounter(2),
                tc->getHwEventCounter(3));
    }
    efiPrintf("expected cycle events %d/%d",
            TRIGGER_WAVEFORM(getExpectedEventCount(TriggerWheel::T_PRIMARY)),
            TRIGGER_WAVEFORM(getExpectedEventCount(TriggerWheel::T_SECONDARY)));
 
    efiPrintf("trigger type=%d/need2ndChannel=%s", (int)engineConfiguration->trigger.type,
            boolToString(TRIGGER_WAVEFORM(needSecondTriggerInput)));
 
 
    efiPrintf("synchronizationNeeded=%s/isError=%s/total errors=%lu ord_err=%lu/total revolutions=%d/self=%s",
            boolToString(ts->isSynchronizationNeeded),
            boolToString(tc->isTriggerDecoderError()),
            tc->triggerState.totalTriggerErrorCounter,
            tc->triggerState.orderingErrorCounter,
            tc->triggerState.getSynchronizationCounter(),
            boolToString(tc->directSelfStimulation));
 
    if (TRIGGER_WAVEFORM(isSynchronizationNeeded)) {
        efiPrintf("gap from %.2f to %.2f", TRIGGER_WAVEFORM(synchronizationRatioFrom[0]), TRIGGER_WAVEFORM(synchronizationRatioTo[0]));
    }
 
#endif /* EFI_PROD_CODE || EFI_SIMULATOR */
 
#if EFI_PROD_CODE
 
    efiPrintf("primary trigger input: %s", hwPortname(engineConfiguration->triggerInputPins[0]));
    efiPrintf("primary trigger simulator: %s %s freq=%d",
            hwPortname(engineConfiguration->triggerSimulatorPins[0]),
            getPin_output_mode_e(engineConfiguration->triggerSimulatorPinModes[0]),
            engineConfiguration->triggerSimulatorRpm);
 
    if (ts->needSecondTriggerInput) {
        efiPrintf("secondary trigger input: %s", hwPortname(engineConfiguration->triggerInputPins[1]));
#if EFI_EMULATE_POSITION_SENSORS
        efiPrintf("secondary trigger simulator: %s %s phase=%d",
                hwPortname(engineConfiguration->triggerSimulatorPins[1]),
                getPin_output_mode_e(engineConfiguration->triggerSimulatorPinModes[1]), triggerEmulatorSignals[0].safe.phaseIndex);
#endif /* EFI_EMULATE_POSITION_SENSORS */
    }
 
 
    for (int camInputIndex = 0; camInputIndex<CAM_INPUTS_COUNT;camInputIndex++) {
        if (isBrainPinValid(engineConfiguration->camInputs[camInputIndex])) {
            int camLogicalIndex = camInputIndex % CAMS_PER_BANK;
            efiPrintf("VVT input: %s mode %s", hwPortname(engineConfiguration->camInputs[camInputIndex]),
                    getVvt_mode_e(engineConfiguration->vvtMode[camLogicalIndex]));
            efiPrintf("VVT %d event counters: %d/%d",
                    camInputIndex,
                    tc->vvtEventRiseCounter[camInputIndex], tc->vvtEventFallCounter[camInputIndex]);
        }
    }
 
    efiPrintf("primary logic input: %s", hwPortname(engineConfiguration->logicAnalyzerPins[0]));
    efiPrintf("secondary logic input: %s", hwPortname(engineConfiguration->logicAnalyzerPins[1]));
 
 
    efiPrintf("totalTriggerHandlerMaxTime=%lu", triggerMaxDuration);
 
#endif /* EFI_PROD_CODE */
 
#if EFI_ENGINE_SNIFFER
    efiPrintf("engine sniffer current size=%d", waveChart.getSize());
#endif /* EFI_ENGINE_SNIFFER */
 
}

Referenced by initTriggerCentral(), and resetRunningTriggerCounters().

Here is the call graph for this function:

Here is the caller graph for this function:

validateTriggerInputs()

void validateTriggerInputs

(

)

Definition at line 1266 of file trigger_central.cpp.

                             {
    if (!isBrainPinValid(engineConfiguration->triggerInputPins[0]) && isBrainPinValid(engineConfiguration->triggerInputPins[1])) {
        criticalError("First trigger channel not configured while second one is.");
    }
 
    if (!isBrainPinValid(engineConfiguration->camInputs[0]) && isBrainPinValid(engineConfiguration->camInputs[2])) {
        criticalError("First bank cam input is required if second bank specified");
    }
}

Referenced by startHardware().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.