/*! \brief sdlog thread. * * Test logging to microSD card on e407. * */ msg_t sdlog_thread(void *p) { void * arg __attribute__ ((unused)) = p; static const evhandler_t evhndl_sdclog[] = { sdc_log_data, sdc_log_data, sdc_log_data, sdc_log_data, sdc_log_data }; struct EventListener el0, el1, el2, el3, el4; chRegSetThreadName("sdlog_thread"); #ifdef DEBUG_SDCLOG /*chThdSleepMilliseconds(1000);*/ #endif SDCLOGDBG("Start sdlog thread\r\n"); // init structure datafile_state.log_sequence = 0; datafile_state.write_errors = 0; datafile_state.sd_log_opened = false; sdc_reset_fp_index(); sdc_init_eod((uint8_t)0xa5); // Assert data is halfword aligned if(((sizeof(GENERIC_message)*8) % 16) != 0) { SDCLOGDBG("%s: GENERIC message is not halfword aligned.\r\n", __func__); return (SDC_ASSERT_ERROR); } // Assert we will not overflow Payload if( (sizeof(MPU9150_read_data) > (sizeof(datafile_state.log_data.data)-1)) || (sizeof(MPL3115A2_read_data) > (sizeof(datafile_state.log_data.data)-1)) || (sizeof(ADIS16405_burst_data) > (sizeof(datafile_state.log_data.data)-1))) { SDCLOGDBG("%s: DATA size is too large\r\n"); return (SDC_ASSERT_ERROR); } chEvtRegister(&mpl3115a2_data_event , &el0, MPL3115A2); chEvtRegister(&adis_spi_burst_data_captured, &el1, ADIS16405); chEvtRegister(&mpu9150_data_event , &el2, MPU9150); chEvtRegister(&sdc_halt_event , &el3, SENSOR_LOG_HALT); chEvtRegister(&sdc_start_event , &el4, SENSOR_LOG_START); while(1) { if(!fs_stop) { chEvtDispatch(evhndl_sdclog, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(50))); } else { chEvtDispatch(evhndl_sdclog, chEvtWaitOneTimeout((1<<SENSOR_LOG_START), MS2ST(50))); } } return -1; }
int main(void) { halInit(); chSysInit(); static const evhandler_t evhndl[] = { }; // CDC. sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); chThdSleepMilliseconds(4000); uart_init(); chThdCreateStatic(uart_thread_wa, sizeof(uart_thread_wa), NORMALPRIO, uart_thread, NULL); while (true) { palTogglePad(GPIOC, GPIOC_LED); chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(100))); } }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler }; Thread *shelltp = NULL; struct EventListener el0, el1; /* * 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(); /* * Activates the serial driver 2 using the driver default configuration. */ sdStart(&SD2, NULL); /* * Shell manager initialization. */ shellInit(); /* * Initializes the MMC driver to work with SPI2. */ palSetPadMode(IOPORT2, GPIOB_SPI2NSS, PAL_MODE_OUTPUT_PUSHPULL); palSetPad(IOPORT2, GPIOB_SPI2NSS); mmcObjectInit(&MMCD1, &SPID2, &ls_spicfg, &hs_spicfg, mmc_is_protected, mmc_is_inserted); mmcStart(&MMCD1, NULL); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&MMCD1.inserted_event, &el0, 0); chEvtRegister(&MMCD1.removed_event, &el1, 1); while (TRUE) { if (!shelltp) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminated(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS)); } return 0; }
int main(void) { halInit(); chSysInit(); uint8_t i; event_listener_t tel; // Serial Port Setup sdStart(&SD1, NULL); palSetPadMode(GPIOC, 4, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOC, 5, PAL_MODE_ALTERNATE(7)); chprintf((BaseSequentialStream*)&SD1, "Up and Running\n\r"); palSetPadMode(GPIOB, 3, PAL_MODE_ALTERNATE(6)); /* SCK. */ palSetPadMode(GPIOB, 4, PAL_MODE_ALTERNATE(6)); /* MISO.*/ palSetPadMode(GPIOB, 5, PAL_MODE_ALTERNATE(6)); /* MOSI.*/ palSetPadMode(GPIOC, GPIOC_PIN1, PAL_MODE_OUTPUT_PUSHPULL); palSetPad(GPIOC, GPIOC_PIN1); palSetPadMode(GPIOC, GPIOC_PIN2, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(GPIOC, GPIOC_PIN2); palSetPadMode(GPIOC, GPIOC_PIN3, PAL_MODE_INPUT_PULLUP); spiStart(&SPID3, &nrf24l01SPI); chMtxObjectInit(&nrfMutex); //FROM RX--- extStart(&EXTD1, &extcfg); //--- nrf24l01ObjectInit(&nrf24l01); nrf24l01Start(&nrf24l01, &nrf24l01Config); //FROM RX --- extChannelEnable(&EXTD1, 3); //----- initNRF24L01(&nrf24l01); chprintf((BaseSequentialStream*)&SD1, "\n\rUp and Running\n\r"); shellInit(); chEvtRegister(&shell_terminated, &tel, 0); shelltp1 = shellCreate(&shell_cfg1, sizeof(waShell), NORMALPRIO); //FROM RX--- chThdCreateStatic(recieverWorkingArea, sizeof(recieverWorkingArea), NORMALPRIO, receiverThread, NULL); //FROM RX^^^^ /* for (i=0;i<32;i++) { serialOutBuf[i] = 3; } */ for (;;) { chEvtDispatch(fhandlers, chEvtWaitOne(ALL_EVENTS)); } }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { TimerHandler, InsertHandler, RemoveHandler }; static EvTimer evt; struct EventListener el0, el1, el2; /* * 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(); /* * Activates the serial driver 1 using the driver default configuration. */ sdStart(&SD1, NULL); /* * Buzzer driver initialization. */ buzzInit(); /* * Initializes the MMC driver to work with SPI2. */ mmcObjectInit(&MMCD1); mmcStart(&MMCD1, &mmccfg); /* * Activates the card insertion monitor. */ tmr_init(&MMCD1); /* * Creates the blinker threads. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ evtInit(&evt, MS2ST(500)); /* Initializes an event timer object. */ evtStart(&evt); /* Starts the event timer. */ chEvtRegister(&evt.et_es, &el0, 0); /* Registers on the timer event source. */ chEvtRegister(&inserted_event, &el1, 1); chEvtRegister(&removed_event, &el2, 2); while (TRUE) chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS)); return 0; }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler }; Thread *shelltp = NULL; struct EventListener el0, el1; /* * 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(); /* * Activates the serial driver 1 and SDC driver 1 using default * configuration. */ sdStart(&SD1, NULL); sdcStart(&SDCD1, NULL); /* * Shell manager initialization. */ shellInit(); /* * Activates the card insertion monitor. */ tmr_init(&SDCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); while (TRUE) { if (!shelltp) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminated(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS)); } }
/*------------------------------------------------------------------------* * Simulator main. * *------------------------------------------------------------------------*/ int main(void) { EventListener sd1fel, sd2fel, tel; /* * HAL initialization. */ halInit(); /* * ChibiOS/RT initialization. */ 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"); (void) sdGetAndClearFlags(&SD1); chEvtRegister(&SD1.sevent, &sd1fel, 1); cputs(" - Listening for connections on SD2"); (void) sdGetAndClearFlags(&SD2); chEvtRegister(&SD2.sevent, &sd2fel, 2); /* * Events servicing loop. */ while (!chThdShouldTerminate()) chEvtDispatch(fhandlers, chEvtWaitOne(ALL_EVENTS)); /* * Clean simulator exit. */ chEvtUnregister(&SD1.sevent, &sd1fel); chEvtUnregister(&SD2.sevent, &sd2fel); return 0; }
/*------------------------------------------------------------------------* * Simulator main. * *------------------------------------------------------------------------*/ int main(void) { EventListener sd1fel, sd2fel, 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"); (void) chIOGetAndClearFlags(&SD1); chEvtRegister(chIOGetEventSource(&SD1), &sd1fel, 1); cputs(" - Listening for connections on SD2"); (void) chIOGetAndClearFlags(&SD2); chEvtRegister(chIOGetEventSource(&SD2), &sd2fel, 2); /* * Events servicing loop. */ while (!chThdShouldTerminate()) chEvtDispatch(fhandlers, chEvtWaitOne(ALL_EVENTS)); /* * Clean simulator exit. */ chEvtUnregister(chIOGetEventSource(&SD1), &sd1fel); chEvtUnregister(chIOGetEventSource(&SD2), &sd2fel); return 0; }
/*------------------------------------------------------------------------* * Simulator main. * *------------------------------------------------------------------------*/ int main(void) { initTestStream(&testStream); /* * 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); /* * 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); rusEfiFunctionalTest(); /* * Events servicing loop. */ while (!chThdShouldTerminate()) { chEvtDispatch(fhandlers, chEvtWaitOne(ALL_EVENTS)); printPendingMessages(); chThdSleepMilliseconds(100); } /* * Clean simulator exit. */ chEvtUnregister(chnGetEventSource(&SD1), &sd1fel); chEvtUnregister(chnGetEventSource(&SD2), &sd2fel); return 0; }
int main(void) { static const evhandler_t evhndl[] = {InsertHandler, RemoveHandler}; struct EventListener el0, el1; // os init halInit(); chSysInit(); // setup LED pads palSetPadMode(GPIOD, 12, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST); palClearPad(GPIOD, 12); // green LED palSetPadMode(GPIOD, 15, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST); palClearPad(GPIOD, 15); // blue LED // setup pads to USART2 function (connect these pads through RS232 transceiver with PC, terminal emu needs 38400 baud) sdStart(&SD2, NULL); palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7) | PAL_STM32_OSPEED_HIGHEST); // TX palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); // RX // setup pads to SPI1 function (connect these pads to your SD card accordingly) palSetPadMode(GPIOC, 4, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST); // NSS palSetPadMode(GPIOA, 5, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); // SCK palSetPadMode(GPIOA, 6, PAL_MODE_ALTERNATE(5)); // MISO palSetPadMode(GPIOA, 7, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); // MOSI palSetPad(GPIOC, 4); // set NSS high // initialize MMC driver mmcObjectInit(&MMCD1, &SPID1, &ls_spicfg, &hs_spicfg, mmc_is_protected, mmc_is_inserted); mmcStart(&MMCD1, NULL); // ChibiOS has no I2S support yet; // codec.c initializes everything necessary // except the I2S TX DMA interrupt vector (because it would // conflict with the ChibiOS kernel) // we can make ChibiOS call our own handler by letting // it create the DMA stream for SPI3 dmaStreamAllocate(SPID3.dmatx, STM32_SPI_SPI3_IRQ_PRIORITY, (stm32_dmaisr_t)I2SDmaTxInterrupt, &SPID3); // blink thread; also checks the user button chThdCreateStatic(waBlinkThread, sizeof(waBlinkThread), NORMALPRIO, BlinkThread, NULL); chEvtRegister(&MMCD1.inserted_event, &el0, 0); chEvtRegister(&MMCD1.removed_event, &el1, 1); while(TRUE) { chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS)); } }
/*! \brief ADIS Newdata Thread */ static msg_t Thread_adis_newdata(void *arg) { (void)arg; chRegSetThreadName("adis_newdata"); static const evhandler_t evhndl_newdata[] = { adis_newdata_handler }; struct EventListener evl_spi_cb2; chEvtRegister(&adis_spi_cb_newdata, &evl_spi_cb2, 0); while (TRUE) { chEvtDispatch(evhndl_newdata, chEvtWaitOneTimeout((eventmask_t)1, US2ST(50))); } return -1; }
static msg_t Thread_mpu9150_int(void* arg) { (void) arg; static const evhandler_t evhndl_mpu9150[] = { mpu9150_int_event_handler }; struct EventListener evl_mpu9150; chRegSetThreadName("mpu9150_int"); chEvtRegister(&mpu9150_int_event, &evl_mpu9150, 0); while (TRUE) { chEvtDispatch(evhndl_mpu9150, chEvtWaitOneTimeout(EVENT_MASK(0), MS2ST(50))); } return -1; }
msg_t data_udp_send_thread(void *p) { void * arg __attribute__ ((unused)) = p; static const evhandler_t evhndl_mpu9150[] = { data_udp_send_mpu9150_data }; struct EventListener evl_mpu9150; err_t err; ip_addr_t ip_addr_sensor; ip_addr_t ip_addr_fc; chRegSetThreadName("data_udp_send_thread"); chEvtRegister(&mpu9150_data_event, &evl_mpu9150, 0); IMU_A_IP_ADDR(&ip_addr_sensor); IP_PSAS_FC(&ip_addr_fc); mpu9150_mac_info.conn = netconn_new( NETCONN_UDP ); /* Bind to the local address, or to ANY address */ // netconn_bind(conn, NULL, DATA_UDP_TX_THREAD_PORT ); //local port, NULL is bind to ALL ADDRESSES! (IP_ADDR_ANY) err = netconn_bind(mpu9150_mac_info.conn, &ip_addr_sensor, IMU_A_TX_PORT ); //local port if (err == ERR_OK) { /* Connect to specific address or a broadcast address */ /* * \todo Understand why a UDP needs a connect... * This may be a LwIP thing that chooses between tcp_/udp_/raw_ connections internally. * */ // netconn_connect(conn, IP_ADDR_BROADCAST, DATA_UDP_TX_THREAD_PORT ); err = netconn_connect(mpu9150_mac_info.conn, &ip_addr_fc, FC_LISTEN_PORT_IMU_A ); if(err == ERR_OK) { while (TRUE) { chEvtDispatch(evhndl_mpu9150, chEvtWaitOneTimeout(EVENT_MASK(0), MS2ST(50))); } } return RDY_RESET; } return RDY_RESET; }
msg_t WebThread(void *p) { EvTimer evt1, evt2; EventListener el0, el1, el2; uip_ipaddr_t ipaddr; (void)p; /* * Event sources setup. */ chEvtRegister(macGetReceiveEventSource(ÐD1), &el0, FRAME_RECEIVED_ID); chEvtAddFlags(EVENT_MASK(FRAME_RECEIVED_ID)); /* In case some frames are already buffered */ evtInit(&evt1, MS2ST(500)); evtStart(&evt1); chEvtRegister(&evt1.et_es, &el1, PERIODIC_TIMER_ID); evtInit(&evt2, S2ST(10)); evtStart(&evt2); chEvtRegister(&evt2.et_es, &el2, ARP_TIMER_ID); /* * EMAC driver start. */ macStart(ÐD1, &mac_config); (void)macPollLinkStatus(ÐD1); /* * uIP initialization. */ uip_init(); uip_setethaddr(macaddr); uip_ipaddr(ipaddr, IPADDR0, IPADDR1, IPADDR2, IPADDR3); uip_sethostaddr(ipaddr); httpd_init(); while (TRUE) { chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS)); } return 0; }
static void evt1_execute(void) { event_listener_t el1, el2; /* * Testing chEvtRegisterMask() and chEvtUnregister(). */ chEvtObjectInit(&es1); chEvtRegisterMask(&es1, &el1, 1); chEvtRegisterMask(&es1, &el2, 2); test_assert(1, chEvtIsListeningI(&es1), "no listener"); chEvtUnregister(&es1, &el1); test_assert(2, chEvtIsListeningI(&es1), "no listener"); chEvtUnregister(&es1, &el2); test_assert(3, !chEvtIsListeningI(&es1), "stuck listener"); /* * Testing chEvtDispatch(). */ chEvtDispatch(evhndl, 7); test_assert_sequence(4, "ABC"); }
/*! \brief ADIS DIO1 thread * * For burst mode transactions t_readrate is 1uS * */ static msg_t Thread_adis_dio1(void *arg) { (void)arg; static const evhandler_t evhndl_dio1[] = { adis_burst_read_handler, //adis_read_id_handler, adis_spi_cb_txdone_handler, adis_release_bus }; struct EventListener evl_dio; struct EventListener evl_spi_ev; struct EventListener evl_spi_release; chRegSetThreadName("adis_dio"); chEvtRegister(&adis_dio1_event, &evl_dio, 0); chEvtRegister(&adis_spi_cb_txdone_event, &evl_spi_ev, 1); chEvtRegister(&adis_spi_cb_releasebus, &evl_spi_release, 2); while (TRUE) { chEvtDispatch(evhndl_dio1, chEvtWaitOneTimeout((EVENT_MASK(2)|EVENT_MASK(1)|EVENT_MASK(0)), US2ST(50))); } return -1; }
void BaseThread::dispatchEvents(const evhandler_t handlers[], eventmask_t mask) { chEvtDispatch(handlers, mask); }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { WKUP_button_handler }; struct EventListener el0; /* * 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(); /* * Initialize event structures BEFORE using them */ chEvtInit(&wkup_event); /* * Shell manager initialization. */ usbSerialShellStart(commands); // Enable Continuous GPT for 1ms Interval gptStart(&GPTD1, &gpt1cfg); gptStartContinuous(&GPTD1,10000); // Configure pins for Feedback ADC's palSetPadMode(GPIOA, GPIOA_PIN4, PAL_MODE_INPUT_ANALOG); palSetPadMode(GPIOA, GPIOA_PIN5, PAL_MODE_INPUT_ANALOG); // Configure pins for Input ADC's palSetPadMode(GPIOF, GPIOF_PIN6, PAL_MODE_INPUT_ANALOG); palSetPadMode(GPIOF, GPIOF_PIN7, PAL_MODE_INPUT_ANALOG); // Configure pins for LED's // PD3: Vertical Axis LED palSetPadMode(GPIOD, GPIOD_PIN3, PAL_MODE_OUTPUT_PUSHPULL); // PD4: Lateral Axis LED palSetPadMode(GPIOD, GPIOD_PIN4, PAL_MODE_OUTPUT_PUSHPULL); // Configure pins for switches // PD8: Drive Enable Switch palSetPadMode(GPIOD, GPIOD_PIN8, PAL_MODE_INPUT); // PD9: Mode Select Switch palSetPadMode(GPIOD, GPIOD_PIN9, PAL_MODE_INPUT); // Configure pins for long lead GMD Enable/Watchdog // PD5: Enable out to GMD palSetPadMode(GPIOD, GPIOD_PIN5, PAL_MODE_OUTPUT_PUSHPULL); // PD6: Watchdog out to GMD palSetPadMode(GPIOD, GPIOD_PIN6, PAL_MODE_OUTPUT_PUSHPULL); // Configure pins for short lead GMD Enable/Watchdog // PD10: Enable out to GMD palSetPadMode(GPIOD, GPIOD_PIN10, PAL_MODE_OUTPUT_PUSHPULL); // PD11: Watchdog out to GMD palSetPadMode(GPIOD, GPIOD_PIN11, PAL_MODE_OUTPUT_PUSHPULL); // Configure pins for PWM output (D12-D15: TIM4, channel 1-4) palSetPadMode(GPIOD, GPIOD_PIN12, PAL_MODE_ALTERNATE(2)); //U-pole, short lead palSetPadMode(GPIOD, GPIOD_PIN13, PAL_MODE_ALTERNATE(2)); //V-pole, short lead palSetPadMode(GPIOD, GPIOD_PIN14, PAL_MODE_ALTERNATE(2)); //U-pole, long lead palSetPadMode(GPIOD, GPIOD_PIN15, PAL_MODE_ALTERNATE(2)); //V-pole, long lead adcStart(&ADCD1, NULL); adcStart(&ADCD2, NULL); adcStart(&ADCD3, NULL); pwmStart(&PWMD4, &pwmcfg); // Enable TIM4 PWM channel 1-4 with initial DC=0% /* @param[in] pwmp pointer to a @p PWMDriver object * @param[in] channel PWM channel identifier (0...PWM_CHANNELS-1) * @param[in] width PWM pulse width as clock pulses number */ pwmEnableChannel(&PWMD4, 0, 0); pwmEnableChannel(&PWMD4, 1, 0); pwmEnableChannel(&PWMD4, 2, 0); pwmEnableChannel(&PWMD4, 3, 0); // Set axis control gain and limit values // Set Vertical Axis Gains vertAxisStruct.U16PositionPGain = 4; vertAxisStruct.U16PositionIGain = 1; vertAxisStruct.U16PositionDGain = 0; // Set vertical axis limits vertAxisStruct.U16CommandLimit = VERTICAL_COMMAND_LIMIT; vertAxisStruct.U16HighPosnLimit = 5100; vertAxisStruct.U16LowPosnLimit = 2480; // Set Lateral Axis Gains latAxisStruct.U16PositionPGain = 2; latAxisStruct.U16PositionIGain = 0; latAxisStruct.U16PositionDGain = 0; // Set lateral axis limits latAxisStruct.U16CommandLimit = LATERAL_COMMAND_LIMIT; latAxisStruct.U16HighPosnLimit = 5300; latAxisStruct.U16LowPosnLimit = 3100; /* * Activates the serial driver 6 and SDC driver 1 using default * configuration. */ sdStart(&SD6, NULL); /* * Activates the EXT driver 1. * This is for the external interrupt */ extStart(&EXTD1, &extcfg); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&wkup_event, &el0, 0); while (TRUE) { //Cycle motordrive if timer fails if(U32DelayCount++ > 2500){ motordrive(&GPTD1); } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
int main(void) { static Thread *shelltp = NULL; static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler, packetReceivedHandler }; struct EventListener el0, el1, el2; chEvtRegister(&packet_event, &el2, 0); chEvtInit(&packet_event); /* * 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(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); /* * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1000); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * Shell manager initialization. */ shellInit(); /* * Activates the serial driver 6 and SDC driver 1 using default * configuration. */ sdStart(&SD6, NULL); sdcStart(&SDCD1, NULL); /* * Activates the card insertion monitor. */ tmr_init(&SDCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Creates the LWIP threads (it changes priority internally). */ chThdCreateStatic(wa_lwip_thread, LWIP_THREAD_STACK_SIZE, NORMALPRIO + 2, lwip_thread, NULL); /* * Creates the HTTP thread (it changes priority internally). */ /* chThdCreateStatic(wa_http_server, sizeof(wa_http_server), NORMALPRIO + 1, http_server, NULL); */ WORKING_AREA(wa_udp_receive_server, PWM_REC_STACK_SIZE); chThdCreateStatic(wa_udp_receive_server, sizeof(wa_udp_receive_server), NORMALPRIO +1, udp_receive_server_init, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); while (TRUE) { if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE)) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminated(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } if (palReadPad(GPIOA, GPIOA_BUTTON_WKUP) != 0) { } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
void Event::Dispatch(const evhandler_t handlers[], eventmask_t mask) { chEvtDispatch(handlers, mask); }
int main(void) { static Thread *shelltp = NULL; static const evhandler_t evhndl_main[] = { extdetail_WKUP_button_handler }; struct EventListener el0; /* * 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(); extdetail_init(); palSetPad(GPIOC, GPIOC_LED); palSetPad(GPIOA, GPIOA_SPI1_SCK); palSetPad(GPIOA, GPIOA_SPI1_NSS); /* * SPI1 I/O pins setup. */ palSetPadMode(adis_connections.spi_sck_port, adis_connections.spi_sck_pad, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); palSetPadMode(adis_connections.spi_miso_port, adis_connections.spi_miso_pad, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST| PAL_STM32_PUDR_FLOATING); palSetPadMode(adis_connections.spi_mosi_port, adis_connections.spi_mosi_pad, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST ); palSetPadMode(adis_connections.spi_cs_port, adis_connections.spi_cs_pad, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST); palSetPad(GPIOA, GPIOA_SPI1_SCK); palSetPad(GPIOA, GPIOA_SPI1_NSS); /*! * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU_PSAS); sduStart(&SDU_PSAS, &serusbcfg); /*! * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1000); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); shellInit(); iwdg_begin(); /*! * Activates the serial driver 6 and SDC driver 1 using default * configuration. */ sdStart(&SD6, NULL); spiStart(&SPID1, &adis_spicfg); /* Set transfer parameters. */ chThdSleepMilliseconds(300); adis_init(); adis_reset(); /*! Activates the EXT driver 1. */ extStart(&EXTD1, &extcfg); chThdCreateStatic(waThread_blinker, sizeof(waThread_blinker), NORMALPRIO, Thread_blinker, NULL); chThdCreateStatic(waThread_adis_dio1, sizeof(waThread_adis_dio1), NORMALPRIO, Thread_adis_dio1, NULL); chThdCreateStatic(waThread_adis_newdata, sizeof(waThread_adis_newdata), NORMALPRIO, Thread_adis_newdata, NULL); chThdCreateStatic(waThread_indwatchdog, sizeof(waThread_indwatchdog), NORMALPRIO, Thread_indwatchdog, NULL); chEvtRegister(&extdetail_wkup_event, &el0, 0); while (TRUE) { if (!shelltp && (SDU_PSAS.config->usbp->state == USB_ACTIVE)) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminated(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } chEvtDispatch(evhndl_main, chEvtWaitOneTimeout((eventmask_t)1, MS2ST(500))); } }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler, ShellHandler }; event_listener_t el0, el1, el2; /* * 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(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); /* * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * Shell manager initialization. */ shellInit(); /* * Activates the card insertion monitor. */ tmr_init(&SDCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, handling SD card events and shell * start/exit. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); chEvtRegister(&shell_terminated, &el2, 2); while (true) { if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE)) { shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO + 1, shellThread, (void *)&shell_cfg1); } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler, ShellHandler }; event_listener_t el0, el1, el2; /* * 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. * - lwIP subsystem initialization using the default configuration. */ halInit(); chSysInit(); /* * Initialize RNG */ rccEnableAHB2(RCC_AHB2ENR_RNGEN, 0); RNG->CR |= RNG_CR_IE; RNG->CR |= RNG_CR_RNGEN; /* lwip */ lwipInit(NULL); /* * Target-dependent setup code. */ portab_setup(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&PORTAB_SDU1); sduStart(&PORTAB_SDU1, &serusbcfg); /* * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * Shell manager initialization. */ shellInit(); /* * Activates the SDC driver 1 using default configuration. */ sdcStart(&SDCD1, NULL); /* * Activates the card insertion monitor. */ tmr_init(&SDCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Creates the HTTPS thread (it changes priority internally). */ chThdCreateStatic(wa_https_server, sizeof(wa_https_server), NORMALPRIO + 1, https_server, NULL); /* * Normal main() thread activity, handling SD card events and shell * start/exit. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); chEvtRegister(&shell_terminated, &el2, 2); while (true) { if (!shelltp && (PORTAB_SDU1.config->usbp->state == USB_ACTIVE)) { shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO + 1, shellThread, (void *)&shell_cfg1); } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, TIME_MS2I(500))); } }
int main(void) { static const evhandler_t evhndl_main[] = { extdetail_WKUP_button_handler }; struct EventListener el0; /* * 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(); extdetail_init(); palSetPad(GPIOC, GPIOC_LED); /*! * GPIO Pins for generating pulses at data input detect and data output send. * Used for measuring latency timing of data * * \sa board.h */ palClearPad( TIMEOUTPUT_PORT, TIMEOUTPUT_PIN); palSetPadMode(TIMEOUTPUT_PORT, TIMEOUTPUT_PIN, PAL_MODE_OUTPUT_PUSHPULL); palSetPad( TIMEINPUT_PORT, TIMEINPUT_PIN); palSetPadMode(TIMEINPUT_PORT, TIMEINPUT_PIN, PAL_MODE_OUTPUT_PUSHPULL ); /* * I2C2 I/O pins setup */ palSetPadMode(si_i2c_connections.i2c_sda_port , si_i2c_connections.i2c_sda_pad, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_OSPEED_HIGHEST |PAL_STM32_PUDR_FLOATING ); palSetPadMode(si_i2c_connections.i2c_scl_port, si_i2c_connections.i2c_scl_pad, PAL_MODE_ALTERNATE(4) | PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUDR_FLOATING); palSetPad(si_i2c_connections.i2c_scl_port, si_i2c_connections.i2c_scl_pad ); static const ShellCommand commands[] = { {"mem", cmd_mem}, {"threads", cmd_threads}, {NULL, NULL} }; usbSerialShellStart(commands); mpu9150_start(&I2CD2); i2cStart(mpu9150_driver.i2c_instance, &si_i2c_config); mpu9150_init(mpu9150_driver.i2c_instance); /* Administrative threads */ chThdCreateStatic(waThread_blinker, sizeof(waThread_blinker), NORMALPRIO, Thread_blinker, NULL); chThdCreateStatic(waThread_indwatchdog, sizeof(waThread_indwatchdog), NORMALPRIO, Thread_indwatchdog, NULL); /* MAC */ /*! * Use a locally administered MAC address second LSbit of MSB of MAC should be 1 * Use unicast address LSbit of MSB of MAC should be 0 */ data_udp_init(); chThdCreateStatic(wa_lwip_thread , sizeof(wa_lwip_thread) , NORMALPRIO + 2, lwip_thread , SENSOR_LWIP); chThdCreateStatic(wa_data_udp_send_thread , sizeof(wa_data_udp_send_thread) , NORMALPRIO , data_udp_send_thread , NULL); /* i2c MPU9150 */ chThdCreateStatic(waThread_mpu9150_int, sizeof(waThread_mpu9150_int) , NORMALPRIO , Thread_mpu9150_int, NULL); /* SPI ADIS */ //chThdCreateStatic(waThread_adis_dio1, sizeof(waThread_adis_dio1), NORMALPRIO, Thread_adis_dio1, NULL); //chThdCreateStatic(waThread_adis_newdata, sizeof(waThread_adis_newdata), NORMALPRIO, Thread_adis_newdata, NULL); /*! Activates the EXT driver 1. */ extStart(&EXTD1, &extcfg); chEvtRegister(&extdetail_wkup_event, &el0, 0); while (TRUE) { chEvtDispatch(evhndl_main, chEvtWaitOneTimeout((eventmask_t)1, MS2ST(500))); } }
msg_t data_udp_send_thread(void *p) { void * arg __attribute__ ((unused)) = p; static const evhandler_t evhndl_imu_a[] = { data_udp_send_mpu9150_data, data_udp_send_mpl3115a2_data, data_udp_send_adis16405_data }; struct EventListener evl_mpu9150; struct EventListener evl_mpl3115a2; struct EventListener evl_adis16405; err_t err_mpu_conn; err_t err_mpl_conn; err_t err_adis_conn; ip_addr_t ip_addr_sensor; ip_addr_t ip_addr_fc; chRegSetThreadName("data_udp_send_thread"); chEvtRegister(&mpu9150_data_event, &evl_mpu9150, 0); chEvtRegister(&mpl3115a2_data_event, &evl_mpl3115a2, 1); chEvtRegister(&adis_spi_burst_data_captured, &evl_adis16405, 2); IMU_A_IP_ADDR(&ip_addr_sensor); IP_PSAS_FC(&ip_addr_fc); mpu9150_mac_info.conn = netconn_new( NETCONN_UDP ); if(mpu9150_mac_info.conn == NULL) { log_error("mpu new conn is null"); while(1); } mpl3115a2_mac_info.conn = netconn_new( NETCONN_UDP ); if(mpl3115a2_mac_info.conn == NULL) { log_error("mpl new conn is null"); while(1); } adis16405_mac_info.conn = netconn_new( NETCONN_UDP ); if(adis16405_mac_info.conn == NULL) { log_error("adis new conn is null"); while(1); } /* Bind to the local address, or to ANY address */ // netconn_bind(conn, NULL, DATA_UDP_TX_THREAD_PORT ); //local port, NULL is bind to ALL ADDRESSES! (IP_ADDR_ANY) err_mpu_conn = netconn_bind(mpu9150_mac_info.conn, &ip_addr_sensor, IMU_A_TX_PORT_MPU ); //local port if (err_mpu_conn != ERR_OK) { log_error("mpu bind is not OK"); while(1); } err_mpl_conn = netconn_bind(mpl3115a2_mac_info.conn, &ip_addr_sensor, IMU_A_TX_PORT_MPL ); //local port if (err_mpl_conn != ERR_OK) { log_error("mpl bind is not OK"); while(1); } err_adis_conn = netconn_bind(adis16405_mac_info.conn, &ip_addr_sensor, IMU_A_TX_PORT_ADIS ); //local port if (err_adis_conn != ERR_OK) { log_error("adis bind is not OK"); while(1); } if ((err_mpu_conn == ERR_OK) && (err_adis_conn == ERR_OK)) { /* Connect to specific address or a broadcast address */ /* * \todo Understand why a UDP needs a connect... * This may be a LwIP thing that chooses between tcp_/udp_/raw_ connections internally. * */ // netconn_connect(conn, IP_ADDR_BROADCAST, DATA_UDP_TX_THREAD_PORT ); err_mpu_conn = netconn_connect(mpu9150_mac_info.conn, &ip_addr_fc, FC_LISTEN_PORT_IMU_A ); if (err_mpu_conn != ERR_OK) { log_error("mpu port connect is not OK"); while(1); } err_mpl_conn = netconn_connect(mpl3115a2_mac_info.conn, &ip_addr_fc, FC_LISTEN_PORT_IMU_A ); if (err_mpl_conn != ERR_OK) { log_error("mpl port connect is not OK"); while(1); } err_adis_conn = netconn_connect(adis16405_mac_info.conn, &ip_addr_fc, FC_LISTEN_PORT_IMU_A); if (err_adis_conn != ERR_OK) { log_error("adis port connect is not OK"); while(1); } if(err_mpu_conn == ERR_OK) { while (TRUE) { chEvtDispatch(evhndl_imu_a, chEvtWaitOneTimeout(EVENT_MASK(2)| EVENT_MASK(1)|EVENT_MASK(0), MS2ST(50))); } } else { log_error("Conn not ok"); } return RDY_RESET; } else { log_error("2 conn not ok"); } return RDY_RESET; }
/* * Application entry point. */ int main(void) { static thread_t *shelltp = NULL; static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler }; event_listener_t el0, el1; /* * 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. * - lwIP subsystem initialization using the default configuration. */ halInit(); chSysInit(); lwipInit(NULL); /* * Initialize board LED. */ palSetLineMode(LINE_ARD_D13, PAL_MODE_OUTPUT_PUSHPULL); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU2); sduStart(&SDU2, &serusbcfg); /* * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * Shell manager initialization. */ shellInit(); /* * Activates the serial driver 1 and SDC driver 1 using default * configuration. */ sdStart(&SD1, NULL); sdcStart(&SDCD1, NULL); /* * Activates the card insertion monitor. */ tmr_init(&SDCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Creates the HTTP thread (it changes priority internally). */ chThdCreateStatic(wa_http_server, sizeof(wa_http_server), NORMALPRIO + 1, http_server, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); while (true) { if (!shelltp && (SDU2.config->usbp->state == USB_ACTIVE)) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminatedX(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } if (palReadPad(GPIOI, GPIOI_BUTTON_USER) != 0) { } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
/* * Application entry point. */ int main(void) { static thread_t *shelltp = NULL; static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler }; event_listener_t el0, el1; /* * 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(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); /* * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * Shell manager initialization. */ shellInit(); /* * Activates the card insertion monitor. */ tmr_init(&SDCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); while (true) { if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE)) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminatedX(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
void fatfs_dispatch_event( void ) { chEvtDispatch( evhndl, chEvtWaitOneTimeout( ALL_EVENTS, MS2ST( 500 ) ) ); }