RpmCalculator Class Reference

#include <rpm_calculator.h>

Inheritance diagram for RpmCalculator:

Collaboration diagram for RpmCalculator:

Public Member Functions
	RpmCalculator ()
operation_mode_e	getOperationMode () const override
void	onSlowCallback ()
bool	isStopped () const override
bool	isSpinningUp () const
bool	isCranking () const override
bool	isRunning () const
bool	checkIfSpinning (efitick_t nowNt) const
spinning_state_e	getState () const
void	setSpinningUp (efitick_t nowNt)
void	setStopSpinning ()
float	getCachedRpm () const
float	getMinCrankingRpm () const
void	onNewEngineCycle ()
uint32_t	getRevolutionCounterM (void) const
void	setRpmValue (float value)
void	assignRpmValue (float value)
uint32_t	getRevolutionCounterSinceStart (void) const
float	getRpmAcceleration () const
float	getSecondsSinceEngineStart (efitick_t nowNt) const
floatus_t	getOneDegreeUs () override
Public Member Functions inherited from StoredValueSensor
SensorResult	get () const final override
	StoredValueSensor (SensorType type, efidur_t timeoutNt)
void	invalidate ()
void	invalidate (UnexpectedCode why)
void	setValidValue (float value, efitick_t timestamp)
void	showInfo (const char *sensorName) const override
virtual void	setTimeout (int timeoutMs)
Public Member Functions inherited from Sensor
bool	Register ()
const char *	getSensorName () const
virtual bool	hasSensor () const
virtual float	getRaw () const
virtual bool	isRedundant () const
void	unregister ()
SensorType	type () const

Data Fields
float	previousRpmValue = 0
floatus_t	oneDegreeUs = NAN
Timer	lastTdcTimer
float	rpmRate = 0

Protected Member Functions
void	showInfo (const char *sensorName) const override
Protected Member Functions inherited from Sensor
	Sensor (SensorType type)

Private Attributes
float	cachedRpmValue = 0
float	minCrankingRpm = 0
uint32_t	revolutionCounterSinceBoot = 0
uint32_t	revolutionCounterSinceStart = 0
spinning_state_e	state = STOPPED
bool	isSpinning = false
Timer	engineStartTimer

Additional Inherited Members
Static Public Member Functions inherited from Sensor
static void	showAllSensorInfo ()
static void	showInfo (SensorType type)
static void	resetRegistry ()
static const Sensor *	getSensorOfType (SensorType type)
static SensorResult	get (SensorType type)
static float	getOrZero (SensorType type)
static float	getRaw (SensorType type)
static bool	isRedundant (SensorType type)
static bool	hasSensor (SensorType type)
static void	setMockValue (SensorType type, float value, bool mockRedundant=false)
static void	setInvalidMockValue (SensorType type)
static void	resetMockValue (SensorType type)
static void	resetAllMocks ()
static void	inhibitTimeouts (bool inhibit)
static const char *	getSensorName (SensorType type)
Static Protected Attributes inherited from Sensor
static bool	s_inhibitSensorTimeouts = false

Detailed Description

Most consumers should access value via Sensor framework by SensorType::Rpm key

Definition at line 42 of file rpm_calculator.h.

Constructor & Destructor Documentation

RpmCalculator()

RpmCalculator::RpmCalculator

(

)

Definition at line 102 of file rpm_calculator.cpp.

                             :
        StoredValueSensor(SensorType::Rpm, 0)
    {
    assignRpmValue(0);
}

Here is the call graph for this function:

Member Function Documentation

assignRpmValue()

void RpmCalculator::assignRpmValue

(

float

value

)

The same as setRpmValue() but without state change. We need this to be public because of calling rpmState->assignRpmValue() from rpmShaftPositionCallback()

this would make sure that we have good numbers for first cranking revolution #275 cranking could be improved

