engine_controller.cpp File Reference

Detailed Description

Controllers package entry point code.

Date

Feb 7, 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 engine_controller.cpp.

Functions
void	initDataStructures ()
static void	doPeriodicSlowCallback ()
static void	resetAccel ()
void	initPeriodicEvents ()
char *	getPinNameByAdcChannel (const char *msg, adc_channel_e hwChannel, char *buffer, size_t bufferSize)
static void	printSensorInfo ()
static void	getShort (int offset)
static void	getByte (int offset)
static void	setBit (const char *offsetStr, const char *bitStr, const char *valueStr)
static void	setShort (const int offset, const int value)
static void	setByte (const int offset, const int value)
static void	getBit (int offset, int bit)
static void	getInt (int offset)
static void	setInt (const int offset, const int value)
static void	getFloat (int offset)
static void	setFloat (const char *offsetStr, const char *valueStr)
static void	initConfigActions ()
void	commonInitEngineController ()
PUBLIC_API_WEAK bool	validateBoardConfig ()
bool	validateConfigOnStartUpOrBurn ()
void	commonEarlyInit ()
void	initRealHardwareEngineController ()
int	getRusEfiVersion ()

Variables
Engine ___engine	CCM_OPTIONAL
Engine *	engine
static PeriodicFastController	fastController
static PeriodicSlowController	slowController
static EngineStateBlinkingTask	engineStateBlinkingTask
static volatile char	UNUSED_RAM_SIZE [RAM_UNUSED_SIZE]

Function Documentation

commonEarlyInit()

void commonEarlyInit

(

)

Initialize hardware drivers

Definition at line 699 of file engine_controller.cpp.

                       {
    // Start this early - it will start LED blinking and such
    startStatusThreads();
 
#if EFI_SHAFT_POSITION_INPUT
    // todo: figure out better startup logic
    initTriggerCentral();
#endif /* EFI_SHAFT_POSITION_INPUT */
 
    /**
     * Initialize hardware drivers
     */
    initHardware();
 
    initQcBenchControls();
 
#if EFI_FILE_LOGGING
    initMmcCard();
#endif /* EFI_FILE_LOGGING */
 
#if EFI_ENGINE_EMULATOR
    initEngineEmulator();
#endif
 
#if EFI_LUA
    startLua();
#endif // EFI_LUA
 
#if EFI_CAN_SERIAL
    // needs to be called after initCan() inside initHardware()
    startCanConsole();
#endif /* EFI_CAN_SERIAL */
 
}

Referenced by initEfiWithConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

commonInitEngineController()

void commonInitEngineController

(

)

This has to go after 'enginePins.startPins()' in order to properly detect un-assigned output pins

