settings.cpp File Reference

Detailed Description

This file is about configuring engine via the human-readable protocol.

Date

Dec 30, 2012

Author

Andrey Belomutskiy, (c) 2012-2020

Definition in file settings.cpp.

Functions
void	printSpiState ()
void	printConfiguration ()
	Prints current engine configuration to human-readable console.
static void	setIdleSolenoidFrequency (int value)
static void	setCrankingRpm (int value)
static void	setAlgorithmInt (int value)
static void	setFiringOrder (int value)
static void	setRpmHardLimit (int value)
static void	setCrankingIACExtra (float percent)
static void	setCrankingFuel (float fuelMilligram)
static void	setGlobalTriggerAngleOffset (float value)
static void	setCrankingTimingAngle (float value)
static void	setCrankingInjectionMode (int value)
static void	setInjectionMode (int value)
static void	setIgnitionMode (int value)
static void	setIndividualCoilsIgnition ()
static void	setTriggerType (int value)
static void	setDebugMode (int value)
static void	setWholeTimingMap (float value)
static void	setWholeTimingMapCmd (float value)
static brain_pin_e	parseBrainPinWithErrorMessage (const char *pinName)
static void	setIgnitionPin (const char *indexStr, const char *pinName)
void	readPin (const char *pinName)
static void	benchSetPinValue (const char *pinName, int bit)
static void	benchClearPin (const char *pinName)
static void	benchSetPin (const char *pinName)
static void	setIndividualPin (const char *pinName, brain_pin_e *targetPin, const char *name)
static void	setVssPin (const char *pinName)
static void	setIdlePin (const char *pinName)
static void	setAlternatorPin (const char *pinName)
static void	setTriggerInputPin (const char *indexStr, const char *pinName)
static void	setTriggerSimulatorPin (const char *indexStr, const char *pinName)
static void	setAnalogInputPin (const char *sensorStr, const char *pinName)
static void	setLogicInputPin (const char *indexStr, const char *pinName)
static void	setSpiMode (int index, bool mode)
static void	enableOrDisable (const char *param, bool isEnabled)
static void	enable (const char *param)
static void	disable (const char *param)
static void	enableSpi (int index)
static void	disableSpi (int index)
static void	scheduleStopEngine ()
static void	getValue (const char *paramStr)
static void	setScriptCurve1Value (float value)
static void	setScriptCurve2Value (float value)
static void	setValue (const char *paramStr, const char *valueStr)
void	initSettings ()
void	printDateTime ()
void	setDateTime (const char *const isoDateTime)
void	setEngineTypeAndSave (int value)
void	setEngineType (int value, bool isWriteToFlash)

Variables
int	waveChartUsedSize
WaveChart	waveChart
bool	verboseRxCan = false
const command_f_s	commandsF []
const command_i_s	commandsI []

Function Documentation

benchClearPin()

static void benchClearPin ( const char *  pinName )

static

