/*------------------------------------------------------------------------* * Simulator main. * *------------------------------------------------------------------------*/ int main(void) { event_listener_t tel; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Serial ports (simulated) initialization. */ sdStart(&SD1, NULL); sdStart(&SD2, NULL); /* * Shell manager initialization. */ shellInit(); chEvtRegister(&shell_terminated, &tel, 0); /* * Console thread started. */ cdtp = chThdCreateFromHeap(NULL, CONSOLE_WA_SIZE, NORMALPRIO + 1, console_thread, NULL); /* * Initializing connection/disconnection events. */ cputs("Shell service started on SD1, SD2"); cputs(" - Listening for connections on SD1"); chEvtRegister(chnGetEventSource(&SD1), &sd1fel, 1); cputs(" - Listening for connections on SD2"); chEvtRegister(chnGetEventSource(&SD2), &sd2fel, 2); /* * Events servicing loop. */ while (!chThdShouldTerminateX()) chEvtDispatch(fhandlers, chEvtWaitOne(ALL_EVENTS)); /* * Clean simulator exit. */ chEvtUnregister(chnGetEventSource(&SD1), &sd1fel); chEvtUnregister(chnGetEventSource(&SD2), &sd2fel); return 0; }
static THD_FUNCTION(thSerEcho, arg) { (void)arg; chRegSetThreadName("SerEcho"); event_listener_t elSerData; eventflags_t flags; chEvtRegisterMask((event_source_t *)chnGetEventSource(&SD1), &elSerData, EVENT_MASK(1)); while (!chThdShouldTerminateX()) { chEvtWaitOneTimeout(EVENT_MASK(1), MS2ST(10)); flags = chEvtGetAndClearFlags(&elSerData); if (flags & CHN_INPUT_AVAILABLE) { msg_t charbuf; do { charbuf = chnGetTimeout(&SD1, TIME_IMMEDIATE); if ( charbuf != Q_TIMEOUT ) { chSequentialStreamPut(&SD1, charbuf); } } while (charbuf != Q_TIMEOUT); } } }
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); b_isCommandLineConsoleOverTTL = GET_CONSOLE_MODE_VALUE() == EFI_USE_UART_FOR_CONSOLE; if (isCommandLineConsoleOverTTL()) { /* * Activates the serial * it is important to set 'NONE' as flow control! in terminal application on the PC */ serialConfig.speed = engineConfiguration->uartConsoleSerialSpeed; 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((event_source_t *) chnGetEventSource(EFI_CONSOLE_UART_DEVICE), &consoleEventListener, 1); } #else b_isCommandLineConsoleOverTTL = false; #endif /* EFI_PROD_CODE */ chThdCreateStatic(consoleThreadStack, sizeof(consoleThreadStack), NORMALPRIO, (tfunc_t)consoleThreadThreadEntryPoint, NULL); addConsoleAction(SWITCH_TO_BINARY_COMMAND, switchToBinaryProtocol); }
CCM_FUNC static THD_FUNCTION(ThreadBDU, arg) { event_listener_t el1; eventmask_t flags; (void)arg; chRegSetThreadName("BDU"); chEvtRegisterMask(chnGetEventSource(&SDU2), &el1, ALL_EVENTS); while(USBD1.state != USB_READY) chThdSleepMilliseconds(10); while(SDU2.state != SDU_READY) chThdSleepMilliseconds(10); while (TRUE) { chEvtWaitAnyTimeout(ALL_EVENTS, TIME_IMMEDIATE); flags = chEvtGetAndClearFlags(&el1); pwmEnableChannel(&PWMD_LED2, CHN_LED2, PWM_PERCENTAGE_TO_WIDTH(&PWMD_LED2, 8000)); if (flags & CHN_INPUT_AVAILABLE) { pwmEnableChannel(&PWMD_LED2, CHN_LED2, PWM_PERCENTAGE_TO_WIDTH(&PWMD_LED2, 1000)); readCommand((BaseChannel *)&SDU2); } else chThdSleepMilliseconds(2); } return; }
static void cmd_gps_passthrough(BaseSequentialStream *chp, int argc, char *argv[]) { (void)argc; (void)argv; static const SerialConfig sc = { 9600, 0, USART_CR2_STOP1_BITS | USART_CR2_LINEN, 0}; sdStart(&SD1, &sc); EventListener elSerData; flagsmask_t flags; chEvtRegisterMask(chnGetEventSource(&SD1), &elSerData, EVENT_MASK(1)); while (TRUE) { chEvtWaitOneTimeout(EVENT_MASK(1), MS2ST(10)); flags = chEvtGetAndClearFlags(&elSerData); if (flags & CHN_INPUT_AVAILABLE) { msg_t charbuf; do { charbuf = chnGetTimeout(&SD1, TIME_IMMEDIATE); if ( charbuf != Q_TIMEOUT ) { chSequentialStreamPut(chp, charbuf); } } while (charbuf != Q_TIMEOUT); } } }
static THD_FUNCTION(uart_thread, arg) { (void)arg; chRegSetThreadName("UART thread"); // KPA. event_listener_t kpa_event_listener; chEvtRegisterMaskWithFlags((event_source_t*)chnGetEventSource(&SD1), &kpa_event_listener, EVENT_MASK(1), CHN_INPUT_AVAILABLE); struct writer kpa_writer; writer_init(&kpa_writer, &SD1, uart_write); // FBV. event_listener_t fbv_event_listener; chEvtRegisterMaskWithFlags((event_source_t*)chnGetEventSource(&SD6), &fbv_event_listener, EVENT_MASK(2), CHN_INPUT_AVAILABLE); struct writer fbv_writer; writer_init(&fbv_writer, &SD6, uart_write); // Bridge- struct bridge bridge; bridge_init(&bridge, &kpa_writer, &fbv_writer); uint8_t byte = 0; while (true) { eventflags_t evt = chEvtWaitAnyTimeout(EVENT_MASK(1) | EVENT_MASK(2), MS2ST(1)); if (evt & EVENT_MASK(1)) { chEvtGetAndClearFlags(&kpa_event_listener); while (readByte(&SD1, &byte)) bridge_update_kpa(&bridge, byte); } if (evt & EVENT_MASK(2)) { chEvtGetAndClearFlags(&fbv_event_listener); while (readByte(&SD6, &byte)) bridge_update_fbv(&bridge, byte); } bridge_update_time(&bridge, clock_get_ms()); } }
static THD_FUNCTION(serialThread, arg) { (void)arg; event_listener_t new_data_listener; event_listener_t sd1_listener; event_listener_t sd2_listener; chEvtRegister(&new_data_event, &new_data_listener, 0); eventflags_t events = CHN_INPUT_AVAILABLE | SD_PARITY_ERROR | SD_FRAMING_ERROR | SD_OVERRUN_ERROR | SD_NOISE_ERROR | SD_BREAK_DETECTED; chEvtRegisterMaskWithFlags(chnGetEventSource(&SD1), &sd1_listener, EVENT_MASK(1), events); chEvtRegisterMaskWithFlags(chnGetEventSource(&SD2), &sd2_listener, EVENT_MASK(2), events); bool need_wait = false; while(true) { eventflags_t flags1 = 0; eventflags_t flags2 = 0; if (need_wait) { eventmask_t mask = chEvtWaitAnyTimeout(ALL_EVENTS, MS2ST(1000)); if (mask & EVENT_MASK(1)) { flags1 = chEvtGetAndClearFlags(&sd1_listener); print_error("DOWNLINK", flags1, &SD1); } if (mask & EVENT_MASK(2)) { flags2 = chEvtGetAndClearFlags(&sd2_listener); print_error("UPLINK", flags2, &SD2); } } // Always stay as master, even if the USB goes into sleep mode is_master |= usbGetDriverStateI(&USBD1) == USB_ACTIVE; router_set_master(is_master); need_wait = true; need_wait &= read_from_serial(&SD2, UP_LINK) == 0; need_wait &= read_from_serial(&SD1, DOWN_LINK) == 0; update_transport(); } }
static THD_FUNCTION( esp8266, arg ) { (void)arg; chRegSetThreadName( "esp8266" ); event_listener_t serialListener; /* Registering on the serial driver 6 as event 1, interested in * error flags and data-available only, other flags will not wakeup * the thread. */ chEvtRegisterMaskWithFlags( (struct event_source_t *)chnGetEventSource( &SD6 ), &serialListener, EVENT_MASK( 1 ), SD_FRAMING_ERROR | SD_PARITY_ERROR | CHN_INPUT_AVAILABLE ); while( true ) { // Waiting for any of the events we're registered on. eventmask_t evt = chEvtWaitAny( ALL_EVENTS ); // Serving events. if( evt & EVENT_MASK(1) ) { /* Event from the serial interface, getting serial * flags as first thing. */ eventflags_t flags = chEvtGetAndClearFlags( &serialListener ); //Handling errors first. if( flags & (SD_FRAMING_ERROR | SD_PARITY_ERROR) ) { DPRINT( 4, KRED "FRAMING/PARITY ERROR" ); } if( flags & CHN_INPUT_AVAILABLE ) { char c; c = sdGet( &SD6 ); sdPut( &SD3, c ); } } } }