Definition at line 405 of file engine_controller.cpp.

                                  {
#if EFI_PROD_CODE
    addConsoleAction("sensorinfo", printSensorInfo);
    addConsoleAction("reset_accel", resetAccel);
#endif /* EFI_PROD_CODE */
 
#if EFI_SIMULATOR || EFI_UNIT_TEST
    printf("commonInitEngineController\n");
#endif
 
#if !EFI_UNIT_TEST
    initConfigActions();
#endif /* EFI_UNIT_TEST */
 
#if EFI_ENGINE_CONTROL
    /**
     * This has to go after 'enginePins.startPins()' in order to
     * properly detect un-assigned output pins
     */
    prepareOutputSignals();
 
    engine->injectionEvents.addFuelEvents();
#endif // EFI_ENGINE_CONTROL
 
#if EFI_SENSOR_CHART
    initSensorChart();
#endif /* EFI_SENSOR_CHART */
 
#if EFI_PROD_CODE || EFI_SIMULATOR
    initSettings();
 
    if (hasFirmwareError()) {
        return;
    }
#endif
 
#if ! EFI_UNIT_TEST && EFI_ENGINE_CONTROL
    initBenchTest();
#endif /* ! EFI_UNIT_TEST && EFI_ENGINE_CONTROL */
 
#if EFI_ALTERNATOR_CONTROL
    initAlternatorCtrl();
#endif /* EFI_ALTERNATOR_CONTROL */
 
#if EFI_VVT_PID
    initVvtActuators();
#endif /* EFI_VVT_PID */
 
#if EFI_MALFUNCTION_INDICATOR
    initMalfunctionIndicator();
#endif /* EFI_MALFUNCTION_INDICATOR */
 
#if !EFI_UNIT_TEST
    // This is tested independently - don't configure sensors for tests.
    // This lets us selectively mock them for each test.
    initNewSensors();
#endif /* EFI_UNIT_TEST */
 
    initSensors();
 
    initAccelEnrichment();
 
    initScriptImpl();
 
    initGpPwm();
 
#if EFI_IDLE_CONTROL
    startIdleThread();
#endif /* EFI_IDLE_CONTROL */
 
#if EFI_TCU
    initGearController();
#endif
 
    initButtonDebounce();
 
#if EFI_ELECTRONIC_THROTTLE_BODY
    initElectronicThrottle();
#endif /* EFI_ELECTRONIC_THROTTLE_BODY */
 
#if EFI_MAP_AVERAGING
    if (engineConfiguration->isMapAveragingEnabled) {
        initMapAveraging();
    }
#endif /* EFI_MAP_AVERAGING */
 
#if EFI_BOOST_CONTROL
    initBoostCtrl();
#endif /* EFI_BOOST_CONTROL */
 
#if EFI_LAUNCH_CONTROL
    initLaunchControl();
#endif
 
  initIgnitionAdvanceControl();
 
#if EFI_UNIT_TEST
    engine->rpmCalculator.Register();
#endif /* EFI_UNIT_TEST */
 
#if EFI_AUX_VALVES
    initAuxValves();
#endif /* EFI_AUX_VALVES */
 
    initTachometer();
    initSpeedometer();
 
#if EFI_LTFT_CONTROL
    initLtft();
#endif
}

Referenced by initRealHardwareEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

doPeriodicSlowCallback()

static void doPeriodicSlowCallback ( )

static

rusEfi usually runs on hardware which halts execution while writing to internal flash, so we postpone writes to until engine is stopped. Writes in case of self-stimulation are fine.

todo: allow writing if 2nd bank of flash is used

Definition at line 180 of file engine_controller.cpp.

                                     {
#if EFI_SHAFT_POSITION_INPUT
    efiAssertVoid(ObdCode::CUSTOM_ERR_6661, getCurrentRemainingStack() > 64, "lowStckOnEv");
 
    slowStartStopButtonCallback();
 
    engine->rpmCalculator.onSlowCallback();
    if (engine->rpmCalculator.isStopped()) {
        resetAccel();
    }
#endif /* EFI_SHAFT_POSITION_INPUT */
 
    engine->periodicSlowCallback();
 
#if EFI_SHAFT_POSITION_INPUT
    if (engine->triggerCentral.directSelfStimulation || engine->rpmCalculator.isStopped()) {
        /**
         * rusEfi usually runs on hardware which halts execution while writing to internal flash, so we
         * postpone writes to until engine is stopped. Writes in case of self-stimulation are fine.
         *
         * todo: allow writing if 2nd bank of flash is used
         */
#if EFI_CONFIGURATION_STORAGE
        writeToFlashIfPending();
#endif /* EFI_CONFIGURATION_STORAGE */
    }
#else /* if EFI_SHAFT_POSITION_INPUT */
    #if EFI_CONFIGURATION_STORAGE
        writeToFlashIfPending();
    #endif /* EFI_CONFIGURATION_STORAGE */
#endif /* EFI_SHAFT_POSITION_INPUT */
 
#if EFI_TCU
    if (engineConfiguration->tcuEnabled && engineConfiguration->gearControllerMode != GearControllerMode::None) {
        if (engine->gearController == NULL) {
            initGearController();
        } else if (engine->gearController->getMode() != engineConfiguration->gearControllerMode) {
            initGearController();
        }
        engine->gearController->update();
    }
#endif // EFI_TCU
 
    tryResetWatchdog();
}

