/**
* sets the alarm to the specified number of microseconds from now.
* This function should be invoked under kernel lock which would disable interrupts.
*/
void setHardwareUsTimer(int32_t timeUs) {
/**
* #259 BUG error: not positive timeUs
* Once in a while we night get an interrupt where we do not expect it
*/
if (timeUs <= 0) {
timerFreezeCounter++;
warning(CUSTOM_OBD_42, "local freeze cnt=%d", timerFreezeCounter);
}
if (timeUs < 2)
timeUs = 2; // for some reason '1' does not really work
efiAssertVoid(timeUs > 0, "not positive timeUs");
efiAssertVoid(timeUs < 10 * US_PER_SECOND, "setHardwareUsTimer() too large");
if (GPTDEVICE.state == GPT_ONESHOT)
gptStopTimerI(&GPTDEVICE);
efiAssertVoid(GPTDEVICE.state == GPT_READY, "hw timer");
if (hasFirmwareError())
return;
gptStartOneShotI(&GPTDEVICE, timeUs);
lastSetTimerTimeNt = getTimeNowNt();
lastSetTimerValue = timeUs;
isTimerPending = TRUE;
timerRestartCounter++;
}
/**
* sets the alarm to the specified number of microseconds from now.
* This function should be invoked under kernel lock which would disable interrupts.
*/
void setHardwareUsTimer(int32_t timeUs) {
setHwTimerCounter++;
/**
* #259 BUG error: not positive timeUs
* Once in a while we night get an interrupt where we do not expect it
*/
if (timeUs <= 0) {
timerFreezeCounter++;
warning(CUSTOM_OBD_LOCAL_FREEZE, "local freeze cnt=%d", timerFreezeCounter);
}
if (timeUs < 2)
timeUs = 2; // for some reason '1' does not really work
efiAssertVoid(CUSTOM_ERR_6681, timeUs > 0, "not positive timeUs");
if (timeUs >= 10 * US_PER_SECOND) {
firmwareError(CUSTOM_ERR_TIMER_OVERFLOW, "setHardwareUsTimer() too long: %d", timeUs);
return;
}
if (GPTDEVICE.state == GPT_ONESHOT) {
gptStopTimerI(&GPTDEVICE);
}
if (GPTDEVICE.state != GPT_READY) {
firmwareError(CUSTOM_HW_TIMER, "HW timer state %d/%d", GPTDEVICE.state, setHwTimerCounter);
return;
}
if (hasFirmwareError())
return;
gptStartOneShotI(&GPTDEVICE, timeUs);
lastSetTimerTimeNt = getTimeNowNt();
lastSetTimerValue = timeUs;
isTimerPending = TRUE;
timerRestartCounter++;
}
/**
* This method would blink all the LEDs just to test them
*/
static void initialLedsBlink(void) {
if (hasFirmwareError()) {
// make sure we do not turn the fatal LED off if already have
// fatal error by now
return;
}
int size = sizeof(leds) / sizeof(leds[0]);
for (int i = 0; i < size && !hasFirmwareError(); i++)
leds[i]->setValue(1);
chThdSleepMilliseconds(100);
// re-checking in case the error has happened while we were sleeping
for (int i = 0; i < size && !hasFirmwareError(); i++)
leds[i]->setValue(0);
}
void updateHD44780lcd(void) {
lcd_HD44780_set_position(0, 9);
/**
* this would blink so that we know the LCD is alive
*/
if (getTimeNowSeconds() % 2 == 0) {
lcd_HD44780_print_char('R');
} else {
lcd_HD44780_print_char(' ');
}
lcd_HD44780_set_position(0, 10);
char * ptr = itoa10(buffer, getRpm());
ptr[0] = 0;
int len = ptr - buffer;
for (int i = 0; i < 6 - len; i++) {
lcd_HD44780_print_char(' ');
}
lcd_HD44780_print_string(buffer);
if (hasFirmwareError()) {
memcpy(buffer, getFirmwareError(), LCD_WIDTH);
buffer[LCD_WIDTH] = 0;
lcd_HD44780_set_position(1, 0);
lcd_HD44780_print_string(buffer);
return;
}
lcd_HD44780_set_position(1, 0);
memset(buffer, ' ', LCD_WIDTH);
memcpy(buffer, getWarninig(), LCD_WIDTH);
buffer[LCD_WIDTH] = 0;
lcd_HD44780_print_string(buffer);
if (engineConfiguration->HD44780height < 3) {
return;
}
int index = (getTimeNowSeconds() / 2) % (NUMBER_OF_DIFFERENT_LINES / 2);
prepareCurrentSecondLine(index);
buffer[LCD_WIDTH] = 0;
lcd_HD44780_set_position(2, 0);
lcd_HD44780_print_string(buffer);
prepareCurrentSecondLine(index + NUMBER_OF_DIFFERENT_LINES / 2);
buffer[LCD_WIDTH] = 0;
lcd_HD44780_set_position(3, 0);
lcd_HD44780_print_string(buffer);
#if EFI_PROD_CODE
dateToString(dateBuffer);
lcd_HD44780_set_position(1, 0);
lcd_HD44780_print_string(dateBuffer);
#endif /* EFI_PROD_CODE */
}
void initEngineEmulator(board_configuration_s *boardConfiguration) {
if (hasFirmwareError())
return;
#if EFI_POTENTIOMETER
initPotentiometers(boardConfiguration);
#endif /* EFI_POTENTIOMETER */
//initECUstimulator();
initTriggerEmulator();
}
/**
* @brief Sends all pending data to dev console
*/
void updateDevConsoleState(Engine *engine) {
if (!isConsoleReady()) {
return;
}
// looks like this is not needed anymore
// checkIfShouldHalt();
printPending();
/**
* this should go before the firmware error so that console can detect connection
*/
printSensors(&logger, false);
#if EFI_PROD_CODE || defined(__DOXYGEN__)
// todo: unify with simulator!
if (hasFirmwareError()) {
scheduleMsg(&logger, "FATAL error: %s", errorMessageBuffer);
warningEnabled = false;
scheduleLogging(&logger);
return;
}
#endif
#if (EFI_PROD_CODE && HAL_USE_ADC) || defined(__DOXYGEN__)
pokeAdcInputs();
#endif
if (!fullLog) {
return;
}
systime_t nowSeconds = getTimeNowSeconds();
printInfo(nowSeconds);
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
int currentCkpEventCounter = getCrankEventCounter();
if (prevCkpEventCounter == currentCkpEventCounter && timeOfPreviousReport == nowSeconds) {
return;
}
timeOfPreviousReport = nowSeconds;
prevCkpEventCounter = currentCkpEventCounter;
#else
chThdSleepMilliseconds(200);
#endif
printState();
#if EFI_WAVE_ANALYZER
printWave(&logger);
#endif
scheduleLogging(&logger);
}
void initEngineEmulator(Logging *sharedLogger, Engine *engine) {
if (hasFirmwareError())
return;
#if EFI_POTENTIOMETER
initPotentiometers(sharedLogger, &engine->engineConfiguration->bc);
#endif /* EFI_POTENTIOMETER */
//initECUstimulator();
initTriggerEmulator(sharedLogger, engine);
}
void EventQueue::insertTask(scheduling_s *scheduling, uint64_t nowUs, int delayUs, schfunc_t callback, void *param) {
if (callback == NULL)
firmwareError("NULL callback");
uint64_t time = nowUs + delayUs;
int alreadyPending = checkIfPending(scheduling);
if (alreadyPending || hasFirmwareError())
return;
scheduling->momentUs = time;
scheduling->callback = callback;
scheduling->param = param;
LL_PREPEND(head, scheduling);
}
void initWaveAnalyzer(Logging *sharedLogger) {
logger = sharedLogger;
if (hasFirmwareError()) {
return;
}
#if EFI_WAVE_ANALYZER
initWave(WA_CHANNEL_1, 0);
initWave(WA_CHANNEL_2, 1);
addTriggerEventListener(waTriggerEventListener, "wave analyzer", engine);
addConsoleAction("waveinfo", showWaveInfo);
addConsoleActionII("set_logic_input_mode", setWaveModeSilent);
chThdCreateStatic(waThreadStack, sizeof(waThreadStack), NORMALPRIO, (tfunc_t)waThread, NULL);
#else
print("wave disabled\r\n");
#endif
}
void initHardware(Logging *logger, Engine *engine) {
engine_configuration_s *engineConfiguration = engine->engineConfiguration;
efiAssertVoid(engineConfiguration!=NULL, "engineConfiguration");
board_configuration_s *boardConfiguration = &engineConfiguration->bc;
printMsg(logger, "initHardware()");
// todo: enable protection. it's disabled because it takes
// 10 extra seconds to re-flash the chip
//flashProtect();
chMtxInit(&spiMtx);
#if EFI_HISTOGRAMS
/**
* histograms is a data structure for CPU monitor, it does not depend on configuration
*/
initHistogramsModule();
#endif /* EFI_HISTOGRAMS */
/**
* This is so early because we want to init logger
* which would be used while finding trigger synch index
* while config read
*/
initTriggerDecoder();
/**
* We need the LED_ERROR pin even before we read configuration
*/
initPrimaryPins();
if (hasFirmwareError()) {
return;
}
initDataStructures(PASS_ENGINE_PARAMETER_F);
#if EFI_INTERNAL_FLASH
palSetPadMode(CONFIG_RESET_SWITCH_PORT, CONFIG_RESET_SWITCH_PIN, PAL_MODE_INPUT_PULLUP);
initFlash(engine);
/**
* this call reads configuration from flash memory or sets default configuration
* if flash state does not look right.
*/
if (SHOULD_INGORE_FLASH()) {
engineConfiguration->engineType = FORD_ASPIRE_1996;
resetConfigurationExt(logger, engineConfiguration->engineType, engine);
writeToFlash();
} else {
readFromFlash();
}
#else
engineConfiguration->engineType = FORD_ASPIRE_1996;
resetConfigurationExt(logger, engineConfiguration->engineType, engineConfiguration, engineConfiguration2, boardConfiguration);
#endif /* EFI_INTERNAL_FLASH */
if (hasFirmwareError()) {
return;
}
mySetPadMode2("board test", boardConfiguration->boardTestModeJumperPin, PAL_MODE_INPUT_PULLUP);
bool isBoardTestMode_b = GET_BOARD_TEST_MODE_VALUE();
initAdcInputs(isBoardTestMode_b);
if (isBoardTestMode_b) {
// this method never returns
initBoardTest();
}
initRtc();
initOutputPins();
#if EFI_HIP_9011
initHip9011();
#endif /* EFI_HIP_9011 */
#if EFI_MAX_31855
initMax31855(boardConfiguration);
#endif /* EFI_MAX_31855 */
#if EFI_CAN_SUPPORT
initCan();
#endif /* EFI_CAN_SUPPORT */
// init_adc_mcp3208(&adcState, &SPID2);
// requestAdcValue(&adcState, 0);
// todo: figure out better startup logic
initTriggerCentral(engine);
#if EFI_SHAFT_POSITION_INPUT
initShaftPositionInputCapture();
#endif /* EFI_SHAFT_POSITION_INPUT */
initSpiModules(boardConfiguration);
#if EFI_FILE_LOGGING
initMmcCard();
#endif /* EFI_FILE_LOGGING */
// initFixedLeds();
// initBooleanInputs();
#if EFI_UART_GPS
initGps();
#endif
#if ADC_SNIFFER
initAdcDriver();
#endif
#if EFI_HD44780_LCD
// initI2Cmodule();
lcd_HD44780_init();
if (hasFirmwareError())
return;
lcd_HD44780_print_string(VCS_VERSION);
#endif /* EFI_HD44780_LCD */
addConsoleActionII("i2c", sendI2Cbyte);
// while (true) {
// for (int addr = 0x20; addr < 0x28; addr++) {
// sendI2Cbyte(addr, 0);
// int err = i2cGetErrors(&I2CD1);
// print("I2C: err=%x from %d\r\n", err, addr);
// chThdSleepMilliseconds(5);
// sendI2Cbyte(addr, 255);
// chThdSleepMilliseconds(5);
// }
// }
printMsg(logger, "initHardware() OK!");
}
void initHardware(Logging *l) {
efiAssertVoid(CUSTOM_IH_STACK, getRemainingStack(chThdGetSelfX()) > 256, "init h");
sharedLogger = l;
engine_configuration_s *engineConfiguration = engine->engineConfigurationPtr;
efiAssertVoid(CUSTOM_EC_NULL, engineConfiguration!=NULL, "engineConfiguration");
board_configuration_s *boardConfiguration = &engineConfiguration->bc;
printMsg(sharedLogger, "initHardware()");
// todo: enable protection. it's disabled because it takes
// 10 extra seconds to re-flash the chip
//flashProtect();
chMtxObjectInit(&spiMtx);
#if EFI_HISTOGRAMS
/**
* histograms is a data structure for CPU monitor, it does not depend on configuration
*/
initHistogramsModule();
#endif /* EFI_HISTOGRAMS */
/**
* We need the LED_ERROR pin even before we read configuration
*/
initPrimaryPins();
if (hasFirmwareError()) {
return;
}
#if EFI_INTERNAL_FLASH
palSetPadMode(CONFIG_RESET_SWITCH_PORT, CONFIG_RESET_SWITCH_PIN, PAL_MODE_INPUT_PULLUP);
initFlash(sharedLogger);
/**
* this call reads configuration from flash memory or sets default configuration
* if flash state does not look right.
*/
if (SHOULD_INGORE_FLASH()) {
engineConfiguration->engineType = DEFAULT_ENGINE_TYPE;
resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
writeToFlashNow();
} else {
readFromFlash();
}
#else
engineConfiguration->engineType = DEFAULT_ENGINE_TYPE;
resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
#endif /* EFI_INTERNAL_FLASH */
#if EFI_HD44780_LCD
// initI2Cmodule();
lcd_HD44780_init(sharedLogger);
if (hasFirmwareError())
return;
lcd_HD44780_print_string(VCS_VERSION);
#endif /* EFI_HD44780_LCD */
if (hasFirmwareError()) {
return;
}
#if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__)
initTriggerDecoder();
#endif
bool isBoardTestMode_b;
if (CONFIGB(boardTestModeJumperPin) != GPIO_UNASSIGNED) {
efiSetPadMode("board test", CONFIGB(boardTestModeJumperPin),
PAL_MODE_INPUT_PULLUP);
isBoardTestMode_b = (!efiReadPin(CONFIGB(boardTestModeJumperPin)));
// we can now relese this pin, it is actually used as output sometimes
unmarkPin(CONFIGB(boardTestModeJumperPin));
} else {
isBoardTestMode_b = false;
}
#if HAL_USE_ADC || defined(__DOXYGEN__)
initAdcInputs(isBoardTestMode_b);
#endif
if (isBoardTestMode_b) {
// this method never returns
initBoardTest();
}
initRtc();
initOutputPins();
#if EFI_MAX_31855
initMax31855(sharedLogger, getSpiDevice(CONFIGB(max31855spiDevice)), CONFIGB(max31855_cs));
#endif /* EFI_MAX_31855 */
#if EFI_CAN_SUPPORT
initCan();
#endif /* EFI_CAN_SUPPORT */
// init_adc_mcp3208(&adcState, &SPID2);
// requestAdcValue(&adcState, 0);
#if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__)
// todo: figure out better startup logic
initTriggerCentral(sharedLogger);
#endif /* EFI_SHAFT_POSITION_INPUT */
turnOnHardware(sharedLogger);
#if HAL_USE_SPI || defined(__DOXYGEN__)
initSpiModules(boardConfiguration);
#endif
#if EFI_HIP_9011 || defined(__DOXYGEN__)
initHip9011(sharedLogger);
#endif /* EFI_HIP_9011 */
#if EFI_FILE_LOGGING || defined(__DOXYGEN__)
initMmcCard();
#endif /* EFI_FILE_LOGGING */
#if EFI_MEMS || defined(__DOXYGEN__)
initAccelerometer(PASS_ENGINE_PARAMETER_SIGNATURE);
#endif
// initFixedLeds();
#if EFI_BOSCH_YAW || defined(__DOXYGEN__)
initBoschYawRateSensor();
#endif /* EFI_BOSCH_YAW */
// initBooleanInputs();
#if EFI_UART_GPS || defined(__DOXYGEN__)
initGps();
#endif
#if EFI_SERVO
initServo();
#endif
#if ADC_SNIFFER || defined(__DOXYGEN__)
initAdcDriver();
#endif
#if HAL_USE_I2C || defined(__DOXYGEN__)
addConsoleActionII("i2c", sendI2Cbyte);
#endif
// USBMassStorageDriver UMSD1;
// while (true) {
// for (int addr = 0x20; addr < 0x28; addr++) {
// sendI2Cbyte(addr, 0);
// int err = i2cGetErrors(&I2CD1);
// print("I2C: err=%x from %d\r\n", err, addr);
// chThdSleepMilliseconds(5);
// sendI2Cbyte(addr, 255);
// chThdSleepMilliseconds(5);
// }
// }
#if EFI_VEHICLE_SPEED || defined(__DOXYGEN__)
initVehicleSpeed(sharedLogger);
#endif
#if EFI_CDM_INTEGRATION
cdmIonInit();
#endif
#if HAL_USE_EXT || defined(__DOXYGEN__)
initJoystick(sharedLogger);
#endif
calcFastAdcIndexes();
printMsg(sharedLogger, "initHardware() OK!");
}
