map_averaging.h File Reference

Detailed Description

Date

Dec 11, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file map_averaging.h.

Data Structures
class	MapAverager

Functions
void	mapAveragingAdcCallback (float instantVoltage)
void	initMapAveraging ()
void	refreshMapAveragingPreCalc ()
void	mapAveragingTriggerCallback (uint32_t index, efitick_t edgeTimestamp)
void	postMapState (TunerStudioOutputChannels *tsOutputChannels)
MapAverager &	getMapAvg (size_t idx)

Function Documentation

getMapAvg()

MapAverager& getMapAvg

(

size_t

idx

)

Definition at line 26 of file init_map.cpp.

                                   {
    return idx == 0 ? fastMapSensor : fastMapSensor2;
}

Referenced by mapAveragingAdcCallback(), and startAveraging().

Here is the caller graph for this function:

initMapAveraging()

void initMapAveraging

(

)

Definition at line 268 of file map_averaging.cpp.

                        {
    applyMapMinBufferLength();
}

Referenced by commonInitEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

mapAveragingAdcCallback()

void mapAveragingAdcCallback

(

float

instantVoltage

)

This method is invoked from ADC callback.

Note

This method is invoked OFTEN, this method is a potential bottleneck - the implementation should be as fast as possible

Definition at line 135 of file map_averaging.cpp.

                                                   {
    efiAssertVoid(ObdCode::CUSTOM_ERR_6650, hasLotsOfRemainingStack(), "lowstck#9a");
 
    SensorResult mapResult = getMapAvg(currentMapAverager).submit(instantVoltage);
 
    if (!mapResult) {
        // hopefully this warning is not too much CPU consumption for fast ADC callback
        warning(ObdCode::CUSTOM_INSTANT_MAP_DECODING, "Invalid MAP at %f", instantVoltage);
    }
 
    float instantMap = mapResult.value_or(0);
#if EFI_TUNER_STUDIO
    engine->outputChannels.instantMAPValue = instantMap;
#endif // EFI_TUNER_STUDIO
}

Referenced by onFastAdcComplete().

Here is the call graph for this function:

Here is the caller graph for this function:

mapAveragingTriggerCallback()

void mapAveragingTriggerCallback	(	uint32_t	index,
		efitick_t	edgeTimestamp
	)

Shaft Position callback used to schedule start and end of MAP averaging

Definition at line 211 of file map_averaging.cpp.

                                                 {
#if EFI_ENGINE_CONTROL && EFI_PROD_CODE
    // this callback is invoked on interrupt thread
    if (index != (uint32_t)engineConfiguration->mapAveragingSchedulingAtIndex)
        return;
 
    int rpm = Sensor::getOrZero(SensorType::Rpm);
    if (!isValidRpm(rpm)) {
        return;
    }
 
    ScopePerf perf(PE::MapAveragingTriggerCallback);
 
    if (engineConfiguration->mapMinBufferLength != mapMinBufferLength) {
        applyMapMinBufferLength();
    }
 
    // todo: this could be pre-calculated
    int samplingCount = engineConfiguration->measureMapOnlyInOneCylinder ? 1 : engineConfiguration->cylindersCount;
 
    for (int i = 0; i < samplingCount; i++) {
        angle_t samplingStart = engine->engineState.mapAveragingStart[i];
 
        angle_t samplingDuration = engine->engineState.mapAveragingDuration;
        // todo: this assertion could be moved out of trigger handler
        assertAngleRange(samplingDuration, "samplingDuration", ObdCode::CUSTOM_ERR_6563);
        if (samplingDuration <= 0) {
            warning(ObdCode::CUSTOM_MAP_ANGLE_PARAM, "map sampling angle should be positive");
            return;
        }
 
        angle_t samplingEnd = samplingStart + samplingDuration;
 
        if (cisnan(samplingEnd)) {
            // todo: when would this happen?
            warning(ObdCode::CUSTOM_ERR_6549, "no map angles");
            return;
        }
 
        // todo: pre-calculate samplingEnd for each cylinder
        wrapAngle(samplingEnd, "samplingEnd", ObdCode::CUSTOM_ERR_6563);
        // only if value is already prepared
        int structIndex = getRevolutionCounter() % 2;
 
        scheduling_s *startTimer = &startTimers[i][structIndex];
        scheduling_s *endTimer = &endTimers[i][structIndex];
 
        // at the moment we schedule based on time prediction based on current RPM and angle
        // we are loosing precision in case of changing RPM - the further away is the event the worse is precision
        // todo: schedule this based on closest trigger event, same as ignition works
        scheduleByAngle(startTimer, edgeTimestamp, samplingStart,
                { startAveraging, endTimer });
    }
#endif // EFI_ENGINE_CONTROL && EFI_PROD_CODE
}

Referenced by TriggerCentral::handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

postMapState()

void postMapState

(

TunerStudioOutputChannels *

tsOutputChannels

)

Definition at line 172 of file map_averaging.cpp.

                                                               {
    tsOutputChannels->debugFloatField2 = engine->engineState.mapAveragingDuration;
}

Referenced by updateTunerStudioState().

Here is the caller graph for this function:

refreshMapAveragingPreCalc()

void refreshMapAveragingPreCalc

(

)

Definition at line 177 of file map_averaging.cpp.

                                  {
    int rpm = Sensor::getOrZero(SensorType::Rpm);
    if (isValidRpm(rpm)) {
        MAP_sensor_config_s * c = &engineConfiguration->map;
        angle_t start = interpolate2d(rpm, c->samplingAngleBins, c->samplingAngle);
        efiAssertVoid(ObdCode::CUSTOM_ERR_MAP_START_ASSERT, !cisnan(start), "start");
 
        angle_t offsetAngle = engine->triggerCentral.triggerFormDetails.eventAngles[engineConfiguration->mapAveragingSchedulingAtIndex];
        efiAssertVoid(ObdCode::CUSTOM_ERR_MAP_AVG_OFFSET, !cisnan(offsetAngle), "offsetAngle");
 
        for (size_t i = 0; i < engineConfiguration->cylindersCount; i++) {
          // todo: potential micro-optimization to reuse getEngineState()->engineCycle?
            angle_t cylinderOffset = getEngineCycle(getEngineRotationState()->getOperationMode()) * i / engineConfiguration->cylindersCount;
            efiAssertVoid(ObdCode::CUSTOM_ERR_MAP_CYL_OFFSET, !cisnan(cylinderOffset), "cylinderOffset");
            // part of this formula related to specific cylinder offset is never changing - we can
            // move the loop into start-up calculation and not have this loop as part of periodic calculation
            // todo: change the logic as described above in order to reduce periodic CPU usage?
            float cylinderStart = start + cylinderOffset - offsetAngle + tdcPosition();
            wrapAngle(cylinderStart, "cylinderStart", ObdCode::CUSTOM_ERR_6562);
            engine->engineState.mapAveragingStart[i] = cylinderStart;
        }
        engine->engineState.mapAveragingDuration = interpolate2d(rpm, c->samplingWindowBins, c->samplingWindow);
    } else {
        for (size_t i = 0; i < engineConfiguration->cylindersCount; i++) {
            engine->engineState.mapAveragingStart[i] = NAN;
        }
        engine->engineState.mapAveragingDuration = NAN;
    }
 
}

Referenced by Engine::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

Go to the source code of this file.