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 (scheduling_s *endAveragingScheduling)

void	mapAveragingAdcCallback (float instantVoltage)

static void	applyMapMinBufferLength ()

void	postMapState (TunerStudioOutputChannels *tsOutputChannels)

void	refreshMapAveragingPreCalc ()

void	mapAveragingTriggerCallback (uint32_t index, efitick_t edgeTimestamp)

void	initMapAveraging ()

Variables
static float	averagedMapRunningBuffer [MAX_MAP_BUFFER_LENGTH]

int	mapMinBufferLength = 0

static int	averagedMapBufIdx = 0

static scheduling_s	startTimers [MAX_CYLINDER_COUNT][2]

static scheduling_s	endTimers [MAX_CYLINDER_COUNT][2]

static size_t	currentMapAverager = 0

Function Documentation

◆ applyMapMinBufferLength()

static void applyMapMinBufferLength ( )

static

Definition at line 160 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 153 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.

41 {

42 }

Referenced by Engine::periodicSlowCallback().

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:

◆ startAveraging()

static void startAveraging ( scheduling_s * endAveragingScheduling )

static

Definition at line 65 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(endAveragingScheduling, getTimeNowNt(), engine->engineState.mapAveragingDuration,
         { endAveraging, &averager });
 }