#include <closed_loop_idle.h>

Inheritance diagram for LongTermIdleTrim:

Collaboration diagram for LongTermIdleTrim:

[legend]

Public Member Functions
	LongTermIdleTrim ()

float	getLtitFactor (float rpm, float clt) const

void	update (float rpm, float clt, bool acActive, bool fan1Active, bool fan2Active, float idleIntegral)

void	smoothLtitTable (float intensity)

void	onIgnitionStateChanged (bool ignitionOn)

void	checkIfShouldSave ()

virtual void	loadLtitFromConfig ()

bool	hasValidData () const

Data Fields
bool	updatedLtit = false

Data Fields inherited from closed_loop_idle_s
bool	isStableIdle: 1 {}

bool	unusedBit_1_1: 1 {}

bool	unusedBit_1_2: 1 {}

bool	unusedBit_1_3: 1 {}

bool	unusedBit_1_4: 1 {}

bool	unusedBit_1_5: 1 {}

bool	unusedBit_1_6: 1 {}

bool	unusedBit_1_7: 1 {}

bool	unusedBit_1_8: 1 {}

bool	unusedBit_1_9: 1 {}

bool	unusedBit_1_10: 1 {}

bool	unusedBit_1_11: 1 {}

bool	unusedBit_1_12: 1 {}

bool	unusedBit_1_13: 1 {}

bool	unusedBit_1_14: 1 {}

bool	unusedBit_1_15: 1 {}

bool	unusedBit_1_16: 1 {}

bool	unusedBit_1_17: 1 {}

bool	unusedBit_1_18: 1 {}

bool	unusedBit_1_19: 1 {}

bool	unusedBit_1_20: 1 {}

bool	unusedBit_1_21: 1 {}

bool	unusedBit_1_22: 1 {}

bool	unusedBit_1_23: 1 {}

bool	unusedBit_1_24: 1 {}

bool	unusedBit_1_25: 1 {}

bool	unusedBit_1_26: 1 {}

bool	unusedBit_1_27: 1 {}

bool	unusedBit_1_28: 1 {}

bool	unusedBit_1_29: 1 {}

bool	unusedBit_1_30: 1 {}

bool	unusedBit_1_31: 1 {}

float	emaError = (float)0

Private Member Functions
bool	isValidConditionsForLearning (float idleIntegral) const

void	initializeTableWithDefaults ()

Private Attributes
float	ltitTableHelper [LTIT_TABLE_SIZE]

bool	ltitTableInitialized = false

Timer	m_updateTimer

Timer	m_stableIdleTimer

Timer	m_ignitionOffTimer

bool	m_ignitionState = false

bool	m_pendingSave = false

Detailed Description

Definition at line 14 of file closed_loop_idle.h.

Constructor & Destructor Documentation

◆ LongTermIdleTrim()

LongTermIdleTrim::LongTermIdleTrim ( )

Definition at line 12 of file closed_loop_idle.cpp.

                                   {
    initializeTableWithDefaults();
    emaError = 0.0f; //TODO: unused?
    ltitTableInitialized = false;
    m_pendingSave = false;
}

Here is the call graph for this function:

Member Function Documentation

◆ checkIfShouldSave()

void LongTermIdleTrim::checkIfShouldSave ( )

Definition at line 229 of file closed_loop_idle.cpp.

                                         {
    // Handle delayed save after ignition off
    if (m_pendingSave && !m_ignitionState) {
        float saveDelaySeconds = engineConfiguration->ltitIgnitionOffSaveDelay;
        if (saveDelaySeconds <= 0) {
            //TODO: this is part of setDefaultEngineConfiguration?
            saveDelaySeconds = 5.0f; // Default 5 seconds
        }
 
        if (m_ignitionOffTimer.hasElapsedSec(saveDelaySeconds)) {
            // TODO: copyArray?
            // Save to flash memory
            for (int i = 0; i < LTIT_TABLE_SIZE; i++) {
                // Convert float to autoscaled uint16_t
                config->ltitTable[i] = static_cast<uint16_t>(ltitTableHelper[i]);
            }
 
#if EFI_PROD_CODE
            //TODO: we need to use requestBurn here?
            setNeedToWriteConfiguration();
#endif // EFI_PROD_CODE
            m_pendingSave = false;
        }
    }
}

Referenced by IdleController::onFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLtitFactor()

float LongTermIdleTrim::getLtitFactor	(	float	rpm,
		float	clt
	)		const

Definition at line 67 of file closed_loop_idle.cpp.

                                                                {
    //TODO: rpm unused?
    UNUSED(rpm);
 
    if (!ltitTableInitialized) {
        return 1.0f; // No correction if not initialized
    }
 
    // Use 2D interpolation based only on CLT (temperature)
    return interpolate2d(clt, config->cltIdleCorrBins, ltitTableHelper) * 0.01f;
}

Here is the call graph for this function:

◆ hasValidData()

bool LongTermIdleTrim::hasValidData ( ) const

