rpm_calculator.cpp File Reference

Detailed Description

RPM calculator.

Here we listen to position sensor events in order to figure our if engine is currently running or not. Actual getRpm() is calculated once per crankshaft revolution, based on the amount of time passed since the start of previous shaft revolution.

We also have 'instant RPM' logic separate from this 'cycle RPM' logic. Open question is why do we not use instant RPM instead of cycle RPM more often.

Date

Jan 1, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file rpm_calculator.cpp.

Functions
operation_mode_e	lookupOperationMode ()
static bool	doesTriggerImplyOperationMode (trigger_type_e type)
void	rpmShaftPositionCallback (trigger_event_e ckpSignalType, uint32_t trgEventIndex, efitick_t nowNt)
	Shaft position callback used by RPM calculation logic.
static void	onTdcCallback ()
void	tdcMarkCallback (uint32_t trgEventIndex, efitick_t nowNt)
efitick_t	scheduleByAngle (scheduling_s *timer, efitick_t nowNt, angle_t angle, action_s const &action)

Function Documentation

doesTriggerImplyOperationMode()

static bool doesTriggerImplyOperationMode ( trigger_type_e  type )

static

Definition at line 68 of file rpm_calculator.cpp.

                                                               {
    switch (type) {
        case trigger_type_e::TT_TOOTHED_WHEEL:
        case trigger_type_e::TT_HALF_MOON:
        case trigger_type_e::TT_3_1_CAM:   // huh why is this trigger with CAM suffix right in the name on this exception list?!
        case trigger_type_e::TT_36_2_2_2:   // this trigger is special due to rotary application https://github.com/rusefi/rusefi/issues/5566
        case trigger_type_e::TT_TOOTHED_WHEEL_60_2:
        case trigger_type_e::TT_TOOTHED_WHEEL_36_1:
            // These modes could be either cam or crank speed
            return false;
        default:
            return true;
    }
}

Referenced by RpmCalculator::getOperationMode().

Here is the caller graph for this function:

lookupOperationMode()

operation_mode_e lookupOperationMode

(

)

Definition at line 57 of file rpm_calculator.cpp.

                                       {
    if (engineConfiguration->twoStroke) {
        return TWO_STROKE;
    } else {
        return engineConfiguration->skippedWheelOnCam ? FOUR_STROKE_CAM_SENSOR : FOUR_STROKE_CRANK_SENSOR;
    }
}

Referenced by TriggerCentral::applyShapesConfiguration(), and RpmCalculator::getOperationMode().

Here is the caller graph for this function:

onTdcCallback()

static void onTdcCallback ( )

static

This callback has nothing to do with actual engine control, it just sends a Top Dead Center mark to the rusEfi console digital sniffer.

Definition at line 340 of file rpm_calculator.cpp.

                            {
#if EFI_UNIT_TEST
    if (!engine->needTdcCallback) {
        return;
    }
#endif /* EFI_UNIT_TEST */
 
    float rpm = Sensor::getOrZero(SensorType::Rpm);
    addEngineSnifferTdcEvent(rpm);
#if EFI_TOOTH_LOGGER
    LogTriggerTopDeadCenter(getTimeNowNt());
#endif /* EFI_TOOTH_LOGGER */
}

Here is the call graph for this function:

rpmShaftPositionCallback()

void rpmShaftPositionCallback	(	trigger_event_e	ckpSignalType,
		uint32_t	trgEventIndex,
		efitick_t	nowNt
	)

Shaft position callback used by RPM calculation logic.

This callback should always be the first of trigger callbacks because other callbacks depend of values updated here. This callback is invoked on interrupt thread.

Four stroke cycle is two crankshaft revolutions

We always do '* 2' because the event signal is already adjusted to 'per engine cycle' and each revolution of crankshaft consists of two engine cycles revolutions

