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 *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); } }
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(); 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); } }
/* * 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); } }
/** * @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) { /* * 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); } }
/* * 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) { static thread_t *shelltp = NULL; static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler }; event_listener_t el0, el1; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); /* * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1500); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); /* * Shell manager initialization. */ shellInit(); /* * Activates the card insertion monitor. */ tmr_init(&SDCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); while (true) { if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE)) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminatedX(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
void 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); } } }
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; }
/* * 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(&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); /* * Stopping and restarting the USB in order to test the stop procedure. The * following lines are not usually required. */ chThdSleepMilliseconds(3000); usbDisconnectBus(serusbcfg.usbp); usbStop(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 && (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. */ } chThdSleepMilliseconds(1000); } }
/* * 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(); lwipInit(NULL); /* * 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 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 HTTP thread (it changes priority internally). */ chThdCreateStatic(wa_http_server, sizeof(wa_http_server), NORMALPRIO + 1, http_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 && (SDU1.config->usbp->state == USB_ACTIVE)) { shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO + 1, shellThread, (void *)&shell_cfg1); } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
/* * Application entry point. */ int main(void) { /* * 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); /* LSM303DLHC Object Initialization.*/ lsm303dlhcObjectInit(&LSM303DLHCD1); /* Activates the LSM303DLHC driver.*/ lsm303dlhcStart(&LSM303DLHCD1, &lsm303dlhccfg); /* Normal main() thread activity, printing MEMS data on the SDU1.*/ while (true) { lsm303dlhcAccelerometerReadRaw(&LSM303DLHCD1, accraw); chprintf(chp, "LSM303DLHC Accelerometer raw data...\r\n"); for(i = 0; i < LSM303DLHC_ACC_NUMBER_OF_AXES; i++) { chprintf(chp, "%c-axis: %d\r\n", axisID[i], accraw[i]); } lsm303dlhcCompassReadRaw(&LSM303DLHCD1, compraw); chprintf(chp, "LSM303DLHC Compass raw data...\r\n"); for(i = 0; i < LSM303DLHC_COMP_NUMBER_OF_AXES; i++) { chprintf(chp, "%c-axis: %d\r\n", axisID[i], compraw[i]); } lsm303dlhcAccelerometerReadCooked(&LSM303DLHCD1, acccooked); chprintf(chp, "LSM303DLHC Accelerometer cooked data...\r\n"); for(i = 0; i < LSM303DLHC_ACC_NUMBER_OF_AXES; i++) { chprintf(chp, "%c-axis: %.3f\r\n", axisID[i], acccooked[i]); } lsm303dlhcCompassReadCooked(&LSM303DLHCD1, compcooked); chprintf(chp, "LSM303DLHC Compass cooked data...\r\n"); for(i = 0; i < LSM303DLHC_COMP_NUMBER_OF_AXES; i++) { chprintf(chp, "%c-axis: %.3f\r\n", axisID[i], compcooked[i]); } chThdSleepMilliseconds(100); cls(chp); } lsm303dlhcStop(&LSM303DLHCD1); }