rusEFI
The most advanced open source ECU
Loading...
Searching...
No Matches
Functions | Variables
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.

227 {
228 benchSetPinValue(pinName, 0);
229}
static void benchSetPinValue(const char *pinName, int bit)
Definition settings.cpp:215

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.

231 {
232 benchSetPinValue(pinName, 1);
233}

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.

215 {
217 if (pin == Gpio::Invalid) {
218 return;
219 }
220 efiSetPadModeWithoutOwnershipAcquisition("bench_pin_test", pin, PAL_MODE_OUTPUT_PUSHPULL);
221 // low-level API which does not care about 'qcDirectPinControlMode'
222 palWritePad(getHwPort("write", pin), getHwPin("write", pin), bit);
223 efiPrintf("pin %s set value", hwPortname(pin));
224 readPin(pinName);
225}
@ Invalid
ioportid_t getHwPort(const char *msg, brain_pin_e brainPin)
ioportmask_t getHwPin(const char *msg, brain_pin_e brainPin)
void efiSetPadModeWithoutOwnershipAcquisition(const char *msg, brain_pin_e brainPin, iomode_t mode)
Definition io_pins.cpp:61
const char * hwPortname(brain_pin_e brainPin)
static brain_pin_e parseBrainPinWithErrorMessage(const char *pinName)
Definition settings.cpp:176
void readPin(const char *pinName)
Definition settings.cpp:205
brain_pin_e pin
Definition stm32_adc.cpp:15

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 449 of file settings.cpp.

449 {
450 enableOrDisable(param, false);
451}
static void enableOrDisable(const char *param, bool isEnabled)
Definition settings.cpp:366
static tstrWifiInitParam param

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 457 of file settings.cpp.

457 {
458 setSpiMode(index, false);
459}
static void setSpiMode(int index, bool mode)
Definition settings.cpp:346

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

◆ enableOrDisable()

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

Definition at line 366 of file settings.cpp.

366 {
367 if (strEqualCaseInsensitive(param, "useTLE8888_cranking_hack")) {
369#if EFI_SHAFT_POSITION_INPUT
370 } else if (strEqualCaseInsensitive(param, CMD_TRIGGER_HW_INPUT)) {
372#endif // EFI_SHAFT_POSITION_INPUT
373 } else if (strEqualCaseInsensitive(param, "verboseTLE8888")) {
375 } else if (strEqualCaseInsensitive(param, "verboseRxCan")) {
376 verboseRxCan = isEnabled;
377 } else if (strEqualCaseInsensitive(param, "verboseCan")) {
378 engineConfiguration->verboseCan = isEnabled;
379 } else if (strEqualCaseInsensitive(param, "verboseCan2")) {
380 engineConfiguration->verboseCan2 = isEnabled;
381#if (EFI_CAN_BUS_COUNT >= 3)
382 } else if (strEqualCaseInsensitive(param, "verboseCan3")) {
383 engineConfiguration->verboseCan3 = isEnabled;
384#endif
385 } else if (strEqualCaseInsensitive(param, "verboseIsoTp")) {
387 } else if (strEqualCaseInsensitive(param, "artificialMisfire")) {
389 } else if (strEqualCaseInsensitive(param, "logic_level_trigger")) {
391 } else if (strEqualCaseInsensitive(param, "can_broadcast")) {
393// } else if (strEqualCaseInsensitive(param, "etb_auto")) {
394// engine->etbAutoTune = isEnabled;
395 } else if (strEqualCaseInsensitive(param, "verboseKLine")) {
397 } else if (strEqualCaseInsensitive(param, "stepperidle")) {
399 } else if (strEqualCaseInsensitive(param, "two_wire_wasted_spark")) {
402 } else if (strEqualCaseInsensitive(param, "altcontrol")) {
404 } else if (strEqualCaseInsensitive(param, "sd")) {
406 } else if (strEqualCaseInsensitive(param, CMD_FUNCTIONAL_TEST_MODE)) {
407 engine->isFunctionalTestMode = isEnabled;
408 } else if (strEqualCaseInsensitive(param, "can_read")) {
410 } else if (strEqualCaseInsensitive(param, "can_write")) {
412 } else if (strEqualCaseInsensitive(param, CMD_INJECTION)) {
414 } else if (strEqualCaseInsensitive(param, CMD_PWM)) {
415 engine->isPwmEnabled = isEnabled;
416 } else if (strEqualCaseInsensitive(param, "trigger_details")) {
418 } else if (strEqualCaseInsensitive(param, "vvt_details")) {
420 } else if (strEqualCaseInsensitive(param, "invertCamVVTSignal")) {
422 } else if (strEqualCaseInsensitive(param, CMD_IGNITION)) {
424#if EFI_EMULATE_POSITION_SENSORS
425 } else if (strEqualCaseInsensitive(param, CMD_SELF_STIMULATION)) {
426 if (isEnabled) {
428 } else {
430 }
431 } else if (strEqualCaseInsensitive(param, CMD_EXTERNAL_STIMULATION)) {
432 if (isEnabled) {
434 } else {
436 }
437#endif // EFI_EMULATE_POSITION_SENSORS
438 } else {
439 efiPrintf("unexpected [%s]", param);
440 return; // well, MISRA would not like this 'return' here :(
441 }
442 efiPrintf("[%s] %s", param, isEnabled ? "enabled" : "disabled");
443}
bool isFunctionalTestMode
Definition engine.h:340
bool isPwmEnabled
Definition engine.h:117
TriggerCentral * getTriggerCentral()
Definition engine.cpp:591
static EngineAccessor engine
Definition engine.h:413
void incrementGlobalConfigurationVersion(const char *msg)
static constexpr engine_configuration_s * engineConfiguration
bool verboseRxCan
Definition settings.cpp:364
void disableTriggerStimulator()
void enableExternalTriggerStimulator()
void enableTriggerStimulator(bool incGlobalConfiguration)

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 453 of file settings.cpp.