Definition at line 261 of file rpm_calculator.cpp.

                                                 {
 
    bool alwaysInstantRpm = engineConfiguration->alwaysInstantRpm;
 
    RpmCalculator *rpmState = &engine->rpmCalculator;
 
    if (trgEventIndex == 0) {
        if (HAVE_CAM_INPUT()) {
            engine->triggerCentral.validateCamVvtCounters();
        }
 
 
        bool hadRpmRecently = rpmState->checkIfSpinning(nowNt);
 
        float periodSeconds = engine->rpmCalculator.lastTdcTimer.getElapsedSecondsAndReset(nowNt);
 
        if (hadRpmRecently) {
        /**
         * Four stroke cycle is two crankshaft revolutions
         *
         * We always do '* 2' because the event signal is already adjusted to 'per engine cycle'
         * and each revolution of crankshaft consists of two engine cycles revolutions
         *
         */
            if (!alwaysInstantRpm) {
                if (periodSeconds == 0) {
                    rpmState->setRpmValue(0);
                    rpmState->rpmRate = 0;
                } else {
                  // todo: extract utility method? see duplication with high_pressure_pump.cpp
                    int mult = (int)getEngineCycle(getEngineRotationState()->getOperationMode()) / 360;
                    float rpm = 60 * mult / periodSeconds;
 
                    auto rpmDelta = rpm - rpmState->previousRpmValue;
                    rpmState->rpmRate = rpmDelta / (mult * periodSeconds);
 
                    rpmState->setRpmValue(rpm);
                }
            }
        } else {
            // we are here only once trigger is synchronized for the first time
            // while transitioning  from 'spinning' to 'running'
            engine->triggerCentral.instantRpm.movePreSynchTimestamps();
        }
 
        rpmState->onNewEngineCycle();
    }
 
 
    // Always update instant RPM even when not spinning up
    engine->triggerCentral.instantRpm.updateInstantRpm(
            engine->triggerCentral.triggerState.currentCycle.current_index,
 
        engine->triggerCentral.triggerShape, &engine->triggerCentral.triggerFormDetails,
        trgEventIndex, nowNt);
 
    float instantRpm = engine->triggerCentral.instantRpm.getInstantRpm();
    if (alwaysInstantRpm) {
        rpmState->setRpmValue(instantRpm);
    } else if (rpmState->isSpinningUp()) {
        rpmState->assignRpmValue(instantRpm);
#if 0
        efiPrintf("** RPM: idx=%d sig=%d iRPM=%d", trgEventIndex, ckpSignalType, instantRpm);
#else
        UNUSED(ckpSignalType);
#endif
    }
}

Referenced by TriggerCentral::handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

scheduleByAngle()

efitick_t scheduleByAngle	(	scheduling_s *	timer,
		efitick_t	nowNt,
		angle_t	angle,
		action_s const &	action
	)

Schedules a callback 'angle' degree of crankshaft from now. The callback would be executed once after the duration of time which it takes the crankshaft to rotate to the specified angle.

Returns

tick time of scheduled action

Definition at line 389 of file rpm_calculator.cpp.

                                                                                                       {
    float delayUs = engine->rpmCalculator.oneDegreeUs * angle;
 
    efitick_t actionTimeNt = sumTickAndFloat(nowNt, USF2NT(delayUs));
 
    engine->scheduler.schedule("angle", timer, actionTimeNt, action);
 
    return actionTimeNt;
}

Referenced by fireSparkAndPrepareNextSchedule(), MapAveragingModule::onEnginePhase(), Engine::onSparkFireKnockSense(), InjectionEvent::onTriggerTooth(), HpfpController::pinTurnOn(), TriggerScheduler::scheduleEventsUntilNextTriggerTooth(), TriggerScheduler::scheduleOrQueue(), scheduleSparkEvent(), startAveraging(), tdcMarkCallback(), and turnSparkPinHighStartCharging().

Here is the call graph for this function:

Here is the caller graph for this function:

tdcMarkCallback()

void tdcMarkCallback	(	uint32_t	trgEventIndex,
		efitick_t	nowNt
	)

This trigger callback schedules the actual physical TDC callback in relation to trigger synchronization point.

Definition at line 357 of file rpm_calculator.cpp.

                                                 {
    bool isTriggerSynchronizationPoint = trgEventIndex == 0;
    if (isTriggerSynchronizationPoint && getTriggerCentral()->isEngineSnifferEnabled) {
 
#if EFI_UNIT_TEST
        if (!engine->tdcMarkEnabled) {
            return;
        }
#endif // EFI_UNIT_TEST
 
 
        // two instances of scheduling_s are needed to properly handle event overlap
        int revIndex2 = getRevolutionCounter() % 2;
        float rpm = Sensor::getOrZero(SensorType::Rpm);
        // todo: use tooth event-based scheduling, not just time-based scheduling
        if (rpm != 0) {
            angle_t tdcPosition = tdcPosition();
            // we need a positive angle offset here
            wrapAngle(tdcPosition, "tdcPosition", ObdCode::CUSTOM_ERR_6553);
            scheduleByAngle(&engine->tdcScheduler[revIndex2], nowNt, tdcPosition, action_s::make<onTdcCallback>());
        }
    }
}

Referenced by TriggerCentral::handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.