advance_map.h File Reference

Functions
angle_t	getCylinderIgnitionTrim (size_t cylinderNumber, float rpm, float ignitionLoad)
float	getInitialAdvance (float rpm, float map, float advanceMax)
angle_t	getCrankingAdvance (float rpm, float engineLoad)
angle_t	getRunningAdvance (float rpm, float engineLoad)
angle_t	getAdvanceCorrections (float engineLoad)
size_t	getMultiSparkCount (float rpm)
void	initIgnitionAdvanceControl ()

Function Documentation

getAdvanceCorrections()

angle_t getAdvanceCorrections

(

float

engineLoad

)

Definition at line 164 of file ignition_state.cpp.

                                                {
    auto iat = Sensor::get(SensorType::Iat);
 
    if (!iat) {
        engine->ignitionState.timingIatCorrection = 0;
    } else {
        engine->ignitionState.timingIatCorrection = interpolate3d(
            config->ignitionIatCorrTable,
            config->ignitionIatCorrLoadBins, engineLoad,
            config->ignitionIatCorrTempBins, iat.Value
        );
    }
 
#if EFI_IDLE_CONTROL
    float instantRpm = engine->triggerCentral.instantRpm.getInstantRpm();
 
    engine->ignitionState.timingPidCorrection = engine->module<IdleController>()->getIdleTimingAdjustment(instantRpm);
#endif // EFI_IDLE_CONTROL
 
    engine->ignitionState.dfcoTimingRetard = engine->module<DfcoController>()->getTimingRetard();
 
#if EFI_TUNER_STUDIO
    engine->outputChannels.multiSparkCounter = engine->engineState.multispark.count;
#endif /* EFI_TUNER_STUDIO */
 
    return engine->ignitionState.timingIatCorrection
        + engine->ignitionState.cltTimingCorrection
        + engine->ignitionState.timingPidCorrection
        - engine->ignitionState.dfcoTimingRetard;
}

Referenced by IgnitionState::getAdvance().

Here is the call graph for this function:

Here is the caller graph for this function:

getCrankingAdvance()

angle_t getCrankingAdvance	(	float	rpm,
		float	engineLoad
	)

Returns

ignition timing angle advance before TDC for Cranking

Definition at line 198 of file ignition_state.cpp.

                                                        {
    // get advance from the separate table for Cranking
    if (engineConfiguration->useSeparateAdvanceForCranking) {
        return interpolate2d(rpm, config->crankingAdvanceBins, config->crankingAdvance);
    }
 
    // Interpolate the cranking timing angle to the earlier running angle for faster engine start
    angle_t crankingToRunningTransitionAngle = getRunningAdvance(engineConfiguration->cranking.rpm, engineLoad);
    // interpolate not from zero, but starting from min. possible rpm detected
    return interpolateClamped(engine->rpmCalculator.getMinCrankingRpm(), engineConfiguration->crankingTimingAngle, engineConfiguration->cranking.rpm, crankingToRunningTransitionAngle, rpm);
}

Referenced by IgnitionState::getAdvance().

Here is the call graph for this function:

Here is the caller graph for this function:

getCylinderIgnitionTrim()

angle_t getCylinderIgnitionTrim	(	size_t	cylinderNumber,
		float	rpm,
		float	ignitionLoad
	)

Definition at line 257 of file ignition_state.cpp.

                                                                                      {
    return IgnitionState::getInterpolatedIgnitionTrim(cylinderNumber, rpm, ignitionLoad);
}

Referenced by EngineState::periodicFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

getInitialAdvance()

float getInitialAdvance	(	float	rpm,
		float	map,
		float	advanceMax
	)

this method is used to build default advance map

Definition at line 72 of file default_ignition.cpp.

                                                                {
    map = std::min(map, 100.0f);
    float advance = getAdvanceForRpm(rpm, advanceMax);
 
    if (rpm >= 3000)
        return round10(advance + 0.1 * (100 - map));
    return round10(advance + 0.1 * (100 - map) * rpm / 3000);
}

Referenced by buildTimingMap().

Here is the call graph for this function:

Here is the caller graph for this function:

getMultiSparkCount()

size_t getMultiSparkCount

(

float

rpm

)

