void initElectronicThrottle(void) {
addConsoleAction("ethinfo", showEthInfo);
addConsoleAction("etbreset", etbReset);
if (!hasPedalPositionSensor()) {
return;
}
autoTune.SetOutputStep(0.1);
startETBPins();
// manual duty cycle control without PID. Percent value from 0 to 100
addConsoleActionNANF("set_etb", setThrottleDutyCycle);
tuneWorkingPidSettings.pFactor = 1;
tuneWorkingPidSettings.iFactor = 0;
tuneWorkingPidSettings.dFactor = 0;
// tuneWorkingPidSettings.offset = 10; // todo: not hard-coded value
//todo tuneWorkingPidSettings.periodMs = 10;
tuneWorkingPidSettings.minValue = 0;
tuneWorkingPidSettings.maxValue = 100;
tuneWorkingPidSettings.periodMs = 100;
// this is useful once you do "enable etb_auto"
addConsoleActionF("set_etbat_output", setTempOutput);
addConsoleActionF("set_etbat_step", setAutoStep);
addConsoleActionI("set_etbat_period", setAutoPeriod);
addConsoleActionI("set_etbat_offset", setAutoOffset);
pid.reset();
etbController.Start();
}
static void initConfigActions(void) {
addConsoleActionSS("set_float", (VoidCharPtrCharPtr) setFloat);
addConsoleActionII("set_int", (VoidIntInt) setInt);
addConsoleActionII("set_short", (VoidIntInt) setShort);
addConsoleActionSSS("set_bit", setBit);
addConsoleActionI("get_float", getFloat);
addConsoleActionI("get_int", getInt);
addConsoleActionI("get_short", getShort);
addConsoleActionII("get_bit", getBit);
}
void initTriggerEmulatorLogic(Logging *sharedLogger) {
logger = sharedLogger;
TriggerShape *s = &engine->triggerCentral.triggerShape;
setTriggerEmulatorRPM(engineConfiguration->bc.triggerSimulatorFrequency PASS_ENGINE_PARAMETER_SUFFIX);
pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.waves[0].pinStates, s->wave.waves[1].pinStates,
s->wave.waves[2].pinStates };
triggerSignal.weComplexInit("position sensor", s->getSize(), s->wave.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM,
pinStates, updateTriggerShapeIfNeeded, emulatorApplyPinState);
addConsoleActionI("rpm", setTriggerEmulatorRPM);
addConsoleActionI("stop_stimulator_at_index", setEmulatorAtIndex);
addConsoleAction("resume_stimulator", resumeStimulator);
}
void initAccelEnrichment(Logging *sharedLogger) {
logger = sharedLogger;
addConsoleActionI("set_tps_accel_len", setTpsAccelLen);
addConsoleActionF("set_tps_accel_threshold", setTpsAccelThr);
addConsoleActionF("set_tps_ccel_multiplier", setTpsAccelMult);
addConsoleActionI("set_map_accel_len", setMapAccelLen);
addConsoleActionF("set_map_accel_threshold", setMapAccelThr);
addConsoleActionF("set_map_ccel_multiplier", setMapAccelMult);
addConsoleActionF("set_decel_threshold", setDecelThr);
addConsoleActionF("set_decel_multiplier", setDecelMult);
addConsoleAction("accelinfo", accelInfo);
setMapAccelLen(engineConfiguration->mapAccelLength);
setTpsAccelLen(engineConfiguration->tpsAccelLength);
}
void startIdleThread(Logging*sharedLogger, Engine *engine) {
logger = sharedLogger;
// todo: re-initialize idle pins on the fly
initIdleHardware();
idlePositionController.init();
scheduleMsg(logger, "initial idle %d", idlePositionController.value);
chThdCreateStatic(ivThreadStack, sizeof(ivThreadStack), NORMALPRIO, (tfunc_t) ivThread, NULL);
// this is idle switch INPUT - sometimes there is a switch on the throttle pedal
// this switch is not used yet
if (boardConfiguration->clutchDownPin != GPIO_UNASSIGNED)
mySetPadMode2("clutch down switch", boardConfiguration->clutchDownPin,
getInputMode(boardConfiguration->clutchDownPinMode));
if (boardConfiguration->clutchUpPin != GPIO_UNASSIGNED)
mySetPadMode2("clutch up switch", boardConfiguration->clutchUpPin,
getInputMode(boardConfiguration->clutchUpPinMode));
addConsoleAction("idleinfo", showIdleInfo);
addConsoleActionI("set_idle_enabled", (VoidInt) setIdleControlEnabled);
addConsoleActionII("blipidle", blipIdle);
// split this whole file into manual controller and auto controller? move these commands into the file
// which would be dedicated to just auto-controller?
addConsoleAction("idlebench", startIdleBench);
apply();
}
void initPotentiometers(Logging *sharedLogger, board_configuration_s *boardConfiguration) {
logger = sharedLogger;
#if EFI_POTENTIOMETER
if (boardConfiguration->digitalPotentiometerSpiDevice == SPI_NONE) {
scheduleMsg(logger, "digiPot spi disabled");
return;
}
turnOnSpi(boardConfiguration->digitalPotentiometerSpiDevice);
for (int i = 0; i < DIGIPOT_COUNT; i++) {
brain_pin_e csPin = boardConfiguration->digitalPotentiometerChipSelect[i];
if (csPin == GPIO_UNASSIGNED) {
continue;
}
initPotentiometer(&potConfig[i], getSpiDevice(boardConfiguration->digitalPotentiometerSpiDevice),
csPin);
}
addConsoleActionII("pot", setPotResistanceCommand);
addConsoleActionI("potd1", setPotValue1);
setPotResistance(&potConfig[0], 0, 3000);
setPotResistance(&potConfig[0], 1, 7000);
#else
print("digiPot logic disabled\r\n");
#endif
}
void initBoardTest(void) {
is_board_test_mode = true;
addConsoleAction("n", nextStep);
addConsoleActionI("set", setIndex);
chThdCreateStatic(btThreadStack, sizeof(btThreadStack), NORMALPRIO, (tfunc_t) ivThread, NULL);
// this code is ugly as hell, I had no time to think. Todo: refactor
processAdcPin(&fastAdc, 0, "fast");
while (currentIndex < slowAdc.size()) {
processAdcPin(&slowAdc, currentIndex, "slow");
currentIndex++;
}
currentIndex = 0;
int pinsCount = sizeof(BLINK_PINS) / sizeof(brain_pin_e);
while (currentIndex < pinsCount) {
currentPin = BLINK_PINS[currentIndex];
printBoardTestState();
mySetPadMode2("test", currentPin, PAL_STM32_MODE_OUTPUT);
currentIndex++;
waitForKey();
}
// no buffered logger still, just plain old stdout
while (1) {
print("Board test done, thank you! Time to remove that jumper and reboot\r\n");
print("Bye!\r\n");
chThdSleepSeconds(1);
}
}
void initConsoleLogic() {
#if EFI_PROD_CODE || EFI_SIMULATOR
initLogging(&logging, "rfi console");
#endif /* EFI_PROD_CODE */
resetConsoleActions();
addConsoleAction("help", helpCommand);
addConsoleActionI("echo", echo);
}
void initHip9011(Logging *sharedLogger) {
driver = getSpiDevice(spiDevice);
logger = sharedLogger;
addConsoleAction("hipinfo", showHipInfo);
if (!boardConfiguration->isHip9011Enabled)
return;
currentAngleWindowWidth =
engineConfiguration->knockDetectionWindowEnd - engineConfiguration->knockDetectionWindowStart;
prepareHip9011RpmLookup(currentAngleWindowWidth);
// todo: configurable
// driver = getSpiDevice(boardConfiguration->hip9011SpiDevice);
spicfg.ssport = getHwPort(boardConfiguration->hip9011CsPin);
spicfg.sspad = getHwPin(boardConfiguration->hip9011CsPin);
outputPinRegisterExt2("hip int/hold", &intHold, boardConfiguration->hip9011IntHoldPin,
&boardConfiguration->hip9011IntHoldPinMode);
outputPinRegisterExt2("hip CS", &hipCs, boardConfiguration->hip9011CsPin,
&boardConfiguration->hip9011CsPinMode);
scheduleMsg(logger, "Starting HIP9011/TPIC8101 driver");
spiStart(driver, &spicfg);
currentBandIndex = getBandIndex();
/**
* this engine cycle callback would be scheduling actual integration start and end callbacks
*/
addTriggerEventListener(&intHoldCallback, "DD int/hold", engine);
// MISO PB14
// palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(EFI_SPI2_AF) | PAL_STM32_PUDR_PULLUP);
// MOSI PB15
// palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(EFI_SPI2_AF) | PAL_STM32_OTYPE_OPENDRAIN);
addConsoleActionF("set_gain", setGain);
addConsoleActionF("set_band", setBand);
addConsoleActionI("set_hip_prescalerandsdo", setPrescalerAndSDO);
addConsoleActionF("set_knock_threshold", setKnockThresh);
addConsoleActionI("set_max_knock_sub_deg", setMaxKnockSubDeg);
chThdCreateStatic(hipTreadStack, sizeof(hipTreadStack), NORMALPRIO, (tfunc_t) hipThread, NULL);
}
void initAccelEnrichment(Logging *sharedLogger) {
logger = sharedLogger;
addConsoleActionI("set_tps_accel_len", setTpsAccelLen);
addConsoleActionF("set_tps_accel_threshold", setTpsAccelThr);
addConsoleActionF("set_tps_accel_multiplier", setTpsAccelMult);
addConsoleActionF("set_tps_decel_threshold", setTpsDecelThr);
addConsoleActionF("set_tps_decel_multiplier", setTpsDecelMult);
addConsoleActionI("set_engine_load_accel_len", setEngineLoadAccelLen);
addConsoleActionF("set_engine_load_accel_threshold", setEngineLoadAccelThr);
addConsoleActionF("set_engine_load_accel_multiplier", setEngineLoadAccelMult);
addConsoleActionF("set_engine_decel_threshold", setDecelThr);
addConsoleActionF("set_engine_decel_multiplier", setDecelMult);
addConsoleAction("accelinfo", accelInfo);
updateAccelParameters();
}
void initHip9011(Logging *sharedLogger) {
logger = sharedLogger;
addConsoleAction("hipinfo", showHipInfo);
if (!CONFIGB(isHip9011Enabled))
return;
instance.setAngleWindowWidth();
#if EFI_PROD_CODE
driver = getSpiDevice(engineConfiguration->hip9011SpiDevice);
if (driver == NULL) {
// error already reported
return;
}
hipSpiCfg.ssport = getHwPort("hip", CONFIGB(hip9011CsPin));
hipSpiCfg.sspad = getHwPin("hip", CONFIGB(hip9011CsPin));
#endif /* EFI_PROD_CODE */
startHip9001_pins();
scheduleMsg(logger, "Starting HIP9011/TPIC8101 driver");
spiStart(driver, &hipSpiCfg);
instance.currentBandIndex = getBandIndex();
/**
* this engine cycle callback would be scheduling actual integration start and end callbacks
*/
addTriggerEventListener(&intHoldCallback, "DD int/hold", engine);
// MISO PB14
// palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(EFI_SPI2_AF) | PAL_STM32_PUDR_PULLUP);
// MOSI PB15
// palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(EFI_SPI2_AF) | PAL_STM32_OTYPE_OPENDRAIN);
addConsoleActionF("set_gain", setHipGain);
addConsoleActionF("set_band", setHipBand);
addConsoleActionI("set_hip_prescalerandsdo", setPrescalerAndSDO);
addConsoleActionF("set_knock_threshold", setKnockThresh);
addConsoleActionI("set_max_knock_sub_deg", setMaxKnockSubDeg);
chThdCreateStatic(hipTreadStack, sizeof(hipTreadStack), NORMALPRIO, (tfunc_t)(void*) hipThread, NULL);
}
static void initECUstimulator(void) {
mySetPadMode("TEN", DIAG_PORT, DIAG_PIN,
PAL_MODE_OUTPUT_PUSHPULL);
addConsoleActionI("diag", setDiag);
addConsoleAction("emu", startEmulator);
addConsoleActionII("ad", printAdvance);
setDiag(1);
chThdCreateStatic(eeThreadStack, sizeof(eeThreadStack), NORMALPRIO, (tfunc_t) eeThread, NULL);
}
void initWaveChart(WaveChart *chart) {
/**
* constructor does not work because we need specific initialization order
*/
chart->init();
printStatus();
#if DEBUG_WAVE
initLoggingExt(&debugLogging, "wave chart debug", &debugLogging.DEFAULT_BUFFER, sizeof(debugLogging.DEFAULT_BUFFER));
#endif
#if EFI_HISTOGRAMS
initHistogram(&engineSnifferHisto, "wave chart");
#endif /* EFI_HISTOGRAMS */
addConsoleActionI("chartsize", setChartSize);
addConsoleActionI("chart", setChartActive);
#if ! EFI_UNIT_TEST
addConsoleAction("reset_engine_chart", resetNow);
#endif
}
void initTimePerfActions(Logging *sharedLogger) {
logger = sharedLogger;
#if EFI_RTC || defined(__DOXYGEN__)
rtcStartTime = rtcGetTimeUnixSec(&RTCD1);
#endif
// initOutputPin("test pad", &testOutput, TEST_PORT, TEST_PIN);
addConsoleActionI("perftest", runTests);
addConsoleAction("timeinfo", timeInfo);
addConsoleAction("chtest", runChibioTest);
}
void initWaveChart(WaveChart *chart) {
initLogging(&logger, "wave info");
if (!isChartActive) {
printMsg(&logger, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! chart disabled");
}
printStatus();
initLoggingExt(&chart->logging, "wave chart", WAVE_LOGGING_BUFFER, sizeof(WAVE_LOGGING_BUFFER));
chart->isInitialized = TRUE;
#if DEBUG_WAVE
initLoggingExt(&debugLogging, "wave chart debug", &debugLogging.DEFAULT_BUFFER, sizeof(debugLogging.DEFAULT_BUFFER));
#endif
#if EFI_HISTOGRAMS
initHistogram(&waveChartHisto, "wave chart");
#endif /* EFI_HISTOGRAMS */
resetWaveChart(chart);
addConsoleActionI("chartsize", setChartSize);
addConsoleActionI("chart", setChartActive);
}
void startIdleThread() {
initLogging(&logger, "Idle Valve Control");
startSimplePwm(&idleValve, "Idle Valve",
boardConfiguration->idleValvePin,
0.5,
IDLE_AIR_CONTROL_VALVE_PWM_FREQUENCY,
IDLE_VALVE
);
idleInit(&idle);
scheduleMsg(&logger, "initial idle %d", idle.value);
chThdCreateStatic(ivThreadStack, sizeof(ivThreadStack), NORMALPRIO, (tfunc_t)ivThread, NULL);
// this is idle switch INPUT - sometimes there is a switch on the throttle pedal
// this switch is not used yet
mySetPadMode("idle switch", getHwPort(boardConfiguration->idleSwitchPin), getHwPin(boardConfiguration->idleSwitchPin), PAL_MODE_INPUT);
addConsoleActionI("set_idle_rpm", setIdleRpmAction);
addConsoleActionI("set_idle_pwm", setIdleValvePwm);
addConsoleActionI("set_idle_enabled", setIdleControlEnabled);
}
void startTunerStudioConnectivity(void) {
if (sizeof(persistent_config_s) != getTunerStudioPageSize(0))
firmwareError("TS page size mismatch: %d/%d", sizeof(persistent_config_s), getTunerStudioPageSize(0));
if (sizeof(TunerStudioOutputChannels) != TS_OUTPUT_SIZE)
firmwareError("TS outputs size mismatch: %d/%d", sizeof(TunerStudioOutputChannels), TS_OUTPUT_SIZE);
memset(&tsState, 0, sizeof(tsState));
syncTunerStudioCopy();
addConsoleAction("tsinfo", printTsStats);
addConsoleAction("reset_ts", resetTs);
addConsoleActionI("set_ts_speed", setTsSpeed);
tsChannel.channel = getTsSerialDevice();
tsChannel.writeBuffer = tsCrcWriteBuffer;
chThdCreateStatic(tsThreadStack, sizeof(tsThreadStack), NORMALPRIO, tsThreadEntryPoint, NULL);
}
void initElectronicThrottle(void) {
initLogging(&logger, "Electronic Throttle");
engineConfiguration->tpsMin = 140;
engineConfiguration->tpsMax = 898;
// these two lines are controlling direction
// outputPinRegister("etb1", ELECTRONIC_THROTTLE_CONTROL_1, ETB_CONTROL_LINE_1_PORT, ETB_CONTROL_LINE_1_PIN);
// outputPinRegister("etb2", ELECTRONIC_THROTTLE_CONTROL_2, ETB_CONTROL_LINE_2_PORT, ETB_CONTROL_LINE_2_PIN);
// this line used for PWM
startSimplePwmExt(&etbPwm, "etb",
boardConfiguration->electronicThrottlePin1,
ELECTRONIC_THROTTLE_CONTROL_1,
500,
0.80);
addConsoleActionI("e", setThrottleConsole);
chThdCreateStatic(etbTreadStack, sizeof(etbTreadStack), NORMALPRIO, (tfunc_t) etbThread, NULL);
}
void initPwmTester(void) {
initLogging(&logger, "pwm test");
addConsoleActionI("pwmtest", startPwmTest);
startPwmTest(1000);
/**
* injector channels #4-#8 are used for individual squirt test
*/
// todo: yet, it's some horrible code duplication
outSignals[0].output = &enginePins.injectors[4];
outSignals[1].output = &enginePins.injectors[5];
outSignals[2].output = &enginePins.injectors[6];
outSignals[3].output = &enginePins.injectors[7];
outSignals[4].output = &enginePins.injectors[8];
outSignals[5].output = &enginePins.injectors[9];
outSignals[6].output = &enginePins.injectors[10];
outSignals[7].output = &enginePins.injectors[11];
/**
* this would schedule a callback in 2ms from now
*/
scheduleTask("test", &ioTest, MS2US(2), testCallback, NULL);
}
void initConsoleLogic(Logging *sharedLogger) {
logging = sharedLogger;
// resetConsoleActions();
addConsoleAction("help", helpCommand);
addConsoleActionI("echo", echo);
}
void initAdcInputs() {
initLoggingExt(&logger, "ADC", LOGGING_BUFFER, sizeof(LOGGING_BUFFER));
printStatus();
addConsoleActionI(ADC_DEBUG_KEY, &setAdcDebugReporting);
#ifdef EFI_INTERNAL_ADC
/*
* Initializes the ADC driver.
*/
adcStart(&ADC_SLOW, NULL);
adcStart(&ADC_FAST, NULL);
adcgrpcfg_slow.sqr2 = 0;
adcgrpcfg_slow.sqr3 = 0;
int index = 0;
#if EFI_USE_ADC_CHANNEL_IN0
initSlowChannel(index++, ADC_CHANNEL_IN0); // PA0
#endif
#if EFI_USE_ADC_CHANNEL_IN1
initSlowChannel(index++, ADC_CHANNEL_IN1); // PA1
#endif
#if EFI_USE_ADC_CHANNEL_IN2
initSlowChannel(index++, ADC_CHANNEL_IN2); // PA2
#endif
#if EFI_USE_ADC_CHANNEL_IN3
initSlowChannel(index++, ADC_CHANNEL_IN3); // PA3
#endif
#if EFI_USE_ADC_CHANNEL_IN4
initSlowChannel(index++, ADC_CHANNEL_IN4); // PA4
#endif
#if EFI_USE_ADC_CHANNEL_IN5
initSlowChannel(index++, ADC_CHANNEL_IN5); // PA5 - this is also TIM2_CH1
#endif
#if EFI_USE_ADC_CHANNEL_IN6
initSlowChannel(index++, ADC_CHANNEL_IN6); // PA6
#endif
#if EFI_USE_ADC_CHANNEL_IN7
initSlowChannel(index++, ADC_CHANNEL_IN7); // PA7
#endif
#if EFI_USE_ADC_CHANNEL_IN8
initSlowChannel(index++, ADC_CHANNEL_IN8); // PB0
#endif
#if EFI_USE_ADC_CHANNEL_IN9
initSlowChannel(index++, ADC_CHANNEL_IN9); // PB1
#endif
#if EFI_USE_ADC_CHANNEL_IN10
initSlowChannel(index++, ADC_CHANNEL_IN10); // PC0
#endif
#if EFI_USE_ADC_CHANNEL_IN11
initSlowChannel(index++, ADC_CHANNEL_IN11); // PC1
#endif
#if EFI_USE_ADC_CHANNEL_IN12
initSlowChannel(index++, ADC_CHANNEL_IN12); // PC2
#endif
#if EFI_USE_ADC_CHANNEL_IN13
initSlowChannel(index++, ADC_CHANNEL_IN13); // PC3
#endif
#if EFI_USE_ADC_CHANNEL_IN14
initSlowChannel(index++, ADC_CHANNEL_IN14); // PC4
#endif
#if EFI_USE_ADC_CHANNEL_IN15
initSlowChannel(index++, ADC_CHANNEL_IN15); // PC5
#endif
if (index != EFI_ADC_SLOW_CHANNELS_COUNT)
fatal("Invalud internal ADC config");
/*
* Initializes the PWM driver.
*/
pwmStart(EFI_INTERNAL_SLOW_ADC_PWM, &pwmcfg_slow);
pwmStart(EFI_INTERNAL_FAST_ADC_PWM, &pwmcfg_fast);
addConsoleActionI("adc", printAdcValue);
addConsoleAction("fadc", printFullAdcReport);
#else
printSimpleMsg(&logger, "ADC disabled", 0);
#endif
}
void initAdcInputs(bool boardTestMode) {
printMsg(&logger, "initAdcInputs()");
configureInputs();
printStatus();
addConsoleActionI("adcDebug", &setAdcDebugReporting);
#if EFI_INTERNAL_ADC
/*
* Initializes the ADC driver.
*/
adcStart(&ADC_SLOW_DEVICE, NULL);
adcStart(&ADC_FAST_DEVICE, NULL);
for (int adc = 0; adc < HW_MAX_ADC_INDEX; adc++) {
adc_channel_mode_e mode = adcHwChannelEnabled[adc];
/**
* in board test mode all currently enabled ADC channels are running in slow mode
*/
if (mode == ADC_SLOW || (boardTestMode && mode == ADC_FAST)) {
slowAdc.addChannel((adc_channel_e) (ADC_CHANNEL_IN0 + adc));
} else if (mode == ADC_FAST) {
fastAdc.addChannel((adc_channel_e) (ADC_CHANNEL_IN0 + adc));
}
}
slowAdc.init();
pwmStart(EFI_INTERNAL_SLOW_ADC_PWM, &pwmcfg_slow);
if (boardConfiguration->isFastAdcEnabled) {
fastAdc.init();
/*
* Initializes the PWM driver.
*/
pwmStart(EFI_INTERNAL_FAST_ADC_PWM, &pwmcfg_fast);
}
// ADC_CHANNEL_IN0 // PA0
// ADC_CHANNEL_IN1 // PA1
// ADC_CHANNEL_IN2 // PA2
// ADC_CHANNEL_IN3 // PA3
// ADC_CHANNEL_IN4 // PA4
// ADC_CHANNEL_IN5 // PA5 - this is also TIM2_CH1
// ADC_CHANNEL_IN6 // PA6
// ADC_CHANNEL_IN7 // PA7
// ADC_CHANNEL_IN8 // PB0
// ADC_CHANNEL_IN9 // PB1
// ADC_CHANNEL_IN10 // PC0
// ADC_CHANNEL_IN11 // PC1
// ADC_CHANNEL_IN12 // PC2
// ADC_CHANNEL_IN13 // PC3
// ADC_CHANNEL_IN14 // PC4
// ADC_CHANNEL_IN15 // PC5
//if(slowAdcChannelCount > ADC_MAX_SLOW_CHANNELS_COUNT) // todo: do we need this logic? do we need this check
addConsoleActionI("adc", (VoidInt) printAdcValue);
addConsoleAction("fadc", printFullAdcReport);
#else
printMsg(&logger, "ADC disabled");
#endif
}
TEST(misc, testConsoleLogic) {
print("******************************************* testConsoleLogic\r\n");
resetConsoleActions();
helpCommand();
char * cmd = "he ha";
ASSERT_EQ(2, findEndOfToken(cmd));
cmd = "\"hee\" ha";
ASSERT_EQ(5, findEndOfToken(cmd));
cmd = "\"h e\" ha";
ASSERT_EQ(5, findEndOfToken(cmd));
strcpy(buffer, "echo");
ASSERT_TRUE(strEqual("echo", unquote(buffer)));
strcpy(buffer, "\"echo\"");
ASSERT_TRUE(strEqual("echo", unquote(buffer))) << "unquote quoted";
char *ptr = validateSecureLine(UNKNOWN_COMMAND);
ASSERT_EQ(0, strcmp(UNKNOWN_COMMAND, ptr));
ASSERT_EQ(10, tokenLength(UNKNOWN_COMMAND));
// handling invalid token should work
strcpy(buffer, "sdasdafasd asd");
handleConsoleLine(buffer);
print("\r\naddConsoleActionI\r\n");
addConsoleActionI("echoi", testEchoI);
strcpy(buffer, "echoi 239");
handleConsoleLine(buffer);
ASSERT_EQ(239, lastInteger);
print("\r\naddConsoleActionI 240 with two spaces\r\n");
strcpy(buffer, "echoi 240");
handleConsoleLine(buffer);
ASSERT_EQ(240, lastInteger);
print("\r\naddConsoleActionII\r\n");
addConsoleActionII("echoii", testEchoII);
strcpy(buffer, "echoii 22 239");
handleConsoleLine(buffer);
ASSERT_EQ(22, lastInteger);
ASSERT_EQ(239, lastInteger2);
print("\r\naddConsoleActionII three spaces\r\n");
strcpy(buffer, "echoii 21 220");
handleConsoleLine(buffer);
ASSERT_EQ(21, lastInteger);
ASSERT_EQ(220, lastInteger2);
print("\r\addConsoleActionSSS\r\n");
addConsoleActionSSS("echosss", testEchoSSS);
strcpy(buffer, "echosss 111 222 333");
handleConsoleLine(buffer);
ASSERT_EQ(111, atoi(lastFirst));
ASSERT_EQ(333, atoi(lastThird));
strcpy(buffer, "echosss \" 1\" 222 333");
handleConsoleLine(buffer);
ASSERT_TRUE(strEqual("\" 1\"", lastFirst));
//addConsoleActionSSS("GPS", testGpsParser);
}
void initSensorChart(void) {
addConsoleActionI("set_sensor_chart_freq", setSensorChartFrequency);
initialized = true;
}
void initAdcInputs(bool boardTestMode) {
printMsg(&logger, "initAdcInputs()");
if (ADC_BUF_DEPTH_FAST > MAX_ADC_GRP_BUF_DEPTH)
firmwareError(CUSTOM_ERR_ADC_DEPTH_FAST, "ADC_BUF_DEPTH_FAST too high");
if (ADC_BUF_DEPTH_SLOW > MAX_ADC_GRP_BUF_DEPTH)
firmwareError(CUSTOM_ERR_ADC_DEPTH_SLOW, "ADC_BUF_DEPTH_SLOW too high");
configureInputs();
// migrate to 'enable adcdebug'
addConsoleActionI("adcdebug", &setAdcDebugReporting);
#if EFI_INTERNAL_ADC
/*
* Initializes the ADC driver.
*/
adcStart(&ADC_SLOW_DEVICE, NULL);
adcStart(&ADC_FAST_DEVICE, NULL);
adcSTM32EnableTSVREFE(); // Internal temperature sensor
for (int adc = 0; adc < HW_MAX_ADC_INDEX; adc++) {
adc_channel_mode_e mode = adcHwChannelEnabled[adc];
/**
* in board test mode all currently enabled ADC channels are running in slow mode
*/
if (mode == ADC_SLOW || (boardTestMode && mode == ADC_FAST)) {
slowAdc.enableChannelAndPin((adc_channel_e) (ADC_CHANNEL_IN0 + adc));
} else if (mode == ADC_FAST) {
fastAdc.enableChannelAndPin((adc_channel_e) (ADC_CHANNEL_IN0 + adc));
}
}
// Internal temperature sensor, Available on ADC1 only
slowAdc.enableChannel((adc_channel_e)ADC_CHANNEL_SENSOR);
slowAdc.init();
#if HAL_USE_PWM || defined(__DOXYGEN__)
pwmStart(EFI_INTERNAL_SLOW_ADC_PWM, &pwmcfg_slow);
pwmEnablePeriodicNotification(EFI_INTERNAL_SLOW_ADC_PWM);
#endif /* HAL_USE_PWM */
if (CONFIGB(isFastAdcEnabled)) {
fastAdc.init();
/*
* Initializes the PWM driver.
*/
#if HAL_USE_PWM || defined(__DOXYGEN__)
pwmStart(EFI_INTERNAL_FAST_ADC_PWM, &pwmcfg_fast);
pwmEnablePeriodicNotification(EFI_INTERNAL_FAST_ADC_PWM);
#endif /* HAL_USE_PWM */
}
// ADC_CHANNEL_IN0 // PA0
// ADC_CHANNEL_IN1 // PA1
// ADC_CHANNEL_IN2 // PA2
// ADC_CHANNEL_IN3 // PA3
// ADC_CHANNEL_IN4 // PA4
// ADC_CHANNEL_IN5 // PA5 - this is also TIM2_CH1
// ADC_CHANNEL_IN6 // PA6
// ADC_CHANNEL_IN7 // PA7
// ADC_CHANNEL_IN8 // PB0
// ADC_CHANNEL_IN9 // PB1
// ADC_CHANNEL_IN10 // PC0
// ADC_CHANNEL_IN11 // PC1
// ADC_CHANNEL_IN12 // PC2
// ADC_CHANNEL_IN13 // PC3
// ADC_CHANNEL_IN14 // PC4
// ADC_CHANNEL_IN15 // PC5
//if(slowAdcChannelCount > ADC_MAX_SLOW_CHANNELS_COUNT) // todo: do we need this logic? do we need this check
addConsoleActionI("adc", (VoidInt) printAdcValue);
#else
printMsg(&logger, "ADC disabled");
#endif
}
void initSettings(engine_configuration_s *engineConfiguration) {
addConsoleActionP("showconfig", (VoidPtr) doPrintConfiguration, &engine);
addConsoleAction("tempinfo", printTemperatureInfo);
addConsoleAction("tpsinfo", printTPSInfo);
addConsoleAction("info", printAllInfo);
addConsoleActionF("set_ignition_offset", setIgnitionOffset);
addConsoleActionF("set_injection_offset", setInjectionOffset);
addConsoleActionF("set_global_trigger_offset_angle", setGlobalTriggerAngleOffset);
addConsoleActionI("set_sensor_chart_mode", setSensorChartMode);
addConsoleActionI("set_fixed_mode_timing", setFixedModeTiming);
addConsoleActionI("set_timing_mode", setTimingMode);
addConsoleActionI("set_engine_type", setEngineType);
addConsoleActionI("set_injection_pin_mode", setInjectionPinMode);
addConsoleActionI("set_ignition_pin_mode", setIgnitionPinMode);
addConsoleActionI("set_idle_pin_mode", setIdlePinMode);
addConsoleActionI("set_fuel_pump_pin_mode", setFuelPumpPinMode);
addConsoleActionI("set_malfunction_indicator_pin_mode", setMalfunctionIndicatorPinMode);
addConsoleActionI("set_operation_mode", setOM);
// todo: start saving values into flash right away?
addConsoleActionF("set_global_fuel_correction", setGlobalFuelCorrection);
addConsoleActionF("set_cranking_fuel", setCrankingFuel);
addConsoleActionI("set_cranking_rpm", setCrankingRpm);
addConsoleActionF("set_cranking_timing_angle", setCrankingTimingAngle);
addConsoleActionF("set_cranking_charge_angle", setCrankingChargeAngle);
addConsoleActionI("set_ignition_mode", setIgnitionMode);
addConsoleActionI("set_cranking_injection_mode", setCrankingInjectionMode);
addConsoleActionI("set_injection_mode", setInjectionMode);
addConsoleActionF("set_whole_phase_map", setWholePhaseMapCmd);
addConsoleActionF("set_whole_timing_map", setWholeTimingMapCmd);
addConsoleActionF("set_whole_fuel_map", setWholeFuelMapCmd);
addConsoleActionF("set_whole_ve_map", setWholeVeCmd);
addConsoleActionSSS("set_fuel_map", setFuelMap);
addConsoleActionF("set_whole_timing_map", setWholeTimingMap);
addConsoleActionSSS("set_timing_map", setTimingMap);
addConsoleActionI("set_rpm_hard_limit", setRpmHardLimit);
addConsoleActionI("set_firing_order", setFiringOrder);
addConsoleActionI("set_algorithm", setAlgorithmInt);
addConsoleAction("stopengine", (Void) stopEngine);
// todo: refactor this - looks like all boolean flags should be controlled with less code duplication
addConsoleAction("enable_injection", enableInjection);
addConsoleAction("disable_injection", disableInjection);
addConsoleAction("enable_ignition", enableIgnition);
addConsoleAction("disable_ignition", disableIgnition);
addConsoleActionI("enable_spi", enableSpi);
addConsoleActionI("disable_spi", disableSpi);
addConsoleActionS("enable", enable);
addConsoleActionS("disable", disable);
addConsoleActionII("set_toothed_wheel", setToothedWheel);
addConsoleActionI("set_trigger_type", setTriggerType);
addConsoleActionF("set_vbatt_divider", setVBattDivider);
addConsoleActionF("set_injector_lag", setInjectorLag);
addConsoleActionF("set_clt_bias", setCltBias);
addConsoleActionF("set_iat_bias", setIatBias);
addConsoleActionI("set_idle_solenoid_freq", setIdleSolenoidFrequency);
addConsoleActionFF("set_fan", setFanSetting);
#if EFI_PROD_CODE
addConsoleActionS("showpin", showPinFunction);
addConsoleActionSS("set_injection_pin", setInjectionPin);
addConsoleActionSS("set_ignition_pin", setIgnitionPin);
addConsoleActionSS("set_trigger_input_pin", setTriggerInputPin);
addConsoleActionSS("set_trigger_simulator_pin", setTriggerSimulatorPin);
addConsoleActionSSP("set_egt_cs_pin", (VoidCharPtrCharPtrVoidPtr) setEgtCSPin, boardConfiguration);
addConsoleActionI("set_egt_spi", setEgtSpi);
addConsoleActionSS("set_trigger_simulator_mode", setTriggerSimulatorMode);
addConsoleActionS("set_fuel_pump_pin", setFuelPumpPin);
addConsoleActionS("set_ac_pin", setACPin);
addConsoleActionS("set_alternator_pin", setAlternatorPin);
addConsoleActionS("set_idle_pin", setIdlePin);
addConsoleActionS("set_main_relay_pin", setMainRelayPin);
addConsoleActionSS("set", setValue);
addConsoleActionS("get", getValue);
#if HAL_USE_ADC || defined(__DOXYGEN__)
addConsoleActionSS("set_analog_input_pin", setAnalogInputPin);
#endif
addConsoleActionSS("set_logic_input_pin", setLogicInputPin);
addConsoleActionI("set_pot_spi", setPotSpi);
#endif /* EFI_PROD_CODE */
}
void initSettings(void) {
initLoggingExt(&logger, "settings control", LOGGING_BUFFER, sizeof(LOGGING_BUFFER));
addConsoleAction("showconfig", doPrintConfiguration);
addConsoleAction("tempinfo", printTemperatureInfo);
addConsoleAction("tpsinfo", printTPSInfo);
addConsoleActionI("set_ignition_offset", setIgnitionOffset);
addConsoleActionI("set_injection_offset", setInjectionOffset);
addConsoleActionI("set_global_trigger_offset_angle", setGlobalTriggerAngleOffset);
addConsoleActionI("set_analog_chart_mode", setAnalogChartMode);
addConsoleActionI("set_fixed_mode_timing", setFixedModeTiming);
addConsoleActionI("set_timing_mode", setTimingMode);
addConsoleActionI("set_engine_type", setEngineType);
addConsoleActionI("set_injection_pin_mode", setInjectionPinMode);
addConsoleActionI("set_ignition_pin_mode", setIgnitionPinMode);
addConsoleActionI("set_idle_pin", setIdlePin);
addConsoleActionI("set_idle_pin_mode", setIdlePinMode);
addConsoleActionI("set_fuel_pump_pin_mode", setFuelPumpPinMode);
addConsoleActionI("set_malfunction_indicator_pin_mode", setMalfunctionIndicatorPinMode);
addConsoleActionI("set_rpm_multiplier", setRpmMultiplier);
// todo: start saving values into flash right away?
addConsoleActionF("set_global_fuel_correction", setGlobalFuelCorrection);
addConsoleActionII("set_cranking_fuel_min", setCrankingFuelMin);
addConsoleActionII("set_cranking_fuel_max", setCrankingFuelMax);
addConsoleActionI("set_cranking_rpm", setCrankingRpm);
addConsoleActionF("set_cranking_timing_angle", setCrankingTimingAngle);
addConsoleActionF("set_cranking_charge_angle", setCrankingChargeAngle);
addConsoleActionI("set_ignition_mode", setIgnitionMode);
addConsoleActionI("set_cranking_injection_mode", setCrankingInjectionMode);
addConsoleActionI("set_injection_mode", setInjectionMode);
addConsoleActionF("set_whole_fuel_map", setWholeFuelMapCmd);
addConsoleActionSSS("set_fuel_map", setFuelMap);
addConsoleActionF("set_whole_timing_map", setWholeTimingMap);
addConsoleActionSSS("set_timing_map", setTimingMap);
addConsoleActionI("set_rpm_hard_limit", setRpmHardLimit);
addConsoleActionI("set_firing_order", setFiringOrder);
addConsoleAction("enable_injection", enableInjection);
addConsoleAction("disable_injection", disableInjection);
}