Here is the call graph for this function:

getBit()

static void getBit ( int  offset, int  bit  )

static

this response is part of rusEfi console API

Definition at line 327 of file engine_controller.cpp.

                                        {
    if (isOutOfBounds(offset))
        return;
    int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
    int value = (*ptr >> bit) & 1;
    /**
     * this response is part of rusEfi console API
     */
    efiPrintf("bit%s%d/%d is %d", CONSOLE_DATA_PROTOCOL_TAG, offset, bit, value);
}

Referenced by initConfigActions().

Here is the caller graph for this function:

getByte()

static void getByte ( int  offset )

static

this response is part of rusEfi console API

Definition at line 270 of file engine_controller.cpp.

                                {
    if (isOutOfBounds(offset))
        return;
    uint8_t *ptr = (uint8_t *) (&((char *) engineConfiguration)[offset]);
    uint8_t value = *ptr;
    /**
     * this response is part of rusEfi console API
     */
    efiPrintf("byte%s%d is %d", CONSOLE_DATA_PROTOCOL_TAG, offset, value);
}

Referenced by initConfigActions(), and setByte().

Here is the caller graph for this function:

getFloat()

static void getFloat ( int  offset )

static

this response is part of rusEfi console API

Definition at line 358 of file engine_controller.cpp.

                                 {
    if (isOutOfBounds(offset))
        return;
    float *ptr = (float *) (&((char *) engineConfiguration)[offset]);
    float value = *ptr;
    /**
     * this response is part of rusEfi console API
     */
    efiPrintf("float%s%d is %.5f", CONSOLE_DATA_PROTOCOL_TAG, offset, value);
}

Referenced by initConfigActions(), and setFloat().

Here is the caller graph for this function:

getInt()

static void getInt ( int  offset )

static

this response is part of rusEfi console API

Definition at line 338 of file engine_controller.cpp.

                               {
    if (isOutOfBounds(offset))
        return;
    int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
    int value = *ptr;
    /**
     * this response is part of rusEfi console API
     */
    efiPrintf("int%s%d is %d", CONSOLE_DATA_PROTOCOL_TAG, offset, value);
}

Referenced by initConfigActions(), and setInt().

Here is the caller graph for this function:

getPinNameByAdcChannel()

char * getPinNameByAdcChannel	(	const char *	msg,
		adc_channel_e	hwChannel,
		char *	buffer,
		size_t	bufferSize
	)

Definition at line 231 of file engine_controller.cpp.

                                                                                                         {
#if HAL_USE_ADC
    if (!isAdcChannelValid(hwChannel)) {
        snprintf(buffer, bufferSize, "NONE");
    } else {
        const char *name = portname(getAdcChannelPort(msg, hwChannel));
        snprintf(buffer, bufferSize, "%s%d", name ? name : "null", getAdcChannelPin(hwChannel));
    }
#else
    snprintf(buffer, bufferSize, "NONE");
#endif /* HAL_USE_ADC */
    return buffer;
}

Referenced by AdcSubscription::PrintInfo(), and printMAPInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

getRusEfiVersion()

int getRusEfiVersion

(

)

See also SIGNATURE_HASH

Definition at line 774 of file engine_controller.cpp.

                       {
    if (UNUSED_RAM_SIZE[0] != 0)
        return 123; // this is here to make the compiler happy about the unused array
    if (UNUSED_CCM_SIZE[0] * 0 != 0)
        return 3211; // this is here to make the compiler happy about the unused array
#if defined(EFI_BOOTLOADER_INCLUDE_CODE)
    // make bootloader code happy too
    if (initBootloader() != 0)
        return 123;
#endif /* EFI_BOOTLOADER_INCLUDE_CODE */
    return VCS_DATE;
}