Definition at line 138 of file rpm_calculator.cpp.

                                                      {
    previousRpmValue = cachedRpmValue;
 
    cachedRpmValue = floatRpmValue;
 
    setValidValue(floatRpmValue, 0);    // 0 for current time since RPM sensor never times out
    if (cachedRpmValue <= 0) {
        oneDegreeUs = NAN;
    } else {
        // here it's really important to have more precise float RPM value, see #796
        oneDegreeUs = getOneDegreeTimeUs(floatRpmValue);
        if (previousRpmValue == 0) {
            /**
             * this would make sure that we have good numbers for first cranking revolution
             * #275 cranking could be improved
             */
            engine->periodicFastCallback();
        }
    }
}

Referenced by RpmCalculator(), rpmShaftPositionCallback(), setRpmValue(), and setStopSpinning().

Here is the call graph for this function:

Here is the caller graph for this function:

checkIfSpinning()

bool RpmCalculator::checkIfSpinning

(

efitick_t

nowNt

)

const

Returns

true if engine is spinning (cranking or running)

Also check if there were no trigger events

Definition at line 118 of file rpm_calculator.cpp.

                                                         {
    if (getLimpManager()->shutdownController.isEngineStop(nowNt)) {
        return false;
    }
 
    // Anything below 60 rpm is not running
    bool noRpmEventsForTooLong = lastTdcTimer.getElapsedSeconds(nowNt) > NO_RPM_EVENTS_TIMEOUT_SECS;
 
    /**
     * Also check if there were no trigger events
     */
    bool noTriggerEventsForTooLong = !engine->triggerCentral.engineMovedRecently(nowNt);
 
    if (noRpmEventsForTooLong || noTriggerEventsForTooLong) {
        return false;
    }
 
    return true;
}

Referenced by rpmShaftPositionCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getCachedRpm()

float RpmCalculator::getCachedRpm

(

)

const

Just a quick getter for rpmValue Should be same exact value as Sensor::get(SensorType::Rpm).Value just quicker. Open question if we have any cases where this opimization is needed.

Definition at line 49 of file rpm_calculator.cpp.

                                        {
    return cachedRpmValue;
}

Referenced by TriggerCentral::handleShaftSignal(), and mainTriggerCallback().

Here is the caller graph for this function:

getMinCrankingRpm()

float RpmCalculator::getMinCrankingRpm

(

)

const

Definition at line 53 of file rpm_calculator.cpp.

                                             {
    return minCrankingRpm;
}

Referenced by getCrankingAdvance().

Here is the caller graph for this function:

getOneDegreeUs()

floatus_t RpmCalculator::getOneDegreeUs ( )

inlineoverridevirtual

Implements EngineRotationState.

Definition at line 124 of file rpm_calculator.h.

                                        {
        return oneDegreeUs;
    }

getOperationMode()

operation_mode_e RpmCalculator::getOperationMode ( ) const

overridevirtual

Implements EngineRotationState.

Definition at line 85 of file rpm_calculator.cpp.

                                                       {
#if EFI_SHAFT_POSITION_INPUT
    // Ignore user-provided setting for well known triggers.
    if (doesTriggerImplyOperationMode(engineConfiguration->trigger.type)) {
        // For example for Miata NA, there is no reason to allow user to set FOUR_STROKE_CRANK_SENSOR
        return engine->triggerCentral.triggerShape.getWheelOperationMode();
    } else
#endif // EFI_SHAFT_POSITION_INPUT
    {
        // For example 36-1, could be on either cam or crank, so we have to ask the user
        return lookupOperationMode();
    }
}

Here is the call graph for this function:

getRevolutionCounterM()

uint32_t RpmCalculator::getRevolutionCounterM

(

void

)

const

Definition at line 212 of file rpm_calculator.cpp.

                                                        {
    return revolutionCounterSinceBoot;
}

getRevolutionCounterSinceStart()

uint32_t RpmCalculator::getRevolutionCounterSinceStart

(

void

)

const

Definition at line 45 of file rpm_calculator.cpp.

                                                                 {
    return revolutionCounterSinceStart;
}

Referenced by getCrankingFuel(), IdleController::getCrankingTaperFraction(), getPostCrankingFuelCorrection(), and updateTunerStudioState().