Definition at line 27 of file closed_loop_idle.cpp.

                                          {
    // More robust validation - check for reasonable range and distribution
    int validCount = 0;
    float totalValue = 0.0f;
 
    for (int i = 0; i < LTIT_TABLE_SIZE; i++) {
        float value = static_cast<float>(config->ltitTable[i]);
 
        // Check if value is in reasonable range (50% to 150%)
        if (value >= 50.0f && value <= 150.0f) {
            validCount++;
            totalValue += value;
        }
    }
 
    // Require at least half the table to be valid and reasonable average
    if (validCount < (LTIT_TABLE_SIZE / 2)) {
        return false;
    }
 
    float avgValue = totalValue / validCount;
    return (avgValue >= 80.0f && avgValue <= 120.0f); // Reasonable average range
}

Referenced by loadLtitFromConfig().

Here is the caller graph for this function:

◆ initializeTableWithDefaults()

void LongTermIdleTrim::initializeTableWithDefaults ( )

private

Definition at line 19 of file closed_loop_idle.cpp.

                                                   {
    // Initialize with 100% (1.0 multiplier) as default
    for (int i = 0; i < LTIT_TABLE_SIZE; i++) {
        ltitTableHelper[i] = 100.0f;
    }
}

Referenced by loadLtitFromConfig(), and LongTermIdleTrim().

Here is the caller graph for this function:

◆ isValidConditionsForLearning()

bool LongTermIdleTrim::isValidConditionsForLearning ( float idleIntegral ) const

private

Definition at line 79 of file closed_loop_idle.cpp.

                                                                            {
    float minThreshold = engineConfiguration->ltitIntegratorThreshold;
    if (std::abs(idleIntegral) < minThreshold) {
        return false; // Integrator too low - PID not working hard enough
    }
 
    // Upper limit to avoid extreme conditions
    if (std::abs(idleIntegral) > 25.0f) {
        return false; // Integrator too high - unstable conditions
    }
 
    // Check if enough time has passed since ignition on
    if (!m_updateTimer.hasElapsedSec(engineConfiguration->ltitIgnitionOnDelay)) {
        return false;
    }
 
    // Must be in stable idle
    if (!isStableIdle) {
        return false;
    }
 
    return true;
}

Referenced by update().

Here is the caller graph for this function:

◆ loadLtitFromConfig()

void LongTermIdleTrim::loadLtitFromConfig ( )

virtual

Definition at line 51 of file closed_loop_idle.cpp.

                                          {
    if (hasValidData()) {
        // Convert autoscaled uint16_t to float
        for (int i = 0; i < LTIT_TABLE_SIZE; i++) {
            ltitTableHelper[i] = static_cast<float>(config->ltitTable[i]);
        }
 
        ltitTableInitialized = true;
    } else {
        //TODO: this is part of setDefaultEngineConfiguration?
        // Initialize with defaults if no valid data
        initializeTableWithDefaults();
        ltitTableInitialized = true;
    }
}