Referenced by errorHandlerInit(), firmwareError(), handleGetVersion(), printVersionForConsole(), readFromFlash(), sayHello(), and updateTunerStudioState().

Here is the caller graph for this function:

getShort()

static void getShort ( int  offset )

static

this response is part of rusEfi console API

Definition at line 259 of file engine_controller.cpp.

                                 {
    if (isOutOfBounds(offset))
        return;
    uint16_t *ptr = (uint16_t *) (&((char *) engineConfiguration)[offset]);
    uint16_t value = *ptr;
    /**
     * this response is part of rusEfi console API
     */
    efiPrintf("short%s%d is %d", CONSOLE_DATA_PROTOCOL_TAG, offset, value);
}

Referenced by initConfigActions(), and setShort().

Here is the caller graph for this function:

initConfigActions()

static void initConfigActions ( )

static

Definition at line 388 of file engine_controller.cpp.

                                {
    addConsoleActionSS("set_float", (VoidCharPtrCharPtr) setFloat);
    addConsoleActionII("set_int", (VoidIntInt) setInt);
    addConsoleActionII("set_short", (VoidIntInt) setShort);
    addConsoleActionII("set_byte", (VoidIntInt) setByte);
    addConsoleActionSSS("set_bit", setBit);
 
    addConsoleActionI("get_float", getFloat);
    addConsoleActionI("get_int", getInt);
    addConsoleActionI("get_short", getShort);
    addConsoleActionI("get_byte", getByte);
    addConsoleActionII("get_bit", getBit);
}

Referenced by commonInitEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

initDataStructures()

void initDataStructures

(

)

Definition at line 103 of file engine_controller.cpp.

                          {
#if EFI_ENGINE_CONTROL
    initFuelMap();
    initSpeedDensity();
    IgnitionEventList &events = engine->ignitionEvents;
    for (size_t i=0;i<efi::size(events.elements);i++) {
      // above-zero value helps distinguish events
      events.elements[i].sparkCounter = 1;
    }
  // above-zero value helps distinguish events
    engine->engineState.globalSparkCounter = 1;
#endif // EFI_ENGINE_CONTROL
}

Referenced by runRusEfi().

Here is the call graph for this function:

Here is the caller graph for this function:

initPeriodicEvents()

void initPeriodicEvents

(

)

Definition at line 226 of file engine_controller.cpp.

                          {
    slowController.start();
    fastController.start();
}

Referenced by runRusEfi().

Here is the caller graph for this function:

initRealHardwareEngineController()

void initRealHardwareEngineController

(

)

Definition at line 735 of file engine_controller.cpp.

                                        {
    commonInitEngineController();
    initWarningRunningPins();
 
#if EFI_LOGIC_ANALYZER
    if (engineConfiguration->isWaveAnalyzerEnabled) {
        initWaveAnalyzer();
    }
#endif /* EFI_LOGIC_ANALYZER */
 
    if (hasFirmwareError()) {
        return;
    }
 
    engineStateBlinkingTask.start();
 
    initVrThresholdPwm();
}

Referenced by initEfiWithConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

printSensorInfo()

static void printSensorInfo ( )

static

Definition at line 246 of file engine_controller.cpp.

                              {
#if HAL_USE_ADC
    // Print info about analog mappings
    AdcSubscription::PrintInfo();
#endif // HAL_USE_ADC
 
    // Print info about all sensors
    Sensor::showAllSensorInfo();
}

Referenced by commonInitEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

resetAccel()

static void resetAccel ( )

static

Definition at line 169 of file engine_controller.cpp.

                         {
    engine->module<TpsAccelEnrichment>()->resetAE();
 
#if EFI_ENGINE_CONTROL
    for (size_t i = 0; i < efi::size(engine->injectionEvents.elements); i++)
    {
        engine->injectionEvents.elements[i].getWallFuel().resetWF();
    }
#endif // EFI_ENGINE_CONTROL
}

