trigger_central.cpp File Reference

Functions
int	getCrankDivider (operation_mode_e operationMode)
static bool	vvtWithRealDecoder (vvt_mode_e vvtMode)
static void	turnOffAllDebugFields (void *arg)
static angle_t	adjustCrankPhase (int camIndex)
static angle_t	wrapVvt (angle_t vvtPosition, int period)
static void	logVvtFront (bool useOnlyRise, bool isImportantFront, TriggerValue front, efitick_t nowNt, int index)
void	hwHandleVvtCamSignal (bool isRising, efitick_t timestamp, int index)
void	hwHandleVvtCamSignal (TriggerValue front, efitick_t nowNt, int index)
void	handleVvtCamSignal (TriggerValue front, efitick_t nowNt, int index)
void	hwHandleShaftSignal (int signalIndex, bool isRising, efitick_t timestamp)
void	handleShaftSignal (int signalIndex, bool isRising, efitick_t timestamp)
static void	reportEventToWaveChart (trigger_event_e ckpSignalType, int triggerEventIndex, bool addOppositeEvent)
BOARD_WEAK bool	boardAllowTriggerActions ()
static void	triggerShapeInfo ()
void	triggerInfo (void)
static void	resetRunningTriggerCounters ()
void	onConfigurationChangeTriggerCallback ()
static void	initVvtShape (TriggerWaveform &shape, const TriggerConfiguration &p_config, TriggerDecoderBase &initState)
static void	calculateTriggerSynchPoint (const PrimaryTriggerConfiguration &primaryTriggerConfiguration, TriggerWaveform &shape, TriggerDecoderBase &initState)
void	validateTriggerInputs ()
void	initTriggerCentral ()

Variables
WaveChart	waveChart
static scheduling_s	debugToggleScheduling
int	triggerReentrant = 0
int	maxTriggerReentrant = 0
uint32_t	triggerDuration
uint32_t	triggerMaxDuration = 0
static const bool	isUpEvent [4] = { false, true, false, true }
static const int	wheelIndeces [4] = { 0, 0, 1, 1}
PwmConfig	triggerEmulatorSignals [NUM_EMULATOR_CHANNELS]
TriggerDecoderBase	initState ("init")

Function Documentation

adjustCrankPhase()

static angle_t adjustCrankPhase ( int  camIndex )

static

Definition at line 162 of file trigger_central.cpp.

                                              {
    float maxSyncThreshold = engineConfiguration->maxCamPhaseResolveRpm;
    if (maxSyncThreshold != 0 && Sensor::getOrZero(SensorType::Rpm) > maxSyncThreshold) {
        // The user has elected to stop trying to resolve crank phase after some RPM.
        // Maybe their cam sensor only works at low RPM or something.
        // Anyway, don't try to change crank phase at all, and return that we made no change.
        return 0;
    }
 
    operation_mode_e operationMode = getEngineRotationState()->getOperationMode();
 
    auto crankDivider = getCrankDivider(operationMode);
    if (crankDivider == 1) {
        // Crank divider of 1 means there's no ambiguity, so don't try to resolve it
        return 0;
    }
 
    TriggerCentral *tc = getTriggerCentral();
 
    vvt_mode_e vvtMode = engineConfiguration->vvtMode[camIndex];
    switch (vvtMode) {
    case VVT_MAP_V_TWIN:
    case VVT_MITSUBISHI_4G63:
    case VVT_MITSUBISHI_4G9x:
        return tc->syncEnginePhaseAndReport(crankDivider, 1);
    case VVT_SINGLE_TOOTH:
    case VVT_NISSAN_VQ:
    case VVT_BOSCH_QUICK_START:
    case VVT_MIATA_NB:
    case VVT_TOYOTA_3_TOOTH:
    case VVT_TOYOTA_4_1:
    case VVT_FORD_COYOTE:
    case VVT_DEV:
    case VVT_FORD_ST170:
    case VVT_BARRA_3_PLUS_1:
    case VVT_NISSAN_MR:
    case VVT_MAZDA_SKYACTIV:
    case VVT_MAZDA_L:
    case VVT_MITSUBISHI_4G69:
    case VVT_MITSUBISHI_3A92:
    case VVT_MITSUBISHI_6G72:
    case VVT_MITSUBISHI_6G75:
    case VVT_HONDA_K_EXHAUST:
    case VVT_HONDA_CBR_600:
        return tc->syncEnginePhaseAndReport(crankDivider, 0);
    case VVT_HONDA_K_INTAKE:
        // with 4 evenly spaced tooth we cannot use this wheel for engine sync
        criticalError("Honda K Intake is not suitable for engine sync");
        [[fallthrough]];
    case VVT_INACTIVE:
        // do nothing
        return 0;
    }
    return 0;
}