453 {
454 setSpiMode(index, true);
455}

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 468 of file settings.cpp.

468 {
469
470 {
471 float value = getConfigValueByName(paramStr);
472 if (value != EFI_ERROR_CODE) {
473 efiPrintf("%s value: %.2f", paramStr, value);
474 return;
475 }
476 }
477
478 if (strEqualCaseInsensitive(paramStr, "tps_min")) {
479 efiPrintf("tps_min=%d", engineConfiguration->tpsMin);
480 } else if (strEqualCaseInsensitive(paramStr, "tps_max")) {
481 efiPrintf("tps_max=%d", engineConfiguration->tpsMax);
482 } else if (strEqualCaseInsensitive(paramStr, "global_trigger_offset_angle")) {
483 efiPrintf("global_trigger_offset=%.2f", engineConfiguration->globalTriggerAngleOffset);
484#if EFI_SHAFT_POSITION_INPUT
485 } else if (strEqualCaseInsensitive(paramStr, "trigger_hw_input")) {
486 efiPrintf("trigger_hw_input=%s", boolToString(getTriggerCentral()->hwTriggerInputEnabled));
487#endif // EFI_SHAFT_POSITION_INPUT
488 } else if (strEqualCaseInsensitive(paramStr, CMD_DATE)) {
490 } else {
491 efiPrintf("Invalid Parameter: %s", paramStr);
492 }
493}
const char * boolToString(bool value)
Definition efilib.cpp:19
void printDateTime()
Definition settings.cpp:695
float getConfigValueByName(const char *name)

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 637 of file settings.cpp.