Referenced by commonInitEngineController(), and doPeriodicSlowCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

setBit()

static void setBit ( const char *  offsetStr, const char *  bitStr, const char *  valueStr  )

static

this response is part of rusEfi console API

Definition at line 281 of file engine_controller.cpp.

                                                                                    {
    int offset = atoi(offsetStr);
    if (absI(offset) == absI(ATOI_ERROR_CODE)) {
        efiPrintf("invalid offset [%s]", offsetStr);
        return;
    }
    if (isOutOfBounds(offset)) {
        return;
    }
    int bit = atoi(bitStr);
    if (absI(bit) == absI(ATOI_ERROR_CODE)) {
        efiPrintf("invalid bit [%s]", bitStr);
        return;
    }
    int value = atoi(valueStr);
    if (absI(value) == absI(ATOI_ERROR_CODE)) {
        efiPrintf("invalid value [%s]", valueStr);
        return;
    }
    int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
    *ptr ^= (-value ^ *ptr) & (1 << bit);
    /**
     * this response is part of rusEfi console API
     */
    efiPrintf("bit%s%d/%d is %d", CONSOLE_DATA_PROTOCOL_TAG, offset, bit, value);
    incrementGlobalConfigurationVersion("setBit");
}

Referenced by initConfigActions().

Here is the call graph for this function:

Here is the caller graph for this function:

setByte()

static void setByte ( const int  offset, const int  value  )

static

Definition at line 318 of file engine_controller.cpp.

                                                       {
    if (isOutOfBounds(offset))
        return;
    uint8_t *ptr = (uint8_t *) (&((char *) engineConfiguration)[offset]);
    *ptr = (uint8_t) value;
    getByte(offset);
    incrementGlobalConfigurationVersion("setByte");
}

Referenced by initConfigActions().

Here is the call graph for this function:

Here is the caller graph for this function:

setFloat()

static void setFloat ( const char *  offsetStr, const char *  valueStr  )

static

Definition at line 369 of file engine_controller.cpp.

                                                                  {
    int offset = atoi(offsetStr);
    if (absI(offset) == absI(ATOI_ERROR_CODE)) {
        efiPrintf("invalid offset [%s]", offsetStr);
        return;
    }
    if (isOutOfBounds(offset))
        return;
    float value = atoff(valueStr);
    if (std::isnan(value)) {
        efiPrintf("invalid value [%s]", valueStr);
        return;
    }
    float *ptr = (float *) (&((char *) engineConfiguration)[offset]);
    *ptr = value;
    getFloat(offset);
    incrementGlobalConfigurationVersion("setFloat");
}

Referenced by initConfigActions().

Here is the call graph for this function:

Here is the caller graph for this function:

setInt()

static void setInt ( const int  offset, const int  value  )

static

Definition at line 349 of file engine_controller.cpp.

                                                      {
    if (isOutOfBounds(offset))
        return;
    int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
    *ptr = value;
    getInt(offset);
    incrementGlobalConfigurationVersion("setInt");
}

Referenced by initConfigActions().

Here is the call graph for this function:

Here is the caller graph for this function:

setShort()

static void setShort ( const int  offset, const int  value  )

static

Definition at line 309 of file engine_controller.cpp.

                                                        {
    if (isOutOfBounds(offset))
        return;
    uint16_t *ptr = (uint16_t *) (&((char *) engineConfiguration)[offset]);
    *ptr = (uint16_t) value;
    getShort(offset);
    incrementGlobalConfigurationVersion("setShort");
}

Referenced by initConfigActions().

Here is the call graph for this function:

Here is the caller graph for this function:

validateBoardConfig()

PUBLIC_API_WEAK bool validateBoardConfig

(

)

Definition at line 517 of file engine_controller.cpp.

                                           {
  return true;
}

Referenced by validateConfigOnStartUpOrBurn().

