/*
* 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);
mmcStart(&MMCD1, &mmccfg);
/*
* Activates the card insertion monitor.
*/
tmr_init(&MMCD1);
/*
* 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, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500)));
}
return 0;
}
/** Application entry point. */
int main(void) {
static thread_t *shelltp = NULL;
/* Initializes a serial-over-USB CDC driver. */
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
sdStart(&SD3, NULL);
chprintf((BaseSequentialStream *)&SD3 , "\n> boot\n");
/*
* 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();
/* Initialize global objects. */
config_init();
chMtxObjectInit(&robot_pose_lock);
/* Initialise timestamp module */
timestamp_stm32_init();
/* bus enumerator init */
static __attribute__((section(".ccm"))) struct bus_enumerator_entry_allocator
bus_enum_entries_alloc[MAX_NB_BUS_ENUMERATOR_ENTRIES];
bus_enumerator_init(&bus_enumerator,
bus_enum_entries_alloc,
MAX_NB_BUS_ENUMERATOR_ENTRIES);
/* allocate and init motor manager */
static __attribute__((section(".ccm"))) trajectory_t trajectory_buffer[MAX_NB_TRAJECTORY_BUFFERS];
static __attribute__((section(".ccm"))) float trajectory_points_buffer[ACTUATOR_TRAJECTORY_NB_POINTS
* ACTUATOR_TRAJECTORY_POINT_DIMENSION
* MAX_NB_TRAJECTORY_BUFFERS];
static __attribute__((section(".ccm"))) motor_driver_t motor_driver_buffer[MAX_NB_MOTOR_DRIVERS];
motor_manager_init(&motor_manager,
trajectory_buffer,
MAX_NB_TRAJECTORY_BUFFERS,
trajectory_points_buffer,
MAX_NB_TRAJECTORY_BUFFERS,
motor_driver_buffer,
MAX_NB_MOTOR_DRIVERS,
&bus_enumerator);
differential_base_init();
/* Checks if there is any log message from a previous boot */
if (panic_log_read() != NULL) {
/* Turns on the user LED if yes */
palClearPad(GPIOC, GPIOC_LED);
/* Turn on all LEDs on the front panel. */
palSetPad(GPIOF, GPIOF_LED_READY);
palSetPad(GPIOF, GPIOF_LED_DEBUG);
palSetPad(GPIOF, GPIOF_LED_ERROR);
palSetPad(GPIOF, GPIOF_LED_POWER_ERROR);
palSetPad(GPIOF, GPIOF_LED_PC_ERROR);
palSetPad(GPIOF, GPIOF_LED_BUS_ERROR);
palSetPad(GPIOF, GPIOF_LED_YELLOW_1);
palSetPad(GPIOF, GPIOF_LED_YELLOW_2);
palSetPad(GPIOF, GPIOF_LED_GREEN_1);
palSetPad(GPIOF, GPIOF_LED_GREEN_2);
} else {
struct netif *ethernet_if;
differential_base_tracking_start(); // tracy
ip_thread_init();
chThdSleepMilliseconds(1000);
ethernet_if = netif_find("ms0");
if (ethernet_if) {
dhcp_start(ethernet_if);
}
sntp_init();
can_bridge_init();
uavcan_node_start(10);
rpc_server_init();
message_server_init();
interface_panel_init();
odometry_publisher_init();
#ifdef ENABLE_STREAM
#warning "Enabling robot stream can lead to lwip crash. Do not use in match until fixed."
stream_init();
#endif
}
/* main thread, spawns a shell on USB connection. */
while (1) {
if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE)) {
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, USB_SHELL_PRIO);
} else if (chThdTerminatedX(shelltp)) {
chThdRelease(shelltp); /* Recovers memory of the previous shell. */
shelltp = NULL; /* Triggers spawning of a new shell. */
}
chThdSleepMilliseconds(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.
* - 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) {
thread_t *shelltp1 = NULL;
thread_t *shelltp2 = NULL;
/*
* 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 two serial-over-USB CDC drivers.
*/
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg1);
sduObjectInit(&SDU2);
sduStart(&SDU2, &serusbcfg2);
/*
* 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(serusbcfg1.usbp);
chThdSleepMilliseconds(1500);
usbStart(serusbcfg1.usbp, &usbcfg);
usbConnectBus(serusbcfg1.usbp);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Creates the blinker threads.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state.
*/
while (true) {
if (!shelltp1 && (SDU1.config->usbp->state == USB_ACTIVE))
shelltp1 = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminatedX(shelltp1)) {
chThdRelease(shelltp1); /* Recovers memory of the previous shell. */
shelltp1 = NULL; /* Triggers spawning of a new shell. */
}
if (!shelltp2 && (SDU2.config->usbp->state == USB_ACTIVE))
shelltp2 = shellCreate(&shell_cfg2, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminatedX(shelltp2)) {
chThdRelease(shelltp2); /* Recovers memory of the previous shell. */
shelltp2 = NULL; /* Triggers spawning of a new shell. */
}
chThdSleepMilliseconds(1000);
}
}
/*
* Application entry point.
*/
int main(void) {
Thread *shelltp = NULL;
/*
* 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();
/*
* Shell manager initialization.
*/
shellInit();
/*
* 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);
/*
* Initialise SDRAM, board.h has already configured GPIO correctly (except that ST example uses 50MHz not 100MHz?)
*/
SDRAM_Init();
sdram_bulk_erase();
/*
* Activates the LCD-related drivers.
*/
spiStart(&SPID5, &spi_cfg5);
ili9341Start(&ILI9341D1, &ili9341_cfg);
initialize_lcd();
ltdcStart(<DCD1, <dc_cfg);
/*
* Activates the DMA2D-related drivers.
*/
dma2dStart(&DMA2DD1, &dma2d_cfg);
dma2d_test();
/*
* Creating the blinker threads.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO + 10,
Thread1, NULL);
chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO + 10,
Thread2, NULL);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (TRUE) {
if (!shelltp) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
}
}
else {
/* If the previous shell exited.*/
if (chThdTerminated(shelltp)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp);
shelltp = NULL;
}
}
chThdSleepMilliseconds(500);
}
}
/*
* Application entry point.
*/
int main(void) {
Thread *shelltp = NULL;
/*
* 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();
/*
* Shell manager initialization.
*/
shellInit();
/*
* 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);
/*
* Activates the serial driver 2 using the driver default configuration.
* PA2(TX) and PA3(RX) are routed to USART2.
*/
sdStart(&SD2, NULL);
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));
/*
* Initializes the SPI driver 1 in order to access the MEMS. The signals
* are already initialized in the board file.
*/
spiStart(&SPID1, &spi1cfg);
/*
* Initializes the SPI driver 2. The SPI2 signals are routed as follow:
* PB12 - NSS.
* PB13 - SCK.
* PB14 - MISO.
* PB15 - MOSI.
*/
spiStart(&SPID2, &spi2cfg);
palSetPad(GPIOB, 12);
palSetPadMode(GPIOB, 12, PAL_MODE_OUTPUT_PUSHPULL |
PAL_STM32_OSPEED_HIGHEST); /* NSS. */
palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5) |
PAL_STM32_OSPEED_HIGHEST); /* SCK. */
palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(5)); /* MISO. */
palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5) |
PAL_STM32_OSPEED_HIGHEST); /* MOSI. */
/*
* Initializes the PWM driver 4, routes the TIM4 outputs to the board LEDs.
*/
pwmStart(&PWMD4, &pwmcfg);
palSetPadMode(GPIOD, GPIOD_LED4, PAL_MODE_ALTERNATE(2)); /* Green. */
palSetPadMode(GPIOD, GPIOD_LED3, PAL_MODE_ALTERNATE(2)); /* Orange. */
palSetPadMode(GPIOD, GPIOD_LED5, PAL_MODE_ALTERNATE(2)); /* Red. */
palSetPadMode(GPIOD, GPIOD_LED6, PAL_MODE_ALTERNATE(2)); /* Blue. */
/*
* Creates the example thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1),
NORMALPRIO + 10, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (TRUE) {
if (!shelltp) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
}
}
else {
/* If the previous shell exited.*/
if (chThdTerminated(shelltp)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp);
shelltp = NULL;
}
}
chThdSleepMilliseconds(500);
}
}
/*
* Application entry point.
*/
int main(void) {
color_t color = Black;
uint16_t pen = 0;
Thread *shelltp = NULL;
/*
* 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();
gdispInit();
ginputGetMouse(0);
gdispSetOrientation(GDISP_ROTATE_90);
drawScreen();
/*
* 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();
/*
* 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 check the button state.
*/
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. */
}
ginputGetMouseStatus(0, &ev);
if (!(ev.current_buttons & GINPUT_MOUSE_BTN_LEFT))
{
chThdSleepMicroseconds(500); // Senza questo sleep l'USB non parte
continue;
}
/* inside color box ? */
if(ev.y >= OFFSET && ev.y <= COLOR_SIZE) {
if(GET_COLOR(0)) color = Black;
else if(GET_COLOR(1)) color = Red;
else if(GET_COLOR(2)) color = Yellow;
else if(GET_COLOR(3)) color = Green;
else if(GET_COLOR(4)) color = Blue;
else if(GET_COLOR(5)) color = White;
/* inside pen box ? */
} else if(ev.x >= OFFSET && ev.x <= PEN_SIZE) {
if(GET_PEN(1)) pen = 0;
else if(GET_PEN(2)) pen = 1;
else if(GET_PEN(3)) pen = 2;
else if(GET_PEN(4)) pen = 3;
else if(GET_PEN(5)) pen = 4;
/* inside drawing area ? */
} else if(DRAW_AREA(ev.x, ev.y)) {
if(pen == 0)
gdispDrawPixel(ev.x, ev.y, color);
else
gdispFillCircle(ev.x, ev.y, pen, color);
}
}
}
/*
* Application entry point.
*/
int main(void) {
thread_t *shelltp = NULL;
/*
* 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();
/*
* Shell manager initialization.
*/
shellInit();
/*
* 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);
/*
* Creating the blinker threads.
*/
chThdCreateStatic(waThread1, sizeof(waThread1),
NORMALPRIO + 10, Thread1, NULL);
chThdCreateStatic(waThread2, sizeof(waThread2),
NORMALPRIO + 10, Thread2, NULL);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (true) {
if (!shelltp) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
}
}
else {
/* If the previous shell exited.*/
if (chThdTerminatedX(shelltp)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp);
shelltp = NULL;
}
}
chThdSleepMilliseconds(500);
}
}
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) {
Thread *shelltp0 = NULL;
Thread *shelltp2 = NULL;
unsigned int i = 0;
/*
* 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);
// Activate all serial drivers.
sdStart(&SD1, NULL);
sdStart(&SD2, NULL);
sdStart(&SD3, NULL);
sdStart(&SD4, NULL);
sdStart(&SD5, NULL);
sdStart(&SD6, NULL);
// Activates the UART driver 1, PA9(TX) and PA10(RX) are routed to USART1.
palSetPadMode(GPIOB, 6, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOB, 7, PAL_MODE_ALTERNATE(7));
// Activates the UART driver 2, PA2(TX) and PA3(RX) are routed to USART2.
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));
// Activates the UART driver 3, PB10(TX) and PB11(RX) are routed to USART3.
palSetPadMode(GPIOB, 10, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOB, 11, PAL_MODE_ALTERNATE(7));
// Activates the UART driver 4, PC10(TX) and PC11(RX) are routed to UART4.
palSetPadMode(GPIOC, 10, PAL_MODE_ALTERNATE(8));
palSetPadMode(GPIOC, 11, PAL_MODE_ALTERNATE(8));
// Activates the UART driver 5, PC12(TX) and PD2(RX) are routed to UART5.
palSetPadMode(GPIOC, 12, PAL_MODE_ALTERNATE(8));
palSetPadMode(GPIOD, 2, PAL_MODE_ALTERNATE(8));
// Activates the UART driver 6, PC6(TX) and PC7(RX) are routed to USART6.
palSetPadMode(GPIOC, 6, PAL_MODE_ALTERNATE(8));
palSetPadMode(GPIOC, 7, PAL_MODE_ALTERNATE(8));
/*
* 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(250);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg2, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg3, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg4, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg5, SHELL_WA_SIZE, NORMALPRIO);
shellCreate(&shell_cfg6, SHELL_WA_SIZE, NORMALPRIO);
/*
* Normal main() thread activity, in this demo it just performs
* a shell respawn upon its termination.
*/
while (true) {
if (!shelltp0) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Spawns a new shell.*/
shelltp0 = shellCreate(&shell_cfg0, SHELL_WA_SIZE, NORMALPRIO);
}
} else {
/* If the previous shell exited.*/
if (chThdTerminated(shelltp0)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp0);
shelltp0 = NULL;
}
}
chThdSleepMilliseconds(1000);
}
}
/*
* 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)));
}
}
/*
* Application entry point.
*/
int main(void) {
Thread *shelltp = NULL;
/*
* 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(&SERIAL_DRIVER, NULL);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Activates the EXT driver.
*/
extStart(&EXTD1, &extcfg);
/*
* Activates the I2C driver.
*/
i2cStart(&I2C_DRIVER, &i2c1cfg);
/*
* Activates the SPI driver.
*/
spiStart(&SPI_DRIVER, &spi1cfg);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
chThdSleepMilliseconds(200);
if (gyrotp == NULL)
gyrotp = gyroRun(&SPI_DRIVER, NORMALPRIO);
if (acctp == NULL)
acctp = accRun(&I2C_DRIVER, NORMALPRIO);
if (magtp == NULL)
magtp = magRun(&I2C_DRIVER, NORMALPRIO);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state.
*/
while (TRUE) {
if (!shelltp)
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO - 1);
else if (chThdTerminated(shelltp)) {
chThdRelease(shelltp);
shelltp = NULL;
}
chThdSleepMilliseconds(200);
}
}
/*
* Application entry point.
*/
int main(void) {
RTCANConfig rtcan_config = {1000000, 100, 60};
Thread *shelltp = NULL;
/*
* 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(&SERIAL_DRIVER, NULL);
/*
* Shell manager initialization.
*/
shellInit();
rtcanInit();
rtcanStart (&RTCAND1, &rtcan_config);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Creates the subscriber thread #1.
*/
chThdCreateFromHeap (NULL, WA_SIZE_512B, NORMALPRIO + 1, SubscriberThread1, NULL);
/*
* Creates the subscriber thread #2.
*/
chThdCreateFromHeap (NULL, WA_SIZE_512B, NORMALPRIO + 1, SubscriberThread2, NULL);
/*
* Creates the RX thread.
*/
// chThdCreateFromHeap (NULL, WA_SIZE_512B, NORMALPRIO + 2, RxThread, NULL);
Middleware & mw = Middleware::instance();
RemotePublisher rpub("led23", sizeof(LEDDataDebug));
rpub.id((123 << 8) | 40);
mw.advertise(&rpub);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state.
*/
while (TRUE) {
if (!shelltp)
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO - 1);
else if (chThdTerminated(shelltp)) {
chThdRelease(shelltp);
shelltp = NULL;
}
chThdSleepMilliseconds(200);
}
}
