MapAveragingModule Class Reference

#include <map_averaging.h>

Inheritance diagram for MapAveragingModule:

Collaboration diagram for MapAveragingModule:

Public Member Functions
void	onConfigurationChange (engine_configuration_s const *previousConfig) override
void	onFastCallback () override
void	onEnginePhase (float, efitick_t edgeTimestamp, float currentPhase, float nextPhase) override
void	triggerCallback (uint32_t index, efitick_t edgeTimestamp)
void	init ()
void	submitSample (float voltsMap1, float voltsMap2)
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	setDefaultConfiguration ()
virtual void	onSlowCallback ()
virtual void	onEngineStop ()
virtual void	onIgnitionStateChanged (bool)
virtual bool	needsDelayedShutoff ()

Data Fields
mapSampler	samplers [MAX_CYLINDER_COUNT]

Detailed Description

Definition at line 67 of file map_averaging.h.

Member Function Documentation

init()

void MapAveragingModule::init

(

)

Definition at line 235 of file map_averaging.cpp.

                              {
      for (size_t cylinderIndex = 0; cylinderIndex < MAX_CYLINDER_COUNT; cylinderIndex++) {
        samplers[cylinderIndex].cylinderNumber = cylinderIndex;
      }
 
    if (engineConfiguration->isMapAveragingEnabled) {
        efiPrintf("initMapAveraging...");
        applyMapMinBufferLength();
    } else {
        efiPrintf("Running without MapAveraging...");
    }
}

Here is the call graph for this function:

onConfigurationChange()

void MapAveragingModule::onConfigurationChange ( engine_configuration_s const *  previousConfig )

overridevirtual

Reimplemented from EngineModule.

Definition at line 229 of file map_averaging.cpp.

                                                                                            {
    if (!previousConfig || engineConfiguration->mapMinBufferLength != previousConfig->mapMinBufferLength) {
        applyMapMinBufferLength();
    }
}

Here is the call graph for this function:

onEnginePhase()

void MapAveragingModule::onEnginePhase ( float  , efitick_t  edgeTimestamp, float  currentPhase, float  nextPhase  )

overridevirtual

Reimplemented from EngineModule.

Definition at line 199 of file map_averaging.cpp.

                                         {
    if (!engineConfiguration->isMapAveragingEnabled) {
        return;
    }
 
    ScopePerf perf(PE::MapAveragingTriggerCallback);
 
    int samplingCount = engineConfiguration->measureMapOnlyInOneCylinder ? 1 : engineConfiguration->cylindersCount;
 
    for (int i = 0; i < samplingCount; i++) {
        angle_t samplingStart = engine->engineState.mapAveragingStart[i];
 
        if (!isPhaseInRange(samplingStart, currentPhase, nextPhase)) {
            continue;
        }
 
        float angleOffset = samplingStart - currentPhase;
        if (angleOffset < 0) {
            angleOffset += engine->engineState.engineCycle;
        }
 
        auto& s = samplers[i];
 
        scheduleByAngle(&s.timer, edgeTimestamp, angleOffset, action_s::make<startAveraging>(&s));
    }
}

Here is the call graph for this function:

onFastCallback()

void MapAveragingModule::onFastCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 178 of file map_averaging.cpp.

                                        {
    float rpm = Sensor::getOrZero(SensorType::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");
 
    for (size_t i = 0; i < engineConfiguration->cylindersCount; i++) {
        float cylinderStart = start + engine->cylinders[i].getAngleOffset();
        wrapAngle(cylinderStart, "cylinderStart", ObdCode::CUSTOM_ERR_6562);
        engine->engineState.mapAveragingStart[i] = cylinderStart;
    }
 
    angle_t duration = interpolate2d(rpm, c->samplingWindowBins, c->samplingWindow);
    assertAngleRange(duration, "samplingDuration", ObdCode::CUSTOM_ERR_6563);
 
    // Clamp the duration to slightly less than one cylinder period
    float cylinderPeriod = engine->engineState.engineCycle / engineConfiguration->cylindersCount;
    engine->engineState.mapAveragingDuration = clampF(10, duration, cylinderPeriod - 10);
}

Here is the call graph for this function:

submitSample()

void MapAveragingModule::submitSample	(	float	voltsMap1,
		float	voltsMap2
	)

triggerCallback()

void MapAveragingModule::triggerCallback	(	uint32_t	index,
		efitick_t	edgeTimestamp
	)

Field Documentation

samplers

mapSampler MapAveragingModule::samplers[MAX_CYLINDER_COUNT]

Definition at line 77 of file map_averaging.h.

Referenced by init(), and onEnginePhase().

---

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

• controllers/modules/map_averaging/map_averaging.h
• controllers/modules/map_averaging/map_averaging.cpp