Referenced by IdleController::init(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ onIgnitionStateChanged()

void LongTermIdleTrim::onIgnitionStateChanged ( bool ignitionOn )

Definition at line 211 of file closed_loop_idle.cpp.

                                                             {
    m_ignitionState = ignitionOn;
 
    if (ignitionOn) {
        // Reset timers when ignition turns on
        m_updateTimer.reset();
        m_stableIdleTimer.reset();
        isStableIdle = false;
        m_pendingSave = false;
    } else if (updatedLtit) {
        // Schedule save after ignition off
        // TODO: maybe move all this to EngineModule & use needsDelayedShutoff?
        m_pendingSave = true;
        m_ignitionOffTimer.reset();
        updatedLtit = false;
    }
}

Referenced by IdleController::onIgnitionStateChanged().

Here is the caller graph for this function:

◆ smoothLtitTable()

void LongTermIdleTrim::smoothLtitTable ( float intensity )

Definition at line 256 of file closed_loop_idle.cpp.

                                                      {
    if (!engineConfiguration->ltitEnabled || intensity <= 0.0f || intensity > 100.0f) {
        return; // Invalid intensity or LTIT disabled
    }
 
    // Normalize intensity to 0.0-1.0 range
    float normalizedIntensity = intensity / 100.0f;
 
    // Apply 1D smoothing for the temperature-based curve
    float temp[LTIT_TABLE_SIZE];
 
    for (int i = 0; i < LTIT_TABLE_SIZE; i++) {
        float sum = ltitTableHelper[i];
        int count = 1;
 
        // Add values from adjacent cells if they exist
        if (i > 0) {
            sum += ltitTableHelper[i-1];
            count++;
        }
        if (i < LTIT_TABLE_SIZE-1) {
            sum += ltitTableHelper[i+1];
            count++;
        }
 
        // Calculate the average of the cell and its neighbors
        float avg = sum / count;
 
        // Apply weighted average based on intensity
        temp[i] = ltitTableHelper[i] * (1.0f - normalizedIntensity) + avg * normalizedIntensity;
    }
 
    // Copy back the smoothed values
    for (int i = 0; i < LTIT_TABLE_SIZE; i++) {
        ltitTableHelper[i] = temp[i];
    }
 
    // Mark for saving
    m_pendingSave = true;
}

◆ update()

void LongTermIdleTrim::update	(	float	rpm,
		float	clt,
		bool	acActive,
		bool	fan1Active,
		bool	fan2Active,
		float	idleIntegral
	)

Definition at line 103 of file closed_loop_idle.cpp.

                                                                                                                       {
    //TODO: acActive unused, fan1Active, fan2Active, check comment about isValidConditionsForLearning
    UNUSED(acActive); UNUSED(fan1Active); UNUSED(fan2Active);
 
    if (!engineConfiguration->ltitEnabled) {
        return;
    }
 
    // Try to load data periodically until successful
    if (!ltitTableInitialized) {
        loadLtitFromConfig();
        return;
    }
 
    // Check ignition delay
    if (!m_updateTimer.hasElapsedSec(engineConfiguration->ltitIgnitionOnDelay)) {
        m_stableIdleTimer.reset();
        isStableIdle = false;
        return;
    }
 
    auto& idleController = engine->engineModules.get<IdleController>();
    auto currentPhase = idleController->getCurrentPhase();
 
    // LTIT should only learn during Phase::Idling
    if (currentPhase != IIdleController::Phase::Idling) {
        m_stableIdleTimer.reset();
        isStableIdle = false;
        return;
    }
 
    // Check if we're in idle RPM range
    float targetRpm = idleController->getTargetRpm(clt).ClosedLoopTarget;
    float rpmDelta = std::abs(rpm - targetRpm);
    bool isIdleRpm = rpmDelta < engineConfiguration->ltitStableRpmThreshold;
 
    // Check stability
    if (!isIdleRpm) {
        m_stableIdleTimer.reset();
        isStableIdle = false;
        return;
    }
 
    // Check if stable for minimum time
    // TODO: set ltitStableTime default value? also move to autoscale 0.1 like other configs with seconds?
    if (!isStableIdle && m_stableIdleTimer.hasElapsedSec(engineConfiguration->ltitStableTime)) {
        isStableIdle = true;
    }
 
    if (!isStableIdle) {
        return;
    }
 
    if (!idleController->isIdleClosedLoop) {
        return;
    }
 
    // Main table learning (now allowed even with AC/Fan active)
    // Validate conditions
    if (!isValidConditionsForLearning(idleIntegral)) {
        return;
    }
 
    // Check minimum update interval (fixed slowCallback period: 50ms)
    if (!m_updateTimer.hasElapsedSec(1.0f)) {
        return;
    }
    m_updateTimer.reset();
 
    //TODO: docs?, weird use of non-public interpolation.h, we are trying to the get bin index for X temp?
    // also ltitTableHelper scale will depend on clt idle bins?
    // Use proper bin finding with getBin function for CLT only
    auto cltBin = priv::getBin(clt, config->cltIdleCorrBins);
 
    // Apply correction rate in %/s (percentage per second)
    // Using fixed slowCallback delta time (50ms = 0.05s) for consistent behavior
    const float deltaTime = 0.05f; // SLOW_CALLBACK_PERIOD_MS / 1000.0f
    float correctionPerSecond = idleIntegral * engineConfiguration->ltitCorrectionRate * 0.01f; // Convert % to decimal
    float correction = correctionPerSecond * deltaTime; // Apply time-based correction
    float alpha = engineConfiguration->ltitEmaAlpha / 255.0f;
 
    // Primary cell (largest weight)
    float newValue = ltitTableHelper[cltBin.Idx] * (1.0f + correction);
    newValue = alpha * newValue + (1.0f - alpha) * ltitTableHelper[cltBin.Idx];
 
    // Apply clamping
    float clampMin = engineConfiguration->ltitClampMin > 0 ? engineConfiguration->ltitClampMin : 0.0f;
    float clampMax = engineConfiguration->ltitClampMax > 0 ? engineConfiguration->ltitClampMax : 250.0f;
    ltitTableHelper[cltBin.Idx] = clampF(clampMin, newValue, clampMax);
 
    // Apply to adjacent cells with reduced weight (for better interpolation)
    float adjWeight = 0.3f; // 30% weight for adjacent cells
    for (int di = -1; di <= 1; di++) {
        if (di == 0) continue; // Skip primary cell
 
        int adjI = cltBin.Idx + di;
 
        if (adjI >= 0 && adjI < LTIT_TABLE_SIZE) {
            float adjCorrection = correction * adjWeight;
            float adjNewValue = ltitTableHelper[adjI] * (1.0f + adjCorrection);
            adjNewValue = alpha * adjNewValue + (1.0f - alpha) * ltitTableHelper[adjI];
            ltitTableHelper[adjI] = clampF(clampMin, adjNewValue, clampMax);
        }
    }
 
    updatedLtit = true;
}