Referenced by handleVvtCamSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

boardAllowTriggerActions()

BOARD_WEAK bool boardAllowTriggerActions

(

)

Definition at line 747 of file trigger_central.cpp.

{ return true; }

Referenced by TriggerCentral::handleShaftSignal().

Here is the caller graph for this function:

calculateTriggerSynchPoint()

static void calculateTriggerSynchPoint ( const PrimaryTriggerConfiguration &  primaryTriggerConfiguration, TriggerWaveform &  shape, TriggerDecoderBase &  initState  )

static

Calculate 'shape.triggerShapeSynchPointIndex' value using 'TriggerDecoderBase *state'

Definition at line 1093 of file trigger_central.cpp.

                                       {
 
#if EFI_PROD_CODE
    efiAssertVoid(ObdCode::CUSTOM_TRIGGER_STACK, hasLotsOfRemainingStack(), "calc s");
#endif
 
    shape.initializeSyncPoint(initState, primaryTriggerConfiguration);
 
    if (shape.getSize() >= PWM_PHASE_MAX_COUNT) {
        // todo: by the time we are here we had already modified a lot of RAM out of bounds!
        firmwareError(ObdCode::CUSTOM_ERR_TRIGGER_WAVEFORM_TOO_LONG, "Trigger length above maximum: %d", shape.getSize());
        shape.setShapeDefinitionError(true);
        return;
    }
 
    if (shape.getSize() == 0) {
        firmwareError(ObdCode::CUSTOM_ERR_TRIGGER_ZERO, "triggerShape size is zero");
    }
}

Referenced by TriggerCentral::updateWaveform().

Here is the call graph for this function:

Here is the caller graph for this function:

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 99 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:

handleShaftSignal()

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

no need to process VR falls further

Definition at line 475 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 (engineConfiguration->triggerInputDebugPins[signalIndex] != Gpio::Unassigned) {
#if EFI_PROD_CODE
        writePad("trigger debug", engineConfiguration->triggerInputDebugPins[signalIndex], 1);
#endif /* EFI_PROD_CODE */
        getExecutorInterface()->scheduleByTimestampNt("dbg_off", &debugToggleScheduling, timestamp + DEBUG_PIN_DELAY, &turnOffAllDebugFields);
    }
 
#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	nowNt,
		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 275 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);
    }
 
#ifdef VR_HW_CHECK_MODE
    // some boards do not have hardware VR input LEDs which makes such boards harder to validate
    // from experience we know that assembly mistakes happen and quality control is required
    extern ioportid_t criticalErrorLedPort;
    extern ioportmask_t criticalErrorLedPin;
 
    for (int i = 0 ; i < 100 ; i++) {
        // turning pin ON and busy-waiting a bit
        palWritePad(criticalErrorLedPort, criticalErrorLedPin, 1);
    }
 
    palWritePad(criticalErrorLedPort, criticalErrorLedPin, 0);
