/* * @file trigger_central.cpp * Here we have a bunch of higher-level methods which are not directly related to actual signal decoding * * @date Feb 23, 2014 * @author Andrey Belomutskiy, (c) 2012-2020 */ #include "pch.h" #include "os_access.h" #include "trigger_central.h" #include "trigger_decoder.h" #include "main_trigger_callback.h" #include "listener_array.h" #include "tooth_logger.h" #include "hip9011.h" #include "logic_analyzer.h" #include "local_version_holder.h" #include "trigger_simulator.h" #include "trigger_emulator_algo.h" #include "tooth_logger.h" #include "map_averaging.h" #include "main_trigger_callback.h" #include "status_loop.h" #if EFI_TUNER_STUDIO #include "tunerstudio.h" #endif /* EFI_TUNER_STUDIO */ #if EFI_ENGINE_SNIFFER #include "engine_sniffer.h" WaveChart waveChart; #endif /* EFI_ENGINE_SNIFFER */ static scheduling_s debugToggleScheduling; #define DEBUG_PIN_DELAY US2NT(60) #if EFI_SHAFT_POSITION_INPUT TriggerCentral::TriggerCentral() : vvtEventRiseCounter(), vvtEventFallCounter(), vvtPosition(), triggerState("TRG") { memset(&hwEventCounters, 0, sizeof(hwEventCounters)); triggerState.resetTriggerState(); noiseFilter.resetAccumSignalData(); } void TriggerNoiseFilter::resetAccumSignalData() { memset(lastSignalTimes, 0xff, sizeof(lastSignalTimes)); // = -1 memset(accumSignalPeriods, 0, sizeof(accumSignalPeriods)); memset(accumSignalPrevPeriods, 0, sizeof(accumSignalPrevPeriods)); } int TriggerCentral::getHwEventCounter(int index) const { return hwEventCounters[index]; } angle_t TriggerCentral::getVVTPosition(uint8_t bankIndex, uint8_t camIndex) { if (bankIndex >= BANKS_COUNT || camIndex >= CAMS_PER_BANK) { return NAN; } return vvtPosition[bankIndex][camIndex]; } /** * @return angle since trigger synchronization point, NOT angle since TDC. */ expected TriggerCentral::getCurrentEnginePhase(efitick_t nowNt) const { floatus_t oneDegreeUs = engine->rpmCalculator.oneDegreeUs; if (cisnan(oneDegreeUs)) { return unexpected; } return m_syncPointTimer.getElapsedUs(nowNt) / oneDegreeUs; } /** * todo: why is this method NOT reciprocal to getRpmMultiplier?! */ static int getCrankDivider(operation_mode_e operationMode) { 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_TWELVE_TIMES_CRANK_SENSOR: return SYMMETRICAL_TWELVE_TIMES_CRANK_SENSOR_DIVIDER; default: case FOUR_STROKE_CAM_SENSOR: case TWO_STROKE: // That's easy - trigger cycle matches engine cycle return 1; } } static bool vvtWithRealDecoder(vvt_mode_e vvtMode) { // todo: why does VVT_2JZ not use real decoder? return vvtMode != VVT_INACTIVE && vvtMode != VVT_2JZ && vvtMode != VVT_HONDA_K && vvtMode != VVT_MAP_V_TWIN_ANOTHER && vvtMode != VVT_SECOND_HALF && vvtMode != VVT_FIRST_HALF; } static angle_t syncAndReport(TriggerCentral *tc, int divider, int remainder) { angle_t engineCycle = getEngineCycle(engine->getOperationMode()); return tc->triggerState.syncEnginePhase(divider, remainder, engineCycle); } static void turnOffAllDebugFields(void *arg) { (void)arg; #if EFI_PROD_CODE for (int index = 0;indextriggerInputDebugPins[index] != Gpio::Unassigned) { writePad("trigger debug", engineConfiguration->triggerInputDebugPins[index], 0); } } for (int index = 0;indexcamInputsDebug[index] != Gpio::Unassigned) { writePad("cam debug", engineConfiguration->camInputsDebug[index], 0); } } #endif /* EFI_PROD_CODE */ } static angle_t adjustCrankPhase(int camIndex) { 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; } TriggerCentral *tc = &engine->triggerCentral; operation_mode_e operationMode = engine->getOperationMode(); vvt_mode_e vvtMode = engineConfiguration->vvtMode[camIndex]; switch (vvtMode) { case VVT_FIRST_HALF: case VVT_MAP_V_TWIN_ANOTHER: return syncAndReport(tc, getCrankDivider(operationMode), 1); case VVT_SECOND_HALF: case VVT_NISSAN_VQ: case VVT_BOSCH_QUICK_START: return syncAndReport(tc, getCrankDivider(operationMode), 0); case VVT_MIATA_NB: /** * NB2 is a symmetrical crank, there are four phases total */ return syncAndReport(tc, getCrankDivider(operationMode), 0); case VVT_2JZ: case VVT_TOYOTA_4_1: case VVT_FORD_ST170: case VVT_BARRA_3_PLUS_1: case VVT_NISSAN_MR: case VVT_MITSUBISHI_3A92: case VVT_MITSUBISHI_6G75: return syncAndReport(tc, getCrankDivider(operationMode), engineConfiguration->tempBooleanForVerySpecialCases ? 1 : 0); case VVT_HONDA_K: firmwareError(OBD_PCM_Processor_Fault, "Undecided on VVT phase of %s", getVvt_mode_e(vvtMode)); return 0; case VVT_INACTIVE: // do nothing return 0; } return 0; } /** * See also wrapAngle */ static angle_t wrapVvt(angle_t vvtPosition, int period) { // Wrap VVT position in to the range [-360, 360) while (vvtPosition < -period / 2) { vvtPosition += period; } while (vvtPosition >= period / 2) { vvtPosition -= period; } return vvtPosition; } static void logFront(bool isImportantFront, efitick_t nowNt, int index) { extern const char *vvtNames[]; const char *vvtName = vvtNames[index]; if (isImportantFront && engineConfiguration->camInputsDebug[index] != Gpio::Unassigned) { #if EFI_PROD_CODE writePad("cam debug", engineConfiguration->camInputsDebug[index], 1); #endif /* EFI_PROD_CODE */ engine->executor.scheduleByTimestampNt("dbg_on", &debugToggleScheduling, nowNt + DEBUG_PIN_DELAY, &turnOffAllDebugFields); } if (engineConfiguration->displayLogicLevelsInEngineSniffer && isImportantFront) { if (engineConfiguration->vvtCamSensorUseRise) { // todo: unify TS composite logger code with console Engine Sniffer // todo: better API to reduce copy/paste? #if EFI_TOOTH_LOGGER LogTriggerTooth(SHAFT_SECONDARY_RISING, nowNt); LogTriggerTooth(SHAFT_SECONDARY_FALLING, nowNt); #endif /* EFI_TOOTH_LOGGER */ addEngineSnifferEvent(vvtName, PROTOCOL_ES_UP); addEngineSnifferEvent(vvtName, PROTOCOL_ES_DOWN); } else { #if EFI_TOOTH_LOGGER LogTriggerTooth(SHAFT_SECONDARY_FALLING, nowNt); LogTriggerTooth(SHAFT_SECONDARY_RISING, nowNt); #endif /* EFI_TOOTH_LOGGER */ addEngineSnifferEvent(vvtName, PROTOCOL_ES_DOWN); addEngineSnifferEvent(vvtName, PROTOCOL_ES_UP); } } } void hwHandleVvtCamSignal(trigger_value_e front, efitick_t nowNt, int index) { if (engine->directSelfStimulation || !engine->hwTriggerInputEnabled) { // sensor noise + self-stim = loss of trigger sync return; } int bankIndex = index / CAMS_PER_BANK; int camIndex = index % CAMS_PER_BANK; TriggerCentral *tc = &engine->triggerCentral; if (front == TV_RISE) { tc->vvtEventRiseCounter[index]++; } else { tc->vvtEventFallCounter[index]++; } extern const char *vvtNames[]; const char *vvtName = vvtNames[index]; if (engineConfiguration->vvtMode[camIndex] == VVT_INACTIVE) { warning(CUSTOM_VVT_MODE_NOT_SELECTED, "VVT: event on %d but no mode", camIndex); } #if 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 if (!engineConfiguration->displayLogicLevelsInEngineSniffer) { addEngineSnifferEvent(vvtName, front == TV_RISE ? PROTOCOL_ES_UP : PROTOCOL_ES_DOWN); #if EFI_TOOTH_LOGGER // todo: we need to start logging different VVT channels differently!!! trigger_event_e tooth = front == TV_RISE ? SHAFT_SECONDARY_RISING : SHAFT_SECONDARY_FALLING; LogTriggerTooth(tooth, nowNt); #endif /* EFI_TOOTH_LOGGER */ } bool isImportantFront = (engineConfiguration->vvtCamSensorUseRise ^ (front == TV_FALL)); bool isVvtWithRealDecoder = vvtWithRealDecoder(engineConfiguration->vvtMode[camIndex]); if (!isVvtWithRealDecoder && !isImportantFront) { // todo: there should be a way to always use real trigger code for this logic? return; } logFront(isImportantFront, nowNt, index); // 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", tc->vvtShape[camIndex], nullptr, engine->vvtTriggerConfiguration[camIndex], front == TV_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.vvtStateIndex = vvtDecoder.currentCycle.current_index; } 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; } switch(engineConfiguration->vvtMode[camIndex]) { case VVT_2JZ: // we do not know if we are in sync or out of sync, so we have to be looking for both possibilities if ((currentPosition < engineConfiguration->scriptSetting[4] || currentPosition > engineConfiguration->scriptSetting[5]) && (currentPosition < engineConfiguration->scriptSetting[4] + 360 || currentPosition > engineConfiguration->scriptSetting[5] + 360)) { // outside of the expected range return; } break; default: // else, do nothing break; } tc->triggerState.vvtCounter++; auto vvtPosition = engineConfiguration->vvtOffsets[bankIndex * CAMS_PER_BANK + camIndex] - currentPosition; if (index != 0) { // todo: only assign initial position of not first cam once cam was synchronized tc->vvtPosition[bankIndex][camIndex] = wrapVvt(vvtPosition, FOUR_STROKE_CYCLE_DURATION); // at the moment we use only primary VVT to sync crank phase return; } 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); // this could be just an 'if' but let's have it expandable for future use :) switch(engineConfiguration->vvtMode[camIndex]) { case VVT_HONDA_K: // 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 (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(CUSTOM_VVT_SYNC_POSITION, "VVT sync position too close to trigger sync"); } tc->vvtPosition[bankIndex][camIndex] = vvtPosition; } int triggerReentrant = 0; int maxTriggerReentrant = 0; uint32_t triggerDuration; uint32_t triggerMaxDuration = 0; /** * This function is called by all "hardaware" trigger inputs: * - Hardware triggers * - Trigger replay from CSV (unit tests) */ void hwHandleShaftSignal(int signalIndex, bool isRising, efitick_t timestamp) { ScopePerf perf(PE::HandleShaftSignal); #if 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 (engine->directSelfStimulation || !engine->hwTriggerInputEnabled) { // sensor noise + self-stim = loss of trigger sync return; } handleShaftSignal(signalIndex, isRising, timestamp); } // Handle all shaft signals - hardware or emulated both void handleShaftSignal(int signalIndex, bool isRising, efitick_t timestamp) { 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); } // Don't accept trigger input in case of some problems if (!engine->limpManager.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 && engineConfiguration->useOnlyRisingEdgeForTrigger; 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, engine->primaryTriggerConfiguration)) { /** * 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 */ engine->executor.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++; engine->triggerCentral.handleShaftSignal(signal, timestamp); triggerReentrant--; triggerDuration = getTimeNowLowerNt() - triggerHandlerEntryTime; triggerMaxDuration = maxI(triggerMaxDuration, triggerDuration); } void TriggerCentral::resetCounters() { memset(hwEventCounters, 0, sizeof(hwEventCounters)); } static char shaft_signal_msg_index[15]; static const bool isUpEvent[6] = { false, true, false, true, false, true }; static const char *eventId[6] = { PROTOCOL_CRANK1, PROTOCOL_CRANK1, PROTOCOL_CRANK2, PROTOCOL_CRANK2, PROTOCOL_CRANK3, PROTOCOL_CRANK3 }; static void reportEventToWaveChart(trigger_event_e ckpSignalType, int index) { if (!engine->isEngineSnifferEnabled) { // this is here just as a shortcut so that we avoid engine sniffer as soon as possible return; // engineSnifferRpmThreshold is accounted for inside engine->isEngineSnifferEnabled } itoa10(&shaft_signal_msg_index[2], index); bool isUp = isUpEvent[(int) ckpSignalType]; shaft_signal_msg_index[0] = isUp ? 'u' : 'd'; addEngineSnifferEvent(eventId[(int )ckpSignalType], (char* ) shaft_signal_msg_index); if (engineConfiguration->useOnlyRisingEdgeForTrigger) { // let's add the opposite event right away shaft_signal_msg_index[0] = isUp ? 'd' : 'u'; addEngineSnifferEvent(eventId[(int )ckpSignalType], (char* ) shaft_signal_msg_index); } } /** * This is used to filter noise spikes (interference) in trigger signal. See * The basic idea is to use not just edges, but the average amount of time the signal stays in '0' or '1'. * So we update 'accumulated periods' to track where the signal is. * And then compare between the current period and previous, with some tolerance (allowing for the wheel speed change). * @return true if the signal is passed through. */ bool TriggerNoiseFilter::noiseFilter(efitick_t nowNt, TriggerDecoderBase * triggerState, trigger_event_e signal) { // todo: find a better place for these defs static const trigger_event_e opposite[4] = { SHAFT_PRIMARY_RISING, SHAFT_PRIMARY_FALLING, SHAFT_SECONDARY_RISING, SHAFT_SECONDARY_FALLING }; static const trigger_wheel_e triggerIdx[4] = { T_PRIMARY, T_PRIMARY, T_SECONDARY, T_SECONDARY }; // we process all trigger channels independently trigger_wheel_e ti = triggerIdx[signal]; // falling is opposite to rising, and vise versa trigger_event_e os = opposite[signal]; // todo: currently only primary channel is filtered, because there are some weird trigger types on other channels if (ti != T_PRIMARY) return true; // update period accumulator: for rising signal, we update '0' accumulator, and for falling - '1' if (lastSignalTimes[signal] != -1) accumSignalPeriods[signal] += nowNt - lastSignalTimes[signal]; // save current time for this trigger channel lastSignalTimes[signal] = nowNt; // now we want to compare current accumulated period to the stored one efitick_t currentPeriod = accumSignalPeriods[signal]; // the trick is to compare between different efitick_t allowedPeriod = accumSignalPrevPeriods[os]; // but first check if we're expecting a gap bool isGapExpected = TRIGGER_WAVEFORM(isSynchronizationNeeded) && triggerState->getShaftSynchronized() && (triggerState->currentCycle.eventCount[ti] + 1) == TRIGGER_WAVEFORM(getExpectedEventCount(ti)); if (isGapExpected) { // usually we need to extend the period for gaps, based on the trigger info allowedPeriod *= TRIGGER_WAVEFORM(syncRatioAvg); } // also we need some margin for rapidly changing trigger-wheel speed, // that's why we expect the period to be no less than 2/3 of the previous period (this is just an empirical 'magic' coef.) efitick_t minAllowedPeriod = 2 * allowedPeriod / 3; // but no longer than 5/4 of the previous 'normal' period efitick_t maxAllowedPeriod = 5 * allowedPeriod / 4; // above all, check if the signal comes not too early if (currentPeriod >= minAllowedPeriod) { // now we store this period as a reference for the next time, // BUT we store only 'normal' periods, and ignore too long periods (i.e. gaps) if (!isGapExpected && (maxAllowedPeriod == 0 || currentPeriod <= maxAllowedPeriod)) { accumSignalPrevPeriods[signal] = currentPeriod; } // reset accumulator accumSignalPeriods[signal] = 0; return true; } // all premature or extra-long events are ignored - treated as interference return false; } void TriggerCentral::decodeMapCam(efitick_t timestamp, float currentPhase) { #if WITH_TS_STATE if (engineConfiguration->vvtMode[0] == VVT_MAP_V_TWIN_ANOTHER && Sensor::getOrZero(SensorType::Rpm) < engineConfiguration->cranking.rpm) { // we are trying to figure out which 360 half of the total 720 degree cycle is which, so we compare those in 360 degree sense. auto toothAngle360 = currentPhase; while (toothAngle360 >= 360) { toothAngle360 -= 360; } if (mapCamPrevToothAngle < engineConfiguration->mapCamDetectionAnglePosition && toothAngle360 > engineConfiguration->mapCamDetectionAnglePosition) { // we are somewhere close to 'mapCamDetectionAnglePosition' // warning: hack hack hack float map = engine->outputChannels.instantMAPValue; // Compute diff against the last time we were here float diff = map - mapCamPrevCycleValue; mapCamPrevCycleValue = map; if (diff > 0) { mapVvt_map_peak++; int revolutionCounter = engine->triggerCentral.triggerState.getTotalRevolutionCounter(); mapVvt_MAP_AT_CYCLE_COUNT = revolutionCounter - prevChangeAtCycle; prevChangeAtCycle = revolutionCounter; hwHandleVvtCamSignal(TV_RISE, timestamp, /*index*/0); hwHandleVvtCamSignal(TV_FALL, timestamp, /*index*/0); #if EFI_UNIT_TEST // hack? feature? existing unit test relies on VVT phase available right away // but current implementation which is based on periodicFastCallback would only make result available on NEXT tooth int rpm = Sensor::getOrZero(SensorType::Rpm); efitick_t nowNt = getTimeNowNt(); engine->limpManager.updateState(rpm, nowNt); #endif // EFI_UNIT_TEST } mapVvt_MAP_AT_SPECIAL_POINT = map; mapVvt_MAP_AT_DIFF = diff; } mapCamPrevToothAngle = toothAngle360; } #endif // WITH_TS_STATE } /** * This method is NOT invoked for VR falls. */ void TriggerCentral::handleShaftSignal(trigger_event_e signal, efitick_t timestamp) { if (triggerShape.shapeDefinitionError) { // trigger is broken, we cannot do anything here warning(CUSTOM_ERR_UNEXPECTED_SHAFT_EVENT, "Shaft event while trigger is mis-configured"); // magic value to indicate a problem hwEventCounters[0] = 155; return; } // This code gathers some statistics on signals and compares accumulated periods to filter interference if (engineConfiguration->useNoiselessTriggerDecoder) { if (!noiseFilter.noiseFilter(timestamp, &triggerState, signal)) { return; } if (!isUsefulSignal(signal, engine->primaryTriggerConfiguration)) { return; } } engine->onTriggerSignalEvent(); m_lastEventTimer.reset(timestamp); int eventIndex = (int) signal; efiAssertVoid(CUSTOM_TRIGGER_EVENT_TYPE, eventIndex >= 0 && eventIndex < HW_EVENT_TYPES, "signal type"); hwEventCounters[eventIndex]++; // Decode the trigger! auto decodeResult = triggerState.decodeTriggerEvent( "trigger", triggerShape, engine, engine->primaryTriggerConfiguration, signal, timestamp); // Don't propagate state if we don't know where we are if (decodeResult) { ScopePerf perf(PE::ShaftPositionListeners); /** * If we only have a crank position sensor with four stroke, here we are extending crank revolutions with a 360 degree * cycle into a four stroke, 720 degrees cycle. */ int crankDivider = getCrankDivider(triggerShape.getOperationMode()); int crankInternalIndex = triggerState.getTotalRevolutionCounter() % crankDivider; int triggerIndexForListeners = decodeResult.Value.CurrentIndex + (crankInternalIndex * triggerShape.getSize()); if (triggerIndexForListeners == 0) { m_syncPointTimer.reset(timestamp); } reportEventToWaveChart(signal, triggerIndexForListeners); // Compute the current engine absolute phase, 0 means currently at #1 TDC auto currentPhase = engine->triggerCentral.triggerFormDetails.eventAngles[triggerIndexForListeners] - tdcPosition(); wrapAngle(currentPhase, "currentEnginePhase", CUSTOM_ERR_6555); #if EFI_TUNER_STUDIO engine->outputChannels.currentEnginePhase = currentPhase; #endif // EFI_TUNER_STUDIO #if TRIGGER_EXTREME_LOGGING efiPrintf("trigger %d %d %d", triggerIndexForListeners, getRevolutionCounter(), (int)getTimeNowUs()); #endif /* TRIGGER_EXTREME_LOGGING */ // Update engine RPM rpmShaftPositionCallback(signal, triggerIndexForListeners, timestamp); // Schedule the TDC mark tdcMarkCallback(triggerIndexForListeners, timestamp); #if !EFI_UNIT_TEST #if EFI_MAP_AVERAGING mapAveragingTriggerCallback(triggerIndexForListeners, timestamp); #endif /* EFI_MAP_AVERAGING */ #endif /* EFI_UNIT_TEST */ #if EFI_LOGIC_ANALYZER waTriggerEventListener(signal, triggerIndexForListeners, timestamp); #endif // TODO: is this logic to compute next trigger tooth angle correct? auto nextToothIndex = triggerIndexForListeners; float nextPhase = 0; do { // I don't love this. nextToothIndex = (nextToothIndex + 1) % engine->engineCycleEventCount; nextPhase = engine->triggerCentral.triggerFormDetails.eventAngles[nextToothIndex] - tdcPosition(); wrapAngle(nextPhase, "nextEnginePhase", CUSTOM_ERR_6555); } while (nextPhase == currentPhase); // Handle ignition and injection mainTriggerCallback(triggerIndexForListeners, timestamp, currentPhase, nextPhase); // Decode the MAP based "cam" sensor decodeMapCam(timestamp, currentPhase); } else { // We don't have sync, but report to the wave chart anyway as index 0. reportEventToWaveChart(signal, 0); } } static void triggerShapeInfo() { #if EFI_PROD_CODE || EFI_SIMULATOR TriggerWaveform *shape = &engine->triggerCentral.triggerShape; TriggerFormDetails *triggerFormDetails = &engine->triggerCentral.triggerFormDetails; efiPrintf("useRise=%s", boolToString(TRIGGER_WAVEFORM(useRiseEdge))); efiPrintf("gap from %.2f to %.2f", TRIGGER_WAVEFORM(syncronizationRatioFrom[0]), TRIGGER_WAVEFORM(syncronizationRatioTo[0])); for (size_t i = 0; i < shape->getSize(); i++) { efiPrintf("event %d %.2f", i, triggerFormDetails->eventAngles[i]); } #endif } #if EFI_PROD_CODE extern PwmConfig triggerSignal; #endif /* #if EFI_PROD_CODE */ void triggerInfo(void) { #if EFI_PROD_CODE || EFI_SIMULATOR TriggerWaveform *ts = &engine->triggerCentral.triggerShape; #if (HAL_TRIGGER_USE_PAL == TRUE) && (PAL_USE_CALLBACKS == TRUE) efiPrintf("trigger PAL mode %d", engine->hwTriggerInputEnabled); #else #endif /* HAL_TRIGGER_USE_PAL */ efiPrintf("Template %s (%d) trigger %s (%d) useRiseEdge=%s onlyFront=%s tdcOffset=%.2f", getEngine_type_e(engineConfiguration->engineType), engineConfiguration->engineType, getTrigger_type_e(engineConfiguration->trigger.type), engineConfiguration->trigger.type, boolToString(TRIGGER_WAVEFORM(useRiseEdge)), boolToString(engineConfiguration->useOnlyRisingEdgeForTrigger), TRIGGER_WAVEFORM(tdcPosition)); if (engineConfiguration->trigger.type == TT_TOOTHED_WHEEL) { efiPrintf("total %d/skipped %d", engineConfiguration->trigger.customTotalToothCount, engineConfiguration->trigger.customSkippedToothCount); } efiPrintf("trigger#1 event counters up=%d/down=%d", engine->triggerCentral.getHwEventCounter(0), engine->triggerCentral.getHwEventCounter(1)); if (ts->needSecondTriggerInput) { efiPrintf("trigger#2 event counters up=%d/down=%d", engine->triggerCentral.getHwEventCounter(2), engine->triggerCentral.getHwEventCounter(3)); } efiPrintf("expected cycle events %d/%d/%d", TRIGGER_WAVEFORM(getExpectedEventCount(0)), TRIGGER_WAVEFORM(getExpectedEventCount(1)), TRIGGER_WAVEFORM(getExpectedEventCount(2))); efiPrintf("trigger type=%d/need2ndChannel=%s", engineConfiguration->trigger.type, boolToString(TRIGGER_WAVEFORM(needSecondTriggerInput))); efiPrintf("synchronizationNeeded=%s/isError=%s/total errors=%d ord_err=%d/total revolutions=%d/self=%s", boolToString(ts->isSynchronizationNeeded), boolToString(engine->triggerCentral.isTriggerDecoderError()), engine->triggerCentral.triggerState.totalTriggerErrorCounter, engine->triggerCentral.triggerState.orderingErrorCounter, engine->triggerCentral.triggerState.getTotalRevolutionCounter(), boolToString(engine->directSelfStimulation)); if (TRIGGER_WAVEFORM(isSynchronizationNeeded)) { efiPrintf("gap from %.2f to %.2f", TRIGGER_WAVEFORM(syncronizationRatioFrom[0]), TRIGGER_WAVEFORM(syncronizationRatioTo[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->triggerSimulatorFrequency); 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]), triggerSignal.safe.phaseIndex); #endif /* EFI_EMULATE_POSITION_SENSORS */ } for (int camInputIndex = 0; camInputIndexcamInputs[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, engine->triggerCentral.vvtEventRiseCounter[camInputIndex], engine->triggerCentral.vvtEventFallCounter[camInputIndex]); } } // efiPrintf("3rd trigger simulator: %s %s", hwPortname(engineConfiguration->triggerSimulatorPins[2]), // getPin_output_mode_e(engineConfiguration->triggerSimulatorPinModes[2])); efiPrintf("trigger error extra LED: %s %s", hwPortname(engineConfiguration->triggerErrorPin), getPin_output_mode_e(engineConfiguration->triggerErrorPinMode)); efiPrintf("primary logic input: %s", hwPortname(engineConfiguration->logicAnalyzerPins[0])); efiPrintf("secondary logic input: %s", hwPortname(engineConfiguration->logicAnalyzerPins[1])); efiPrintf("totalTriggerHandlerMaxTime=%d", triggerMaxDuration); #endif /* EFI_PROD_CODE */ #if EFI_ENGINE_SNIFFER efiPrintf("engine sniffer current size=%d", waveChart.getSize()); #endif /* EFI_ENGINE_SNIFFER */ } static void resetRunningTriggerCounters() { #if !EFI_UNIT_TEST engine->triggerCentral.resetCounters(); triggerInfo(); #endif } void onConfigurationChangeTriggerCallback() { bool changed = false; // todo: how do we static_assert here? efiAssertVoid(OBD_PCM_Processor_Fault, 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]); } 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(useOnlyRisingEdgeForTrigger); changed |= isConfigurationChanged(globalTriggerAngleOffset); changed |= isConfigurationChanged(trigger.customTotalToothCount); changed |= isConfigurationChanged(trigger.customSkippedToothCount); changed |= isConfigurationChanged(vvtCamSensorUseRise); changed |= isConfigurationChanged(overrideTriggerGaps); if (changed) { #if EFI_ENGINE_CONTROL engine->updateTriggerWaveform(); engine->triggerCentral.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 engine->triggerCentral.triggerConfigChanged = engine->triggerCentral.triggerConfigChanged || changed; } /** * @returns true if configuration just changed, and if that change has affected trigger */ bool TriggerCentral::checkIfTriggerConfigChanged() { bool result = triggerVersion.isOld(engine->getGlobalConfigurationVersion()) && triggerConfigChanged; triggerConfigChanged = false; // whoever has called the method is supposed to react to changes return result; } bool TriggerCentral::isTriggerConfigChanged() { return triggerConfigChanged; } void validateTriggerInputs() { if (engineConfiguration->triggerInputPins[0] == Gpio::Unassigned && engineConfiguration->triggerInputPins[1] != Gpio::Unassigned) { firmwareError(OBD_PCM_Processor_Fault, "First trigger channel is missing"); } if (engineConfiguration->camInputs[0] == Gpio::Unassigned && engineConfiguration->camInputs[1] != Gpio::Unassigned) { firmwareError(OBD_PCM_Processor_Fault, "If you only have cam on exhaust please pretend that it's on intake in configuration"); } if (engineConfiguration->camInputs[0] == Gpio::Unassigned && engineConfiguration->camInputs[2] != Gpio::Unassigned) { firmwareError(OBD_PCM_Processor_Fault, "First bank cam input is required if second bank specified"); } } void initTriggerCentral() { strcpy((char*) shaft_signal_msg_index, "x_"); #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 } /** * @return TRUE is something is wrong with trigger decoding */ bool TriggerCentral::isTriggerDecoderError() { return engine->triggerErrorDetection.sum(6) > 4; } #endif // EFI_SHAFT_POSITION_INPUT