map_averaging.cpp File Reference

Detailed Description

In order to have best MAP estimate possible, we real MAP value at a relatively high frequency and average the value within a specified angle position window for each cylinder

Date

Dec 11, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

This file is part of rusEfi - see http://rusefi.com

rusEfi is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

rusEfi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file map_averaging.cpp.

Functions
	fail ("EFI_SHAFT_POSITION_INPUT required to have EFI_EMULATE_POSITION_SENSORS") static NamedOutputPin mapAveragingPin("map")
static void	endAveraging (MapAverager *arg)
static void	startAveraging (sampler *s)
float	filterMapValue (float value)
void	mapAveragingAdcCallback (float instantVoltage)
static void	applyMapMinBufferLength ()
void	refreshMapAveragingPreCalc ()
void	mapAveragingTriggerCallback (uint32_t index, efitick_t edgeTimestamp)
void	initMapAveraging ()

Variables
static float	averagedMapRunningBuffer [MAX_MAP_BUFFER_LENGTH]
static int	mapMinBufferLength = 0
static int	averagedMapBufIdx = 0
static sampler	samplers [MAX_CYLINDER_COUNT][2]
static size_t	currentMapAverager = 0

Function Documentation

applyMapMinBufferLength()

static void applyMapMinBufferLength ( )

static

Definition at line 176 of file map_averaging.cpp.

                                      {
    // check range
    mapMinBufferLength = maxI(minI(engineConfiguration->mapMinBufferLength, MAX_MAP_BUFFER_LENGTH), 1);
    // reset index
    averagedMapBufIdx = 0;
    // fill with maximum values
    for (int i = 0; i < mapMinBufferLength; i++) {
        averagedMapRunningBuffer[i] = FLT_MAX;
    }
}

Referenced by initMapAveraging(), and mapAveragingTriggerCallback().

Here is the caller graph for this function:

endAveraging()

static void endAveraging ( MapAverager *  arg )

static

Definition at line 169 of file map_averaging.cpp.

                                           {
    arg->stop();
 
    mapAveragingPin.setLow();
}

Here is the call graph for this function:

fail()

fail

(

"EFI_SHAFT_POSITION_INPUT required to have EFI_EMULATE_POSITION_SENSORS"

)

this instance does not have a real physical pin - it's only used for engine sniffer

todo: we can kind of add real physical pin just for a very narrow case of troubleshooting but only if we ever need it :)

Engine idles around 20Hz and revs up to 140Hz, at 60/2 and 8 cylinders we have about 20Khz events If we can read buffer at 50Hz we want buffer to be about 400 elements.

Definition at line 34 of file trigger_emulator_algo.cpp.

                                             {
}

Referenced by Engine::periodicSlowCallback().

Here is the caller graph for this function:

filterMapValue()

float filterMapValue

(

float

value

)

Definition at line 105 of file map_averaging.cpp.

                                  {
  static float state = 0;
  if (state == 0) {
    state = value;
    return value;
  }
  float result = state + engineConfiguration->mapExpAverageAlpha * (value - state);
  state = result;
  return result;
}

Referenced by MapAverager::stop().

Here is the caller graph for this function:

initMapAveraging()

void initMapAveraging

(

)

Definition at line 277 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 151 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);
    }
 
#if EFI_TUNER_STUDIO
    float instantMap = mapResult.value_or(0);
    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 221 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 (std::isnan(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;
 
        sampler* s = &samplers[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(&s->startTimer, edgeTimestamp, samplingStart,
                { startAveraging, s });
    }
#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:

refreshMapAveragingPreCalc()

void refreshMapAveragingPreCalc

(

)

Definition at line 187 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, !std::isnan(start), "start");
 
        angle_t offsetAngle = engine->triggerCentral.triggerFormDetails.eventAngles[engineConfiguration->mapAveragingSchedulingAtIndex];
        efiAssertVoid(ObdCode::CUSTOM_ERR_MAP_AVG_OFFSET, !std::isnan(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, !std::isnan(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:

startAveraging()

static void startAveraging ( sampler *  s )

static

Definition at line 69 of file map_averaging.cpp.

                                       {
    efiAssertVoid(ObdCode::CUSTOM_ERR_6649, hasLotsOfRemainingStack(), "lowstck#9");
 
    // TODO: set currentMapAverager based on cylinder bank
    auto& averager = getMapAvg(currentMapAverager);
    averager.start();
 
    mapAveragingPin.setHigh();
 
    scheduleByAngle(&s->endTimer, getTimeNowNt(), engine->engineState.mapAveragingDuration,
        { endAveraging, &averager });
}

Here is the call graph for this function:

Variable Documentation

averagedMapBufIdx

int averagedMapBufIdx = 0

static

Definition at line 52 of file map_averaging.cpp.

Referenced by applyMapMinBufferLength(), and MapAverager::stop().

averagedMapRunningBuffer

float averagedMapRunningBuffer[MAX_MAP_BUFFER_LENGTH]

static

Definition at line 50 of file map_averaging.cpp.

Referenced by applyMapMinBufferLength(), and MapAverager::stop().

currentMapAverager

size_t currentMapAverager = 0

static

Definition at line 67 of file map_averaging.cpp.

Referenced by mapAveragingAdcCallback(), and startAveraging().

mapMinBufferLength

int mapMinBufferLength = 0

static

Definition at line 51 of file map_averaging.cpp.

Referenced by applyMapMinBufferLength(), mapAveragingTriggerCallback(), and MapAverager::stop().

samplers

sampler samplers[MAX_CYLINDER_COUNT][2]

static

Definition at line 62 of file map_averaging.cpp.

Referenced by mapAveragingTriggerCallback().

Go to the source code of this file.