#endif // VR_HW_CHECK_MODE
 
    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);
        // yes we log data from all VVT channels into same fields for now
        tc->triggerState.vvtSyncGapRatio = vvtDecoder.triggerSyncGapRatio;
        tc->triggerState.vvtToothDurations0 = (uint32_t)NT2US(vvtDecoder.toothDurations[0]);
        tc->triggerState.vvtStateIndex = vvtDecoder.currentCycle.current_index;
    }
 
    // 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;
 
    switch(engineConfiguration->vvtMode[camIndex]) {
    case VVT_TOYOTA_3_TOOTH:
    {
        int from = engineConfiguration->camDecoder2jzPosition - engineConfiguration->camDecoder2jzPrecision;
        int to   = engineConfiguration->camDecoder2jzPosition + engineConfiguration->camDecoder2jzPrecision;
        // we do not know if we are in sync or out of sync, so we have to be looking for both possibilities
        if ((currentPosition < from       || currentPosition > to) &&
            (currentPosition < from + 360 || currentPosition > to + 360)) {
            // outside of the expected range
            return;
        }
    }
        break;
    default:
        // else, do nothing
        break;
    }
 
    // 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;
    }
 
    // 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 444 of file trigger_central.cpp.

                                                                              {
    TriggerCentral *tc = getTriggerCentral();
    ScopePerf perf(PE::HandleShaftSignal);
#ifdef VR_HW_CHECK_MODE
    // some boards do not have hardware VR input LEDs which makes such boards harder to validate
    // from experience we know that assembly mistakes happen and quality control is required
    extern ioportid_t criticalErrorLedPort;
    extern ioportmask_t criticalErrorLedPin;
 
#if HW_CHECK_ALWAYS_STIMULATE
    disableTriggerStimulator();
#endif // HW_CHECK_ALWAYS_STIMULATE
 
 
    for (int i = 0 ; i < 100 ; i++) {
        // turning pin ON and busy-waiting a bit
        palWritePad(criticalErrorLedPort, criticalErrorLedPin, 1);
    }
 
    palWritePad(criticalErrorLedPort, criticalErrorLedPin, 0);
#endif // VR_HW_CHECK_MODE
 
    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	timestamp,
		int	index
	)

Definition at line 261 of file trigger_central.cpp.

                                                                         {
    hwHandleVvtCamSignal(isRising ? TriggerValue::RISE : TriggerValue::FALL, timestamp, index);
}

Referenced by cam_callback(), comp_cam_callback(), and TriggerCentral::decodeMapCam().

Here is the caller graph for this function:

hwHandleVvtCamSignal() [2/2]

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

Definition at line 266 of file trigger_central.cpp.

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

Here is the call graph for this function:

initTriggerCentral()

void initTriggerCentral

(

)

Definition at line 1228 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:

initVvtShape()

static void initVvtShape ( TriggerWaveform &  shape, const TriggerConfiguration &  p_config, TriggerDecoderBase &  initState  )

static

Definition at line 1075 of file trigger_central.cpp.

                                                                                                                      {
    shape.initializeTriggerWaveform(FOUR_STROKE_CAM_SENSOR, p_config.TriggerType);
    shape.initializeSyncPoint(initState, p_config);
}

Referenced by TriggerCentral::updateWaveform().

Here is the call graph for this function:

Here is the caller graph for this function:

logVvtFront()

static void logVvtFront ( bool  useOnlyRise, bool  isImportantFront, TriggerValue  front, efitick_t  nowNt, int  index  )

static

Definition at line 232 of file trigger_central.cpp.

                                                                                                                 {
    if (isImportantFront && isBrainPinValid(engineConfiguration->camInputsDebug[index])) {
#if EFI_PROD_CODE
        writePad("cam debug", engineConfiguration->camInputsDebug[index], 1);
#endif /* EFI_PROD_CODE */
        getExecutorInterface()->scheduleByTimestampNt("dbg_on", &debugToggleScheduling, nowNt + DEBUG_PIN_DELAY, &turnOffAllDebugFields);
    }
 
    if (!useOnlyRise || engineConfiguration->displayLogicLevelsInEngineSniffer) {
        // If we care about both edges OR displayLogicLevel is set, log every front exactly as it is
        addEngineSnifferVvtEvent(index, front == TriggerValue::RISE ? FrontDirection::UP : FrontDirection::DOWN);
 
#if EFI_TOOTH_LOGGER
        LogTriggerTooth(front == TriggerValue::RISE ? SHAFT_SECONDARY_RISING : SHAFT_SECONDARY_FALLING, nowNt);
#endif /* EFI_TOOTH_LOGGER */
    } else {
        if (isImportantFront) {
            // On the important edge, log a rise+fall pair, and nothing on the real falling edge
            addEngineSnifferVvtEvent(index, FrontDirection::UP);
            addEngineSnifferVvtEvent(index, FrontDirection::DOWN);
 
#if EFI_TOOTH_LOGGER
            LogTriggerTooth(SHAFT_SECONDARY_RISING, nowNt);
            LogTriggerTooth(SHAFT_SECONDARY_FALLING, nowNt);
#endif /* EFI_TOOTH_LOGGER */
        }
    }
}