637 {
638#if EFI_SIMULATOR
639 printf("initSettings\n");
640#endif // EFI_SIMULATOR
641
642 // todo: start saving values into flash right away?
643
644#if EFI_ENGINE_CONTROL
645 // used by HW CI
646 addConsoleAction(CMD_INDIVIDUAL_INJECTION, setIndividualCoilsIgnition);
648 addConsoleActionF("set_whole_timing_map", setWholeTimingMapCmd);
649#endif // EFI_ENGINE_CONTROL
650
652
653 // todo: refactor this - looks like all boolean flags should be controlled with less code duplication
654 addConsoleActionI("enable_spi", enableSpi);
655 addConsoleActionI("disable_spi", disableSpi);
656
657 addConsoleActionS(CMD_ENABLE, enable);
658 addConsoleActionS(CMD_DISABLE, disable);
659
661 addConsoleActionS(CMD_GET, getValue);
662
663#if EFI_PROD_CODE
664 addConsoleActionSS(CMD_IGNITION_PIN, setIgnitionPin);
665 addConsoleActionSS(CMD_TRIGGER_PIN, setTriggerInputPin);
666 addConsoleActionSS(CMD_TRIGGER_SIMULATOR_PIN, setTriggerSimulatorPin);
667
668 addConsoleActionI(CMD_ECU_UNLOCK, unlockEcu);
669
670 addConsoleActionS(CMD_ALTERNATOR_PIN, setAlternatorPin);
671 addConsoleActionS(CMD_IDLE_PIN, setIdlePin);
672
673 addConsoleActionS("bench_clearpin", benchClearPin);
674 addConsoleActionS("bench_setpin", benchSetPin);
675 addConsoleActionS("readpin", readPin);
676 addConsoleAction("hw_qc_mode", [](){
677 setHwQcMode();
678 });
679 addConsoleActionS("bench_set_output_mode", [](const char *pinName){
681 if (pin == Gpio::Invalid) {
682 return;
683 }
684 efiSetPadModeWithoutOwnershipAcquisition("manual-mode", pin, PAL_MODE_OUTPUT_PUSHPULL);
685 });
686
687#if HAL_USE_ADC
689 addConsoleActionSS("set_analog_input_pin", setAnalogInputPin);
690#endif // HAL_USE_ADC
691 addConsoleActionSS(CMD_LOGIC_PIN, setLogicInputPin);
692#endif // EFI_PROD_CODE
693}
void printFullAdcReport(void)
void setHwQcMode()
void addConsoleActionF(const char *token, VoidFloat callback)
void addConsoleActionS(const char *token, VoidCharPtr callback)
void addConsoleAction(const char *token, Void callback)
Register console action without parameters.
void addConsoleActionSS(const char *token, VoidCharPtrCharPtr callback)
void addConsoleActionI(const char *token, VoidInt callback)
Register a console command with one Integer parameter.
void(* Void)(void)
void unlockEcu(int password)
Definition engine2.cpp:320
static void enableSpi(int index)
Definition settings.cpp:453
static void enable(const char *param)
Definition settings.cpp:445
static void setIgnitionPin(const char *indexStr, const char *pinName)
Definition settings.cpp:190
static void benchSetPin(const char *pinName)
Definition settings.cpp:231
static void getValue(const char *paramStr)
Definition settings.cpp:468
static void disableSpi(int index)
Definition settings.cpp:457
static void setIndividualCoilsIgnition()
Definition settings.cpp:146
static void setValue(const char *paramStr, const char *valueStr)
Definition settings.cpp:561
static void setAlternatorPin(const char *pinName)
Definition settings.cpp:255
static void benchClearPin(const char *pinName)
Definition settings.cpp:227
void printConfiguration()
Prints current engine configuration to human-readable console.
Definition settings.cpp:57
static void setWholeTimingMapCmd(float value)
Definition settings.cpp:166
static void setTriggerSimulatorPin(const char *indexStr, const char *pinName)
Definition settings.cpp:278
static void setTriggerInputPin(const char *indexStr, const char *pinName)
Definition settings.cpp:265
static void setAnalogInputPin(const char *sensorStr, const char *pinName)
Definition settings.cpp:294
static void setIdlePin(const char *pinName)
Definition settings.cpp:251
static void setLogicInputPin(const char *indexStr, const char *pinName)
Definition settings.cpp:330
static void scheduleStopEngine()
Definition settings.cpp:464
static void disable(const char *param)
Definition settings.cpp:449
printf("\n")

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.

176 {
177 brain_pin_e pin = parseBrainPin(pinName);
178 if (pin == Gpio::Invalid) {
179 efiPrintf("invalid pin name [%s]", pinName);
180 }
181 return pin;
182}
brain_pin_e parseBrainPin(const char *str)

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.