Here is the caller graph for this function:

getRpmAcceleration()

float RpmCalculator::getRpmAcceleration

(

)

const

RPM rate of change between current RPM and RPM measured during previous engine cycle see also SC_RPM_ACCEL

Definition at line 27 of file rpm_calculator.cpp.

                                              {
    return rpmRate;
}

Referenced by updateTunerStudioState().

Here is the caller graph for this function:

getSecondsSinceEngineStart()

float RpmCalculator::getSecondsSinceEngineStart

(

efitick_t

nowNt

)

const

Definition at line 331 of file rpm_calculator.cpp.

                                                                     {
    return engineStartTimer.getElapsedSeconds(nowNt);
}

Referenced by LtftState::load(), VvtController::onFastCallback(), and LimpManager::updateState().

Here is the caller graph for this function:

getState()

spinning_state_e RpmCalculator::getState

(

)

const

This accessor is used in unit-tests.

Definition at line 203 of file rpm_calculator.cpp.

                                               {
    return state;
}

Referenced by configureRusefiLuaHooks().

Here is the caller graph for this function:

isCranking()

bool RpmCalculator::isCranking ( ) const

overridevirtual

Returns true if the engine is cranking OR spinning up

Implements EngineRotationState.

Definition at line 36 of file rpm_calculator.cpp.

                                     {
    // Spinning-up with non-zero RPM is suitable for all engine math, as good as cranking
    return state == CRANKING || (state == SPINNING_UP && cachedRpmValue > 0);
}

Referenced by IgnitionState::getAdvance(), getInjectionMass(), FanController::getState(), WallFuelController::onFastCallback(), EngineState::periodicFastCallback(), Engine::periodicSlowCallback(), showInfo(), and tle8888startup().

Here is the caller graph for this function:

isRunning()

bool RpmCalculator::isRunning

(

)

const

Returns true if the engine is running and not cranking

Returns

true if there was a full shaft revolution within the last second

Definition at line 111 of file rpm_calculator.cpp.

                                    {
    return state == RUNNING;
}

Referenced by IdleController::determinePhase(), disengageStarterIfNeeded(), ShortTermFuelTrim::getCorrectionState(), FanController::getState(), TripOdometer::onSlowCallback(), Engine::periodicSlowCallback(), StepperMotorBase::setInitialPosition(), showInfo(), startKnockSampling(), startStopButtonToggle(), and LimpManager::updateState().

Here is the caller graph for this function:

isSpinningUp()

bool RpmCalculator::isSpinningUp

(

)

const

Returns true if the engine is spinning up

Definition at line 41 of file rpm_calculator.cpp.

                                       {
    return state == SPINNING_UP;
}

Referenced by getCurrentIgnitionMode(), rpmShaftPositionCallback(), setSpinningUp(), and showInfo().

Here is the caller graph for this function:

isStopped()

bool RpmCalculator::isStopped ( ) const

overridevirtual

Returns true if the engine is not spinning (RPM==0)

Implements EngineRotationState.

Definition at line 31 of file rpm_calculator.cpp.

                                    {
    // Spinning-up with zero RPM means that the engine is not ready yet, and is treated as 'stopped'.
    return state == STOPPED || (state == SPINNING_UP && cachedRpmValue == 0);
}

Referenced by doPeriodicSlowCallback(), executeTSCommand(), setSpinningUp(), showInfo(), slowStartStopButtonCallback(), startStopButtonToggle(), and storageAllowWriteID().

Here is the caller graph for this function:

onNewEngineCycle()

void RpmCalculator::onNewEngineCycle

(

)

This method is invoked once per engine cycle right after we calculate new RPM value

Definition at line 207 of file rpm_calculator.cpp.

                                     {
    revolutionCounterSinceBoot++;
    revolutionCounterSinceStart++;
}

Referenced by rpmShaftPositionCallback().

Here is the caller graph for this function:

onSlowCallback()

void RpmCalculator::onSlowCallback

(

)