Referenced by handleVvtCamSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

onConfigurationChangeTriggerCallback()

void onConfigurationChangeTriggerCallback

(

)

Definition at line 1023 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->updateTriggerWaveform();
        getTriggerCentral()->noiseFilter.resetAccumSignalData();
    #endif
    }
#if EFI_DEFAILED_LOGGING
    efiPrintf("isTriggerConfigChanged=%d", triggerConfigChanged);
#endif /* EFI_DEFAILED_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:

reportEventToWaveChart()

static void reportEventToWaveChart ( trigger_event_e  ckpSignalType, int  triggerEventIndex, bool  addOppositeEvent  )

static

Definition at line 567 of file trigger_central.cpp.

                                                                                                                {
    if (!getTriggerCentral()->isEngineSnifferEnabled) { // this is here just as a shortcut so that we avoid engine sniffer as soon as possible
        return; // engineSnifferRpmThreshold is accounted for inside getTriggerCentral()->isEngineSnifferEnabled
    }
 
    int wheelIndex = wheelIndeces[(int )ckpSignalType];
 
    bool isUp = isUpEvent[(int) ckpSignalType];
 
    addEngineSnifferCrankEvent(wheelIndex, triggerEventIndex, isUp ? FrontDirection::UP : FrontDirection::DOWN);
    if (addOppositeEvent) {
        // let's add the opposite event right away
        addEngineSnifferCrankEvent(wheelIndex, triggerEventIndex, isUp ? FrontDirection::DOWN : FrontDirection::UP);
    }
}

Referenced by TriggerCentral::handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

resetRunningTriggerCounters()

static void resetRunningTriggerCounters ( )

static

Definition at line 1016 of file trigger_central.cpp.

                                          {
#if !EFI_UNIT_TEST
    getTriggerCentral()->resetCounters();
    triggerInfo();
#endif
}

Referenced by initTriggerCentral().

Here is the call graph for this function:

Here is the caller graph for this function:

triggerInfo()

void triggerInfo

(

void

)

Definition at line 918 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.getCrankSynchronizationCounter(),
            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:

triggerShapeInfo()

static void triggerShapeInfo ( )

static

Definition at line 901 of file trigger_central.cpp.

                               {
#if EFI_PROD_CODE || EFI_SIMULATOR
    TriggerWaveform *shape = &getTriggerCentral()->triggerShape;
    TriggerFormDetails *triggerFormDetails = &getTriggerCentral()->triggerFormDetails;
    efiPrintf("syncEdge=%s", getSyncEdge(TRIGGER_WAVEFORM(syncEdge)));
    efiPrintf("gap from %.2f to %.2f", TRIGGER_WAVEFORM(synchronizationRatioFrom[0]), TRIGGER_WAVEFORM(synchronizationRatioTo[0]));
 
    for (size_t i = 0; i < shape->getSize(); i++) {
        efiPrintf("event %d %.2f", i, triggerFormDetails->eventAngles[i]);
    }
#endif
}

Referenced by initTriggerCentral().

Here is the call graph for this function:

Here is the caller graph for this function:

turnOffAllDebugFields()

static void turnOffAllDebugFields ( void *  arg )

static