57 {
58
59 efiPrintf("Template %s/%d trigger %s/%s/%d", getEngine_type_e(engineConfiguration->engineType),
63
64 efiPrintf("configurationVersion=%d", engine->getGlobalConfigurationVersion());
65
66#if EFI_PROD_CODE
68#endif // EFI_PROD_CODE
69}
const char * getEngine_type_e(engine_type_e value)
const char * getTrigger_type_e(trigger_type_e value)
int getGlobalConfigurationVersion() const
Definition engine.cpp:289
constexpr char const * Enum2String(T const e)
void printSpiState()
Definition settings.cpp:46

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 695 of file settings.cpp.

695 {
696#if EFI_RTC
698#else // EFI_RTC
699 efiPrintf("Cannot print time: RTC not supported");
700#endif // EFI_RTC
701}
void printRtcDateTime()

Referenced by getValue(), and initRtc().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ printSpiState()

void printSpiState ( )

◆ readPin()

void readPin ( const char pinName)

Definition at line 205 of file settings.cpp.

205 {
207 if (pin == Gpio::Invalid) {
208 return;
209 }
210 int physicalValue = palReadPad(getHwPort("read", pin), getHwPin("read", pin));
211 efiPrintf("pin %s value %d", hwPortname(pin), physicalValue);
212}

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 464 of file settings.cpp.

464 {
466}
void doScheduleStopEngine(StopRequestedReason reason)

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.

87 {
88 setAlgorithm((engine_load_mode_e) value);
90}
void setAlgorithm(engine_load_mode_e algo)
Here is the call graph for this function:

◆ setAlternatorPin()

static void setAlternatorPin ( const char pinName)
static

Definition at line 255 of file settings.cpp.

255 {
257}
static void setIndividualPin(const char *pinName, brain_pin_e *targetPin, const char *name)
Definition settings.cpp:235

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.

294 {
296 if (pin == Gpio::Invalid) {
297 return;
298 }
300 if (channel == EFI_ADC_ERROR) {
301 efiPrintf("Error with [%s]", pinName);
302 return;
303 }
304 if (strEqual("map", sensorStr)) {
306 efiPrintf("setting MAP to %s/%d", pinName, channel);
307 } else if (strEqual("pps", sensorStr)) {
309 efiPrintf("setting PPS to %s/%d", pinName, channel);
310 } else if (strEqual("afr", sensorStr)) {
312 efiPrintf("setting AFR to %s/%d", pinName, channel);
313 } else if (strEqual("clt", sensorStr)) {
315 efiPrintf("setting CLT to %s/%d", pinName, channel);
316 } else if (strEqual("iat", sensorStr)) {
318 efiPrintf("setting IAT to %s/%d", pinName, channel);
319 } else if (strEqual("tps", sensorStr)) {
321 efiPrintf("setting TPS1 to %s/%d", pinName, channel);
322 } else if (strEqual("tps2", sensorStr)) {
324 efiPrintf("setting TPS2 to %s/%d", pinName, channel);
325 }
327}
uint16_t channel
Definition adc_inputs.h:104
adc_channel_e getAdcChannel(brain_pin_e pin)

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.

109 {
110 setTable(config->crankingCycleBaseFuel, fuelMilligram);
111 efiPrintf("cranking_fuel %.2f", fuelMilligram);
112}
static constexpr persistent_config_s * config
float crankingCycleBaseFuel[CRANKING_CYCLE_CLT_SIZE][CRANKING_CURVE_SIZE]
constexpr void setTable(TElement(&dest)[N][M], const VElement value)
Here is the call graph for this function:

◆ setCrankingIACExtra()

static void setCrankingIACExtra ( float  percent)
static

Definition at line 102 of file settings.cpp.

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

◆ setCrankingInjectionMode()

static void setCrankingInjectionMode ( int  value)
static

Definition at line 126 of file settings.cpp.

Here is the call graph for this function:

◆ setCrankingRpm()

static void setCrankingRpm ( int  value)
static

Definition at line 79 of file settings.cpp.

Here is the call graph for this function:

◆ setCrankingTimingAngle()

static void setCrankingTimingAngle ( float  value)
static

Definition at line 120 of file settings.cpp.

Here is the call graph for this function:

◆ setDateTime()

void setDateTime ( const char *const  isoDateTime)

Definition at line 703 of file settings.cpp.

703 {
704#if EFI_RTC
706 if (strlen(isoDateTime) >= 19 && isoDateTime[10] == 'T') {
707 efidatetime_t dateTime;
708 dateTime.year = atoi(isoDateTime);
709 dateTime.month = atoi(isoDateTime + 5);
710 dateTime.day = atoi(isoDateTime + 8);
711 dateTime.hour = atoi(isoDateTime + 11);
712 dateTime.minute = atoi(isoDateTime + 14);
713 dateTime.second = atoi(isoDateTime + 17);
714 if (dateTime.year != ATOI_ERROR_CODE &&
715 dateTime.month >= 1 && dateTime.month <= 12 &&
716 dateTime.day >= 1 && dateTime.day <= 31 &&
717 dateTime.hour <= 23 &&
718 dateTime.minute <= 59 &&
719 dateTime.second <= 59) {
720 // doesn't concern about leap years or seconds; ChibiOS doesn't support (added) leap seconds anyway
721 setRtcDateTime(&dateTime);
722 efiPrintf("Time is changed to");
724 return;
725 }
726 }
727 efiPrintf("date_set Date parameter %s is wrong", isoDateTime);
728#else // EFI_RTC
729 efiPrintf("Cannot set time: RTC not supported");
730#endif // EFI_RTC
731}
void setRtcDateTime(efidatetime_t const *const dateTime)
uint32_t year

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.

◆ setEngineType()

void setEngineType ( int  value,
bool  isWriteToFlash 
)

Definition at line 739 of file settings.cpp.

739 {
740 {
741#if EFI_PROD_CODE
742 chibios_rt::CriticalSectionLocker csl;
743#endif // EFI_PROD_CODE
744
748
749#if EFI_CONFIGURATION_STORAGE
750 if (isWriteToFlash) {
752 }
753#endif /* EFI_CONFIGURATION_STORAGE */
754 }
756#if EFI_ENGINE_CONTROL && ! EFI_UNIT_TEST
758#endif // ! EFI_UNIT_TEST
759}
void resetEngineSnifferIfInTestMode()
Definition engine.cpp:53
void resetConfigurationExt(configuration_callback_t boardCallback, engine_type_e engineType)
engine_type_e
void writeToFlashNow()

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 735 of file settings.cpp.

735 {
736 setEngineType(value, true);
737}
void setEngineType(int value, bool isWriteToFlash)
Definition settings.cpp:739
Here is the call graph for this function:

◆ setFiringOrder()

static void setFiringOrder ( int  value)
static

Definition at line 92 of file settings.cpp.

Here is the call graph for this function:

◆ setGlobalTriggerAngleOffset()

static void setGlobalTriggerAngleOffset ( float  value)
static

Definition at line 114 of file settings.cpp.

Here is the call graph for this function:

◆ setIdlePin()

static void setIdlePin ( const char pinName)
static

Definition at line 251 of file settings.cpp.

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.

Here is the call graph for this function:

◆ setIgnitionMode()

static void setIgnitionMode ( int  value)
static

Definition at line 138 of file settings.cpp.

138 {
139#if EFI_ENGINE_CONTROL
143#endif // EFI_ENGINE_CONTROL
144}
void prepareOutputSignals()
ignition_mode_e

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.

190 {
191 int index = atoi(indexStr) - 1; // convert from human index into software index
192 if (index < 0 || index >= MAX_CYLINDER_COUNT)
193 return;
195 if (pin == Gpio::Invalid) {
196 return;
197 }
198 efiPrintf("setting ignition pin[%d] to %s please save&restart", index, hwPortname(pin));
201}

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.

146 {
147 setIgnitionMode((int)IM_INDIVIDUAL_COILS);
148}
static void setIgnitionMode(int value)
Definition settings.cpp:138

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.

235 {
237 if (pin == Gpio::Invalid) {
238 return;
239 }
240 efiPrintf("setting %s pin to %s please save&restart", name, hwPortname(pin));
241 *targetPin = pin;
243}

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.

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.

330 {
331 int index = atoi(indexStr);
332 if (index < 0 || index > 2) {
333 return;
334 }
336 if (pin == Gpio::Invalid) {
337 return;
338 }
339 efiPrintf("setting logic input pin[%d] to %s please save&restart", index, hwPortname(pin));
342}
brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT]

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.

