void readFromFlash(void) { efiAssertVoid(getRemainingStack(chThdSelf()) > 256, "read f"); printMsg(logger, "readFromFlash()"); flashRead(FLASH_ADDR, (char *) &persistentState, PERSISTENT_SIZE); persisted_configuration_state_e result; if (!isValidCrc(&persistentState)) { result = CRC_FAILED; resetConfigurationExt(logger, DEFAULT_ENGINE_TYPE PASS_ENGINE_PARAMETER); } else if (persistentState.version != FLASH_DATA_VERSION || persistentState.size != PERSISTENT_SIZE) { result = INCOMPATIBLE_VERSION; resetConfigurationExt(logger, engineConfiguration->engineType PASS_ENGINE_PARAMETER); } else { /** * At this point we know that CRC and version number is what we expect. Safe to assume it's a valid configuration. */ result = OK; applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER); } // we can only change the state after the CRC check engineConfiguration->firmwareVersion = getRusEfiVersion(); if (result == CRC_FAILED) { printMsg(logger, "Need to reset flash to default due to CRC"); } else if (result == INCOMPATIBLE_VERSION) { printMsg(logger, "Resetting but saving engine type [%d]", engineConfiguration->engineType); } else { printMsg(logger, "Got valid configuration from flash!"); } }
static void printInfo(systime_t nowSeconds) { /** * we report the version every 4 seconds - this way the console does not need to * request it and we will display it pretty soon */ if (overflowDiff(nowSeconds, timeOfPreviousPrintVersion) < 4) { return; } timeOfPreviousPrintVersion = nowSeconds; appendPrintf(&logger, "%s%s%d@%s %s %d%s", RUS_EFI_VERSION_TAG, DELIMETER, getRusEfiVersion(), VCS_VERSION, getConfigurationName(engineConfiguration->engineType), getTimeNowSeconds(), DELIMETER); #if EFI_PROD_CODE || defined(__DOXYGEN__) printOutPin(CRANK1, boardConfiguration->triggerInputPins[0]); printOutPin(CRANK2, boardConfiguration->triggerInputPins[1]); #if EFI_WAVE_ANALYZER || defined(__DOXYGEN__) printOutPin(WA_CHANNEL_1, boardConfiguration->logicAnalyzerPins[0]); printOutPin(WA_CHANNEL_2, boardConfiguration->logicAnalyzerPins[1]); #endif for (int i = 0; i < engineConfiguration->specs.cylindersCount; i++) { printOutPin(enginePins.coils[i].name, boardConfiguration->ignitionPins[i]); printOutPin(enginePins.injectors[i].name, boardConfiguration->injectionPins[i]); } #endif }
static void readFromFlash(void) { flashRead(FLASH_ADDR, (char *) &flashState, FLASH_USAGE); setDefaultNonPersistentConfiguration(engineConfiguration2); if (!isValidCrc(&flashState)) { scheduleMsg(&logger, "Need to reset flash to default"); resetConfigurationExt(defaultEngineType, engineConfiguration, engineConfiguration2, boardConfiguration); } else { scheduleMsg(&logger, "Got valid configuration from flash!"); applyNonPersistentConfiguration(engineConfiguration, engineConfiguration2, engineConfiguration->engineType); } // we can only change the state after the CRC check engineConfiguration->firmwareVersion = getRusEfiVersion(); }
void readFromFlash(void) { printMsg(&logger, "readFromFlash()"); flashRead(FLASH_ADDR, (char *) &persistentState, PERSISTENT_SIZE); //setDefaultNonPersistentConfiguration(engineConfiguration2); if (!isValidCrc(&persistentState) || persistentState.size != PERSISTENT_SIZE) { printMsg(&logger, "Need to reset flash to default"); resetConfigurationExt(&logger, defaultEngineType, engineConfiguration, engineConfiguration2, boardConfiguration); } else { printMsg(&logger, "Got valid configuration from flash!"); applyNonPersistentConfiguration(&logger, engineConfiguration, engineConfiguration2); } // we can only change the state after the CRC check engineConfiguration->firmwareVersion = getRusEfiVersion(); }
void rusEfiFunctionalTest(void) { printToConsole("Running rusEfi simulator version:"); static char versionBuffer[20]; itoa10(versionBuffer, (int)getRusEfiVersion()); printToConsole(versionBuffer); initIntermediateLoggingBuffer(); initErrorHandling(); engine->setConfig(config); initializeConsole(&sharedLogger); initStatusLoop(); initDataStructures(PASS_ENGINE_PARAMETER_SIGNATURE); // todo: reduce code duplication with initEngineContoller resetConfigurationExt(NULL, FORD_ESCORT_GT PASS_ENGINE_PARAMETER_SUFFIX); prepareShapes(PASS_ENGINE_PARAMETER_SIGNATURE); initAlgo(&sharedLogger); commonInitEngineController(&sharedLogger); initRpmCalculator(&sharedLogger PASS_ENGINE_PARAMETER_SUFFIX); initTriggerCentral(&sharedLogger); initTriggerEmulator(&sharedLogger PASS_ENGINE_PARAMETER_SUFFIX); #if EFI_MAP_AVERAGING initMapAveraging(&sharedLogger, engine); #endif /* EFI_MAP_AVERAGING */ initMainEventListener(&sharedLogger PASS_ENGINE_PARAMETER_SUFFIX); startStatusThreads(); runChprintfTest(); initPeriodicEvents(PASS_ENGINE_PARAMETER_SIGNATURE); setTriggerEmulatorRPM(DEFAULT_SIM_RPM PASS_ENGINE_PARAMETER_SUFFIX); engineConfiguration->engineSnifferRpmThreshold = DEFAULT_SNIFFER_THR; }
/** * this method could and should be executed before we have any * connectivity so no console output here */ persisted_configuration_state_e readConfiguration(Logging * logger) { efiAssert(getRemainingStack(chThdSelf()) > 256, "read f", PC_ERROR); flashRead(FLASH_ADDR, (char *) &persistentState, PERSISTENT_SIZE); persisted_configuration_state_e result; if (!isValidCrc(&persistentState)) { result = CRC_FAILED; warning(CUSTOM_ERR_FLASH_CRC_FAILED, "flash CRC failed"); resetConfigurationExt(logger, DEFAULT_ENGINE_TYPE PASS_ENGINE_PARAMETER); } else if (persistentState.version != FLASH_DATA_VERSION || persistentState.size != PERSISTENT_SIZE) { result = INCOMPATIBLE_VERSION; resetConfigurationExt(logger, engineConfiguration->engineType PASS_ENGINE_PARAMETER); } else { /** * At this point we know that CRC and version number is what we expect. Safe to assume it's a valid configuration. */ result = OK; applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER); } // we can only change the state after the CRC check engineConfiguration->byFirmwareVersion = getRusEfiVersion(); return result; }
static void sayHello(void) { scheduleMsg(&logger, "*** rusEFI (c) Andrey Belomutskiy 2012-2017. All rights reserved."); scheduleMsg(&logger, "rusEFI v%d@%s", getRusEfiVersion(), VCS_VERSION); scheduleMsg(&logger, "*** Chibios Kernel: %s", CH_KERNEL_VERSION); scheduleMsg(&logger, "*** Compiled: " __DATE__ " - " __TIME__ ""); scheduleMsg(&logger, "COMPILER=%s", __VERSION__); #ifdef CH_FREQUENCY scheduleMsg(&logger, "CH_FREQUENCY=%d", CH_FREQUENCY); #endif #ifdef CORTEX_MAX_KERNEL_PRIORITY scheduleMsg(&logger, "CORTEX_MAX_KERNEL_PRIORITY=%d", CORTEX_MAX_KERNEL_PRIORITY); #endif #ifdef STM32_ADCCLK scheduleMsg(&logger, "STM32_ADCCLK=%d", STM32_ADCCLK); scheduleMsg(&logger, "STM32_TIMCLK1=%d", STM32_TIMCLK1); scheduleMsg(&logger, "STM32_TIMCLK2=%d", STM32_TIMCLK2); #endif #ifdef STM32_PCLK1 scheduleMsg(&logger, "STM32_PCLK1=%d", STM32_PCLK1); scheduleMsg(&logger, "STM32_PCLK2=%d", STM32_PCLK2); #endif scheduleMsg(&logger, "PORT_IDLE_THREAD_STACK_SIZE=%d", PORT_IDLE_THREAD_STACK_SIZE); scheduleMsg(&logger, "CH_DBG_ENABLE_ASSERTS=%d", CH_DBG_ENABLE_ASSERTS); #ifdef CH_DBG_ENABLED scheduleMsg(&logger, "CH_DBG_ENABLED=%d", CH_DBG_ENABLED); #endif scheduleMsg(&logger, "CH_DBG_SYSTEM_STATE_CHECK=%d", CH_DBG_SYSTEM_STATE_CHECK); scheduleMsg(&logger, "CH_DBG_ENABLE_STACK_CHECK=%d", CH_DBG_ENABLE_STACK_CHECK); #ifdef EFI_WAVE_ANALYZER scheduleMsg(&logger, "EFI_WAVE_ANALYZER=%d", EFI_WAVE_ANALYZER); #endif #ifdef EFI_TUNER_STUDIO scheduleMsg(&logger, "EFI_TUNER_STUDIO=%d", EFI_TUNER_STUDIO); #else scheduleMsg(&logger, "EFI_TUNER_STUDIO=%d", 0); #endif #ifdef EFI_SIGNAL_EXECUTOR_SLEEP scheduleMsg(&logger, "EFI_SIGNAL_EXECUTOR_SLEEP=%d", EFI_SIGNAL_EXECUTOR_SLEEP); #endif #ifdef EFI_SIGNAL_EXECUTOR_HW_TIMER scheduleMsg(&logger, "EFI_SIGNAL_EXECUTOR_HW_TIMER=%d", EFI_SIGNAL_EXECUTOR_HW_TIMER); #endif #if defined(EFI_SHAFT_POSITION_INPUT) || defined(__DOXYGEN__) scheduleMsg(&logger, "EFI_SHAFT_POSITION_INPUT=%d", EFI_SHAFT_POSITION_INPUT); #endif #ifdef EFI_INTERNAL_ADC scheduleMsg(&logger, "EFI_INTERNAL_ADC=%d", EFI_INTERNAL_ADC); #endif // printSimpleMsg(&logger, "", ); // printSimpleMsg(&logger, "", ); /** * Time to finish output. This is needed to avoid mix-up of this methods output and console command confirmation */ chThdSleepMilliseconds(5); }
static void myerror(void) { firmwareError(CUSTOM_ERR_TEST_ERROR, "firmwareError: %d", getRusEfiVersion()); }
static void sayHello(void) { printMsg(&logger, "*** rusEFI (c) Andrey Belomutskiy, 2012-2014. All rights reserved."); printMsg(&logger, "rusEFI v%d@%d", getRusEfiVersion(), SVN_VERSION); printMsg(&logger, "*** Chibios Kernel: %s", CH_KERNEL_VERSION); printMsg(&logger, "*** Compiled: " __DATE__ " - " __TIME__ ""); printMsg(&logger, "COMPILER=%s", __VERSION__); printMsg(&logger, "CH_FREQUENCY=%d", CH_FREQUENCY); #ifdef SERIAL_SPEED printMsg(&logger, "SERIAL_SPEED=%d", SERIAL_SPEED); #endif #ifdef STM32_ADCCLK printMsg(&logger, "STM32_ADCCLK=%d", STM32_ADCCLK); printMsg(&logger, "STM32_TIMCLK1=%d", STM32_TIMCLK1); printMsg(&logger, "STM32_TIMCLK2=%d", STM32_TIMCLK2); printMsg(&logger, "STM32_PCLK1=%d", STM32_PCLK1); printMsg(&logger, "STM32_PCLK2=%d", STM32_PCLK2); #endif printMsg(&logger, "CH_DBG_ENABLE_ASSERTS=%d", CH_DBG_ENABLE_ASSERTS); printMsg(&logger, "CH_DBG_ENABLED=%d", CH_DBG_ENABLED); printMsg(&logger, "CH_DBG_SYSTEM_STATE_CHECK=%d", CH_DBG_SYSTEM_STATE_CHECK); printMsg(&logger, "CH_DBG_ENABLE_STACK_CHECK=%d", CH_DBG_ENABLE_STACK_CHECK); #ifdef EFI_WAVE_ANALYZER printMsg(&logger, "EFI_WAVE_ANALYZER=%d", EFI_WAVE_ANALYZER); #endif #ifdef EFI_TUNER_STUDIO printMsg(&logger, "EFI_TUNER_STUDIO=%d", EFI_TUNER_STUDIO); #else printMsg(&logger, "EFI_TUNER_STUDIO=%d", 0); #endif #ifdef EFI_SIGNAL_EXECUTOR_SLEEP printMsg(&logger, "EFI_SIGNAL_EXECUTOR_SLEEP=%d", EFI_SIGNAL_EXECUTOR_SLEEP); #endif #ifdef EFI_SIGNAL_EXECUTOR_HW_TIMER printMsg(&logger, "EFI_SIGNAL_EXECUTOR_HW_TIMER=%d", EFI_SIGNAL_EXECUTOR_HW_TIMER); #endif #ifdef EFI_TUNER_STUDIO_OVER_USB printMsg(&logger, "EFI_TUNER_STUDIO_OVER_USB=%d", EFI_TUNER_STUDIO_OVER_USB); #else printMsg(&logger, "EFI_TUNER_STUDIO_OVER_USB=%d", 0); #endif #ifdef EFI_SHAFT_POSITION_INPUT printMsg(&logger, "EFI_SHAFT_POSITION_INPUT=%d", EFI_SHAFT_POSITION_INPUT); #endif #ifdef EFI_INTERNAL_ADC printMsg(&logger, "EFI_INTERNAL_ADC=%d", EFI_INTERNAL_ADC); #endif // printSimpleMsg(&logger, "", ); // printSimpleMsg(&logger, "", ); /** * Time to finish output. This is needed to avoid mix-up of this methods output and console command confirmation */ chThdSleepMilliseconds(5); }
static void myerror(void) { firmwareError("firmwareError: %d", getRusEfiVersion()); }
static void printSensors(Logging *log, bool fileFormat) { // current time, in milliseconds int nowMs = currentTimeMillis(); float sec = ((float) nowMs) / 1000; reportSensorF(log, fileFormat, "time", "", sec, 3); // log column 1 int rpm = 0; #if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__) rpm = getRpmE(engine); reportSensorI(log, fileFormat, "rpm", "RPM", rpm); // log column 2 // reportSensorF(log, fileFormat, "TRG_0_DUTY", "%", getTriggerDutyCycle(0), 2); // reportSensorF(log, fileFormat, "TRG_1_DUTY", "%", getTriggerDutyCycle(1), 2); #endif #if EFI_PROD_CODE || defined(__DOXYGEN__) reportSensorF(log, fileFormat, "int_temp", "C", getMCUInternalTemperature(), 2); // log column #3 #endif reportSensorI(log, fileFormat, "mode", "v", packEngineMode(PASS_ENGINE_PARAMETER_F)); // log column #3 if (hasCltSensor()) { reportSensorF(log, fileFormat, "CLT", "C", getCoolantTemperature(PASS_ENGINE_PARAMETER_F), 2); // log column #4 } if (hasTpsSensor()) { reportSensorF(log, fileFormat, "TPS", "%", getTPS(PASS_ENGINE_PARAMETER_F), 2); // log column #5 } if (hasVBatt(PASS_ENGINE_PARAMETER_F)) { reportSensorF(log, fileFormat, "vbatt", "V", getVBatt(PASS_ENGINE_PARAMETER_F), 2); // log column #6 } if (hasIatSensor()) { reportSensorF(log, fileFormat, "IAT", "C", getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F), 2); // log column #7 } if (hasMafSensor()) { reportSensorF(log, fileFormat, "maf", "V", getMaf(PASS_ENGINE_PARAMETER_F), 2); reportSensorF(log, fileFormat, "mafr", "kg/hr", getRealMaf(PASS_ENGINE_PARAMETER_F), 2); } #if EFI_ANALOG_SENSORS || defined(__DOXYGEN__) if (engineConfiguration->map.sensor.hwChannel != EFI_ADC_NONE) { reportSensorF(log, fileFormat, "MAP", "kPa", getMap(), 2); // reportSensorF(log, fileFormat, "map_r", "V", getRawMap(), 2); } #endif /* EFI_ANALOG_SENSORS */ #if EFI_ANALOG_SENSORS || defined(__DOXYGEN__) if (hasBaroSensor()) { reportSensorF(log, fileFormat, "baro", "kPa", getBaroPressure(), 2); } #endif /* EFI_ANALOG_SENSORS */ if (hasAfrSensor(PASS_ENGINE_PARAMETER_F)) { reportSensorF(log, fileFormat, "afr", "AFR", getAfr(PASS_ENGINE_PARAMETER_F), 2); } #if EFI_IDLE_CONTROL || defined(__DOXYGEN__) if (fileFormat) { reportSensorF(log, fileFormat, "idle", "%", getIdlePosition(), 2); } #endif /* EFI_IDLE_CONTROL */ #if EFI_ANALOG_SENSORS || defined(__DOXYGEN__) reportSensorF(log, fileFormat, "target", "AFR", engine->engineState.targetAFR, 2); #endif /* EFI_ANALOG_SENSORS */ if (fileFormat) { reportSensorF(log, fileFormat, "tCharge", "K", engine->engineState.tChargeK, 2); // log column #8 reportSensorF(log, fileFormat, "curVE", "%", veMap.getValue(rpm, getMap()), 2); } float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_F); reportSensorF(log, fileFormat, "ENGINE_LOAD", "x", engineLoad, 2); reportSensorF(log, fileFormat, "dwell", "ms", ENGINE(engineState.sparkDwell), 2); if (fileFormat) { reportSensorF(log, fileFormat, "timing", "deg", engine->engineState.timingAdvance, 2); } if (fileFormat) { floatms_t fuelBase = getBaseFuel(rpm PASS_ENGINE_PARAMETER); reportSensorF(log, fileFormat, "f: base", "ms", fuelBase, 2); reportSensorF(log, fileFormat, "f: actual", "ms", ENGINE(actualLastInjection), 2); reportSensorF(log, fileFormat, "f: lag", "ms", engine->engineState.injectorLag, 2); reportSensorF(log, fileFormat, "f: running", "ms", ENGINE(engineState.runningFuel), 2); reportSensorF(log, fileFormat, "f: wall amt", "v", ENGINE(wallFuel).getWallFuel(0), 2); reportSensorF(log, fileFormat, "f: wall crr", "v", ENGINE(wallFuelCorrection), 2); reportSensorI(log, fileFormat, "version", "#", getRusEfiVersion()); } if (engineConfiguration->hasVehicleSpeedSensor) { #if EFI_VEHICLE_SPEED || defined(__DOXYGEN__) float vehicleSpeed = getVehicleSpeed(); #else float vehicleSpeed = 0; #endif /* EFI_PROD_CODE */ reportSensorF(log, fileFormat, "vss", "kph", vehicleSpeed, 2); float sp2rpm = rpm == 0 ? 0 : vehicleSpeed / rpm; reportSensorF(log, fileFormat, "sp2rpm", "x", sp2rpm, 2); } reportSensorF(log, fileFormat, "knck_c", "count", engine->knockCount, 0); reportSensorF(log, fileFormat, "knck_v", "v", engine->knockVolts, 2); // reportSensorF(log, fileFormat, "vref", "V", getVRef(engineConfiguration), 2); if (fileFormat) { reportSensorF(log, fileFormat, "f: tps delta", "v", engine->tpsAccelEnrichment.getMaxDelta(), 2); reportSensorF(log, fileFormat, "f: tps fuel", "ms", engine->engineState.tpsAccelEnrich, 2); reportSensorF(log, fileFormat, "f: el delta", "v", engine->engineLoadAccelEnrichment.getMaxDelta(), 2); reportSensorF(log, fileFormat, "f: el fuel", "v", engine->engineLoadAccelEnrichment.getEngineLoadEnrichment(PASS_ENGINE_PARAMETER_F) * 100 / getMap(), 2); reportSensorF(log, fileFormat, "f: duty", "%", getInjectorDutyCycle(rpm PASS_ENGINE_PARAMETER), 2); } // debugFloat(&logger, "tch", getTCharge1(tps), 2); for (int i = 0;i<FSIO_ADC_COUNT;i++) { if (engineConfiguration->fsioAdc[i] != EFI_ADC_NONE) { strcpy(buf, "adcX"); buf[3] = '0' + i; reportSensorF(log, fileFormat, buf, "", getVoltage("fsio", engineConfiguration->fsioAdc[i]), 2); } } reportSensorI(log, fileFormat, "warn", "count", engine->engineState.warningCounter); reportSensorI(log, fileFormat, "error", "code", engine->engineState.lastErrorCode); }