Definition at line 146 of file trigger_central.cpp.

                                             {
    (void)arg;
#if EFI_PROD_CODE
    for (int index = 0;index<TRIGGER_INPUT_PIN_COUNT;index++) {
        if (isBrainPinValid(engineConfiguration->triggerInputDebugPins[index])) {
            writePad("trigger debug", engineConfiguration->triggerInputDebugPins[index], 0);
        }
    }
    for (int index = 0;index<CAM_INPUTS_COUNT;index++) {
        if (isBrainPinValid(engineConfiguration->camInputsDebug[index])) {
            writePad("cam debug", engineConfiguration->camInputsDebug[index], 0);
        }
    }
#endif /* EFI_PROD_CODE */
}

Referenced by handleShaftSignal(), and logVvtFront().

Here is the call graph for this function:

Here is the caller graph for this function:

validateTriggerInputs()

void validateTriggerInputs

(

)

Definition at line 1218 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:

vvtWithRealDecoder()

static bool vvtWithRealDecoder ( vvt_mode_e  vvtMode )

static

Definition at line 126 of file trigger_central.cpp.

                                                   {
    return vvtMode != VVT_INACTIVE
            && vvtMode != VVT_TOYOTA_3_TOOTH /* VVT_2JZ is an unusual 3/0 missed tooth symmetrical wheel */
            && vvtMode != VVT_HONDA_K_INTAKE
            && vvtMode != VVT_MAP_V_TWIN
            && vvtMode != VVT_SINGLE_TOOTH;
}

Referenced by handleVvtCamSignal().

Here is the caller graph for this function:

wrapVvt()

static angle_t wrapVvt ( angle_t  vvtPosition, int  period  )

static

See also wrapAngle

Definition at line 221 of file trigger_central.cpp.

                                                        {
    // Wrap VVT position in to the range [-360, 360)
    while (vvtPosition < -period / 2) {
        vvtPosition += period;
    }
    while (vvtPosition >= period / 2) {
        vvtPosition -= period;
    }
    return vvtPosition;
}

Referenced by handleVvtCamSignal().

Here is the caller graph for this function:

Variable Documentation

debugToggleScheduling

scheduling_s debugToggleScheduling

static

Definition at line 36 of file trigger_central.cpp.

Referenced by handleShaftSignal(), and logVvtFront().

initState

TriggerDecoderBase initState("init")

(

"init"

)

Referenced by calculateTriggerSynchPoint(), initVvtShape(), and TriggerCentral::updateWaveform().

isUpEvent

const bool isUpEvent[4] = { false, true, false, true }

static

Definition at line 564 of file trigger_central.cpp.

Referenced by reportEventToWaveChart().

maxTriggerReentrant

int maxTriggerReentrant = 0

Definition at line 435 of file trigger_central.cpp.

Referenced by handleShaftSignal(), printRuntimeStats(), and updateTunerStudioState().

triggerDuration

uint32_t triggerDuration

Definition at line 436 of file trigger_central.cpp.

Referenced by handleShaftSignal().

triggerEmulatorSignals

PwmConfig triggerEmulatorSignals[NUM_EMULATOR_CHANNELS]

extern

Definition at line 69 of file trigger_emulator_algo.cpp.

Referenced by disableTriggerStimulator(), emulatorApplyPinState(), setTriggerEmulatorRPM(), startSimulatedTriggerSignal(), startTriggerEmulatorPins(), stopTriggerEmulatorPins(), triggerInfo(), and updateTriggerWaveformIfNeeded().

triggerMaxDuration

uint32_t triggerMaxDuration = 0

Definition at line 437 of file trigger_central.cpp.

Referenced by handleShaftSignal(), resetMaxValues(), and triggerInfo().

triggerReentrant

int triggerReentrant = 0

Definition at line 434 of file trigger_central.cpp.

Referenced by handleShaftSignal().

waveChart

WaveChart waveChart

Definition at line 33 of file trigger_central.cpp.

Referenced by addEngineSnifferTdcEvent(), initTriggerCentral(), printOverallStatus(), Engine::resetEngineSnifferIfInTestMode(), resetNow(), and triggerInfo().

wheelIndeces

const int wheelIndeces[4] = { 0, 0, 1, 1}

static

Definition at line 565 of file trigger_central.cpp.

Referenced by reportEventToWaveChart().

Go to the source code of this file.