Definition at line 261 of file ignition_state.cpp.

                                     {
    // Compute multispark (if enabled)
    if (engineConfiguration->multisparkEnable
        && rpm <= engineConfiguration->multisparkMaxRpm
        && engineConfiguration->multisparkMaxExtraSparkCount > 0) {
        // For zero RPM, disable multispark.  We don't yet know the engine speed, so multispark may not be safe.
        if (rpm == 0) {
            return 0;
        }
 
        floatus_t multiDelay = 1000.0f * engineConfiguration->multisparkSparkDuration;
        floatus_t multiDwell = 1000.0f * engineConfiguration->multisparkDwell;
 
        // dwell times are below 10 seconds here so we use 32 bit type for performance reasons
        engine->engineState.multispark.delay = (uint32_t)USF2NT(multiDelay);
        engine->engineState.multispark.dwell = (uint32_t)USF2NT(multiDwell);
 
        constexpr float usPerDegreeAt1Rpm = 60e6 / 360;
        floatus_t usPerDegree = usPerDegreeAt1Rpm / rpm;
 
        // How long is there for sparks? The user configured an angle, convert to time.
        floatus_t additionalSparksUs = usPerDegree * engineConfiguration->multisparkMaxSparkingAngle;
        // How long does one spark take?
        floatus_t oneSparkTime = multiDelay + multiDwell;
 
        // How many sparks can we fit in the alloted time?
        float sparksFitInTime = additionalSparksUs / oneSparkTime;
 
        // Take the floor (convert to uint8_t) - we want to undershoot, not overshoot
        uint32_t floored = sparksFitInTime;
 
        // Allow no more than the maximum number of extra sparks
        return minI(floored, engineConfiguration->multisparkMaxExtraSparkCount);
    } else {
        return 0;
    }
}

Referenced by EngineState::periodicFastCallback().

Here is the caller graph for this function:

getRunningAdvance()

angle_t getRunningAdvance	(	float	rpm,
		float	engineLoad
	)

Returns

ignition timing angle advance before TDC

Definition at line 37 of file ignition_state.cpp.

                                                       {
    if (std::isnan(engineLoad)) {
        warning(ObdCode::CUSTOM_NAN_ENGINE_LOAD, "NaN engine load");
        return NAN;
    }
 
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !std::isnan(engineLoad), "invalid el", NAN);
 
    // compute base ignition angle from main table
    float advanceAngle = IgnitionState::getInterpolatedIgnitionAngle(rpm, engineLoad);
 
  float vehicleSpeed = Sensor::getOrZero(SensorType::VehicleSpeed);
  float wheelSlip = Sensor::getOrZero(SensorType::WheelSlipRatio);
  engine->ignitionState.tractionAdvanceDrop = tcTimingDropTable.getValue(wheelSlip, vehicleSpeed);
  engine->engineState.tractionControlSparkSkip = tcSparkSkipTable.getValue(wheelSlip, vehicleSpeed);
  engine->engineState.updateSparkSkip();
 
  advanceAngle += engine->ignitionState.tractionAdvanceDrop;
 
#if EFI_ANTILAG_SYSTEM
    if (engine->antilagController.isAntilagCondition) {
        float throttleIntent = Sensor::getOrZero(SensorType::DriverThrottleIntent);
        engine->antilagController.timingALSCorrection = interpolate3d(
            config->ALSTimingRetardTable,
            config->alsIgnRetardLoadBins, throttleIntent,
            config->alsIgnRetardrpmBins, rpm
        );
        advanceAngle += engine->antilagController.timingALSCorrection;
    }
#endif /* EFI_ANTILAG_SYSTEM */
 
    // Add any adjustments if configured
    for (size_t i = 0; i < efi::size(config->ignBlends); i++) {
        auto result = calculateBlend(config->ignBlends[i], rpm, engineLoad);
 
        engine->outputChannels.ignBlendParameter[i] = result.BlendParameter;
        engine->outputChannels.ignBlendBias[i] = result.Bias;
        engine->outputChannels.ignBlendOutput[i] = result.Value;
        engine->outputChannels.ignBlendYAxis[i] = result.TableYAxis;
 
        advanceAngle += result.Value;
    }
 
    // get advance from the separate table for Idle