Here is the call graph for this function:

◆ setScriptCurve1Value()

static void setScriptCurve1Value ( float  value)
static

Definition at line 495 of file settings.cpp.

495 {
496 setLinearCurve(config->scriptCurve1, value, value, 1);
497}
void setLinearCurve(TValue(&array)[TSize], float from, float to, float precision=0.01f)
Here is the call graph for this function:

◆ setScriptCurve2Value()

static void setScriptCurve2Value ( float  value)
static

Definition at line 499 of file settings.cpp.

499 {
500 setLinearCurve(config->scriptCurve2, value, value, 1);
501}
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.

346 {
347 switch (index) {
348 case 1:
350 break;
351 case 2:
353 break;
354 case 3:
356 break;
357 default:
358 efiPrintf("invalid spi index %d", index);
359 return;
360 }
362}

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.

265 {
266 int index = atoi(indexStr);
267 if (index < 0 || index > 2)
268 return;
270 if (pin == Gpio::Invalid) {
271 return;
272 }
273 efiPrintf("setting trigger pin[%d] to %s please save&restart", index, hwPortname(pin));
276}
brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT]

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.

278 {
279 int index = atoi(indexStr);
280 if (index < 0 || index >= TRIGGER_SIMULATOR_PIN_COUNT)
281 return;
283 if (pin == Gpio::Invalid) {
284 return;
285 }
286 efiPrintf("setting trigger simulator pin[%d] to %s please save&restart", index, hwPortname(pin));
289}

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.