Here is the caller graph for this function:

validateConfigOnStartUpOrBurn()

bool validateConfigOnStartUpOrBurn

(

)

Definition at line 522 of file engine_controller.cpp.

                                     {
  if (!validateBoardConfig()) {
    return false;
  }
    if (engineConfiguration->cylindersCount > MAX_CYLINDER_COUNT) {
        criticalError("Invalid cylinder count: %d", engineConfiguration->cylindersCount);
        return false;
    }
#if EFI_PROD_CODE && (BOARD_MC33810_COUNT > 0)
    float maxConfiguredCorr = config->dwellVoltageCorrValues[0];
    for (size_t i = 0;i<efi::size(config->dwellVoltageCorrValues);i++) {
        maxConfiguredCorr = std::max(maxConfiguredCorr, (float)config->dwellVoltageCorrValues[i]);
    }
    float maxConfiguredDwell = config->sparkDwellValues[0];
    for (size_t i = 0;i<efi::size(config->sparkDwellValues);i++) {
        maxConfiguredDwell = std::max(maxConfiguredDwell, (float)config->sparkDwellValues[i]);
    }
    int maxAllowedDwell = getMc33810maxDwellTimer(engineConfiguration->mc33810maxDwellTimer);
        if (maxConfiguredCorr * maxConfiguredDwell > maxAllowedDwell) {
            criticalError("Dwell=%.2f/corr=%.2f while 33810 limit %d", maxConfiguredDwell, maxConfiguredCorr, maxAllowedDwell);
        }
 
#endif // EFI_PROD_CODE && (BOARD_MC33810_COUNT > 0)
    if (engineConfiguration->adcVcc > 5.0f || engineConfiguration->adcVcc < 1.0f) {
    criticalError("Invalid adcVcc: %f", engineConfiguration->adcVcc);
        return false;
    }
    if (engineConfiguration->mapExpAverageAlpha <= 0 || engineConfiguration->mapExpAverageAlpha > 1) {
      engineConfiguration->mapExpAverageAlpha = 1;
    }
 
    if (engineConfiguration->alternator_iTermMin == 0) {
    engineConfiguration->alternator_iTermMin = -1000;
    }
    if (engineConfiguration->alternator_iTermMax == 0) {
    engineConfiguration->alternator_iTermMax = 1000;
    }
 
    ensureArrayIsAscending("Injector deadtime", engineConfiguration->injector.battLagCorrBins);
 
#if EFI_ENGINE_CONTROL
    // Fueling
    {
        ensureArrayIsAscending("VE load", config->veLoadBins);
        ensureArrayIsAscending("VE RPM", config->veRpmBins);
 
        ensureArrayIsAscending("Lambda/AFR load", config->lambdaLoadBins);
        ensureArrayIsAscending("Lambda/AFR RPM", config->lambdaRpmBins);
 
        ensureArrayIsAscending("Fuel CLT mult", config->cltFuelCorrBins);
        ensureArrayIsAscending("Fuel IAT mult", config->iatFuelCorrBins);
 
        ensureArrayIsAscendingOrDefault("Boost CLT mult", config->cltBoostCorrBins);
        ensureArrayIsAscendingOrDefault("Boost IAT mult", config->iatBoostCorrBins);
 
        ensureArrayIsAscending("Injection phase load", config->injPhaseLoadBins);
        ensureArrayIsAscending("Injection phase RPM", config->injPhaseRpmBins);
 
        ensureArrayIsAscendingOrDefault("Fuel Level Sensor", config->fuelLevelBins);
        ensureArrayIsAscendingOrDefault("Fuel Trim Rpm", config->fuelTrimRpmBins);
        ensureArrayIsAscendingOrDefault("Fuel Trim Load", config->fuelTrimLoadBins);
 
        ensureArrayIsAscendingOrDefault("TC slip", engineConfiguration->tractionControlSlipBins);
        ensureArrayIsAscendingOrDefault("TC speed", engineConfiguration->tractionControlSpeedBins);
 
        ensureArrayIsAscending("TPS/TPS AE from", config->tpsTpsAccelFromRpmBins);
        ensureArrayIsAscending("TPS/TPS AE to", config->tpsTpsAccelToRpmBins);
 
        ensureArrayIsAscendingOrDefault("TPS TPS RPM correction", config->tpsTspCorrValuesBins);
 
        ensureArrayIsAscendingOrDefault("Staging Load", config->injectorStagingLoadBins);
        ensureArrayIsAscendingOrDefault("Staging RPM", config->injectorStagingRpmBins);
    }
 
    // Ignition
    {
        ensureArrayIsAscending("Dwell RPM", config->sparkDwellRpmBins);
 
        ensureArrayIsAscending("Ignition load", config->ignitionLoadBins);
        ensureArrayIsAscending("Ignition RPM", config->ignitionRpmBins);
        ensureArrayIsAscendingOrDefault("Ign Trim Rpm", config->ignTrimRpmBins);
        ensureArrayIsAscendingOrDefault("Ign Trim Load", config->ignTrimLoadBins);
 
        ensureArrayIsAscending("Ignition CLT corr", config->cltTimingBins);
 
        ensureArrayIsAscending("Ignition IAT corr IAT", config->ignitionIatCorrTempBins);
        ensureArrayIsAscending("Ignition IAT corr Load", config->ignitionIatCorrLoadBins);
    }
 
    ensureArrayIsAscendingOrDefault("Map estimate TPS", config->mapEstimateTpsBins);
    ensureArrayIsAscendingOrDefault("Map estimate RPM", config->mapEstimateRpmBins);
#endif // EFI_ENGINE_CONTROL
 
    ensureArrayIsAscendingOrDefault("Script Curve 1", config->scriptCurve1Bins);
    ensureArrayIsAscendingOrDefault("Script Curve 2", config->scriptCurve2Bins);
    ensureArrayIsAscendingOrDefault("Script Curve 3", config->scriptCurve3Bins);
    ensureArrayIsAscendingOrDefault("Script Curve 4", config->scriptCurve4Bins);
    ensureArrayIsAscendingOrDefault("Script Curve 5", config->scriptCurve5Bins);
    ensureArrayIsAscendingOrDefault("Script Curve 6", config->scriptCurve6Bins);
 
// todo: huh? why does this not work on CI? ensureArrayIsAscendingOrDefault("Dwell Correction Voltage", engineConfiguration->dwellVoltageCorrVoltBins);
 
    ensureArrayIsAscending("MAF transfer function", config->mafDecodingBins);
 
    // Cranking tables
    ensureArrayIsAscending("Cranking fuel mult", config->crankingFuelBins);
    ensureArrayIsAscending("Cranking duration", config->crankingCycleBins);
    ensureArrayIsAscending("Cranking Fuel CLT", config->crankingCycleFuelCltBins);
    ensureArrayIsAscending("Cranking TPS", config->crankingTpsBins);
 
    // Idle tables
    ensureArrayIsAscending("Idle target RPM", config->cltIdleRpmBins);
    ensureArrayIsAscending("Idle warmup mult", config->cltIdleCorrBins);
    ensureArrayIsAscendingOrDefault("Idle coasting RPM", config->iacCoastingRpmBins);
    ensureArrayIsAscendingOrDefault("Idle VE RPM", config->idleVeRpmBins);
    ensureArrayIsAscendingOrDefault("Idle VE Load", config->idleVeLoadBins);
    ensureArrayIsAscendingOrDefault("Idle timing", config->idleAdvanceBins);
 
    for (size_t index = 0; index < efi::size(engineConfiguration->vrThreshold); index++) {
        auto& cfg = engineConfiguration->vrThreshold[index];
 
        if (cfg.pin == Gpio::Unassigned) {
            continue;
        }
        ensureArrayIsAscending("VR threshold", cfg.rpmBins);
    }
 
#if EFI_BOOST_CONTROL
    // Boost
    ensureArrayIsAscending("Boost control Load", config->boostLoadBins);
    ensureArrayIsAscending("Boost control RPM", config->boostRpmBins);
#endif // EFI_BOOST_CONTROL
 
#if EFI_ANTILAG_SYSTEM
    // ALS
    ensureArrayIsAscendingOrDefault("ign ALS TPS", config->alsIgnRetardLoadBins);
    ensureArrayIsAscendingOrDefault("ign ALS RPM", config->alsIgnRetardrpmBins);
    ensureArrayIsAscendingOrDefault("fuel ALS TPS", config->alsFuelAdjustmentLoadBins);
    ensureArrayIsAscendingOrDefault("fuel ALS RPM", config->alsFuelAdjustmentrpmBins);
#endif // EFI_ANTILAG_SYSTEM
 
#if EFI_ELECTRONIC_THROTTLE_BODY
    // ETB
    ensureArrayIsAscending("Pedal map pedal", config->pedalToTpsPedalBins);
    ensureArrayIsAscending("Pedal map RPM", config->pedalToTpsRpmBins);
#endif // EFI_ELECTRONIC_THROTTLE_BODY
 
    if (isGdiEngine()) {
        ensureArrayIsAscending("HPFP compensation", config->hpfpCompensationRpmBins);
        ensureArrayIsAscending("HPFP deadtime", config->hpfpDeadtimeVoltsBins);
        ensureArrayIsAscending("HPFP lobe profile", config->hpfpLobeProfileQuantityBins);
        ensureArrayIsAscending("HPFP target rpm", config->hpfpTargetRpmBins);
        ensureArrayIsAscending("HPFP target load", config->hpfpTargetLoadBins);
    }
 
    // VVT
    if (isBrainPinValid(engineConfiguration->camInputs[0])) {
        ensureArrayIsAscending("VVT intake load", config->vvtTable1LoadBins);
        ensureArrayIsAscending("VVT intake RPM", config->vvtTable1RpmBins);
    }
 
#if CAM_INPUTS_COUNT != 1
    if (isBrainPinValid(engineConfiguration->camInputs[1])) {
        ensureArrayIsAscending("VVT exhaust load", config->vvtTable2LoadBins);
        ensureArrayIsAscending("VVT exhaust RPM", config->vvtTable2RpmBins);
    }
#endif
 
    if (engineConfiguration->enableOilPressureProtect) {
        ensureArrayIsAscending("Oil pressure protection", config->minimumOilPressureBins);
    }
 
    return true;
}

Referenced by handleBurnCommand(), and initEfiWithConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CCM_OPTIONAL

volatile char UNUSED_CCM_SIZE [CCM_UNUSED_SIZE] CCM_OPTIONAL

Would love to pass reference to configuration object into constructor but C++ does allow attributes after parenthesized initializer

Definition at line 94 of file engine_controller.cpp.

engine

Engine* engine

Definition at line 98 of file engine_controller.cpp.

Referenced by commonInitEngineController(), doPeriodicSlowCallback(), initDataStructures(), and resetAccel().

engineStateBlinkingTask

EngineStateBlinkingTask engineStateBlinkingTask

static

Definition at line 167 of file engine_controller.cpp.

Referenced by initRealHardwareEngineController().

fastController

PeriodicFastController fastController

static

Definition at line 142 of file engine_controller.cpp.

Referenced by initPeriodicEvents().

slowController

PeriodicSlowController slowController

static

Definition at line 143 of file engine_controller.cpp.

Referenced by initPeriodicEvents().

UNUSED_RAM_SIZE

volatile char UNUSED_RAM_SIZE[RAM_UNUSED_SIZE]

static

Definition at line 768 of file engine_controller.cpp.

Referenced by getRusEfiVersion().

Go to the source code of this file.