engine_controller.h File Reference

Detailed Description

Controllers package entry point header.

Date

Feb 7, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file engine_controller.h.

Functions
bool	validateConfigOnStartUpOrBurn ()
bool	validateConfigOnStartUpOrBurn (bool isRunningOnBurn)
char *	getPinNameByAdcChannel (const char *msg, adc_channel_e hwChannel, char *buffer, size_t bufferSize)
void	initPeriodicEvents ()
void	initRealHardwareEngineController ()
void	commonEarlyInit ()
void	commonInitEngineController ()
void	initStartStopButton ()
void	initWarningRunningPins ()
void	initDataStructures ()
void	slowStartStopButtonCallback ()

Function Documentation

commonEarlyInit()

void commonEarlyInit

(

)

Initialize hardware drivers

Definition at line 719 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 386 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_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 && defined (MODULE_MAP_AVERAGING)
    engine->module<MapAveragingModule>()->init();
#else
    efiPrintf("No MapAveraging support!");
#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 */
 
#ifdef MODULE_TACHOMETER
    engine->module<TachometerModule>()->init();
#endif
 
    initSpeedometer();
 
    initStft();
#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:

getPinNameByAdcChannel()

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

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

initDataStructures()

void initDataStructures

(

)

Definition at line 102 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 207 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 755 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:

initStartStopButton()

void initStartStopButton

(

)

See test_start_stop.cpp

Definition at line 11 of file start_stop.cpp.

                           {
    /* startCrankingDuration is efitimesec_t, so we need to multiply it by 1000 to get milliseconds*/
    engine->startStopState.startStopButtonDebounce.init((engineConfiguration->startCrankingDuration*1000),
      engineConfiguration->startStopButtonPin,
      engineConfiguration->startStopButtonMode,
      engineConfiguration->startRequestPinInverted);
}

Referenced by startHardware().

Here is the call graph for this function:

Here is the caller graph for this function:

initWarningRunningPins()

void initWarningRunningPins

(

)

Definition at line 226 of file status_loop.cpp.

                              {
#if EFI_PROD_CODE
    // open question if we need warningLedPin and runningLedPin at all!
    enginePins.warningLedPin.initPin("led: warning status", getWarningLedPin(), LED_PIN_MODE, true);
    enginePins.runningLedPin.initPin("led: running status", getRunningLedPin(), LED_PIN_MODE, true);
#endif /* EFI_PROD_CODE */
}

Referenced by initRealHardwareEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

slowStartStopButtonCallback()

void slowStartStopButtonCallback

(

)

Definition at line 60 of file start_stop.cpp.

                                   {
  if (!isIgnVoltage()) {
    // nothing to crank if we are powered only via USB
    engine->startStopState.timeSinceIgnitionPower.reset();
    return;
  } else if (engine->startStopState.isFirstTime) {
    // initialize when first time with proper power
    engine->startStopState.timeSinceIgnitionPower.reset();
    engine->startStopState.isFirstTime = false;
  }
 
    if (engine->startStopState.timeSinceIgnitionPower.getElapsedUs() < MS2US(engineConfiguration->startButtonSuppressOnStartUpMs)) {
        // where are odd cases of start button combined with ECU power source button we do not want to crank right on start
        return;
    }
 
  if (engine->rpmCalculator.isStopped()) {
    if (engineConfiguration->crankingCondition == CC_BRAKE && !engine->brakePedalSwitchedState) {
      return;
    }
    if (engineConfiguration->crankingCondition == CC_CLUTCH && !engine->clutchUpSwitchedState) {
      return;
    }
 
    if (isCrankingSuppressed()) {
      return;
    }
  }
 
    bool startStopState = engine->startStopState.startStopButtonDebounce.readPinEvent();
 
    if (startStopState && !engine->engineState.startStopState) {
        // we are here on transition from 0 to 1
        startStopButtonToggle();
    }
    // todo: we shall extract start_stop.txt from engine_state.txt
    engine->engineState.startStopState = startStopState;
    engine->engineState.startStopPhysicalState = engine->startStopState.startStopButtonDebounce.getPhysicalState();
 
    bool isStarterEngaged = enginePins.starterControl.getLogicValue();
 
    if (isStarterEngaged) {
        disengageStarterIfNeeded();
    }
}

Referenced by doPeriodicSlowCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

validateConfigOnStartUpOrBurn() [1/2]

bool validateConfigOnStartUpOrBurn

(

)

Definition at line 519 of file engine_controller.cpp.

                                     {
  if (!validateBoardConfig()) {
    return false;
  }
#if defined(HW_HELLEN_UAEFI)
  // todo: make this board-specific validation callback!
  pickEtbOrStepper();
#endif
  if (!validateGdi()) {
    return false;
  }
  if (engineConfiguration->etbMinimumPosition + 1 >= engineConfiguration->etbMaximumPosition) {
        criticalError("Broken ETB min/max %d %d",
          engineConfiguration->etbMinimumPosition,
          engineConfiguration->etbMaximumPosition);
        return false;
  }
 
  defaultsOrFixOnBurn();
    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;
    }
 
    ensureArrayIsAscending("Injector deadtime vBATT", engineConfiguration->injector.battLagCorrBattBins);
    ensureArrayIsAscending("Injector deadtime Pressure", engineConfiguration->injector.battLagCorrPressBins);
 
#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("STFT Rpm", config->fuelTrimRpmBins);
        ensureArrayIsAscendingOrDefault("STFT Load", config->fuelTrimLoadBins);
 
        ensureArrayIsAscendingOrDefault("knock rpm", config->maxKnockRetardRpmBins);
        ensureArrayIsAscendingOrDefault("knock tps", config->maxKnockRetardLoadBins);
 
        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 CLT", config->ignitionCltCorrTempBins);
        ensureArrayIsAscending("Ignition CLT corr Load", config->ignitionCltCorrLoadBins);
 
        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 CLT", config->cltIdleCorrBins);
    ensureArrayIsAscending("Idle warmup mult RPM", config->rpmIdleCorrBins);
    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 [open loop]", config->boostOpenLoopLoadBins);
    ensureArrayIsAscending("Boost control Load [closed loop]", config->boostClosedLoopLoadBins);
    ensureArrayIsAscending("Boost control RPM [open+closed loop]", 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);
 
        ensureArrayIsAscending("HPFP fuel mass compensation fuel pressure", config->hpfpFuelMassCompensationFuelPressure);
        ensureArrayIsAscending("HPFP fuel mass compensation fuel mass", config->hpfpFuelMassCompensationFuelMass);
 
    }
 
    // 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(), initEfiWithConfig(), and validateConfigOnStartUpOrBurn().

Here is the call graph for this function:

Here is the caller graph for this function:

validateConfigOnStartUpOrBurn() [2/2]

bool validateConfigOnStartUpOrBurn

(

bool

isRunningOnBurn

)

Definition at line 712 of file engine_controller.cpp.

                                                         {
    ConfigurationWizard::onConfigOnStartUpOrBurn(isRunningOnBurn);
    return validateConfigOnStartUpOrBurn();
}

Here is the call graph for this function:

Go to the source code of this file.