Definition at line 216 of file rpm_calculator.cpp.

                                   {
    // Stop the engine if it's been too long since we got a trigger event
    if (!engine->triggerCentral.engineMovedRecently(getTimeNowNt())) {
        setStopSpinning();
    }
}

Referenced by doPeriodicSlowCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

setRpmValue()

void RpmCalculator::setRpmValue

(

float

value

)

We are here if RPM is above zero but we have not seen running RPM yet. This gives us cranking hysteresis - a drop of RPM during running is still running, not cranking.

Definition at line 159 of file rpm_calculator.cpp.

                                           {
    if (value > MAX_ALLOWED_RPM) {
        value = 0;
    }
 
    assignRpmValue(value);
    spinning_state_e oldState = state;
    // Change state
    if (cachedRpmValue == 0) {
        // Reset minCrankingRpm between attempts
        minCrankingRpm = 0;
        state = STOPPED;
    } else if (cachedRpmValue >= engineConfiguration->cranking.rpm) {
        if (state != RUNNING) {
            // Store the time the engine started
            engineStartTimer.reset();
        }
 
        state = RUNNING;
    } else if (state == STOPPED || state == SPINNING_UP) {
        /**
         * We are here if RPM is above zero but we have not seen running RPM yet.
         * This gives us cranking hysteresis - a drop of RPM during running is still running, not cranking.
         */
        if (value < minCrankingRpm || minCrankingRpm == 0)
            minCrankingRpm = value;
        state = CRANKING;
    }
#if EFI_ENGINE_CONTROL
    // This presumably fixes injection mode change for cranking-to-running transition.
    // 'isSimultaneous' flag should be updated for events if injection modes differ for cranking and running.
    if (state != oldState && engineConfiguration->crankingInjectionMode != engineConfiguration->injectionMode) {
        // Reset the state of all injectors: when we change fueling modes, we could
        // immediately reschedule an injection that's currently underway.  That will cause
        // the injector's overlappingCounter to get out of sync with reality.  As the fix,
        // every injector's state is forcibly reset just before we could cause that to happen.
        engine->injectionEvents.resetOverlapping();
 
        // reschedule all injection events now that we've reset them
        engine->injectionEvents.addFuelEvents();
    }
#endif
}

Referenced by rpmShaftPositionCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

setSpinningUp()

void RpmCalculator::setSpinningUp

(

efitick_t

nowNt

)

Should be called on every trigger event when the engine is just starting to spin up.

Definition at line 239 of file rpm_calculator.cpp.

                                                 {
    if (!engineConfiguration->isFasterEngineSpinUpEnabled)
        return;
    // Only a completely stopped and non-spinning engine can enter the spinning-up state.
    if (isStopped() && !isSpinning) {
        state = SPINNING_UP;
        engine->triggerCentral.instantRpm.spinningEventIndex = 0;
        isSpinning = true;
    }
    // update variables needed by early instant RPM calc.
    if (isSpinningUp() && !engine->triggerCentral.triggerState.getShaftSynchronized()) {
        engine->triggerCentral.instantRpm.setLastEventTimeForInstantRpm(nowNt);
    }
}

Referenced by Engine::OnTriggerStateProperState().

Here is the call graph for this function:

Here is the caller graph for this function:

setStopSpinning()

void RpmCalculator::setStopSpinning

(

)

Called if the synchronization is lost due to a trigger timeout.

Definition at line 223 of file rpm_calculator.cpp.

                                    {
    isSpinning = false;
    revolutionCounterSinceStart = 0;
    rpmRate = 0;
 
    if (cachedRpmValue != 0) {
        assignRpmValue(0);
        // needed by 'useNoiselessTriggerDecoder'
        engine->triggerCentral.noiseFilter.resetAccumSignalData();
        efiPrintf("engine stopped");
    }
    state = STOPPED;
 
    engine->onEngineStopped();
}

Referenced by onSlowCallback(), and Engine::OnTriggerSynchronizationLost().

Here is the call graph for this function:

Here is the caller graph for this function:

showInfo()