Definition at line 227 of file settings.cpp.

                                               {
    benchSetPinValue(pinName, 0);
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

benchSetPin()

static void benchSetPin ( const char *  pinName )

static

Definition at line 231 of file settings.cpp.

                                             {
    benchSetPinValue(pinName, 1);
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

benchSetPinValue()

static void benchSetPinValue ( const char *  pinName, int  bit  )

static

Definition at line 215 of file settings.cpp.

                                                           {
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    efiSetPadModeWithoutOwnershipAcquisition("bench_pin_test", pin, PAL_MODE_OUTPUT_PUSHPULL);
    // low-level API which does not care about 'qcDirectPinControlMode'
    palWritePad(getHwPort("write", pin), getHwPin("write", pin), bit);
    efiPrintf("pin %s set value", hwPortname(pin));
    readPin(pinName);
}

Referenced by benchClearPin(), and benchSetPin().

Here is the call graph for this function:

Here is the caller graph for this function:

disable()

static void disable ( const char *  param )

static

Definition at line 445 of file settings.cpp.

                                       {
    enableOrDisable(param, false);
}

Referenced by initSettings(), setupTLE9201(), and setupTLE9201IncludingStepper().

Here is the call graph for this function:

Here is the caller graph for this function:

disableSpi()

static void disableSpi ( int  index )

static

Definition at line 453 of file settings.cpp.

                                  {
    setSpiMode(index, false);
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

enable()

static void enable ( const char *  param )

static

Definition at line 441 of file settings.cpp.

                                      {
    enableOrDisable(param, true);
}

Referenced by ACMP_Enable(), ACMP_EnableDMA(), ACMP_EnableLinkToDAC(), ACMP_EnableWindowMode(), ADC12_EnableDMA(), ADC12_EnableHardwareTrigger(), DMAMUX_EnableAlwaysOn(), EDMA_EnableAsyncRequest(), EDMA_EnableAutoStopRequest(), EDMA_TcdEnableAutoStopRequest(), initSettings(), jedec_write_enable(), LPSPI_Enable(), LPUART_EnableRx(), LPUART_EnableRxDMA(), LPUART_EnableTx(), LPUART_EnableTxDMA(), and PORT_EnablePinsDigitalFilter().

Here is the call graph for this function:

Here is the caller graph for this function:

enableOrDisable()

static void enableOrDisable ( const char *  param, bool  isEnabled  )

static

Definition at line 366 of file settings.cpp.

                                                               {
    if (strEqualCaseInsensitive(param, "useTLE8888_cranking_hack")) {
        engineConfiguration->useTLE8888_cranking_hack = isEnabled;
#if EFI_SHAFT_POSITION_INPUT
    } else if (strEqualCaseInsensitive(param, CMD_TRIGGER_HW_INPUT)) {
        getTriggerCentral()->hwTriggerInputEnabled = isEnabled;
#endif // EFI_SHAFT_POSITION_INPUT
    } else if (strEqualCaseInsensitive(param, "verboseTLE8888")) {
        engineConfiguration->verboseTLE8888 = isEnabled;
    } else if (strEqualCaseInsensitive(param, "verboseRxCan")) {
        verboseRxCan = isEnabled;
    } else if (strEqualCaseInsensitive(param, "verboseCan")) {
        engineConfiguration->verboseCan = isEnabled;
    } else if (strEqualCaseInsensitive(param, "verboseCan2")) {
        engineConfiguration->verboseCan2 = isEnabled;
    } else if (strEqualCaseInsensitive(param, "verboseIsoTp")) {
        engineConfiguration->verboseIsoTp = isEnabled;
    } else if (strEqualCaseInsensitive(param, "artificialMisfire")) {
        engineConfiguration->artificialTestMisfire = isEnabled;
    } else if (strEqualCaseInsensitive(param, "logic_level_trigger")) {
        engineConfiguration->displayLogicLevelsInEngineSniffer = isEnabled;
    } else if (strEqualCaseInsensitive(param, "can_broadcast")) {
        engineConfiguration->enableVerboseCanTx = isEnabled;
//  } else if (strEqualCaseInsensitive(param, "etb_auto")) {
//      engine->etbAutoTune = isEnabled;
    } else if (strEqualCaseInsensitive(param, "verboseKLine")) {
        engineConfiguration->verboseKLine = isEnabled;
    } else if (strEqualCaseInsensitive(param, "stepperidle")) {
        engineConfiguration->useStepperIdle = isEnabled;
    } else if (strEqualCaseInsensitive(param, "two_wire_wasted_spark")) {
        engineConfiguration->twoWireBatchIgnition = isEnabled;
        incrementGlobalConfigurationVersion();
    } else if (strEqualCaseInsensitive(param, "altcontrol")) {
        engineConfiguration->isAlternatorControlEnabled = isEnabled;
    } else if (strEqualCaseInsensitive(param, "sd")) {
        engineConfiguration->isSdCardEnabled = isEnabled;
    } else if (strEqualCaseInsensitive(param, CMD_FUNCTIONAL_TEST_MODE)) {
        engine->isFunctionalTestMode = isEnabled;
    } else if (strEqualCaseInsensitive(param, "can_read")) {
        engineConfiguration->canReadEnabled = isEnabled;
    } else if (strEqualCaseInsensitive(param, "can_write")) {
        engineConfiguration->canWriteEnabled = isEnabled;
    } else if (strEqualCaseInsensitive(param, CMD_INJECTION)) {
        engineConfiguration->isInjectionEnabled = isEnabled;
    } else if (strEqualCaseInsensitive(param, CMD_PWM)) {
        engine->isPwmEnabled = isEnabled;
    } else if (strEqualCaseInsensitive(param, "trigger_details")) {
        engineConfiguration->verboseTriggerSynchDetails = isEnabled;
    } else if (strEqualCaseInsensitive(param, "vvt_details")) {
        engineConfiguration->verboseVVTDecoding = isEnabled;
    } else if (strEqualCaseInsensitive(param, "invertCamVVTSignal")) {
        engineConfiguration->invertCamVVTSignal = isEnabled;
    } else if (strEqualCaseInsensitive(param, CMD_IGNITION)) {
        engineConfiguration->isIgnitionEnabled = isEnabled;
#if EFI_EMULATE_POSITION_SENSORS
    } else if (strEqualCaseInsensitive(param, CMD_SELF_STIMULATION)) {
        if (isEnabled) {
            enableTriggerStimulator();
        } else {
            disableTriggerStimulator();
        }
    } else if (strEqualCaseInsensitive(param, CMD_EXTERNAL_STIMULATION)) {
        if (isEnabled) {
            enableExternalTriggerStimulator();
        } else {
            disableTriggerStimulator();
        }
#endif // EFI_EMULATE_POSITION_SENSORS
    } else {
        efiPrintf("unexpected [%s]", param);
        return; // well, MISRA would not like this 'return' here :(
    }
    efiPrintf("[%s] %s", param, isEnabled ? "enabled" : "disabled");
}

Referenced by disable(), and enable().

Here is the call graph for this function:

Here is the caller graph for this function:

enableSpi()

static void enableSpi ( int  index )

static

Definition at line 449 of file settings.cpp.

                                 {
    setSpiMode(index, true);
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

getValue()

static void getValue ( const char *  paramStr )

static

Definition at line 464 of file settings.cpp.

                                           {
 
    {
        float value = getConfigValueByName(paramStr);
        if (value != EFI_ERROR_CODE) {
            efiPrintf("%s value: %.2f", paramStr, value);
            return;
        }
    }
 
    if (strEqualCaseInsensitive(paramStr, "tps_min")) {
        efiPrintf("tps_min=%d", engineConfiguration->tpsMin);
    } else if (strEqualCaseInsensitive(paramStr, "tps_max")) {
        efiPrintf("tps_max=%d", engineConfiguration->tpsMax);
    } else if (strEqualCaseInsensitive(paramStr, "global_trigger_offset_angle")) {
        efiPrintf("global_trigger_offset=%.2f", engineConfiguration->globalTriggerAngleOffset);
#if EFI_SHAFT_POSITION_INPUT
    } else if (strEqualCaseInsensitive(paramStr, "trigger_hw_input")) {
        efiPrintf("trigger_hw_input=%s", boolToString(getTriggerCentral()->hwTriggerInputEnabled));
#endif // EFI_SHAFT_POSITION_INPUT
    } else if (strEqualCaseInsensitive(paramStr, CMD_DATE)) {
        printDateTime();
    } else {
        efiPrintf("Invalid Parameter: %s", paramStr);
    }
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

initSettings()

void initSettings

(

)

Definition at line 633 of file settings.cpp.

                    {
#if EFI_SIMULATOR
    printf("initSettings\n");
#endif // EFI_SIMULATOR
 
    // todo: start saving values into flash right away?
 
#if EFI_ENGINE_CONTROL
    // used by HW CI
    addConsoleAction(CMD_INDIVIDUAL_INJECTION, setIndividualCoilsIgnition);
    addConsoleAction("showconfig", printConfiguration);
    addConsoleActionF("set_whole_timing_map", setWholeTimingMapCmd);
#endif // EFI_ENGINE_CONTROL
 
    addConsoleAction("stopengine", (Void) scheduleStopEngine);
 
    // todo: refactor this - looks like all boolean flags should be controlled with less code duplication
    addConsoleActionI("enable_spi", enableSpi);
    addConsoleActionI("disable_spi", disableSpi);
 
    addConsoleActionS(CMD_ENABLE, enable);
    addConsoleActionS(CMD_DISABLE, disable);
 
    addConsoleActionSS(CMD_SET, setValue);
    addConsoleActionS(CMD_GET, getValue);
 
#if EFI_PROD_CODE
    addConsoleActionSS(CMD_IGNITION_PIN, setIgnitionPin);
    addConsoleActionSS(CMD_TRIGGER_PIN, setTriggerInputPin);
    addConsoleActionSS(CMD_TRIGGER_SIMULATOR_PIN, setTriggerSimulatorPin);
 
    addConsoleActionI(CMD_ECU_UNLOCK, unlockEcu);
 
    addConsoleActionS(CMD_ALTERNATOR_PIN, setAlternatorPin);
    addConsoleActionS(CMD_IDLE_PIN, setIdlePin);
 
    addConsoleActionS("bench_clearpin", benchClearPin);
    addConsoleActionS("bench_setpin", benchSetPin);
    addConsoleActionS("readpin", readPin);
    addConsoleAction("hw_qc_mode", [](){
    setHwQcMode();
  });
    addConsoleActionS("bench_set_output_mode", [](const char *pinName){
      brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
      if (pin == Gpio::Invalid) {
          return;
      }
      efiSetPadModeWithoutOwnershipAcquisition("manual-mode", pin, PAL_MODE_OUTPUT_PUSHPULL);
  });
 
#if HAL_USE_ADC
    addConsoleAction("adc_report", printFullAdcReport);
    addConsoleActionSS("set_analog_input_pin", setAnalogInputPin);
#endif // HAL_USE_ADC
    addConsoleActionSS(CMD_LOGIC_PIN, setLogicInputPin);
#endif // EFI_PROD_CODE
}

Referenced by commonInitEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

parseBrainPinWithErrorMessage()

static brain_pin_e parseBrainPinWithErrorMessage ( const char *  pinName )

static

Definition at line 176 of file settings.cpp.

                                                                      {
    brain_pin_e pin = parseBrainPin(pinName);
    if (pin == Gpio::Invalid) {
        efiPrintf("invalid pin name [%s]", pinName);
    }
    return pin;
}

Referenced by benchSetPinValue(), initSettings(), readPin(), setAnalogInputPin(), setIgnitionPin(), setIndividualPin(), setLogicInputPin(), setTriggerInputPin(), and setTriggerSimulatorPin().

Here is the call graph for this function:

Here is the caller graph for this function:

printConfiguration()

void printConfiguration

(

)

Prints current engine configuration to human-readable console.

Definition at line 57 of file settings.cpp.

                          {
 
    efiPrintf("Template %s/%d trigger %s/%s/%d", getEngine_type_e(engineConfiguration->engineType),
            (int)engineConfiguration->engineType,
            getTrigger_type_e(engineConfiguration->trigger.type),
            Enum2String(engineConfiguration->fuelAlgorithm), (int)engineConfiguration->fuelAlgorithm);
 
    efiPrintf("configurationVersion=%d", engine->getGlobalConfigurationVersion());
 
#if EFI_PROD_CODE
    printSpiState();
#endif // EFI_PROD_CODE
}

Referenced by initSettings(), setAlgorithmInt(), setCrankingInjectionMode(), setCrankingRpm(), setCrankingTimingAngle(), setEngineType(), setFiringOrder(), setGlobalTriggerAngleOffset(), setInjectionMode(), setRpmHardLimit(), and setTriggerType().

Here is the call graph for this function:

Here is the caller graph for this function:

printDateTime()

void printDateTime

(

)

Definition at line 691 of file settings.cpp.

                     {
#if EFI_RTC
    printRtcDateTime();
#else // EFI_RTC
    efiPrintf("Cannot print time: RTC not supported");
#endif // EFI_RTC
}

Referenced by getValue(), and initRtc().

Here is the call graph for this function:

Here is the caller graph for this function:

printSpiState()

void printSpiState

(

)

Definition at line 46 of file settings.cpp.

                     {
    efiPrintf("spi 1=%s/2=%s/3=%s/4=%s",
        boolToString(engineConfiguration->is_enabled_spi_1),
        boolToString(engineConfiguration->is_enabled_spi_2),
        boolToString(engineConfiguration->is_enabled_spi_3),
        boolToString(engineConfiguration->is_enabled_spi_4));
}

Referenced by printConfiguration(), and setSpiMode().

Here is the call graph for this function:

Here is the caller graph for this function:

readPin()

void readPin

(

const char *

pinName

)

Definition at line 205 of file settings.cpp.

                                  {
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    int physicalValue = palReadPad(getHwPort("read", pin), getHwPin("read", pin));
    efiPrintf("pin %s value %d", hwPortname(pin), physicalValue);
}

Referenced by benchSetPinValue(), and initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

scheduleStopEngine()

static void scheduleStopEngine ( )

static

See 'LimpManager::isEngineStop' for code which actually stops engine

Definition at line 460 of file settings.cpp.

                                 {
    doScheduleStopEngine(StopRequestedReason::Console);
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setAlgorithmInt()

static void setAlgorithmInt ( int  value )

static

this method is used in console - it also prints current configuration

Definition at line 87 of file settings.cpp.

                                       {
    setAlgorithm((engine_load_mode_e) value);
    printConfiguration();
}

Here is the call graph for this function:

setAlternatorPin()

static void setAlternatorPin ( const char *  pinName )

static

Definition at line 255 of file settings.cpp.

                                                  {
    setIndividualPin(pinName, &engineConfiguration->alternatorControlPin, "alternator");
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setAnalogInputPin()

static void setAnalogInputPin ( const char *  sensorStr, const char *  pinName  )

static

Definition at line 294 of file settings.cpp.

                                                                          {
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    adc_channel_e channel = getAdcChannel(pin);
    if (channel == EFI_ADC_ERROR) {
        efiPrintf("Error with [%s]", pinName);
        return;
    }
    if (strEqual("map", sensorStr)) {
        engineConfiguration->map.sensor.hwChannel = channel;
        efiPrintf("setting MAP to %s/%d", pinName, channel);
    } else if (strEqual("pps", sensorStr)) {
        engineConfiguration->throttlePedalPositionAdcChannel = channel;
        efiPrintf("setting PPS to %s/%d", pinName, channel);
    } else if (strEqual("afr", sensorStr)) {
        engineConfiguration->afr.hwChannel = channel;
        efiPrintf("setting AFR to %s/%d", pinName, channel);
    } else if (strEqual("clt", sensorStr)) {
        engineConfiguration->clt.adcChannel = channel;
        efiPrintf("setting CLT to %s/%d", pinName, channel);
    } else if (strEqual("iat", sensorStr)) {
        engineConfiguration->iat.adcChannel = channel;
        efiPrintf("setting IAT to %s/%d", pinName, channel);
    } else if (strEqual("tps", sensorStr)) {
        engineConfiguration->tps1_1AdcChannel = channel;
        efiPrintf("setting TPS1 to %s/%d", pinName, channel);
    } else if (strEqual("tps2", sensorStr)) {
        engineConfiguration->tps2_1AdcChannel = channel;
        efiPrintf("setting TPS2 to %s/%d", pinName, channel);
    }
    incrementGlobalConfigurationVersion();
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setCrankingFuel()

static void setCrankingFuel ( float  fuelMilligram )

static

Definition at line 109 of file settings.cpp.

                                                 {
    setTable(config->crankingCycleBaseFuel, fuelMilligram);
    efiPrintf("cranking_fuel %.2f", fuelMilligram);
}

Here is the call graph for this function:

setCrankingIACExtra()

static void setCrankingIACExtra ( float  percent )

static

Definition at line 102 of file settings.cpp.

                                               {
    for (uint8_t i = 0; i < CLT_CRANKING_CURVE_SIZE; i++) {
        config->cltCrankingCorr[i] = percent;
    }
    efiPrintf("cranking_iac %.2f", percent);
}

setCrankingInjectionMode()

static void setCrankingInjectionMode ( int  value )

static

Definition at line 126 of file settings.cpp.

                                                {
    engineConfiguration->crankingInjectionMode = (injection_mode_e) value;
    incrementGlobalConfigurationVersion();
    printConfiguration();
}

Here is the call graph for this function:

setCrankingRpm()

static void setCrankingRpm ( int  value )

static

Definition at line 79 of file settings.cpp.

                                      {
    engineConfiguration->cranking.rpm = value;
    printConfiguration();
}

Here is the call graph for this function:

setCrankingTimingAngle()

static void setCrankingTimingAngle ( float  value )

static

Definition at line 120 of file settings.cpp.

                                                {
    engineConfiguration->crankingTimingAngle = value;
    incrementGlobalConfigurationVersion();
    printConfiguration();
}

Here is the call graph for this function:

setDateTime()

void setDateTime

(

const char *const

isoDateTime

)

Definition at line 699 of file settings.cpp.

                                                 {
#if EFI_RTC
    printRtcDateTime();
    if (strlen(isoDateTime) >= 19 && isoDateTime[10] == 'T') {
        efidatetime_t dateTime;
        dateTime.year = atoi(isoDateTime);
        dateTime.month = atoi(isoDateTime + 5);
        dateTime.day = atoi(isoDateTime + 8);
        dateTime.hour = atoi(isoDateTime + 11);
        dateTime.minute = atoi(isoDateTime + 14);
        dateTime.second = atoi(isoDateTime + 17);
        if (dateTime.year != ATOI_ERROR_CODE &&
                dateTime.month >= 1 && dateTime.month <= 12 &&
                dateTime.day >= 1 && dateTime.day <= 31 &&
                dateTime.hour <= 23 &&
                dateTime.minute <= 59 &&
                dateTime.second <= 59) {
            // doesn't concern about leap years or seconds; ChibiOS doesn't support (added) leap seconds anyway
            setRtcDateTime(&dateTime);
            efiPrintf("Time is changed to");
            printRtcDateTime();
            return;
        }
    }
    efiPrintf("date_set Date parameter %s is wrong", isoDateTime);
#else // EFI_RTC
    efiPrintf("Cannot set time: RTC not supported");
#endif // EFI_RTC
}

Referenced by setValue().

Here is the call graph for this function:

Here is the caller graph for this function:

setDebugMode()

static void setDebugMode ( int  value )

static

Definition at line 158 of file settings.cpp.

                                    {
    engineConfiguration->debugMode = (debug_mode_e) value;
}

setEngineType()

void setEngineType	(	int	value,
		bool	isWriteToFlash
	)

Definition at line 735 of file settings.cpp.

                                                   {
    {
#if EFI_PROD_CODE
        chibios_rt::CriticalSectionLocker csl;
#endif // EFI_PROD_CODE
 
        engineConfiguration->engineType = (engine_type_e)value;
        resetConfigurationExt((engine_type_e)value);
        engine->resetEngineSnifferIfInTestMode();
 
#if EFI_CONFIGURATION_STORAGE
        if (isWriteToFlash) {
            writeToFlashNow();
        }
#endif /* EFI_CONFIGURATION_STORAGE */
    }
    incrementGlobalConfigurationVersion("engineType");
#if EFI_ENGINE_CONTROL && ! EFI_UNIT_TEST
    printConfiguration();
#endif // ! EFI_UNIT_TEST
}

Referenced by applyPreset(), processCanQcBenchTest(), and setEngineTypeAndSave().

Here is the call graph for this function:

Here is the caller graph for this function:

setEngineTypeAndSave()

void setEngineTypeAndSave

(

int

value

)

Definition at line 731 of file settings.cpp.

                                     {
    setEngineType(value, true);
}

Here is the call graph for this function:

setFiringOrder()

static void setFiringOrder ( int  value )

static

Definition at line 92 of file settings.cpp.

                                      {
    engineConfiguration->firingOrder = (firing_order_e) value;
    printConfiguration();
}

Here is the call graph for this function:

setGlobalTriggerAngleOffset()

static void setGlobalTriggerAngleOffset ( float  value )

static

Definition at line 114 of file settings.cpp.

                                                     {
    engineConfiguration->globalTriggerAngleOffset = value;
    incrementGlobalConfigurationVersion();
    printConfiguration();
}

Here is the call graph for this function:

setIdlePin()

static void setIdlePin ( const char *  pinName )

static

Definition at line 251 of file settings.cpp.

                                            {
    setIndividualPin(pinName, &engineConfiguration->idle.solenoidPin, "idle");
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setIdleSolenoidFrequency()

static void setIdleSolenoidFrequency ( int  value )

static

Definition at line 72 of file settings.cpp.

                                                {
    engineConfiguration->idle.solenoidFrequency = value;
    incrementGlobalConfigurationVersion();
}

Here is the call graph for this function:

setIgnitionMode()

static void setIgnitionMode ( int  value )

static

Definition at line 138 of file settings.cpp.

                                       {
#if EFI_ENGINE_CONTROL
    engineConfiguration->ignitionMode = (ignition_mode_e) value;
    incrementGlobalConfigurationVersion();
    prepareOutputSignals();
#endif // EFI_ENGINE_CONTROL
}

Referenced by setIndividualCoilsIgnition().

Here is the call graph for this function:

Here is the caller graph for this function:

setIgnitionPin()

static void setIgnitionPin ( const char *  indexStr, const char *  pinName  )

static

For example: set_ignition_pin 1 PD7 todo: this method counts index from 1 while at least 'set_trigger_input_pin' counts from 0. todo: make things consistent

Definition at line 190 of file settings.cpp.

                                                                      {
    int index = atoi(indexStr) - 1; // convert from human index into software index
    if (index < 0 || index >= MAX_CYLINDER_COUNT)
        return;
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    efiPrintf("setting ignition pin[%d] to %s please save&restart", index, hwPortname(pin));
    engineConfiguration->ignitionPins[index] = pin;
    incrementGlobalConfigurationVersion();
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setIndividualCoilsIgnition()

static void setIndividualCoilsIgnition ( )

static

Definition at line 146 of file settings.cpp.

                                         {
    setIgnitionMode((int)IM_INDIVIDUAL_COILS);
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setIndividualPin()

static void setIndividualPin ( const char *  pinName, brain_pin_e *  targetPin, const char *  name  )

static

Definition at line 235 of file settings.cpp.

                                                                                            {
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    efiPrintf("setting %s pin to %s please save&restart", name, hwPortname(pin));
    *targetPin = pin;
    incrementGlobalConfigurationVersion();
}

Referenced by setAlternatorPin(), setIdlePin(), and setVssPin().

Here is the call graph for this function:

Here is the caller graph for this function:

setInjectionMode()

static void setInjectionMode ( int  value )

static

Definition at line 132 of file settings.cpp.

                                        {
    engineConfiguration->injectionMode = (injection_mode_e) value;
    incrementGlobalConfigurationVersion();
    printConfiguration();
}

Here is the call graph for this function:

setLogicInputPin()

static void setLogicInputPin ( const char *  indexStr, const char *  pinName  )

static

Definition at line 330 of file settings.cpp.

                                                                        {
    int index = atoi(indexStr);
    if (index < 0 || index > 2) {
        return;
    }
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    efiPrintf("setting logic input pin[%d] to %s please save&restart", index, hwPortname(pin));
    engineConfiguration->logicAnalyzerPins[index] = pin;
    incrementGlobalConfigurationVersion();
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setRpmHardLimit()

static void setRpmHardLimit ( int  value )

static

Definition at line 97 of file settings.cpp.

                                       {
    engineConfiguration->rpmHardLimit = value;
    printConfiguration();
}

Here is the call graph for this function:

setScriptCurve1Value()

static void setScriptCurve1Value ( float  value )

static

Definition at line 491 of file settings.cpp.

                                              {
    setLinearCurve(config->scriptCurve1, value, value, 1);
}

Here is the call graph for this function:

setScriptCurve2Value()

static void setScriptCurve2Value ( float  value )

static

Definition at line 495 of file settings.cpp.

                                              {
    setLinearCurve(config->scriptCurve2, value, value, 1);
}

Here is the call graph for this function:

setSpiMode()

static void setSpiMode ( int  index, bool  mode  )

static

Definition at line 346 of file settings.cpp.

                                             {
    switch (index) {
    case 1:
        engineConfiguration->is_enabled_spi_1 = mode;
        break;
    case 2:
        engineConfiguration->is_enabled_spi_2 = mode;
        break;
    case 3:
        engineConfiguration->is_enabled_spi_3 = mode;
        break;
    default:
        efiPrintf("invalid spi index %d", index);
        return;
    }
    printSpiState();
}

Referenced by disableSpi(), and enableSpi().

Here is the call graph for this function:

Here is the caller graph for this function:

setTriggerInputPin()

static void setTriggerInputPin ( const char *  indexStr, const char *  pinName  )

static

For example: set_trigger_input_pin 0 PA5 todo: this method counts index from 0 while at least 'set_ignition_pin' counts from 1. todo: make things consistent

Definition at line 265 of file settings.cpp.

                                                                          {
    int index = atoi(indexStr);
    if (index < 0 || index > 2)
        return;
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    efiPrintf("setting trigger pin[%d] to %s please save&restart", index, hwPortname(pin));
    engineConfiguration->triggerInputPins[index] = pin;
    incrementGlobalConfigurationVersion();
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setTriggerSimulatorPin()

static void setTriggerSimulatorPin ( const char *  indexStr, const char *  pinName  )

static

Definition at line 278 of file settings.cpp.

                                                                              {
    int index = atoi(indexStr);
    if (index < 0 || index >= TRIGGER_SIMULATOR_PIN_COUNT)
        return;
    brain_pin_e pin = parseBrainPinWithErrorMessage(pinName);
    if (pin == Gpio::Invalid) {
        return;
    }
    efiPrintf("setting trigger simulator pin[%d] to %s please save&restart", index, hwPortname(pin));
    engineConfiguration->triggerSimulatorPins[index] = pin;
    incrementGlobalConfigurationVersion();
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setTriggerType()

static void setTriggerType ( int  value )

static

Definition at line 150 of file settings.cpp.

                                      {
    engineConfiguration->trigger.type = (trigger_type_e) value;
    incrementGlobalConfigurationVersion();
    printConfiguration();
    efiPrintf("Do you need to also invoke set operation_mode X?");
    engine->resetEngineSnifferIfInTestMode();
}

Here is the call graph for this function:

setValue()

static void setValue ( const char *  paramStr, const char *  valueStr  )

static

Definition at line 557 of file settings.cpp.

                                                                 {
    float valueF = atoff(valueStr);
    int valueI = atoi(valueStr);
 
    const command_f_s *currentF = &commandsF[0];
    while (currentF < commandsF + sizeof(commandsF)/sizeof(commandsF[0])) {
        if (strEqualCaseInsensitive(paramStr, currentF->token)) {
            currentF->callback(valueF);
            return;
        }
        currentF++;
    }
 
    const command_i_s *currentI = &commandsI[0];
    while (currentI < commandsI + sizeof(commandsI)/sizeof(commandsI[0])) {
        if (strEqualCaseInsensitive(paramStr, currentI->token)) {
            currentI->callback(valueI);
            return;
        }
        currentI++;
    }
 
 
    if (strEqualCaseInsensitive(paramStr, "warning_period")) {
        engineConfiguration->warningPeriod = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "dwell")) {
        setConstantDwell(valueF);
    } else if (strEqualCaseInsensitive(paramStr, CMD_ENGINESNIFFERRPMTHRESHOLD)) {
        engineConfiguration->engineSnifferRpmThreshold = valueI;
#if EFI_EMULATE_POSITION_SENSORS
    } else if (strEqualCaseInsensitive(paramStr, CMD_RPM)) {
        setTriggerEmulatorRPM(valueI);
#endif // EFI_EMULATE_POSITION_SENSORS
    } else if (strEqualCaseInsensitive(paramStr, "mc33_hvolt")) {
        engineConfiguration->mc33_hvolt = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "mc33_i_peak")) {
        engineConfiguration->mc33_i_peak = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "mc33_i_hold")) {
        engineConfiguration->mc33_i_hold = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "mc33_t_max_boost")) {
        engineConfiguration->mc33_t_max_boost = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "mc33_t_peak_off")) {
        engineConfiguration->mc33_t_peak_off = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "vvt_offset")) {
        engineConfiguration->vvtOffsets[0] = valueF;
    } else if (strEqualCaseInsensitive(paramStr, "vvt_mode")) {
        engineConfiguration->vvtMode[0] = (vvt_mode_e)valueI;
    } else if (strEqualCaseInsensitive(paramStr, "wwaeTau")) {
        engineConfiguration->wwaeTau = valueF;
    } else if (strEqualCaseInsensitive(paramStr, "wwaeBeta")) {
        engineConfiguration->wwaeBeta = valueF;
    } else if (strEqualCaseInsensitive(paramStr, "benchTestOffTime")) {
        engineConfiguration->benchTestOffTime = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "benchTestCount")) {
        engineConfiguration->benchTestCount = valueI;
    } else if (strEqualCaseInsensitive(paramStr, "cranking_dwell")) {
        engineConfiguration->ignitionDwellForCrankingMs = valueF;
#if EFI_PROD_CODE
    } else if (strEqualCaseInsensitive(paramStr, CMD_VSS_PIN)) {
        setVssPin(valueStr);
#endif // EFI_PROD_CODE
    } else if (strEqualCaseInsensitive(paramStr, "targetvbatt")) {
        setTable(config->alternatorVoltageTargetTable, valueF);
    } else if (strEqualCaseInsensitive(paramStr, CMD_DATE)) {
        // rusEfi console invokes this method with timestamp in local timezone
        setDateTime(valueStr);
    }
 
    bool isGoodName = setConfigValueByName(paramStr, valueF);
    if (isGoodName) {
       efiPrintf("Settings: applying [%s][%f]", paramStr, valueF);
    }
 
    engine->resetEngineSnifferIfInTestMode();
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

setVssPin()

static void setVssPin ( const char *  pinName )

static

Definition at line 246 of file settings.cpp.

                                           {
    setIndividualPin(pinName, &engineConfiguration->vehicleSpeedSensorInputPin, "VSS");
}

Referenced by setValue().

Here is the call graph for this function:

Here is the caller graph for this function:

setWholeTimingMap()

static void setWholeTimingMap ( float  value )

static

Definition at line 162 of file settings.cpp.

                                           {
    setTable(config->ignitionTable, value);
}

Referenced by setWholeTimingMapCmd().

Here is the call graph for this function:

Here is the caller graph for this function:

setWholeTimingMapCmd()

static void setWholeTimingMapCmd ( float  value )

static

Definition at line 166 of file settings.cpp.

                                              {
    efiPrintf("Setting whole timing advance map to %.2f", value);
    setWholeTimingMap(value);
    engine->resetEngineSnifferIfInTestMode();
}

Referenced by initSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

commandsF

const command_f_s commandsF[]

Initial value:

= {
#if EFI_ENGINE_CONTROL
        {"global_trigger_offset_angle", setGlobalTriggerAngleOffset},
        {"cranking_fuel", setCrankingFuel},
        {"cranking_iac", setCrankingIACExtra},
        {"cranking_timing_angle", setCrankingTimingAngle},
        {"flat_injector_lag", setFlatInjectorLag},
#endif 
        {"script_curve_1_value", setScriptCurve1Value},
        {"script_curve_2_value", setScriptCurve2Value},
}

Definition at line 509 of file settings.cpp.

                                {
#if EFI_ENGINE_CONTROL
        {"global_trigger_offset_angle", setGlobalTriggerAngleOffset},
        {"cranking_fuel", setCrankingFuel},
        {"cranking_iac", setCrankingIACExtra},
        {"cranking_timing_angle", setCrankingTimingAngle},
        {"flat_injector_lag", setFlatInjectorLag},
#endif // EFI_ENGINE_CONTROL
        {"script_curve_1_value", setScriptCurve1Value},
        {"script_curve_2_value", setScriptCurve2Value},
};

Referenced by setValue().

commandsI

const command_i_s commandsI[]

Definition at line 521 of file settings.cpp.

                                {
#if EFI_ENGINE_CONTROL
        {"ignition_mode", setIgnitionMode},
        {"driveWheelRevPerKm", [](int value) {
            engineConfiguration->driveWheelRevPerKm = value;
        }},
        {"cranking_rpm", setCrankingRpm},
        {"cranking_injection_mode", setCrankingInjectionMode},
        {"injection_mode", setInjectionMode},
        {CMD_ENGINE_TYPE, setEngineTypeAndSave},
        {"rpm_hard_limit", setRpmHardLimit},
        {"firing_order", setFiringOrder},
        {"algorithm", setAlgorithmInt},
        {"debug_mode", setDebugMode},
        {"trigger_type", setTriggerType},
        // used by HW CI
        {"idle_solenoid_freq", setIdleSolenoidFrequency},
#endif // EFI_ENGINE_CONTROL
#if EFI_PROD_CODE
#if EFI_BOR_LEVEL
        {"bor", setBor},
#endif // EFI_BOR_LEVEL
#if EFI_CAN_SUPPORT
        {"can_mode", setCanType},
        {"can_vss", setCanVss},
#endif // EFI_CAN_SUPPORT
#if EFI_IDLE_CONTROL
        {"idle_position", setManualIdleValvePosition},
        {"idle_rpm", setTargetIdleRpm},
#endif // EFI_IDLE_CONTROL
#endif // EFI_PROD_CODE
 
        //      {"", },
        //      {"", },
};

Referenced by setValue().

verboseRxCan

bool verboseRxCan = false

Definition at line 364 of file settings.cpp.

Referenced by enableOrDisable(), and processCanRxMessage().

waveChart

WaveChart waveChart

extern

Definition at line 32 of file trigger_central.cpp.

waveChartUsedSize

int waveChartUsedSize

extern

Definition at line 60 of file engine_sniffer.cpp.

Go to the source code of this file.