void printTsStats(void) { #if EFI_PROD_CODE if (!isSerialOverUart()) { scheduleMsg(&tsLogger, "TS RX on %s%d/TX on %s%d @%d", portname(TS_SERIAL_RX_PORT), TS_SERIAL_RX_PIN, portname(TS_SERIAL_TX_PORT), TS_SERIAL_TX_PIN, boardConfiguration->tunerStudioSerialSpeed); } #endif /* EFI_PROD_CODE */ scheduleMsg(&tsLogger, "TunerStudio size=%d / total=%d / errors=%d / H=%d / O=%d / P=%d / B=%d", sizeof(tsOutputChannels), tsState.tsCounter, tsState.errorCounter, tsState.queryCommandCounter, tsState.outputChannelsCommandCounter, tsState.readPageCommandsCounter, tsState.burnCommandCounter); scheduleMsg(&tsLogger, "TunerStudio W=%d / C=%d / P=%d / page=%d", tsState.writeValueCommandCounter, tsState.writeChunkCommandCounter, tsState.pageCommandCounter, currentPageId); scheduleMsg(&tsLogger, "page size=%d", getTunerStudioPageSize(currentPageId)); // scheduleMsg(logger, "analogChartFrequency %d", // (int) (&engineConfiguration->analogChartFrequency) - (int) engineConfiguration); // // int fuelMapOffset = (int) (&engineConfiguration->fuelTable) - (int) engineConfiguration; // scheduleMsg(logger, "fuelTable %d", fuelMapOffset); // // int offset = (int) (&boardConfiguration->hip9011Gain) - (int) engineConfiguration; // scheduleMsg(&tsLogger, "hip9011Gain %d", offset); // // offset = (int) (&engineConfiguration->crankingCycleBins) - (int) engineConfiguration; // scheduleMsg(&tsLogger, "crankingCycleBins %d", offset); // // offset = (int) (&engineConfiguration->engineCycle) - (int) engineConfiguration; // scheduleMsg(&tsLogger, "engineCycle %d", offset); }
static void printStats(void) { #if EFI_PROD_CODE if (!isSerialOverUart()) { scheduleMsg(&logger, "TS RX on %s%d/TX on %s%d", portname(TS_SERIAL_RX_PORT), TS_SERIAL_RX_PIN, portname(TS_SERIAL_TX_PORT), TS_SERIAL_TX_PIN); } #endif /* EFI_PROD_CODE */ scheduleMsg(&logger, "TunerStudio total/error counter=%d/%d H=%d / O counter=%d size=%d / P=%d / B=%d", tsCounter, tsState.errorCounter, tsState.queryCommandCounter, tsState.outputChannelsCommandCounter, sizeof(tsOutputChannels), tsState.readPageCommandsCounter, tsState.burnCommandCounter); scheduleMsg(&logger, "TunerStudio W counter=%d / C = %d / P = %d / current page %d", tsState.writeValueCommandCounter, tsState.writeChunkCommandCounter, tsState.pageCommandCounter, tsState.currentPageId); scheduleMsg(&logger, "page size=%d", sizeof(engine_configuration_s)); // scheduleMsg(&logger, "analogChartFrequency %d", // (int) (&engineConfiguration->analogChartFrequency) - (int) engineConfiguration); // // int fuelMapOffset = (int) (&engineConfiguration->fuelTable) - (int) engineConfiguration; // scheduleMsg(&logger, "fuelTable %d", fuelMapOffset); // // int offset = (int) (&boardConfiguration->o2heaterPin) - (int) engineConfiguration; // scheduleMsg(&logger, "o2heaterPin %d", offset); // // offset = (int) (&boardConfiguration->idleSolenoidFrequency) - (int) engineConfiguration; // scheduleMsg(&logger, "idleSolenoidFrequency %d", offset); }
void startTunerStudioConnectivity(void) { initLogging(&logger, "tuner studio"); if (sizeof(engine_configuration_s) != getTunerStudioPageSize(0)) firmwareError("TS page size mismatch: %d/%d", sizeof(engine_configuration_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)); #if EFI_PROD_CODE if (isSerialOverUart()) { print("TunerStudio over USB serial"); usb_serial_start(); } else { print("TunerStudio over USART"); mySetPadMode("tunerstudio rx", TS_SERIAL_RX_PORT, TS_SERIAL_RX_PIN, PAL_MODE_ALTERNATE(TS_SERIAL_AF)); mySetPadMode("tunerstudio tx", TS_SERIAL_TX_PORT, TS_SERIAL_TX_PIN, PAL_MODE_ALTERNATE(TS_SERIAL_AF)); sdStart(TS_SERIAL_UART_DEVICE, &tsSerialConfig); } #endif /* EFI_PROD_CODE */ syncTunerStudioCopy(); addConsoleAction("tsinfo", printStats); chThdCreateStatic(TS_WORKING_AREA, sizeof(TS_WORKING_AREA), NORMALPRIO, tsThreadEntryPoint, NULL); }
void startConsole(Logging *sharedLogger, CommandHandler console_line_callback_p) { logger = sharedLogger; console_line_callback = console_line_callback_p; #if (defined(EFI_CONSOLE_UART_DEVICE) && ! EFI_SIMULATOR) || defined(__DOXYGEN__) palSetPadMode(CONSOLE_MODE_SWITCH_PORT, CONSOLE_MODE_SWITCH_PIN, PAL_MODE_INPUT_PULLUP); is_serial_over_uart = GET_CONSOLE_MODE_VALUE() == EFI_USE_UART_FOR_CONSOLE; if (isSerialOverUart()) { /* * Activates the serial using the driver default configuration (that's 38400) * it is important to set 'NONE' as flow control! in terminal application on the PC */ sdStart(EFI_CONSOLE_UART_DEVICE, &serialConfig); // cannot use pin repository here because pin repository prints to console palSetPadMode(EFI_CONSOLE_RX_PORT, EFI_CONSOLE_RX_PIN, PAL_MODE_ALTERNATE(EFI_CONSOLE_AF)); palSetPadMode(EFI_CONSOLE_TX_PORT, EFI_CONSOLE_TX_PIN, PAL_MODE_ALTERNATE(EFI_CONSOLE_AF)); isSerialConsoleStarted = true; chEvtRegisterMask((EventSource *) chnGetEventSource(EFI_CONSOLE_UART_DEVICE), &consoleEventListener, 1); } #else is_serial_over_uart = false; #endif /* EFI_PROD_CODE */ chThdCreateStatic(consoleThreadStack, sizeof(consoleThreadStack), NORMALPRIO, consoleThreadThreadEntryPoint, NULL); addConsoleAction(SWITCH_TO_BINARY_COMMAND, switchToBinaryProtocol); }
bool isConsoleReady(void) { if (isSerialOverUart()) { return isSerialConsoleStarted; } else { return is_usb_serial_ready(); } }
BaseChannel * getTsSerialDevice(void) { #if EFI_PROD_CODE || defined(__DOXYGEN__) if (isSerialOverUart()) { // if console uses UART then TS uses USB return (BaseChannel *) &SDU1; } else { return (BaseChannel *) TS_SERIAL_UART_DEVICE; } #else return (BaseChannel *) TS_SIMULATOR_PORT; #endif }
static int ts_serial_ready(bool_t isConsoleRedirect) { #if EFI_PROD_CODE if (isSerialOverUart() ^ isConsoleRedirect) { // TS uses USB when console uses serial return is_usb_serial_ready(); } else { // TS uses serial when console uses USB return true; } #else return true; #endif }
static int ts_serail_ready(void) { #if EFI_PROD_CODE if (isSerialOverUart()) { // TS uses USB when console uses serial return is_usb_serial_ready(); } else { // TS uses serial when console uses USB return TRUE; } #else return TRUE; #endif }
SerialDriver * getConsoleChannel(void) { #if defined(EFI_CONSOLE_UART_DEVICE) || defined(__DOXYGEN__) if (isSerialOverUart()) { return (SerialDriver *) EFI_CONSOLE_UART_DEVICE; } #endif /* EFI_CONSOLE_UART_DEVICE */ #if HAL_USE_SERIAL_USB || defined(__DOXYGEN__) return (SerialDriver *) &SDU1; #else return NULL; #endif }
static msg_t consoleThreadThreadEntryPoint(void *arg) { (void) arg; chRegSetThreadName("console thread"); #if (EFI_PROD_CODE && EFI_USB_SERIAL) || defined(__DOXYGEN__) if (!isSerialOverUart()) { /** * This method contains a long delay, that's the reason why this is not done on the main thread */ usb_serial_start(); } #endif /* EFI_PROD_CODE */ binaryConsole.channel = (BaseChannel *) getConsoleChannel(); while (true) { efiAssert(getRemainingStack(chThdSelf()) > 256, "lowstck#9e", 0); bool end = getConsoleLine((BaseSequentialStream*) getConsoleChannel(), consoleInput, sizeof(consoleInput)); if (end) { // firmware simulator is the only case when this happens continue; } char *trimmed = efiTrim(consoleInput); (console_line_callback)(trimmed); if (consoleInBinaryMode) { #if EFI_SIMULATOR || defined(__DOXYGEN__) logMsg("Switching to binary mode\r\n"); #endif // switch to binary protocol runBinaryProtocolLoop(&binaryConsole, true); } } #if defined __GNUC__ return false; #endif }
void startTsPort(void) { #if EFI_USB_SERIAL || defined(__DOXYGEN__) if (isSerialOverUart()) { print("TunerStudio over USB serial"); /** * This method contains a long delay, that's the reason why this is not done on the main thread */ usb_serial_start(); } else #endif { if (boardConfiguration->useSerialPort) { print("TunerStudio over USART"); mySetPadMode2("tunerstudio rx", engineConfiguration->binarySerialRxPin, PAL_MODE_ALTERNATE(TS_SERIAL_AF)); mySetPadMode2("tunerstudio tx", engineConfiguration->binarySerialTxPin, PAL_MODE_ALTERNATE(TS_SERIAL_AF)); tsSerialConfig.speed = boardConfiguration->tunerStudioSerialSpeed; sdStart(TS_SERIAL_UART_DEVICE, &tsSerialConfig); } } }
/** * @brief Reads a whole line from the input channel. * * @param[in] chp pointer to a @p BaseChannel object * @param[in] line pointer to the line buffer * @param[in] size buffer maximum length * @return The operation status. * @retval TRUE the channel was reset or CTRL-D pressed. * @retval FALSE operation successful. */ static bool getConsoleLine(BaseSequentialStream *chp, char *line, unsigned size) { char *p = line; while (true) { if (!isConsoleReady()) { // we better do not read from USB serial before it is ready chThdSleepMilliseconds(10); continue; } short c = (short) chSequentialStreamGet(chp); if (isSerialOverUart()) { uint32_t flags; chSysLock() ; flags = chEvtGetAndClearFlagsI(&consoleEventListener); chSysUnlock() ; if (flags & SD_OVERRUN_ERROR) { // firmwareError("serial overrun"); } } #if EFI_UART_ECHO_TEST_MODE /** * That's test code - let's test connectivity */ consolePutChar((uint8_t) c); continue; #endif if (c < 0 || c == 4) { return true; } if (c == 8) { if (p != line) { // backspace consolePutChar((uint8_t) c); consolePutChar(0x20); consolePutChar((uint8_t) c); p--; } continue; } if (c == '\r') { consolePutChar('\r'); consolePutChar('\n'); *p = 0; return false; } if (c == '\n') { consolePutChar('\n'); *p = 0; return false; } if (c < 0x20) { continue; } if (p < line + size - 1) { consolePutChar((uint8_t) c); *p++ = (char) c; } } }