void RpmCalculator::showInfo ( const char *  sensorName ) const

overrideprotectedvirtual

Implements Sensor.

Definition at line 66 of file sensor_info_printing.cpp.

                                                {
#if EFI_SHAFT_POSITION_INPUT
    efiPrintf("RPM sensor: stopped: %d spinning up: %d cranking: %d running: %d rpm: %f", 
        isStopped(),
        isSpinningUp(),
        isCranking(),
        isRunning(),
        get().value_or(0)
    );
#endif // EFI_SHAFT_POSITION_INPUT
}

Here is the call graph for this function:

Field Documentation

cachedRpmValue

float RpmCalculator::cachedRpmValue = 0

private

At this point this value is same exact value as in private m_value variable At this point all this is performance optimization? Open question is when do we need it for performance reasons.

Definition at line 143 of file rpm_calculator.h.

Referenced by assignRpmValue(), getCachedRpm(), isCranking(), isStopped(), setRpmValue(), and setStopSpinning().

engineStartTimer

Timer RpmCalculator::engineStartTimer

private

Definition at line 168 of file rpm_calculator.h.

Referenced by getSecondsSinceEngineStart(), and setRpmValue().

isSpinning

bool RpmCalculator::isSpinning = false

private

True if the engine is spinning (regardless of its state), i.e. if shaft position changes. Needed by spinning-up logic.

Definition at line 166 of file rpm_calculator.h.

Referenced by setSpinningUp(), and setStopSpinning().

lastTdcTimer

Timer RpmCalculator::lastTdcTimer

Definition at line 128 of file rpm_calculator.h.

Referenced by checkIfSpinning(), PrimaryTriggerDecoder::onTriggerError(), and rpmShaftPositionCallback().

minCrankingRpm

float RpmCalculator::minCrankingRpm = 0

private

The slowest RPM encountered during cranking, used for interpolating ignition advance

Definition at line 148 of file rpm_calculator.h.

Referenced by getMinCrankingRpm(), and setRpmValue().

oneDegreeUs

floatus_t RpmCalculator::oneDegreeUs = NAN

This is a performance optimization: let's pre-calculate this each time RPM changes NaN while engine is not spinning

Definition at line 122 of file rpm_calculator.h.

Referenced by assignRpmValue(), TriggerCentral::getCurrentEnginePhase(), getOneDegreeUs(), IgnitionState::getSparkHardwareLatencyCorrection(), scheduleByAngle(), and startKnockSampling().

previousRpmValue

float RpmCalculator::previousRpmValue = 0

this is RPM on previous engine cycle.

Definition at line 116 of file rpm_calculator.h.

Referenced by assignRpmValue(), and rpmShaftPositionCallback().

revolutionCounterSinceBoot

uint32_t RpmCalculator::revolutionCounterSinceBoot = 0

private

This counter is incremented with each revolution of one of the shafts. Could be crankshaft could be camshaft.

Definition at line 154 of file rpm_calculator.h.

Referenced by getRevolutionCounterM(), and onNewEngineCycle().

revolutionCounterSinceStart

uint32_t RpmCalculator::revolutionCounterSinceStart = 0

private

Same as the above, but since the engine started spinning

Definition at line 158 of file rpm_calculator.h.

Referenced by getRevolutionCounterSinceStart(), onNewEngineCycle(), and setStopSpinning().

rpmRate

float RpmCalculator::rpmRate = 0

Definition at line 131 of file rpm_calculator.h.

Referenced by getRpmAcceleration(), rpmShaftPositionCallback(), and setStopSpinning().

state

spinning_state_e RpmCalculator::state = STOPPED

private

Definition at line 160 of file rpm_calculator.h.

Referenced by getState(), isCranking(), isRunning(), isSpinningUp(), isStopped(), setRpmValue(), setSpinningUp(), and setStopSpinning().

---

The documentation for this class was generated from the following files:

• controllers/engine_cycle/rpm_calculator.h
• controllers/engine_cycle/rpm_calculator.cpp
• controllers/sensors/sensor_info_printing.cpp