#if EFI_IDLE_CONTROL
    if (engineConfiguration->useSeparateAdvanceForIdle &&
        (engine->module<IdleController>()->isIdlingOrTaper() || engine->module<IdleController>()->isCoastingAdvance())) {
        float idleAdvance = interpolate2d(rpm, config->idleAdvanceBins, config->idleAdvance);
 
        auto tps = Sensor::get(SensorType::DriverThrottleIntent);
        if (tps) {
            // interpolate between idle table and normal (running) table using TPS threshold
            // 0 TPS -> idle table
            // 1/2 threshold -> idle table
            // idle threshold -> normal table
            float idleThreshold = engineConfiguration->idlePidDeactivationTpsThreshold;
            advanceAngle = interpolateClamped(idleThreshold / 2, idleAdvance, idleThreshold, advanceAngle, tps.Value);
        }
    }
#endif
 
#if EFI_IDLE_CONTROL
    // reset ignition table dot, see #8198
    if(engineConfiguration->useSeparateAdvanceForIdle && engine->module<IdleController>()->isIdlingOrTaper()){
        engine->ignitionState.rpmForIgnitionIdleTableDot = rpm;
        engine->ignitionState.rpmForIgnitionTableDot = -1;
        engine->ignitionState.loadForIgnitionTableDot = -1;
    } else {
        engine->ignitionState.rpmForIgnitionIdleTableDot = -1;
        engine->ignitionState.rpmForIgnitionTableDot = rpm;
        engine->ignitionState.loadForIgnitionTableDot = engineLoad;
    }
#endif
 
#if EFI_LAUNCH_CONTROL
    if (engineConfiguration->launchControlEnabled && engineConfiguration->enableLaunchRetard) {
        const float launchAngle = engineConfiguration->launchTimingRetard;
        if (engine->launchController.isPreLaunchCondition) {
            const int launchRpm = engineConfiguration->launchRpm;
            const int smoothRetardStartRpm = (launchRpm - engineConfiguration->launchRpmWindow);
            const int smoothRetardEndRpm = (launchRpm - engineConfiguration->launchCorrectionsEndRpm);
            if (smoothRetardStartRpm <= rpm) {
                if (engineConfiguration->launchSmoothRetard && (rpm <= smoothRetardEndRpm)) {
                    // https://github.com/rusefi/rusefi/issues/5611#issuecomment-2130431696
                    return interpolateClamped(smoothRetardStartRpm, advanceAngle, smoothRetardEndRpm, launchAngle, rpm);
                } else {
                    return launchAngle;
                }
            }
        } else if (engine->launchController.isLaunchCondition) {
            return launchAngle;
        }
    }
    if (engineConfiguration->torqueReductionEnabled
        && engine->shiftTorqueReductionController.isFlatShiftConditionSatisfied
    ) {
        return engine->shiftTorqueReductionController.getTorqueReductionIgnitionRetard();
    }
    if (engineConfiguration->nitrousControlEnabled && engine->module<NitrousController>()->isNitrousCondition) {
        advanceAngle -= engineConfiguration->nitrousIgnitionRetard;
    }
#endif /* EFI_LAUNCH_CONTROL */
 
#ifdef MODULE_VVL_CONTROLLER
    advanceAngle += engine->module<VvlController>().unmock().getTimingModifier();
#endif /* MODULE_VVL_CONTROLLER */
 
    return advanceAngle;
}

Referenced by IgnitionState::getAdvance(), and getCrankingAdvance().

Here is the call graph for this function:

Here is the caller graph for this function:

initIgnitionAdvanceControl()

void initIgnitionAdvanceControl

(

)

Definition at line 299 of file ignition_state.cpp.

                                  {
    tcTimingDropTable.initTable(engineConfiguration->tractionControlTimingDrop, engineConfiguration->tractionControlSlipBins, engineConfiguration->tractionControlSpeedBins);
    tcSparkSkipTable.initTable(engineConfiguration->tractionControlIgnitionSkip, engineConfiguration->tractionControlSlipBins, engineConfiguration->tractionControlSpeedBins);
}

Referenced by commonInitEngineController().

Here is the caller graph for this function:

Go to the source code of this file.