void USBInit() { /* * Shell manager initialization. */ shellInit(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU1); // Init full duplex driver object. Pointer to SerialUSBDriver Struct sduStart(&SDU1, &serusbcfg); // Configures and starts the driver. Pointer to SerialUSBDriver // and serial over usb configuration. /* * 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); // Configures and activates the USB peripheral usbConnectBus(serusbcfg.usbp); // Connects the USB Device }
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 UsbCDC_t::Connect() { usbDisconnectBus(SerUsbCfg.usbp); chThdSleepMilliseconds(1500); usbStart(SerUsbCfg.usbp, &UsbCfg); usbConnectBus(SerUsbCfg.usbp); }
/* * 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))); } }
/* * 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); } }
/** * @brief Init function executed in first lines of tests. Started properly Chibios and ARM */ void init(void) { /* * 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(); /* Timer configuration.*/ rccEnableTIM3(FALSE); rccResetTIM3(); rccEnableTIM4(FALSE); rccResetTIM4(); TIM3->CR1 = 0; /* Initially stopped. */ TIM4->CR1 = 0; /* Initially stopped. */ TIM3->CR2 = TIM_CR2_MMS_1; TIM3->PSC = ((STM32_TIMCLK2 / 1000000) - 1); /* Prescaler value. */ TIM3->SR = 0; /* Clear pending IRQs. */ TIM3->DIER = 0; TIM3->SMCR = TIM_SMCR_MSM; TIM4->CR2 = 0; TIM4->PSC = 0; /* Prescaler value. */ TIM4->SR = 0; /* Clear pending IRQs. */ TIM4->DIER = 0; TIM4->SMCR = TIM_SMCR_TS_1 | TIM_SMCR_MSM | TIM_SMCR_SMS_2 | TIM_SMCR_SMS_1 | TIM_SMCR_SMS_0; TIM4->CR1 = TIM_CR1_CEN; TIM3->CNT = 0; /* Initially stopped. */ TIM4->CNT = 0; /* Initially stopped. */ start_count_time(); chThdSleepMilliseconds(1000); stop_count_time(); /* * 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(250); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * Stopping and restarting the USB in order to test the stop procedure. The * following lines are not usually required. */ chThdSleepMilliseconds(3000); info("---------------ECDSA ECDH Test Suite---------------"); info("CPU frequency %f MHz", STM32_SYSCLK/1000000.0); info("---------------------------------------------------"); info("-----------------Timer second test-----------------"); info("Start timer and wait 1 sec"); start_count_time(); chThdSleepMilliseconds(1000); stop_count_time(); info("Timer result 1sec = %u us", get_us()); info("---------------------------------------------------"); }
/* * 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); } } }
/** * @brief Application entry point. * @details */ int main(void) { /* 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. */ usbStop(serusbcfg.usbp); usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(500); usbConnectBus(serusbcfg.usbp); usbStart(serusbcfg.usbp, &usbcfg); /* Activates the serial driver 4 using the driver's default configuration. */ sdStart(&SD4, NULL); /* Activates the I2C driver 2. */ i2cInit(); i2cStart(&I2CD2, &i2cfg_d2); /* Enables the CRC peripheral clock. */ rccEnableCRC(FALSE); /* Loads settings from external EEPROM chip. */ if (eepromLoadSettings()) { g_boardStatus |= EEPROM_24C02_DETECTED; } /* Initializes the MPU6050 sensor. */ if (mpu6050Init()) { g_boardStatus |= MPU6050_LOW_DETECTED; /* Creates a taken binary semaphore. */ chBSemInit(&bsemNewDataReady, TRUE); /* Creates the MPU6050 polling thread and attitude calculation thread. */ chThdCreateStatic(waPollMPU6050Thread, sizeof(waPollMPU6050Thread), NORMALPRIO + 1, PollMPU6050Thread, NULL); chThdCreateStatic(waAttitudeThread, sizeof(waAttitudeThread), HIGHPRIO, AttitudeThread, NULL); /* Starts motor drivers. */ pwmOutputStart(); /* Starts ADC and ICU input drivers. */ mixedInputStart(); } /* Creates the blinker thread. */ chThdCreateStatic(waBlinkerThread, sizeof(waBlinkerThread), LOWPRIO, BlinkerThread, NULL); /* Normal main() thread activity. */ while (TRUE) { g_chnp = serusbcfg.usbp->state == USB_ACTIVE ? (BaseChannel *)&SDU1 : (BaseChannel *)&SD4; telemetryReadSerialData(); if (eepromIsDataLeft()) { eepromContinueSaving(); } chThdSleepMilliseconds(TELEMETRY_SLEEP_MS); } /* This point should never be reached. */ return 0; }
int main(void) { Thread * pub_tp = NULL; Thread * sub_tp = NULL; halInit(); chSysInit(); /* * Initializes a serial-over-USB CDC driver. */ #if USE_USB_SERIAL sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); #endif /* * 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. */ #if USE_USB_SERIAL usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); #endif /* Start the serial driver. */ #if !USE_USB_SERIAL sdStart(&SD3, NULL); #endif for (;;) { #if USE_USB_SERIAL if (!pub_tp && (SDU1.config->usbp->state == USB_ACTIVE)) { #else if (!pub_tp) { #endif pub_tp = chThdCreateFromHeap(NULL, THD_WA_SIZE(2048), NORMALPRIO, rosserial_pub_thread, NULL); } else if (chThdTerminated(pub_tp)) { chThdRelease(pub_tp); pub_tp = NULL; } chThdSleepMilliseconds(123); #if USE_USB_SERIAL if (!sub_tp && (SDU1.config->usbp->state == USB_ACTIVE)) { #else if (!sub_tp) { #endif sub_tp = chThdCreateFromHeap(NULL, THD_WA_SIZE(2048), NORMALPRIO, rosserial_sub_thread, NULL); } else if (chThdTerminated(sub_tp)) { chThdRelease(sub_tp); sub_tp = NULL; } chThdSleepMilliseconds(500); } return CH_SUCCESS; } }
/* * Application entry point. */ int main(void) { /* * 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(); #if defined(F042) /* This is needed to remap the USB pins PA11,PA12 onto the default PA9,PA10 * so that the USB works. After halInit (which changes that register). * This also means that USART1 can't be used, as it is on PA9,PA10. */ SYSCFG->CFGR1 |= SYSCFG_CFGR1_PA11_PA12_RMP; #endif /* F042 */ chSysInit(); /* * Setup button pad */ palSetPadMode(BUTTON_GPIO, BUTTON_PIN, BUTTON_MODE); /* * Create the blinker thread. */ chThdCreateStatic(waBlinkThr, sizeof(waBlinkThr), NORMALPRIO, BlinkThr, NULL); /* * Setup things for wiegand */ wieg_init(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&OUTPUT_CHANNEL); sduStart(&OUTPUT_CHANNEL, &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); led_blink = 1; /* * Shell manager initialization. */ shellInit(); /* * The main loop. */ /* while(true) { if((palReadPad(BUTTON_GPIO, BUTTON_PIN) == BUTTON_ACTIVE) && (OUTPUT_CHANNEL.config->usbp->state == USB_ACTIVE)) { // sdWrite(&OUTPUT_CHANNEL, (uint8_t *)"hello world\r\n", 13); // chprintf((BaseSequentialStream *)&OUTPUT_CHANNEL, "Hello world\r\n"); chnPutTimeout(&OUTPUT_CHANNEL, 'W', TIME_IMMEDIATE); // wieg_send(wieg_test_buf, 26); led_blink = 1; chThdSleepMilliseconds(200); // chnWrite((BaseChannel *)&OUTPUT_CHANNEL, (uint8_t *)"Hello, world\r\n", 14); } msg_t charbuf; charbuf = chnGetTimeout(&OUTPUT_CHANNEL, TIME_IMMEDIATE); if(charbuf != Q_TIMEOUT) { switch(charbuf) { default: chprintf((BaseSequentialStream *)&OUTPUT_CHANNEL, "Haloooo\r\n"); break; } // chnPutTimeout(&OUTPUT_CHANNEL, (uint8_t)charbuf, TIME_IMMEDIATE); // if(charbuf == '\r') { // chnPutTimeout(&OUTPUT_CHANNEL, '\n', TIME_IMMEDIATE); // } } chThdSleepMilliseconds(50); } */ /* * Normal main() thread activity, spawning shells. */ while (true) { msg_t c; if(serusbcfg.usbp->state == USB_ACTIVE) { c = chnGetTimeout(&OUTPUT_CHANNEL, TIME_IMMEDIATE); if(c != Q_TIMEOUT) { switch(c) { case 'k': if(unlock_pw_recved==0) { unlock_pw_recved++; led_blink = 1; } break; case 'o': if(unlock_pw_recved==1) { unlock_pw_recved++; led_blink = 1; } break; case 'j': if(unlock_pw_recved==2) { unlock_pw_recved++; led_blink = 1; } break; case 'a': if(unlock_pw_recved==3) { unlock_pw_recved++; led_blink = 1; } break; } } if(unlock_pw_recved == 4) { unlock_pw_recved = 0; thread_t *shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO + 1, shellThread, (void *)&shell_cfg1); chThdWait(shelltp); /* Waiting termination. */ } } chThdSleepMilliseconds(50); } }
/* * 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); } }
int main(void) { /* * 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+. * */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * * Start I2C and set up sensors * */ i2cStart(&I2CD2, &i2cfg2); /* Initialize Accelerometer and Gyroscope */ if (MPU6050Init(&mpu6050cfg) != MSG_OK) panic("MPU6050 init failed"); /* Initialization failed */ /* Initialize Magnetometer */ if (HMC5983Init(&hmc5983cfg) != MSG_OK) panic("HMC5983 init failed"); /* Initialization failed */ /* Initialize Barometer */ /* TODO: Add barometer code */ /* Initialize sensor readout */ if (SensorReadInit(&mpu6050cfg, &hmc5983cfg, &mpu6050cal, &hmc5983cal) != MSG_OK) panic("Sensor Read init failed"); /* Initialization failed */ /* * * Start the external interrupts * */ extStart(&EXTD1, &extcfg); /* * * Initialize the RC Outputs * */ if (RCOutputInit(&rcoutputcfg) != MSG_OK) panic("RC output init failed"); /* Initialization failed */ /* * * Start RC Inputs * */ eicuInit(); eicuStart(&EICUD9, &rcinputcfg); eicuEnable(&EICUD9); /* * * Start test thread * */ chThdCreateStatic( waThreadTestEvents, sizeof(waThreadTestEvents), HIGHPRIO, ThreadTestEvents, NULL); while(1) { chThdSleepMilliseconds(100); if (isUSBActive() == true) chprintf((BaseSequentialStream *)&SDU1, "Input width: %u\r\n", ic_test); } }
void InitHardware() { // Pin configuration for motors/ESCs palSetPadMode(GPIOA, 4, PAL_MODE_ALTERNATE(2)); // motor 1 -> PA4 : TIM3 CH2 palSetPadMode(GPIOA, 6, PAL_MODE_ALTERNATE(2)); // motor 2 -> PA6 : TIM3 CH1 palSetPadMode(GPIOB, 0, PAL_MODE_ALTERNATE(2)); // motor 3 -> PB0 : TIM3 CH3 palSetPadMode(GPIOB, 1, PAL_MODE_ALTERNATE(2)); // motor 4 -> PB1 : TIM3 CH4 // Timer 3 used for all motors pwmStart(&PWMD3, &pwmcfg); PWMD3.tim->CR1=0; // Disable counter PWMD3.tim->CNT=0; // Reset timer counter // Enable timer 1 Channel 0 pwmEnableChannel(&PWMD3, 1, THROTTLE_MIN); pwmEnableChannel(&PWMD3, 0, THROTTLE_MIN); pwmEnableChannel(&PWMD3, 2, THROTTLE_MIN); pwmEnableChannel(&PWMD3, 3, THROTTLE_MIN); PWMD3.tim->CCMR2|=(7<<4)|(7<<12); // PWM mode 2 PWMD3.tim->CCMR2&=~((1<<3)|(1<<11)); // Clear OC1PE PWMD3.tim->CCMR1|=(7<<4)|(7<<12); // PWM mode 2 PWMD3.tim->CCMR1&=~((1<<3)|(1<<11)); // Clear OC1PE /* * I2C I/O pins setup. */ palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(4)); palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(4)); i2cStart(&I2CD2, &i2cconfig); #if LOG /* * SPI2 I/O pins setup. */ palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5) |PAL_STM32_OSPEED_HIGHEST); /* New SCK. */ palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(5) |PAL_STM32_OSPEED_HIGHEST); /* New MISO. */ palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); /* New MOSI. */ palSetPadMode(GPIOB, 12, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST); /* New CS. */ palSetPad(GPIOB, 12); #endif /* * LEDs settings */ palSetPadMode(GPIOB, 5, PAL_MODE_OUTPUT_PUSHPULL); /* SCK. */ TURN_LED_OFF(); #if BUZZER /* * UART Inverter settings */ palSetPadMode(GPIOA, 0, PAL_MODE_OUTPUT_PUSHPULL); /* SCK. */ palClearPad(GPIOA, 0); #endif /* * UART Receiver pin */ palSetPadMode(GPIOB, 4, PAL_MODE_ALTERNATE(7)); /* UART 6 RX. */ /* * 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. */ #if (DEBUG_MODE || LOG) sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); #endif }
int main(void) { /* * Start OS and HAL */ halInit(); chSysInit(); setupIPC(); DEBUGEN(printf("App Mode\n")); usbDisconnectBus(&USBD1); /* * Initialize extra driver objects. */ sduObjectInit(&SDU1); sduObjectInit(&SDU2); /* * Start peripherals */ sdStart(&SD1, &uart1Cfg); sdStart(&SD2, &uart2Cfg); sdStart(&SD3, &uart3Cfg); usbStart(&USBD1, &usbcfg); sduStart(&SDU1, &serusbcfg1); sduStart(&SDU2, &serusbcfg2); canStart(&CAND1, &cancfg); dacStart(&DACD1, &dac1cfg1); adcStart(&ADCD1, NULL); adcStart(&ADCD3, NULL); timcapStart(&TIMCAPD3, &tc_conf); pwmStart(&PWMD_LED2, &pwmcfg); eeInit(); // Compare and update versions in EEprom if needed. version_t v; if (readVersionFromEE(VERSION_IDX_APP, &v) == 0 && memcmp(&versions, &v, sizeof(version_t)) != 0) { writeVersionToEE(VERSION_IDX_APP, &versions[VERSION_IDX_APP]); } if (readVersionFromEE(VERSION_IDX_BL, &v) == 0 ) { memcpy(&versions[VERSION_IDX_BL], &v, sizeof(version_t)); } /* * Creates the threads. */ chThdCreateStatic(waThreadBDU, sizeof(waThreadBDU), NORMALPRIO+5, ThreadBDU, NULL); chThdCreateStatic(waThreadSDU, sizeof(waThreadSDU), NORMALPRIO+2, ThreadSDU, NULL); chThdCreateStatic(waThreadADC, sizeof(waThreadADC), NORMALPRIO, ThreadADC, NULL); chThdCreateStatic(waThreadKnock, sizeof(waThreadKnock), NORMALPRIO, ThreadKnock, NULL); chThdCreateStatic(waThreadCAN, sizeof(waThreadCAN), NORMALPRIO, ThreadCAN, NULL); chThdCreateStatic(waThreadSER1, sizeof(waThreadSER1), NORMALPRIO, ThreadSER1, NULL); chThdCreateStatic(waThreadRecord, sizeof(waThreadRecord), NORMALPRIO+1, ThreadRecord, NULL); chThdCreateStatic(waThreadWdg, sizeof(waThreadWdg), HIGHPRIO, ThreadWdg, NULL); /* Create last as it uses pointers from above */ chThdCreateStatic(waThreadMonitor, sizeof(waThreadMonitor), NORMALPRIO+10, ThreadMonitor, NULL); while (TRUE) { while(USBD1.state != USB_READY) chThdSleepMilliseconds(10); chThdSleepMilliseconds(100); if (usbConnected()) { usbConnectBus(&USBD1); } else { usbDisconnectBus(&USBD1); } } }
/* * 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) { /* * 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 and SDC driver 1 using default * configuration. */ sdStart(&SD6, NULL); BaseSequentialStream *chp = (BaseSequentialStream *)&SD6; chprintf(chp, "running main()\r\n"); chThdSleepMilliseconds(50); #if STM32_USB_USE_OTG2 USBDriver *usb_driver = &USBD2; #else USBDriver *usb_driver = &USBD1; #endif /* * Activates the card insertion monitor. */ init_sd(); chprintf(chp, "done starting SDC\r\n"); const bool_t sdcConnectStatus = sdcConnect(&SDCD1); if( sdcConnectStatus != CH_SUCCESS ) { chprintf(chp, "failed to connect to SD Card, sdcConnectStatus = %u\r\n", sdcConnectStatus); for(;;) { chThdSleepMilliseconds(3000); } } chprintf(chp, "setting up MSD\r\n"); const usb_msd_driver_state_t msd_driver_state = msdInit(usb_driver, (BaseBlockDevice*)&SDCD1, &UMSD1, USB_MS_DATA_EP, USB_MSD_INTERFACE_NUMBER); if( msd_driver_state != USB_MSD_DRIVER_OK ) { chprintf(chp, "Error initing USB MSD, %d %s\r\n", msd_driver_state, usb_msd_driver_state_t_to_str(msd_driver_state)); } UMSD1.chp = chp; chprintf(chp, "Initializing SDU1...\r\n"); serusbcfg.usbp = usb_driver; sduObjectInit(&SDU1); /*Disconnect the USB Bus*/ usbDisconnectBus(usb_driver); chThdSleepMilliseconds(200); /*Start the useful functions*/ sduStart(&SDU1, &serusbcfg); msdStart(&UMSD1); usbStart(usb_driver, &msd_usb_config); /*Connect the USB Bus*/ usbConnectBus(usb_driver); /* * Creates the blinker thread. */ chprintf(chp, "starting blinker thread\r\n"); chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); while (TRUE) { palTogglePad(GPIOC, GPIOC_LED); chThdSleepMilliseconds(500); } }
/* Callback for SETUP request on the endpoint 0 (control) */ static bool usb_request_hook_cb(USBDriver *usbp) { const USBDescriptor *dp; /* usbp->setup fields: * 0: bmRequestType (bitmask) * 1: bRequest * 2,3: (LSB,MSB) wValue * 4,5: (LSB,MSB) wIndex * 6,7: (LSB,MSB) wLength (number of bytes to transfer if there is a data phase) */ /* Handle HID class specific requests */ if(((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) && ((usbp->setup[0] & USB_RTYPE_RECIPIENT_MASK) == USB_RTYPE_RECIPIENT_INTERFACE)) { switch(usbp->setup[0] & USB_RTYPE_DIR_MASK) { case USB_RTYPE_DIR_DEV2HOST: switch(usbp->setup[1]) { /* bRequest */ case HID_GET_REPORT: switch(usbp->setup[4]) { /* LSB(wIndex) (check MSB==0?) */ case KEYBOARD_INTERFACE: #ifdef NKRO_ENABLE case NKRO_INTERFACE: #endif /* NKRO_ENABLE */ usbSetupTransfer(usbp, (uint8_t *)&keyboard_report_sent, sizeof(keyboard_report_sent), NULL); return TRUE; break; #ifdef MOUSE_ENABLE case MOUSE_INTERFACE: usbSetupTransfer(usbp, (uint8_t *)&mouse_report_blank, sizeof(mouse_report_blank), NULL); return TRUE; break; #endif /* MOUSE_ENABLE */ #ifdef EXTRAKEY_ENABLE case EXTRAKEY_INTERFACE: if(usbp->setup[3] == 1) { /* MSB(wValue) [Report Type] == 1 [Input Report] */ switch(usbp->setup[2]) { /* LSB(wValue) [Report ID] */ case REPORT_ID_SYSTEM: extra_report_blank[0] = REPORT_ID_SYSTEM; usbSetupTransfer(usbp, (uint8_t *)extra_report_blank, sizeof(extra_report_blank), NULL); return TRUE; break; case REPORT_ID_CONSUMER: extra_report_blank[0] = REPORT_ID_CONSUMER; usbSetupTransfer(usbp, (uint8_t *)extra_report_blank, sizeof(extra_report_blank), NULL); return TRUE; break; default: return FALSE; } } else { return FALSE; } break; #endif /* EXTRAKEY_ENABLE */ default: usbSetupTransfer(usbp, NULL, 0, NULL); return TRUE; break; } break; case HID_GET_PROTOCOL: if((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */ usbSetupTransfer(usbp, &keyboard_protocol, 1, NULL); return TRUE; } break; case HID_GET_IDLE: usbSetupTransfer(usbp, &keyboard_idle, 1, NULL); return TRUE; break; } break; case USB_RTYPE_DIR_HOST2DEV: switch(usbp->setup[1]) { /* bRequest */ case HID_SET_REPORT: switch(usbp->setup[4]) { /* LSB(wIndex) (check MSB==0 and wLength==1?) */ case KEYBOARD_INTERFACE: #ifdef NKRO_ENABLE case NKRO_INTERFACE: #endif /* NKRO_ENABLE */ /* keyboard_led_stats = <read byte from next OUT report> * keyboard_led_stats needs be word (or dword), otherwise we get an exception on F0 */ usbSetupTransfer(usbp, (uint8_t *)&keyboard_led_stats, 1, NULL); return TRUE; break; } break; case HID_SET_PROTOCOL: if((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */ keyboard_protocol = ((usbp->setup[2]) != 0x00); /* LSB(wValue) */ #ifdef NKRO_ENABLE keymap_config.nkro = !!keyboard_protocol; if(!keymap_config.nkro && keyboard_idle) { #else /* NKRO_ENABLE */ if(keyboard_idle) { #endif /* NKRO_ENABLE */ /* arm the idle timer if boot protocol & idle */ osalSysLockFromISR(); chVTSetI(&keyboard_idle_timer, 4*MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp); osalSysUnlockFromISR(); } } usbSetupTransfer(usbp, NULL, 0, NULL); return TRUE; break; case HID_SET_IDLE: keyboard_idle = usbp->setup[3]; /* MSB(wValue) */ /* arm the timer */ #ifdef NKRO_ENABLE if(!keymap_config.nkro && keyboard_idle) { #else /* NKRO_ENABLE */ if(keyboard_idle) { #endif /* NKRO_ENABLE */ osalSysLockFromISR(); chVTSetI(&keyboard_idle_timer, 4*MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp); osalSysUnlockFromISR(); } usbSetupTransfer(usbp, NULL, 0, NULL); return TRUE; break; } break; } } /* Handle the Get_Descriptor Request for HID class (not handled by the default hook) */ if((usbp->setup[0] == 0x81) && (usbp->setup[1] == USB_REQ_GET_DESCRIPTOR)) { dp = usbp->config->get_descriptor_cb(usbp, usbp->setup[3], usbp->setup[2], get_hword(&usbp->setup[4])); if(dp == NULL) return FALSE; usbSetupTransfer(usbp, (uint8_t *)dp->ud_string, dp->ud_size, NULL); return TRUE; } for (int i=0;i<NUM_USB_DRIVERS;i++) { if (drivers.array[i].config.int_in) { // NOTE: Assumes that we only have one serial driver return qmkusbRequestsHook(usbp); } } return FALSE; } /* Start-of-frame callback */ static void usb_sof_cb(USBDriver *usbp) { kbd_sof_cb(usbp); osalSysLockFromISR(); for (int i=0; i<NUM_USB_DRIVERS;i++) { qmkusbSOFHookI(&drivers.array[i].driver); } osalSysUnlockFromISR(); } /* USB driver configuration */ static const USBConfig usbcfg = { usb_event_cb, /* USB events callback */ usb_get_descriptor_cb, /* Device GET_DESCRIPTOR request callback */ usb_request_hook_cb, /* Requests hook callback */ usb_sof_cb /* Start Of Frame callback */ }; /* * Initialize the USB driver */ void init_usb_driver(USBDriver *usbp) { for (int i=0; i<NUM_USB_DRIVERS;i++) { QMKUSBDriver* driver = &drivers.array[i].driver; drivers.array[i].in_ep_config.in_state = &drivers.array[i].in_ep_state; drivers.array[i].out_ep_config.out_state = &drivers.array[i].out_ep_state; drivers.array[i].int_ep_config.in_state = &drivers.array[i].int_ep_state; qmkusbObjectInit(driver, &drivers.array[i].config); qmkusbStart(driver, &drivers.array[i].config); } /* * 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(usbp); wait_ms(1500); usbStart(usbp, &usbcfg); usbConnectBus(usbp); chVTObjectInit(&keyboard_idle_timer); } /* --------------------------------------------------------- * Keyboard functions * --------------------------------------------------------- */ /* keyboard IN callback hander (a kbd report has made it IN) */ void kbd_in_cb(USBDriver *usbp, usbep_t ep) { /* STUB */ (void)usbp; (void)ep; }
static msg_t thdUsbStorage(void *arg) { (void) arg; // unused chRegSetThreadName("UsbStorage:polling"); uint antiBounce=5; EventListener connected; // Should use EXTI interrupt instead of active polling, // but in the chibios_opencm3 implementation, since EXTI is // used via libopencm3, ISR are routed on pprz/opencm3 and cannot // be used concurrently by chibios api // Should be fixed when using chibios-rt branch while (!chThdShouldTerminate() && antiBounce) { const bool_t usbConnected = palReadPad (GPIOA, GPIOA_OTG_FS_VBUS); if (usbConnected) antiBounce--; else antiBounce=5; chThdSleepMilliseconds(20); } isRunning = true; chRegSetThreadName("UsbStorage:connected"); /* Stop the logs*/ chibios_logFinish (true); /* connect sdcard sdc interface sdio */ if (sdioConnect () == false) chThdExit (RDY_TIMEOUT); /* initialize the USB mass storage driver */ msdInit(&UMSD1); /* start the USB mass storage service */ msdStart(&UMSD1, &msdConfig); /* start the USB driver */ usbDisconnectBus(&USBD1); chThdSleepMilliseconds(1000); usbStart(&USBD1, &usbConfig); usbConnectBus(&USBD1); /* wait for a real usb storage connexion before shutting down autopilot */ chEvtRegisterMask(&UMSD1.evt_connected, &connected, EVENT_MASK(1)); chEvtWaitOne(EVENT_MASK(1)); /* stop autopilot */ if (pprzThdPtr != NULL) { chThdTerminate (pprzThdPtr); chThdWait (pprzThdPtr); pprzThdPtr = NULL; } /* wait until usb-storage is unmount and usb cable is unplugged*/ while (!chThdShouldTerminate() && palReadPad (GPIOA, GPIOA_OTG_FS_VBUS)) { chThdSleepMilliseconds(10); } /* then close open descriptors and reboot autopilot */ usbDisconnectBus(&USBD1); chThdSleepMilliseconds(500); msdStop(&UMSD1); sdioDisconnect (); MCU_RESTART(); return RDY_OK; }
/* * 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) { /* * 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); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO + 1, Thread1, NULL); /* * L3GD20 Object Initialization */ l3gd20ObjectInit(&L3GD20D1); /* * Activates the L3GD20 driver. */ l3gd20Start(&L3GD20D1, &l3gd20cfg); while(!palReadLine(LINE_BUTTON)){ chprintf(chp, "Press BTN to calibrate gyroscope...\r\n"); chThdSleepMilliseconds(150); #if CHPRINTF_USE_ANSI_CODE chprintf(chp, "\033[2J\033[1;1H"); #endif } chprintf(chp, "Calibrating Gyroscope sampling bias...\r\n"); chprintf(chp, "Keep it in the rest position while red LED is on\r\n"); chThdSleepMilliseconds(3000); palSetLine(LINE_LED10_RED); chThdSleepMilliseconds(1000); gyroscopeSampleBias(&L3GD20D1); palClearLine(LINE_LED10_RED); #if CHPRINTF_USE_ANSI_CODE chprintf(chp, "\033[2J\033[1;1H"); #endif while (TRUE) { palToggleLine(LINE_LED10_RED); gyroscopeReadRaw(&L3GD20D1, rawdata); for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) chprintf(chp, "RAW-%c:%d\r\n", axesID[i], rawdata[i]); gyroscopeReadCooked(&L3GD20D1, cookeddata); for(i = 0; i < L3GD20_NUMBER_OF_AXES; i++) chprintf(chp, "COOKED-%c:%.3f\r\n", axesID[i], cookeddata[i]); gyroscopeGetTemp(&L3GD20D1, &temperature); chprintf(chp, "TEMP:%.1f C°\r\n", temperature); chThdSleepMilliseconds(150); #if CHPRINTF_USE_ANSI_CODE chprintf(chp, "\033[2J\033[1;1H"); #endif } l3gd20Stop(&L3GD20D1); }
/** 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); } }
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_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 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))); } }
int main(void) { halInit(); chSysInit(); timestamp_stm32_init(); board_io_pwr_en(true); board_sensor_pwr_en(true); error_init(); // standard output sdStart(&UART_CONN1, NULL); stdout = (BaseSequentialStream*)&UART_CONN1; chprintf(stdout, "\n\n\n"); log_init(); log_handler_register(&log_handler_stdout, LOG_LVL_DEBUG, log_handler_stdout_cb); log_info("=== boot ==="); led_start(); // mount SD card board_power_cycle_sdcard(); sdcStart(&SDCD1, NULL); sdcard_mount(); static char logdir[100]; if (sdcard_find_next_file_name_with_prefix("/", "log_", logdir, sizeof(logdir)) < 0) { log_error("could not determine log file directory"); } FRESULT res = f_mkdir(logdir); if (!(res == FR_OK || res == FR_EXIST)) { log_warning("could not create log directory %s", logdir); } size_t logdir_strlen = strlen(logdir); if (sdcard_is_mounted()) { // add .txt to logdir strncpy(&logdir[logdir_strlen], "/log.txt", sizeof(logdir) - logdir_strlen); logdir[sizeof(logdir)-1] = '\0'; sdcard_log_handler_init(logdir, LOG_LVL_INFO); logdir[logdir_strlen] = '\0'; // reset log dir string } log_boot_message(); // initialization parameter_namespace_declare(¶meters, NULL, NULL); // root namespace parameter_string_declare_with_default(&board_name, ¶meters, "name", board_name_p_buf, sizeof(board_name_p_buf), "ins-board"); msgbus_init(&bus); services_init(); // load parameters from SD card log_info("loading parameters from sd card"); sdcard_read_parameter(¶meters, "/config.msgpack"); chprintf(stdout, "current parameters:"); parameter_print(¶meters, (parameter_printfn_t)chprintf, stdout); // UART driver io_setup(); // USB serial driver sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(100); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); // start all services services_start(logdir); // shellInit(); // char buf[STREAM_DEV_STR_SIZE]; // parameter_string_get(&shell_port, buf, sizeof(buf)); // BaseSequentialStream* shell_dev = get_base_seq_stream_device_from_str(buf); // static thread_t *shelltp = NULL; // static ShellConfig shell_cfg; // shell_cfg.sc_channel = shell_dev; // shell_cfg.sc_commands = shell_commands; chThdSleepMilliseconds(500); while (true) { // if (shelltp == NULL && shell_dev != NULL) { // static THD_WORKING_AREA(shell_wa, 2048); // shelltp = shellCreateStatic(&shell_cfg, shell_wa, sizeof(shell_wa), THD_PRIO_SHELL); // } else if (shelltp != NULL && chThdTerminatedX(shelltp)) { // shelltp = NULL; // } log_debug("VCC %f", analog_get_vcc()); log_debug("Temp %f", analog_get_cpu_temp()); log_debug("V_DC %f", analog_get_vdc()); log_debug("CONN2_TX %f", analog_get_voltage(ANALOG_CH_CONN2_TX)); log_debug("CONN2_RX %f", analog_get_voltage(ANALOG_CH_CONN2_RX)); log_debug("CONN3_TX %f", analog_get_voltage(ANALOG_CH_CONN3_TX)); log_debug("CONN3_RX %f", analog_get_voltage(ANALOG_CH_CONN3_RX)); 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) { /* * 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(&SDU2); sduStart(&SDU2, &serusbcfg); /* * GPIOI1 is programmed as output (board LED). */ palClearLine(LINE_ARD_D13); palSetLineMode(LINE_ARD_D13, PAL_MODE_OUTPUT_PUSHPULL); /* * 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, spawning shells. */ while (true) { if (SDU2.config->usbp->state == USB_ACTIVE) { thread_t *shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO + 1, shellThread, (void *)&shell_cfg1); chThdWait(shelltp); } #if 0 if (palReadPad(GPIOI, GPIOI_BUTTON_USER)) { usbDisconnectBus(serusbcfg.usbp); usbStop(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); } #endif 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(); /* * 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); } }
static msg_t LinkMgrThread(void *arg){ (void)arg; chRegSetThreadName("LinkManager"); uint32_t sh = *sh_overxbee; // cached previouse value /* * 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); /* wait slowpoked modems */ chThdSleepMilliseconds(3000); /* define what we need to run based on flag */ if (sh == 1){ SpawnShellThreads(&XBEESD); SpawnMavlinkThreads(&SDU1); } else{ SpawnShellThreads(&SDU1); SpawnMavlinkThreads(&XBEESD); } /* say to all that modem is ready */ setGlobalFlag(GlobalFlags.modem_ready); /* now track changes of flag and fork appropriate threads */ while (TRUE) { chThdSleepMilliseconds(200); if(sh != *sh_overxbee){ // state changed sh = *sh_overxbee; KillShellThreads(); KillMavlinkThreads(); chThdSleepMilliseconds(1); // sdStop(&XBEESD); // sdStart(&XBEESD, &xbee_ser_cfg); // // sduStop(&SDU1); // sduStart(&SDU1, &serusbcfg); // purge queues to be safer // chSysLock(); // chIQResetI(&(SDU1.iqueue)); // chIQResetI(&(SDU1.oqueue)); // chIQResetI(&(XBEESD.iqueue)); // chIQResetI(&(XBEESD.oqueue)); // chSysUnlock(); // now spawn threads with proper serial drivers if (sh == 1){ SpawnShellThreads(&XBEESD); SpawnMavlinkThreads(&SDU1); } else{ SpawnShellThreads(&SDU1); SpawnMavlinkThreads(&XBEESD); } } } return 0; }
int main(void) { // copy vector table memcpy((char *)0x20000000, (const char *)&_vectors, 0x200); // remap SRAM1 to 0x00000000 SYSCFG->MEMRMP |= 0x03; /* system & hardware initialization */ halInit(); // float usb inputs, hope the host notices detach... palSetPadMode(GPIOA, 11, PAL_MODE_INPUT); palSetPadMode(GPIOA, 12, PAL_MODE_INPUT); // setup LEDs palSetPadMode(LED1_PORT,LED1_PIN,PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(LED2_PORT, LED2_PIN, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(LED1_PORT,LED1_PIN); palSetPad(LED2_PORT,LED2_PIN); chSysInit(); palSetPadMode(GPIOA, 11, PAL_MODE_ALTERNATE(10)); palSetPadMode(GPIOA, 12, PAL_MODE_ALTERNATE(10)); palSetPadMode(GPIOC, 8, PAL_MODE_ALTERNATE(12) | PAL_STM32_OSPEED_HIGHEST); palSetPadMode(GPIOC, 9, PAL_MODE_ALTERNATE(12) | PAL_STM32_OSPEED_HIGHEST); palSetPadMode(GPIOC, 10, PAL_MODE_ALTERNATE(12) | PAL_STM32_OSPEED_HIGHEST); palSetPadMode(GPIOC, 11, PAL_MODE_ALTERNATE(12) | PAL_STM32_OSPEED_HIGHEST); palSetPadMode(GPIOC, 12, PAL_MODE_ALTERNATE(12) | PAL_STM32_OSPEED_HIGHEST); palSetPadMode(GPIOD, 2, PAL_MODE_ALTERNATE(12) | PAL_STM32_OSPEED_HIGHEST); chThdSleepMilliseconds(50); /* initialize the SD card */ sdcStart(&SDCD1, NULL); sdcConnect(&SDCD1); /* initialize the USB mass storage driver */ msdInit(&UMSD1); /* turn off green LED, turn on red LED */ palSetPadMode(LED1_PORT, LED1_PIN, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(LED1_PORT, LED1_PIN); palSetPadMode(LED2_PORT, LED2_PIN, PAL_MODE_OUTPUT_PUSHPULL); palSetPad(LED2_PORT, LED2_PIN); /* start the USB mass storage service */ int ret = msdStart(&UMSD1, &msdConfig); if (ret != 0) { /* no media found : bye bye !*/ usbDisconnectBus(&USBD1); chThdSleepMilliseconds(1000); NVIC_SystemReset(); } /* watch the mass storage events */ EventListener connected; EventListener ejected; chEvtRegisterMask(&UMSD1.evt_connected, &connected, EVENT_MASK(1)); chEvtRegisterMask(&UMSD1.evt_ejected, &ejected, EVENT_MASK(2)); /* start the USB driver */ usbDisconnectBus(&USBD1); chThdSleepMilliseconds(1000); usbStart(&USBD1, &usbConfig); usbConnectBus(&USBD1); while (TRUE) { eventmask_t event = chEvtWaitOne(EVENT_MASK(1) | EVENT_MASK(2)); if (event == EVENT_MASK(1)) { /* media connected */ } else if (event == EVENT_MASK(2)) { /* media ejected : bye bye !*/ usbDisconnectBus(&USBD1); chThdSleepMilliseconds(1000); NVIC_SystemReset(); } } return 0; }