Detailed Description

Date: Mar 27, 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 ignition_state.cpp.

Functions
angle_t	getRunningAdvance (float rpm, float engineLoad)

angle_t	getCltTimingCorrection (float engineLoad)

angle_t	getAdvanceCorrections (float engineLoad)

angle_t	getCrankingAdvance (float rpm, float engineLoad)

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

size_t	getMultiSparkCount (float rpm)

void	initIgnitionAdvanceControl ()

Variables
float	minCrankingRpm = 0

static Map3D< TRACTION_CONTROL_ETB_DROP_SLIP_SIZE, TRACTION_CONTROL_ETB_DROP_SPEED_SIZE, int8_t, uint16_t, uint8_t >	tcTimingDropTable {"tct"}

static Map3D< TRACTION_CONTROL_ETB_DROP_SLIP_SIZE, TRACTION_CONTROL_ETB_DROP_SPEED_SIZE, int8_t, uint16_t, uint8_t >	tcSparkSkipTable {"tcs"}

Function Documentation

◆ getAdvanceCorrections()

angle_t getAdvanceCorrections ( float engineLoad )

Definition at line 168 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:

◆ getCltTimingCorrection()

angle_t getCltTimingCorrection ( float engineLoad )

Definition at line 151 of file ignition_state.cpp.

                                                 {
    const auto clt = Sensor::get(SensorType::Clt);
 
    if (!clt)
        return 0; // this error should be already reported somewhere else, let's just handle it
 
    return interpolate3d(
            config->ignitionCltCorrTable,
            config->ignitionCltCorrLoadBins, engineLoad,
            config->ignitionCltCorrTempBins, clt.Value
    );
}

Here is the call graph for this function:

◆ getCrankingAdvance()

angle_t getCrankingAdvance	(	float	rpm,
		float	engineLoad
	)

Returns: ignition timing angle advance before TDC for Cranking

Definition at line 202 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
    if (rpm < minCrankingRpm || minCrankingRpm == 0)
        minCrankingRpm = rpm;
    return interpolateClamped(minCrankingRpm, 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()

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

Definition at line 263 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:

◆ getMultiSparkCount()

size_t getMultiSparkCount ( float rpm )

Definition at line 267 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 41 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 305 of file ignition_state.cpp.

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