150 {
154 efiPrintf("Do you need to also invoke set operation_mode X?");
156}
trigger_type_e
Here is the call graph for this function:

◆ setValue()

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

Definition at line 561 of file settings.cpp.

561 {
562 float valueF = atoff(valueStr);
563 int valueI = atoi(valueStr);
564
565 const command_f_s *currentF = &commandsF[0];
566 while (currentF < commandsF + sizeof(commandsF)/sizeof(commandsF[0])) {
567 if (strEqualCaseInsensitive(paramStr, currentF->token)) {
568 currentF->callback(valueF);
569 return;
570 }
571 currentF++;
572 }
573
574 const command_i_s *currentI = &commandsI[0];
575 while (currentI < commandsI + sizeof(commandsI)/sizeof(commandsI[0])) {
576 if (strEqualCaseInsensitive(paramStr, currentI->token)) {
577 currentI->callback(valueI);
578 return;
579 }
580 currentI++;
581 }
582
583
584 if (strEqualCaseInsensitive(paramStr, "warning_period")) {
586 } else if (strEqualCaseInsensitive(paramStr, "dwell")) {
587 setConstantDwell(valueF);
588 } else if (strEqualCaseInsensitive(paramStr, CMD_ENGINESNIFFERRPMTHRESHOLD)) {
590#if EFI_EMULATE_POSITION_SENSORS
591 } else if (strEqualCaseInsensitive(paramStr, CMD_RPM)) {
592 setTriggerEmulatorRPM(valueI);
593#endif // EFI_EMULATE_POSITION_SENSORS
594 } else if (strEqualCaseInsensitive(paramStr, "mc33_hvolt")) {
596 } else if (strEqualCaseInsensitive(paramStr, "mc33_i_peak")) {
598 } else if (strEqualCaseInsensitive(paramStr, "mc33_i_hold")) {
600 } else if (strEqualCaseInsensitive(paramStr, "mc33_t_max_boost")) {
602 } else if (strEqualCaseInsensitive(paramStr, "mc33_t_peak_off")) {
604 } else if (strEqualCaseInsensitive(paramStr, "vvt_offset")) {
605 engineConfiguration->vvtOffsets[0] = valueF;
606 } else if (strEqualCaseInsensitive(paramStr, "vvt_mode")) {
608 } else if (strEqualCaseInsensitive(paramStr, "wwaeTau")) {
610 } else if (strEqualCaseInsensitive(paramStr, "wwaeBeta")) {
612 } else if (strEqualCaseInsensitive(paramStr, "benchTestOffTime")) {
614 } else if (strEqualCaseInsensitive(paramStr, "benchTestCount")) {
616 } else if (strEqualCaseInsensitive(paramStr, "cranking_dwell")) {
618#if EFI_PROD_CODE
619 } else if (strEqualCaseInsensitive(paramStr, CMD_VSS_PIN)) {
620 setVssPin(valueStr);
621#endif // EFI_PROD_CODE
622 } else if (strEqualCaseInsensitive(paramStr, "targetvbatt")) {
624 } else if (strEqualCaseInsensitive(paramStr, CMD_DATE)) {
625 // rusEfi console invokes this method with timestamp in local timezone
626 setDateTime(valueStr);
627 }
628
629 bool isGoodName = setConfigValueByName(paramStr, valueF);
630 if (isGoodName) {
631 efiPrintf("Settings: applying [%s][%f]", paramStr, valueF);
632 }
633
635}
void setConstantDwell(floatms_t dwellMs)
Sets the same dwell time across the whole getRpm() range set dwell X.
vvt_mode_e
const command_i_s commandsI[]
Definition settings.cpp:525
const command_f_s commandsF[]
Definition settings.cpp:513
static void setVssPin(const char *pinName)
Definition settings.cpp:246
void setDateTime(const char *const isoDateTime)
Definition settings.cpp:703
scaled_channel< int16_t, 10, 1 > alternatorVoltageTargetTable[ALTERNATOR_VOLTAGE_TARGET_SIZE][ALTERNATOR_VOLTAGE_RPM_SIZE]
void setTriggerEmulatorRPM(int rpm)
bool setConfigValueByName(const char *name, float value)

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.

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.

