void senokoShellRestart(void) {
/* Recovers memory of the previous shell. */
if (shell_tp && chThdTerminatedX(shell_tp))
chThdRelease(shell_tp);
shell_tp = shellCreateStatic(&shellConfig, waShellThread,
sizeof(waShellThread), NORMALPRIO);
}
int main(void) {
thread_t *sh = NULL;
PollerData.temp = 0;
PollerData.press = 0;/*
PollerData.uTime = 0;*/
halInit();
chSysInit();
shellInit();
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(1000);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
// SPI-related pins (for display)
palSetPadMode(GPIOB, 11, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOB, 10, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5));
palSetPadMode(GPIOB, 14, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5));
spiStart(&SPID1, &spi1cfg);
spiStart(&SPID2, &spi2cfg);
i2cStart(&I2CD1, &i2cconfig);
initGyro();
initAccel();
initMag();
// nunchuk_status = nunchuk_init();
bmp085_status = bmp085_init();
lcd5110Init();
lcd5110SetPosXY(0, 0);
lcd5110WriteText("P :: ");
lcd5110SetPosXY(0, 1);
lcd5110WriteText("T :: ");
chThdCreateStatic(waThreadBlink, sizeof(waThreadBlink), NORMALPRIO, ThreadBlink, NULL);
chThdCreateStatic(waThreadButton, sizeof(waThreadButton), NORMALPRIO, ThreadButton, NULL);
chThdCreateStatic(waPoller, sizeof(waPoller), NORMALPRIO, ThreadPoller, NULL);
while (TRUE) {
if (!sh) {
sh = shellCreate(&shCfg, SHELL_WA_SIZE, NORMALPRIO);
}
else if (chThdTerminatedX(sh)) {
chThdRelease(sh);
sh = NULL;
}
chThdSleepMilliseconds(1000);
}
return 0; // never returns, lol
}
/*
* Shell exit event.
*/
static void ShellHandler(eventid_t id) {
(void)id;
if (chThdTerminatedX(shelltp)) {
chThdRelease(shelltp);
shelltp = NULL;
}
}
/*
* Shell exit event.
*/
static void ShellHandler(eventid_t id) {
(void)id;
if (chThdTerminatedX(shelltp)) {
chThdWait(shelltp); /* Returning memory to heap. */
shelltp = NULL;
}
}
/*
* 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();
#if defined(DEBUG_USB)
palSetPadMode(GPIOA, 1, PAL_MODE_ALTERNATIVE_2);
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATIVE_2);
sdStart(&SD1, &s0cfg);
#endif /* DEBUG_USB */
/*
* 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);
#if defined(DEBUG_USB)
usb_debug_init();
#endif /* DEBUG_USB */
chThdSleepMilliseconds(1000);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
* Shell manager initialization.
*/
shellInit();
while (!chThdShouldTerminateX()) {
if (!shelltp && (serusbcfg.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. */
}
chThdSleepMilliseconds(1000);
palTogglePad(GPIOB, GPIOB_LED);
}
return 0;
}
static void termination_handler(eventid_t id) {
(void)id;
chprintf((BaseSequentialStream*)&SD1, "Shell Died\n\r");
if (shelltp1 && chThdTerminatedX(shelltp1)) {
chThdWait(shelltp1);
chprintf((BaseSequentialStream*)&SD1, "Restarting from termination handler\n\r");
chThdSleepMilliseconds(100);
shelltp1 = shellCreate(&shell_cfg1, sizeof(waShell), NORMALPRIO);
}
}
/*
* 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();
/*
* 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();
/*
* 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 (chThdTerminatedX(shelltp)) {
chThdRelease(shelltp); /* Recovers memory of the previous shell. */
shelltp = NULL; /* Triggers spawning of a new shell. */
}
chThdSleepMilliseconds(1000);
}
}
/**
* @brief Shell termination handler.
*
* @param[in] id event id.
*/
static void termination_handler(eventid_t id) {
(void)id;
if (shelltp1 && chThdTerminatedX(shelltp1)) {
chThdWait(shelltp1);
shelltp1 = NULL;
chThdSleepMilliseconds(10);
cputs("Init: shell on SD1 terminated");
chSysLock();
chOQResetI(&SD1.oqueue);
chSysUnlock();
}
if (shelltp2 && chThdTerminatedX(shelltp2)) {
chThdWait(shelltp2);
shelltp2 = NULL;
chThdSleepMilliseconds(10);
cputs("Init: shell on SD2 terminated");
chSysLock();
chOQResetI(&SD2.oqueue);
chSysUnlock();
}
}
/*
* 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();
/*
* Activates the serial driver 6 using the driver default configuration.
*/
sdStart(&SD6, NULL);
/*
* Initializes the SDIO drivers.
*/
sdcStart(&SDCD1, &sdccfg);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing.
*/
while (true) {
if (!shelltp)
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. */
}
chThdSleepMilliseconds(1000);
}
}
/*
* 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();
/*
* Activates the serial driver 2 using the driver default configuration.
*/
sdStart(&SD1, NULL);
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)
{
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
}
else if(chThdTerminatedX(shelltp))
{
chThdRelease(shelltp);
shelltp = 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.
* - lwIP subsystem initialization using the default configuration.
*/
halInit();
chSysInit();
lwipInit(NULL);
/*
* 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)));
chThdSleepMilliseconds(500);
}
}
/*
* 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);
/*
* 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 (chThdTerminatedX(shelltp)) {
/* Recovers memory of the previous shell.*/
chThdRelease(shelltp);
shelltp = NULL;
}
}
chThdSleepMilliseconds(500);
}
}
/** 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) {
thread_t *shelltp1 = NULL;
thread_t *shelltp2 = NULL;
event_listener_t shell_el;
/*
* 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.
* Event zero is shell exit.
*/
shellInit();
chEvtRegister(&shell_terminated, &shell_el, 0);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, managing two shells.
*/
while (true) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
/* Starting shells.*/
if (shelltp1 == NULL) {
shelltp1 = chThdCreateFromHeap(NULL, SHELL_WA_SIZE,
"shell1", NORMALPRIO + 1,
shellThread, (void *)&shell_cfg1);
}
if (shelltp2 == NULL) {
shelltp2 = chThdCreateFromHeap(NULL, SHELL_WA_SIZE,
"shell2", NORMALPRIO + 1,
shellThread, (void *)&shell_cfg2);
}
/* Waiting for an exit event then freeing terminated shells.*/
chEvtWaitAny(EVENT_MASK(0));
if (chThdTerminatedX(shelltp1)) {
chThdFreeToHeap(shelltp1);
shelltp1 = NULL;
}
if (chThdTerminatedX(shelltp2)) {
chThdFreeToHeap(shelltp2);
shelltp2 = NULL;
}
}
else {
chThdSleepMilliseconds(1000);
}
}
}
CCM_FUNC static THD_FUNCTION(ThreadSDU, arg)
{
(void)arg;
uint8_t in_buffer[SERIAL_BUFFERS_SIZE];
uint8_t out_buffer[SERIAL_BUFFERS_SIZE];
//uint8_t buffer_check[SERIAL_BUFFERS_SIZE/2];
size_t in, out;
thread_t* th_shell = NULL;
chRegSetThreadName("SDU");
while(USBD1.state != USB_READY) chThdSleepMilliseconds(10);
while(SDU1.state != SDU_READY) chThdSleepMilliseconds(10);
while(SD3.state != SD_READY) chThdSleepMilliseconds(10);
// Enable K-line transceiver
palSetPad(PORT_KLINE_CS, PAD_KLINE_CS);
shellInit();
while (TRUE) {
if (settings.serialMode == SERIAL_MODE_SHELL) {
if (th_shell == NULL || chThdTerminatedX(th_shell)) {
th_shell = shellCreateStatic(&shell_cfg1, waThreadShell, sizeof(waThreadShell), NORMALPRIO +1);
}
chThdSleepMilliseconds(10);
continue;
}
if (settings.serialMode != SERIAL_MODE_KLINE) {
chThdSleepMilliseconds(10);
continue;
}
/* In case we stop it to change baudrate */
while (SD3.state != SD_READY) chThdSleepMilliseconds(10);
if (doKLineInit && 0)
{
sdStop(&SD3);
klineInit(false);
//fiveBaudInit(&SD3);
//sdReadTimeout(&SD3, buffer_check, 1, MS2ST(5)); // noise
doKLineInit = false;
sdStart(&SD3, &uart1Cfg);
}
in = chnReadTimeout(&SDU1, in_buffer, sizeof(in_buffer), TIME_IMMEDIATE);
out = sdReadTimeout(&SD3, out_buffer, sizeof(out_buffer), TIME_IMMEDIATE);
while (in == 0 && out == 0) {
chThdSleepMilliseconds(1);
in = chnReadTimeout(&SDU1, in_buffer, sizeof(in_buffer), TIME_IMMEDIATE);
out = sdReadTimeout(&SD3, out_buffer, sizeof(out_buffer), TIME_IMMEDIATE);
}
if (in > 0)
{
sdWriteTimeout(&SD3, in_buffer, in, MS2ST(10));
}
if (out > 0)
{
chnWriteTimeout(&SDU1, out_buffer, out, MS2ST(10));
}
}
return;
}