162 {
164}
scaled_channel< int16_t, 10, 1 > ignitionTable[IGN_LOAD_COUNT][IGN_RPM_COUNT]

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.

166 {
167 efiPrintf("Setting whole timing advance map to %.2f", value);
168 setWholeTimingMap(value);
170}
static void setWholeTimingMap(float value)
Definition settings.cpp:162

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},
}
void setFlatInjectorLag(float value)
static void setCrankingIACExtra(float percent)
Definition settings.cpp:102
static void setScriptCurve1Value(float value)
Definition settings.cpp:495
static void setCrankingFuel(float fuelMilligram)
Definition settings.cpp:109
static void setCrankingTimingAngle(float value)
Definition settings.cpp:120
static void setScriptCurve2Value(float value)
Definition settings.cpp:499
static void setGlobalTriggerAngleOffset(float value)
Definition settings.cpp:114

Definition at line 513 of file settings.cpp.

513 {
514#if EFI_ENGINE_CONTROL
515 {"global_trigger_offset_angle", setGlobalTriggerAngleOffset},
516 {"cranking_fuel", setCrankingFuel},
517 {"cranking_iac", setCrankingIACExtra},
518 {"cranking_timing_angle", setCrankingTimingAngle},
519 {"flat_injector_lag", setFlatInjectorLag},
520#endif // EFI_ENGINE_CONTROL
521 {"script_curve_1_value", setScriptCurve1Value},
522 {"script_curve_2_value", setScriptCurve2Value},
523};

Referenced by setValue().

◆ commandsI

const command_i_s commandsI[]

Definition at line 525 of file settings.cpp.

525 {
526#if EFI_ENGINE_CONTROL
527 {"ignition_mode", setIgnitionMode},
528 {"driveWheelRevPerKm", [](int value) {
530 }},
531 {"cranking_rpm", setCrankingRpm},
532 {"cranking_injection_mode", setCrankingInjectionMode},
533 {"injection_mode", setInjectionMode},
534 {CMD_ENGINE_TYPE, setEngineTypeAndSave},
535 {"rpm_hard_limit", setRpmHardLimit},
536 {"firing_order", setFiringOrder},
537 {"algorithm", setAlgorithmInt},
538 {"debug_mode", setDebugMode},
539 {"trigger_type", setTriggerType},
540 // used by HW CI
541 {"idle_solenoid_freq", setIdleSolenoidFrequency},
542#endif // EFI_ENGINE_CONTROL
543#if EFI_PROD_CODE
544#if EFI_BOR_LEVEL
545 {"bor", setBor},
546#endif // EFI_BOR_LEVEL
547#if EFI_CAN_SUPPORT
548 {"can_mode", setCanType},
549 {"can_vss", setCanVss},
550#endif // EFI_CAN_SUPPORT
551#if EFI_IDLE_CONTROL
552 {"idle_position", setManualIdleValvePosition},
553 {"idle_rpm", setTargetIdleRpm},
554#endif // EFI_IDLE_CONTROL
555#endif // EFI_PROD_CODE
556
557 // {"", },
558 // {"", },
559};
void setCanType(int type)
Definition can_hw.cpp:118
void setCanVss(int type)
Definition can_vss.cpp:221
void setBor(int borValue)
Definition hardware.cpp:409
void setTargetIdleRpm(int value)
void setManualIdleValvePosition(int positionPercent)
static void setFiringOrder(int value)
Definition settings.cpp:92
static void setIdleSolenoidFrequency(int value)
Definition settings.cpp:72
static void setTriggerType(int value)
Definition settings.cpp:150
static void setInjectionMode(int value)
Definition settings.cpp:132
static void setCrankingRpm(int value)
Definition settings.cpp:79
static void setDebugMode(int value)
Definition settings.cpp:158
void setEngineTypeAndSave(int value)
Definition settings.cpp:735
static void setCrankingInjectionMode(int value)
Definition settings.cpp:126
static void setAlgorithmInt(int value)
Definition settings.cpp:87
static void setRpmHardLimit(int value)
Definition settings.cpp:97

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.