/* * 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(); /* * 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); } }
void senokoShellInit(void) { sdStart(serialDriver, &serialConfig); stream = stream_driver; shellInit(); }
int main(void) { // copy vector table to SRAM1! #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wnonnull" memcpy((char *)0x20000000, (const char)0x00000000, 0x200); #pragma GCC diagnostic pop // remap SRAM1 to 0x00000000 SYSCFG->MEMRMP |= 0x03; halInit(); chSysInit(); sdcard_init(); sysmon_init(); #if ENABLE_SERIAL_DEBUG // SD2 for serial debug output palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7) | PAL_MODE_INPUT); // RX palSetPadMode(GPIOA, 2, PAL_MODE_OUTPUT_PUSHPULL); // TX palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); // TX // 115200 baud static const SerialConfig sd2Cfg = {115200, 0, 0, 0}; sdStart(&SD2, &sd2Cfg); chprintf((BaseSequentialStream * )&SD2,"Hello world!\r\n"); #endif exception_init(); InitPatch0(); InitPConnection(); InitPWM(); // display SPI CS? palSetPadMode(GPIOC, 1, PAL_MODE_OUTPUT_PUSHPULL); palSetPad(GPIOC, 1); chThdSleepMilliseconds(10); palSetPadMode(SW2_PORT, SW2_PIN, PAL_MODE_INPUT_PULLDOWN); axoloti_board_init(); codec_init(); if (!palReadPad(SW2_PORT, SW2_PIN)) { // button S2 not pressed // watchdog_init(); chThdSleepMilliseconds(1); } start_dsp_thread(); adc_init(); axoloti_math_init(); midi_init(); #if ((BOARD_AXOLOTI_V03)||(BOARD_AXOLOTI_V05)) axoloti_control_init(); #endif ui_init(); StartLoadPatchTread(); #if (BOARD_AXOLOTI_V05) configSDRAM(); //memTest(); #endif #ifdef ENABLE_USB_HOST MY_USBH_Init(); #endif if (!exception_check()) { // only try booting a patch when no exception is to be reported #if ((BOARD_AXOLOTI_V03)||(BOARD_AXOLOTI_V05)) sdcard_attemptMountIfUnmounted(); if (fs_ready && !palReadPad(SW2_PORT, SW2_PIN)){ // button S2 not pressed FRESULT res; // res = f_stat("/start.bin", NULL); // if (res == FR_OK) { LoadPatch("/start.bin"); // } } #endif // if no patch booting or running yet // try loading from flash if (patchStatus) { // patch in flash sector 11 memcpy((uint8_t *)PATCHMAINLOC, (uint8_t *)PATCHFLASHLOC, PATCHFLASHSIZE); if ((*(uint32_t *)PATCHMAINLOC != 0xFFFFFFFF) && (*(uint32_t *)PATCHMAINLOC != 0)) { if (!palReadPad(SW2_PORT, SW2_PIN)) // button S2 not pressed StartPatch(); } } } while (1) { 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; }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler }; Thread *shelltp = NULL; struct EventListener el0, el1; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Activates the serial driver 2 using the driver default configuration. */ sdStart(&SD2, NULL); /* * Shell manager initialization. */ shellInit(); /* * Initializes the MMC driver to work with SPI2. */ palSetPadMode(IOPORT2, GPIOB_SPI2NSS, PAL_MODE_OUTPUT_PUSHPULL); palSetPad(IOPORT2, GPIOB_SPI2NSS); mmcObjectInit(&MMCD1); mmcStart(&MMCD1, &mmccfg); /* * Activates the card insertion monitor. */ tmr_init(&MMCD1); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&inserted_event, &el0, 0); chEvtRegister(&removed_event, &el1, 1); while (TRUE) { if (!shelltp) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); else if (chThdTerminated(shelltp)) { chThdRelease(shelltp); /* Recovers memory of the previous shell. */ shelltp = NULL; /* Triggers spawning of a new shell. */ } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } return 0; }
/* * Application entry point. */ int main(void) { enum led_status lstat = LST_INIT; EventListener el0; alert_status_t proto_st = ALST_INIT; alert_status_t bmp085_st = ALST_INIT; alert_status_t mpu6050_st = ALST_INIT; alert_status_t hmc5883_st = ALST_INIT; /* * 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(); #ifdef BOARD_IMU_AHRF /* Clear DRDY pad */ palClearPad(GPIOA, GPIOA_DRDY); /* Activates serial */ sdStart(&SD1, NULL); sdStart(&SD2, NULL); /* Activate pwm */ pwmStart(&PWMD1, &pwm1cfg); /* Activate i2c */ i2cStart(&I2CD1, &i2c1cfg); /* Activate exti */ extStart(&EXTD1, &extcfg); #endif /* BOARD_IMU_AHRF */ #ifdef BOARD_CAPTAIN_PRO2 /* Activates serial */ sdStart(&SD3, NULL); sdStart(&SD4, NULL); /* Activate pwm */ pwmStart(&PWMD3, &pwm3cfg); pwmStart(&PWMD4, &pwm4cfg); pwmStart(&PWMD5, &pwm5cfg); /* Activate i2c */ i2cStart(&I2CD1, &i2c1cfg); /* Activate exti */ extStart(&EXTD1, &extcfg); /* Activate adc */ adcStart(&ADCD1, NULL); #endif /* BOARD_CAPTAIN_PRO2 */ /* alert subsys */ chEvtInit(&alert_event_source); chEvtRegister(&alert_event_source, &el0, 0); /* init devices */ pt_init(); chThdSleepMilliseconds(10); /* power on delay */ #ifdef HAS_DEV_BMP085 bmp085_init(); chThdSleepMilliseconds(50); /* init delay */ #endif #ifdef HAS_DEV_MS5611 ms5611_init(&ms5611cfg); chThdSleepMilliseconds(50); /* init delay */ #endif #ifdef HAS_DEV_MPU6050 mpu6050_init(&mpu6050cfg); chThdSleepMilliseconds(250); /* give some time for mpu6050 configuration */ #endif #ifdef HAS_DEV_HMC5883 hmc5883_init(&hmc5883cfg); #endif #ifdef HAS_DEV_SERVOPWM servopwm_init(&servopwmcfg); #endif #ifdef HAS_DEV_NTC10K ntc10k_init(); #endif #ifdef HAS_DEV_RPM rpm_init(); #endif #ifdef BOARD_IMU_AHRF /* Set DRDY pad */ palSetPad(GPIOA, GPIOA_DRDY); #endif while (TRUE) { eventmask_t msk = chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(100)); if (msk & EVENT_MASK(0)) { flagsmask_t fl = chEvtGetAndClearFlags(&el0); if (fl & ALERT_FLAG_PROTO) proto_st = pt_get_status(); #ifdef HAS_DEV_MPU6050 if (fl & ALERT_FLAG_MPU6050) mpu6050_st = mpu6050_get_status(); #endif #ifdef HAS_DEV_HMC5883 if (fl & ALERT_FLAG_HMC5883) hmc5883_st = hmc5883_get_status(); #endif #ifdef HAS_DEV_BMP085 if (fl & ALERT_FLAG_BMP085) bmp085_st = bmp085_get_status(); #endif #ifdef HAS_DEV_MS5611 if (fl & ALERT_FLAG_BMP085) bmp085_st = ms5611_get_status(); #endif pt_set_sens_state(mpu6050_st, hmc5883_st, bmp085_st); } if (proto_st == ALST_FAIL || mpu6050_st == ALST_FAIL || hmc5883_st == ALST_FAIL || bmp085_st == ALST_FAIL) lstat = LST_FAIL; else if (proto_st == ALST_INIT || mpu6050_st == ALST_INIT || hmc5883_st == ALST_INIT || bmp085_st == ALST_INIT) lstat = LST_INIT; else if (proto_st == ALST_NORMAL && mpu6050_st == ALST_NORMAL && hmc5883_st == ALST_NORMAL && bmp085_st == ALST_NORMAL) lstat = LST_NORMAL; led_update(lstat); } }
/* * 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 1 using the driver default configuration. * PA9 and PA10 are routed to USART1. */ sdStart(&SD1, NULL); palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(7)); /* * If the user button is pressed after the reset then the test suite is * executed immediately before activating the various device drivers in * order to not alter the benchmark scores. */ if (palReadPad(GPIOA, GPIOA_BUTTON)) TestThread(&SD1); /* * Initializes the SPI driver 2. The SPI2 signals are routed as follow: * PB12 - NSS. * PB13 - SCK. * PB14 - MISO. * PB15 - MOSI. */ spiStart(&SPID2, &spicfg); 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 ADC driver 1 and enable the thermal sensor. * The pin PC0 on the port GPIOC is programmed as analog input. */ adcStart(&ADCD1, NULL); adcSTM32EnableTSVREFE(); palSetPadMode(GPIOC, 0, PAL_MODE_INPUT_ANALOG); /* * Initializes the PWM driver 4, routes the TIM4 outputs to the board LEDs. */ pwmStart(&PWMD4, &pwmcfg); palSetPadMode(GPIOB, GPIOB_LED4, PAL_MODE_ALTERNATE(2)); palSetPadMode(GPIOB, GPIOB_LED3, PAL_MODE_ALTERNATE(2)); /* * Creates the example 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, when the button is * pressed the test procedure is launched with output on the serial * driver 1. */ while (TRUE) { if (palReadPad(GPIOA, GPIOA_BUTTON)) TestThread(&SD1); chThdSleepMilliseconds(500); } }
/* * Application entry point. */ int main(void) { Thread *shelltp = NULL; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Activates the serial driver 1 using the driver default configuration. */ sdStart(&SERIAL_DRIVER, NULL); /* * Shell manager initialization. */ shellInit(); /* * Activates the EXT driver. */ extStart(&EXTD1, &extcfg); /* * Activates the I2C driver. */ i2cStart(&I2C_DRIVER, &i2c1cfg); /* * Activates the SPI driver. */ spiStart(&SPI_DRIVER, &spi1cfg); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); chThdSleepMilliseconds(200); if (gyrotp == NULL) gyrotp = gyroRun(&SPI_DRIVER, NORMALPRIO); if (acctp == NULL) acctp = accRun(&I2C_DRIVER, NORMALPRIO); if (magtp == NULL) magtp = magRun(&I2C_DRIVER, NORMALPRIO); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and check the button state. */ while (TRUE) { if (!shelltp) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO - 1); else if (chThdTerminated(shelltp)) { chThdRelease(shelltp); shelltp = NULL; } chThdSleepMilliseconds(200); } }
int main(void) { DMA1_Stream0->CR=0; DMA1_Stream1->CR=0; DMA1_Stream2->CR=0; DMA1_Stream3->CR=0; DMA1_Stream4->CR=0; DMA1_Stream5->CR=0; DMA1_Stream6->CR=0; DMA1_Stream7->CR=0; DMA2_Stream0->CR=0; DMA2_Stream1->CR=0; DMA2_Stream2->CR=0; DMA2_Stream3->CR=0; DMA2_Stream4->CR=0; DMA2_Stream5->CR=0; DMA2_Stream6->CR=0; DMA2_Stream7->CR=0; palClearPad(GPIOD,7); // disable USBH power // copy vector table memcpy((char *)0x20000000, (const char *)&_vectors, 0x200); // remap SRAM1 to 0x00000000 SYSCFG->MEMRMP |= 0x03; // FMC_SDRAMDeInit(0); // RCC->AHB3RSTR |= 1; //RCC_AHB3RSTR_FMCRST RCC->AHB3ENR |= 1; //RCC_AHB3ENR_FMCEN; // HAL_DeInit(); // HAL_Init(); watchdog_feed(); 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); palSetPad(LED1_PORT,LED1_PIN); #ifdef LED2_PIN palSetPadMode(LED2_PORT,LED2_PIN,PAL_MODE_OUTPUT_PUSHPULL); #endif chSysInit(); watchdog_feed(); configSDRAM(); #ifdef SERIALDEBUG // SD2 for serial debug output palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7) | PAL_MODE_INPUT); // RX palSetPadMode(GPIOA, 2, PAL_MODE_OUTPUT_PUSHPULL); // TX palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); // TX // 115200 baud static const SerialConfig sd2Cfg = {115200, 0, 0, 0}; sdStart(&SD2, &sd2Cfg); #endif DBGPRINTCHAR('a'); uint32_t pbuf[16]; SDRAM_ReadBuffer(&pbuf[0], 0 + 0x050000, 16); DBGPRINTCHAR('x'); watchdog_feed(); uint32_t *sdram32 = (uint32_t *)SDRAM_BANK_ADDR; uint8_t *sdram8 = (uint8_t *)SDRAM_BANK_ADDR; if ((sdram8[0] != 'f') || (sdram8[1] != 'l') || (sdram8[2] != 'a') || (sdram8[3] != 's') || (sdram8[4] != 'c') || (sdram8[5] != 'o') || (sdram8[6] != 'p') || (sdram8[7] != 'y')) { DispayAbortErr(1); } DBGPRINTCHAR('b'); uint32_t flength = sdram32[2]; uint32_t fcrc = sdram32[3]; if (flength > 1 * 1024 * 1024) { DispayAbortErr(2); } DBGPRINTCHAR('c'); DBGPRINTHEX(flength); uint32_t ccrc = CalcCRC32((uint8_t *)(SDRAM_BANK_ADDR + 0x010), flength); DBGPRINTCHAR('d'); DBGPRINTHEX(ccrc); DBGPRINTHEX(fcrc); if (ccrc != fcrc) { DispayAbortErr(3); } DBGPRINTCHAR('e'); // unlock sequence FLASH->KEYR = 0x45670123; FLASH->KEYR = 0xCDEF89AB; uint32_t i; for (i = 0; i < 12; i++) { flash_Erase_sector(i); LCD_drawStringN(0, 3, "Erased sector", 128); LCD_drawNumber3D(80, 3, i); refresh_LCD(); palWritePad(LED2_PORT,LED2_PIN,1); chThdSleepMilliseconds(100); palWritePad(LED2_PORT,LED2_PIN,0); DBGPRINTCHAR('f'); DBGPRINTHEX(i); } DBGPRINTCHAR('g'); DBGPRINTHEX(flength); ccrc = CalcCRC32((uint8_t *)(SDRAM_BANK_ADDR + 0x010), flength); DBGPRINTCHAR('h'); DBGPRINTHEX(ccrc); DBGPRINTHEX(fcrc); if (ccrc != fcrc) { DispayAbortErr(4); } DBGPRINTCHAR('i'); int destptr = FLASH_BASE_ADDR; // flash base adress uint32_t *srcptr = (uint32_t *)(SDRAM_BANK_ADDR + 0x010); // sdram base adress + header offset for (i = 0; i < (flength + 3) / 4; i++) { uint32_t d = *srcptr; flash_ProgramWord(destptr, d); if ((FLASH->SR != 0) && (FLASH->SR != 1)) { DBGPRINTCHAR('z'); DBGPRINTHEX(FLASH->SR); } // DBGPRINTHEX(f); if ((i & 0xFFF) == 0) { palWritePad(LED2_PORT,LED2_PIN,1); chThdSleepMilliseconds(100); palWritePad(LED2_PORT,LED2_PIN,0); DBGPRINTCHAR('j'); DBGPRINTHEX(destptr); DBGPRINTHEX(*(srcptr)); } destptr += 4; srcptr++; } DBGPRINTCHAR('k'); ccrc = CalcCRC32((uint8_t *)(FLASH_BASE_ADDR), flength); DBGPRINTCHAR('l'); DBGPRINTHEX(ccrc); DBGPRINTHEX(fcrc); if (ccrc != fcrc) { DispayAbortErr(5); } DBGPRINTCHAR('\r'); DBGPRINTCHAR('\n'); DBGPRINTCHAR('S'); DBGPRINTCHAR('U'); DBGPRINTCHAR('C'); DBGPRINTCHAR('C'); DBGPRINTCHAR('E'); DBGPRINTCHAR('S'); DBGPRINTCHAR('S'); DBGPRINTCHAR('\r'); DBGPRINTCHAR('\n'); chThdSleepMilliseconds(1000); NVIC_SystemReset(); return 0; }
/* * Application entry point. */ int main(void) { RTCANConfig rtcan_config = {1000000, 100, 60}; Thread *shelltp = NULL; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Activates the serial driver 1 using the driver default configuration. */ sdStart(&SERIAL_DRIVER, NULL); /* * Shell manager initialization. */ shellInit(); rtcanInit(); rtcanStart (&RTCAND1, &rtcan_config); /* * Creates the blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Creates the subscriber thread #1. */ chThdCreateFromHeap (NULL, WA_SIZE_512B, NORMALPRIO + 1, SubscriberThread1, NULL); /* * Creates the subscriber thread #2. */ chThdCreateFromHeap (NULL, WA_SIZE_512B, NORMALPRIO + 1, SubscriberThread2, NULL); /* * Creates the RX thread. */ // chThdCreateFromHeap (NULL, WA_SIZE_512B, NORMALPRIO + 2, RxThread, NULL); Middleware & mw = Middleware::instance(); RemotePublisher rpub("led23", sizeof(LEDDataDebug)); rpub.id((123 << 8) | 40); mw.advertise(&rpub); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and check the button state. */ while (TRUE) { if (!shelltp) shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO - 1); else if (chThdTerminated(shelltp)) { chThdRelease(shelltp); shelltp = NULL; } chThdSleepMilliseconds(200); } }
/* * 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(); ADC2status = 0; //write_to_backup_sram(0, 0, 0); startBlinker(); /* initialize and clear the display */ gfxInit(); ginputGetMouse(0); //ginputSetMouseCalibrationRoutines(0, mysave, myload, FALSE); //ginputGetMouse(0); // new ugfx do not need this gwinAttachMouse(0); geventListenerInit(&gl); gwinAttachListener(&gl); //geventAttachSource(&gl, mouse, GLISTEN_MOUSEDOWNMOVES|GLISTEN_MOUSEMETA); //mouse = ginputGetMouse(0); //get screen size width = gdispGetWidth(); height = gdispGetHeight(); swidth = gdispGetWidth(); sheight = gdispGetHeight(); font = gdispOpenFont("UI2"); //startBlinker(); myADCinit(); ICUinit(); /* * Activates the serial driver 1 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)); chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL); //mouse = ginputGetMouse(0); font = gdispOpenFont("UI2"); gwinSetDefaultFont(font); gwinSetDefaultBgColor(Black); gwinSetDefaultColor(White); bHeight = gdispGetFontMetric(font, fontHeight)+2; #if BOOTSCREEN bootScreen(); #endif #ifdef LOGO gdispClear(Black); CreateLogo(); #endif // create main screen createWidgets(); chprintf( (BaseSequentialStream *)&SD2, "Main loop\r\n", NULL ); while (TRUE) { //get an event pe = geventEventWait(&gl, TIME_INFINITE); switch(pe->type) { case GEVENT_TOUCH: { pem = (GEventMouse *)pe; if ((pem->type & GMETA_MOUSE_CLICK)) { //gwinSetColor(ghc, Yellow); chprintf((BaseSequentialStream *)&SD2, "\r\n-touch-click"); } } case GEVENT_GWIN_BUTTON: if (((GEventGWinButton*)pe)->button == ghConsole) { gwinSetText(ghStatus2, "Console", TRUE); chprintf( (BaseSequentialStream *)&SD2, "\r\nConsole button", NULL ); }; break; case GEVENT_GWIN_SLIDER: if (((GEventGWinSlider*)pe)->slider == ghBrightness) { gdispSetBacklight(((GEventGWinSlider *)pe)->position); chprintf((BaseSequentialStream *)&SD2,"Slider %s = %d\r\n", gwinGetText(((GEventGWinSlider *)pe)->slider), ((GEventGWinSlider *)pe)->position); } break; default: break ; } } }
/* * Application entry point. */ int main(void) { static const evhandler_t evhndl[] = { WKUP_button_handler }; struct EventListener el0; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Initialize event structures BEFORE using them */ chEvtInit(&wkup_event); /* * Shell manager initialization. */ usbSerialShellStart(commands); // Enable Continuous GPT for 1ms Interval gptStart(&GPTD1, &gpt1cfg); gptStartContinuous(&GPTD1,10000); // Configure pins for Feedback ADC's palSetPadMode(GPIOA, GPIOA_PIN4, PAL_MODE_INPUT_ANALOG); palSetPadMode(GPIOA, GPIOA_PIN5, PAL_MODE_INPUT_ANALOG); // Configure pins for Input ADC's palSetPadMode(GPIOF, GPIOF_PIN6, PAL_MODE_INPUT_ANALOG); palSetPadMode(GPIOF, GPIOF_PIN7, PAL_MODE_INPUT_ANALOG); // Configure pins for LED's // PD3: Vertical Axis LED palSetPadMode(GPIOD, GPIOD_PIN3, PAL_MODE_OUTPUT_PUSHPULL); // PD4: Lateral Axis LED palSetPadMode(GPIOD, GPIOD_PIN4, PAL_MODE_OUTPUT_PUSHPULL); // Configure pins for switches // PD8: Drive Enable Switch palSetPadMode(GPIOD, GPIOD_PIN8, PAL_MODE_INPUT); // PD9: Mode Select Switch palSetPadMode(GPIOD, GPIOD_PIN9, PAL_MODE_INPUT); // Configure pins for long lead GMD Enable/Watchdog // PD5: Enable out to GMD palSetPadMode(GPIOD, GPIOD_PIN5, PAL_MODE_OUTPUT_PUSHPULL); // PD6: Watchdog out to GMD palSetPadMode(GPIOD, GPIOD_PIN6, PAL_MODE_OUTPUT_PUSHPULL); // Configure pins for short lead GMD Enable/Watchdog // PD10: Enable out to GMD palSetPadMode(GPIOD, GPIOD_PIN10, PAL_MODE_OUTPUT_PUSHPULL); // PD11: Watchdog out to GMD palSetPadMode(GPIOD, GPIOD_PIN11, PAL_MODE_OUTPUT_PUSHPULL); // Configure pins for PWM output (D12-D15: TIM4, channel 1-4) palSetPadMode(GPIOD, GPIOD_PIN12, PAL_MODE_ALTERNATE(2)); //U-pole, short lead palSetPadMode(GPIOD, GPIOD_PIN13, PAL_MODE_ALTERNATE(2)); //V-pole, short lead palSetPadMode(GPIOD, GPIOD_PIN14, PAL_MODE_ALTERNATE(2)); //U-pole, long lead palSetPadMode(GPIOD, GPIOD_PIN15, PAL_MODE_ALTERNATE(2)); //V-pole, long lead adcStart(&ADCD1, NULL); adcStart(&ADCD2, NULL); adcStart(&ADCD3, NULL); pwmStart(&PWMD4, &pwmcfg); // Enable TIM4 PWM channel 1-4 with initial DC=0% /* @param[in] pwmp pointer to a @p PWMDriver object * @param[in] channel PWM channel identifier (0...PWM_CHANNELS-1) * @param[in] width PWM pulse width as clock pulses number */ pwmEnableChannel(&PWMD4, 0, 0); pwmEnableChannel(&PWMD4, 1, 0); pwmEnableChannel(&PWMD4, 2, 0); pwmEnableChannel(&PWMD4, 3, 0); // Set axis control gain and limit values // Set Vertical Axis Gains vertAxisStruct.U16PositionPGain = 4; vertAxisStruct.U16PositionIGain = 1; vertAxisStruct.U16PositionDGain = 0; // Set vertical axis limits vertAxisStruct.U16CommandLimit = VERTICAL_COMMAND_LIMIT; vertAxisStruct.U16HighPosnLimit = 5100; vertAxisStruct.U16LowPosnLimit = 2480; // Set Lateral Axis Gains latAxisStruct.U16PositionPGain = 2; latAxisStruct.U16PositionIGain = 0; latAxisStruct.U16PositionDGain = 0; // Set lateral axis limits latAxisStruct.U16CommandLimit = LATERAL_COMMAND_LIMIT; latAxisStruct.U16HighPosnLimit = 5300; latAxisStruct.U16LowPosnLimit = 3100; /* * Activates the serial driver 6 and SDC driver 1 using default * configuration. */ sdStart(&SD6, NULL); /* * Activates the EXT driver 1. * This is for the external interrupt */ extStart(&EXTD1, &extcfg); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and listen for events. */ chEvtRegister(&wkup_event, &el0, 0); while (TRUE) { //Cycle motordrive if timer fails if(U32DelayCount++ > 2500){ motordrive(&GPTD1); } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
/* * 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); } }
/* * @brief console ... */ void Console::init(SerialDriver *drv) { this->_drv = drv; chMtxInit(&this->_mutex); sdStart(this->_drv, &this->_cfg); }
/* * Application entry point. */ int main(void) { uint8_t i; /* * 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(); palClearPad(IOPORT5, PORTE_LED); /* * Configure TX (PINC3) and RX (PIN2) for the USART1. */ palSetPadMode(IOPORT3, PIN3, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(IOPORT3, PIN2, PAL_MODE_INPUT_PULLUP); /* * Start the Serial driver 1 by using the default configuration. */ sdStart(&SD1, NULL); chprintf(chp, "\r\nChibiOS on XMEGA 128U4A.\r\n"); chprintf(chp, "This program is using trunk branch of the svn repo.\r\n"); chprintf(chp, "AES Encryption/Decryption testhal demo.\r\n"); chprintf(chp, "Example started...\r\n"); cryStart(&CRYD1, &cryConfig); res = cryLoadTransientKey(&CRYD1, (cryalgorithm_t) cry_algo_aes,16, key); res = cryEncryptAES(&CRYD1, tkey, data, data_encrypted); if (res != CRY_NOERROR) { chprintf(chp, "Encryption of data failed.\r\n"); while (true) { chThdSleepMilliseconds(100); } } else { chprintf(chp, "Encryption done.\r\n"); } res = cryDecryptAES(&CRYD1, tkey, data_encrypted, data_decrypted); if (res != CRY_NOERROR) { chprintf(chp, "Decryption of data failed.\r\n"); while (true) { chThdSleepMilliseconds(100); } } else { chprintf(chp, "Decryption done.\r\n"); } // Check if decrypted answer is equal to plaintext. for (i = 0; i < AES_BLOCK_SIZE ; i++ ) { if (data[i] != data_decrypted[i]) { chprintf(chp, "Decrypted data is not equal to data.\r\n"); while (true) { chThdSleepMilliseconds(100); } } } chprintf(chp, "Example ends up every thing is ok.\r\n"); /* * Starts the LED blinker thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); while (true) { chThdSleepMilliseconds(100); } return 0; }
/* * 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(); RCC->CFGR |= RCC_CFGR_MCO_HSI; /* * Activates the serial driver 1 using the driver default configuration. */ sdStart(&SD1, NULL); chprintf((BaseSequentialStream*)&SD1, "Hello world!\r\n"); palTogglePad(IOPORT2, GPIOB_LIGHT); pwmLightInit(); /* * If the user button is pressed after the reset then the test suite is * executed immediately before activating the various device drivers in * order to not alter the benchmark scores. */ // if (palReadPad(GPIOA, GPIOA_BUTTON)) // TestThread(&SD1); /* * Initializes the SPI driver 1. */ // spiStart(&SPID1, &spicfg); /* * Initializes the ADC driver 1. * The pin PC0 on the port GPIOC is programmed as analog input. */ // adcStart(&ADCD1, NULL); // palSetGroupMode(GPIOC, PAL_PORT_BIT(0), 0, PAL_MODE_INPUT_ANALOG); /* * Initializes the PWM driver 3, re-routes the TIM3 outputs, programs the * pins as alternate functions. * Note, the AFIO access routes the TIM3 output pins on the PC6...PC9 * where the LEDs are connected. */ /* pwmStart(&PWMD3, &pwmcfg); AFIO->MAPR |= AFIO_MAPR_TIM3_REMAP_0 | AFIO_MAPR_TIM3_REMAP_1; palSetGroupMode(GPIOC, PAL_PORT_BIT(GPIOC_LED3) | PAL_PORT_BIT(GPIOC_LED4), 0, PAL_MODE_STM32_ALTERNATE_PUSHPULL); */ /* * Creates the example 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, when the button is * pressed the test procedure is launched with output on the serial * driver 1. */ uint32_t cnt = 0; while (TRUE) { /* if (palReadPad(GPIOA, GPIOA_BUTTON)) TestThread(&SD1); */ chprintf((BaseSequentialStream*)&SD1, "Count %10d\r\n", cnt++); chThdSleepMilliseconds(1000); } }
/* * Application entry point. */ int main(void) { msg_t status = MSG_OK; systime_t tmo = MS2ST(4); /* * 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(); /* * Starts I2C */ i2cStart(&I2CD2, &i2cfg2); /* * Prepares the Serial driver 2 */ sdStart(&SD2, NULL); /* Default is 38400-8-N-1.*/ palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); /** * Prepares the accelerometer */ txbuf[0] = ACCEL_CTRL_REG1; /* register address */ txbuf[1] = 0x1; i2cAcquireBus(&I2CD2); status = i2cMasterTransmitTimeout(&I2CD2, mma8451_addr, txbuf, 2, rxbuf, 0, tmo); i2cReleaseBus(&I2CD2); if (status != MSG_OK){ errors = i2cGetErrors(&I2CD2); } /* * Normal main() thread activity, nothing in this test. */ while (TRUE) { palTogglePad(GPIOB, GPIOB_LED_B); chThdSleepMilliseconds(100); txbuf[0] = ACCEL_OUT_DATA; /* register address */ i2cAcquireBus(&I2CD2); status = i2cMasterTransmitTimeout(&I2CD2, mma8451_addr, txbuf, 1, rxbuf, 6, tmo); i2cReleaseBus(&I2CD2); if (status != MSG_OK){ errors = i2cGetErrors(&I2CD2); } acceleration_x = complement2signed(rxbuf[0], rxbuf[1]); acceleration_y = complement2signed(rxbuf[2], rxbuf[3]); acceleration_z = complement2signed(rxbuf[4], rxbuf[5]); print("x: "); printn(acceleration_x); print(" y: "); printn(acceleration_y); print(" z: "); printn(acceleration_z); println(""); } }
/* * Application entry point. */ int main(void) { Thread *shelltp0 = NULL; Thread *shelltp2 = NULL; unsigned int i = 0; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Initializes a serial-over-USB CDC driver. */ sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); // Activate all serial drivers. sdStart(&SD1, NULL); sdStart(&SD2, NULL); sdStart(&SD3, NULL); sdStart(&SD4, NULL); sdStart(&SD5, NULL); sdStart(&SD6, NULL); // Activates the UART driver 1, PA9(TX) and PA10(RX) are routed to USART1. palSetPadMode(GPIOB, 6, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOB, 7, PAL_MODE_ALTERNATE(7)); // Activates the UART driver 2, PA2(TX) and PA3(RX) are routed to USART2. palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); // Activates the UART driver 3, PB10(TX) and PB11(RX) are routed to USART3. palSetPadMode(GPIOB, 10, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOB, 11, PAL_MODE_ALTERNATE(7)); // Activates the UART driver 4, PC10(TX) and PC11(RX) are routed to UART4. palSetPadMode(GPIOC, 10, PAL_MODE_ALTERNATE(8)); palSetPadMode(GPIOC, 11, PAL_MODE_ALTERNATE(8)); // Activates the UART driver 5, PC12(TX) and PD2(RX) are routed to UART5. palSetPadMode(GPIOC, 12, PAL_MODE_ALTERNATE(8)); palSetPadMode(GPIOD, 2, PAL_MODE_ALTERNATE(8)); // Activates the UART driver 6, PC6(TX) and PC7(RX) are routed to USART6. palSetPadMode(GPIOC, 6, PAL_MODE_ALTERNATE(8)); palSetPadMode(GPIOC, 7, PAL_MODE_ALTERNATE(8)); /* * Activates the USB driver and then the USB bus pull-up on D+. * Note, a delay is inserted in order to not have to disconnect the cable * after a reset. */ usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(250); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); shellCreate(&shell_cfg2, SHELL_WA_SIZE, NORMALPRIO); shellCreate(&shell_cfg3, SHELL_WA_SIZE, NORMALPRIO); shellCreate(&shell_cfg4, SHELL_WA_SIZE, NORMALPRIO); shellCreate(&shell_cfg5, SHELL_WA_SIZE, NORMALPRIO); shellCreate(&shell_cfg6, SHELL_WA_SIZE, NORMALPRIO); /* * Normal main() thread activity, in this demo it just performs * a shell respawn upon its termination. */ while (true) { if (!shelltp0) { if (SDU1.config->usbp->state == USB_ACTIVE) { /* Spawns a new shell.*/ shelltp0 = shellCreate(&shell_cfg0, SHELL_WA_SIZE, NORMALPRIO); } } else { /* If the previous shell exited.*/ if (chThdTerminated(shelltp0)) { /* Recovers memory of the previous shell.*/ chThdRelease(shelltp0); shelltp0 = NULL; } } chThdSleepMilliseconds(1000); } }
/* * Application entry point. */ int main(void) { static thread_t *shelltp = NULL; static const evhandler_t evhndl[] = { InsertHandler, RemoveHandler }; event_listener_t el0, el1; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. * - 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 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, 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(GPIOA, GPIOA_BUTTON_WKUP) != 0) { } chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500))); } }
THD_FUNCTION(Thread1, arg) { (void)arg; /* * Activate the serial driver 0 using the driver default configuration. */ sdStart(&SD1, NULL); /* Activate the ADC driver 1 using its config */ adcStart(&ADCD1, &config); while (chnGetTimeout(&SD1, TIME_INFINITE)) { print(start_msg); chThdSleepMilliseconds(2000); /* Test 1 - 1ch1d, no circular */ run_test(test_1_msg, 1, 1, false); /* Test 2 - 1ch8d, no circular */ run_test(test_2_msg, 1, 8, false); /* Test 3 - 4chd1, no circular */ run_test(test_3_msg, 4, 1, false); /* Test 4 - 4ch8d, no circular */ run_test(test_4_msg, 4, 8, false); /* Test 5 - 1ch1d, circular */ run_test(test_5_msg, 1, 1, true); /* Test 6 - 1ch8d, circular */ run_test(test_6_msg, 1, 8, true); /* Test 7 - 4ch1d, circular */ run_test(test_7_msg, 4, 1, true); /* Test 8 - 4ch8d, circular */ run_test(test_8_msg, 4, 8, true); /* Test 9 - 1ch1d, synchronous */ print(test_9_msg); cb_arg = 0; group.num_channels = 1; group.circular = false; group.end_cb = adc_callback; cb_expect = 1; adcConvert(&ADCD1, &group, buffer, 1); while (ADCD1.state == ADC_ACTIVE) ; sniprintf(out_string, 128, chn_fmt_string, group.channels[0]); print(out_string); sniprintf(out_string, 128, raw_fmt_string, buffer[0]); print(out_string); buffer[0] = adcMSP430XAdjustTemp(&group, buffer[0]); sniprintf(out_string, 128, cooked_fmt_string, buffer[0]); print(out_string); if (cb_arg == cb_expect) { print(success_string); } else { print(fail_string); } } }
/* * Application entry point. */ int main(void) { float nick, roll, yaw; static const evhandler_t evhndl[] = {InsertHandler, RemoveHandler}; struct EventListener el0, el1; FRESULT err; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Activates the serial driver 2 using the driver default configuration. * PA2(TX) and PA3(RX) are routed to USART2. */ sdStart(&SD2, NULL); palSetPadMode(GPIOD, 5, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOD, 6, PAL_MODE_ALTERNATE(7)); setup_IMU(); setup_Fernsteuerung(); setup_Motoren(); setup_Regelung(); // initialize MMC driver // setup pads to SPI1 function (connect these pads to your SD card accordingly) palSetPadMode(GPIOC, 4, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST); // NSS palSetPadMode(GPIOA, 5, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); // SCK palSetPadMode(GPIOA, 6, PAL_MODE_ALTERNATE(5)); // MISO palSetPadMode(GPIOA, 7, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_HIGHEST); // MOSI palSetPad(GPIOC, 4); // set NSS high // initialize MMC driver mmcObjectInit(&MMCD1, &SPID1, &ls_spicfg, &hs_spicfg, mmc_is_protected, mmc_is_inserted); mmcStart(&MMCD1, NULL); chEvtRegister(&MMCD1.inserted_event, &el0, 0); chEvtRegister(&MMCD1.removed_event, &el1, 1); chThdSleepMilliseconds(7000); if(mmcConnect(&MMCD1)) { chprintf((BaseChannel *) &SD2, "SD: Failed to connect to card\r\n"); return; } else { chprintf((BaseChannel *) &SD2, "SD: Connected to card\r\n"); } err = f_mount(0, &MMC_FS); if(err != FR_OK) { chprintf((BaseChannel *) &SD2, "SD: f_mount() failed %d\r\n", err); mmcDisconnect(&MMCD1); return; } else { chprintf((BaseChannel *) &SD2, "SD: File system mounted\r\n"); } fs_ready = TRUE; rc = f_open(&Fil, "Quad.TXT", FA_WRITE | FA_CREATE_ALWAYS); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and check the button state, when the button is * pressed the test procedure is launched with output on the serial * driver 2. */ while (TRUE) { update_IMU(); //Ersetzen durch Interrupt Handler!!!!!! nick = getEuler_nick(); roll = getEuler_roll(); yaw = getEuler_yaw(); f_printf(&Fil, "%d;%d;%d\r\n",(int)(nick*100),(int)(roll*100),(int)(yaw*100)); rc = f_sync(&Fil); chThdSleepMilliseconds(10); } }
/* * Application entry point. */ int main(void) { unsigned i; gptcnt_t interval, threshold, worst; /* Enables FPU exceptions.*/ nvicEnableVector(FPU_IRQn, CORTEX_PRIORITY_MASK(1)); /* * 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(); /* * Prepares the Serial driver 2 and GPT drivers 2 and 3. */ sdStart(&SD2, NULL); /* Default is 38400-8-N-1.*/ palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); gptStart(&GPTD2, &gpt2cfg); gptStart(&GPTD3, &gpt3cfg); /* * Initializes the worker threads. */ chThdCreateStatic(waWorkerThread, sizeof waWorkerThread, NORMALPRIO - 20, WorkerThread, NULL); chThdCreateStatic(waPeriodicThread, sizeof waPeriodicThread, NORMALPRIO - 10, PeriodicThread, NULL); /* * Test procedure. */ println(""); println("*** ChibiOS/RT IRQ-STORM-FPU long duration test"); println("***"); print("*** Kernel: "); println(CH_KERNEL_VERSION); print("*** Compiled: "); println(__DATE__ " - " __TIME__); #ifdef CH_COMPILER_NAME print("*** Compiler: "); println(CH_COMPILER_NAME); #endif print("*** Architecture: "); println(CH_ARCHITECTURE_NAME); #ifdef CH_CORE_VARIANT_NAME print("*** Core Variant: "); println(CH_CORE_VARIANT_NAME); #endif #ifdef CH_PORT_INFO print("*** Port Info: "); println(CH_PORT_INFO); #endif #ifdef PLATFORM_NAME print("*** Platform: "); println(PLATFORM_NAME); #endif #ifdef BOARD_NAME print("*** Test Board: "); println(BOARD_NAME); #endif println("***"); print("*** System Clock: "); printn(STM32_SYSCLK); println(""); print("*** Iterations: "); printn(ITERATIONS); println(""); print("*** Randomize: "); printn(RANDOMIZE); println(""); println(""); worst = 0; for (i = 1; i <= ITERATIONS; i++){ print("Iteration "); printn(i); println(""); saturated = FALSE; threshold = 0; for (interval = 2000; interval >= 10; interval -= interval / 10) { gptStartContinuous(&GPTD2, interval - 1); /* Slightly out of phase.*/ gptStartContinuous(&GPTD3, interval + 1); /* Slightly out of phase.*/ chThdSleepMilliseconds(1000); gptStopTimer(&GPTD2); gptStopTimer(&GPTD3); if (!saturated) print("."); else { print("#"); if (threshold == 0) threshold = interval; } } /* Gives the worker threads a chance to empty the mailboxes before next cycle.*/ chThdSleepMilliseconds(20); println(""); print("Saturated at "); printn(threshold); println(" uS"); println(""); if (threshold > worst) worst = threshold; } gptStopTimer(&GPTD2); gptStopTimer(&GPTD3); print("Worst case at "); printn(worst); println(" uS"); println(""); println("Test Complete"); /* * Normal main() thread activity, nothing in this test. */ while (TRUE) { chThdSleepMilliseconds(5000); } }
/* * 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 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)); /* * If the user button is pressed after the reset then the test suite is * executed immediately before activating the various device drivers in * order to not alter the benchmark scores. */ if (palReadPad(GPIOA, GPIOA_BUTTON)) TestThread(&SD2); /* * 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 ADC driver 1 and enable the thermal sensor. * The pin PC0 on the port GPIOC is programmed as analog input. */ adcStart(&ADCD1, NULL); adcSTM32EnableTSVREFE(); palSetPadMode(GPIOC, 1, PAL_MODE_INPUT_ANALOG); /* * 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_LED6, PAL_MODE_ALTERNATE(2)); /* Blue. */ /* * Creates the example thread. */ chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); /* * Initializes the SPI driver 1 in order to access the MEMS. The signals * are initialized in the board file. * Several LIS302DL registers are then initialized. */ spiStart(&SPID1, &spi1cfg); lis302dlWriteRegister(&SPID1, LIS302DL_CTRL_REG1, 0x43); lis302dlWriteRegister(&SPID1, LIS302DL_CTRL_REG2, 0x00); lis302dlWriteRegister(&SPID1, LIS302DL_CTRL_REG3, 0x00); /* * Normal main() thread activity, in this demo it does nothing except * sleeping in a loop and check the button state, when the button is * pressed the test procedure is launched with output on the serial * driver 2. */ while (TRUE) { int8_t x, y, z; if (palReadPad(GPIOA, GPIOA_BUTTON)) TestThread(&SD2); x = (int8_t)lis302dlReadRegister(&SPID1, LIS302DL_OUTX); y = (int8_t)lis302dlReadRegister(&SPID1, LIS302DL_OUTY); z = (int8_t)lis302dlReadRegister(&SPID1, LIS302DL_OUTZ); chprintf((BaseChannel *)&SD2, "%d, %d, %d\r\n", x, y, z); 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; } }
CCM_FUNC static THD_FUNCTION(ThreadSDU, arg) { (void)arg; uint8_t in_buffer[SERIAL_BUFFERS_SIZE]; uint8_t out_buffer[SERIAL_BUFFERS_SIZE]; //uint8_t buffer_check[SERIAL_BUFFERS_SIZE/2]; size_t in, out; thread_t* th_shell = NULL; chRegSetThreadName("SDU"); while(USBD1.state != USB_READY) chThdSleepMilliseconds(10); while(SDU1.state != SDU_READY) chThdSleepMilliseconds(10); while(SD3.state != SD_READY) chThdSleepMilliseconds(10); // Enable K-line transceiver palSetPad(PORT_KLINE_CS, PAD_KLINE_CS); shellInit(); while (TRUE) { if (settings.serialMode == SERIAL_MODE_SHELL) { if (th_shell == NULL || chThdTerminatedX(th_shell)) { th_shell = shellCreateStatic(&shell_cfg1, waThreadShell, sizeof(waThreadShell), NORMALPRIO +1); } chThdSleepMilliseconds(10); continue; } if (settings.serialMode != SERIAL_MODE_KLINE) { chThdSleepMilliseconds(10); continue; } /* In case we stop it to change baudrate */ while (SD3.state != SD_READY) chThdSleepMilliseconds(10); if (doKLineInit && 0) { sdStop(&SD3); klineInit(false); //fiveBaudInit(&SD3); //sdReadTimeout(&SD3, buffer_check, 1, MS2ST(5)); // noise doKLineInit = false; sdStart(&SD3, &uart1Cfg); } in = chnReadTimeout(&SDU1, in_buffer, sizeof(in_buffer), TIME_IMMEDIATE); out = sdReadTimeout(&SD3, out_buffer, sizeof(out_buffer), TIME_IMMEDIATE); while (in == 0 && out == 0) { chThdSleepMilliseconds(1); in = chnReadTimeout(&SDU1, in_buffer, sizeof(in_buffer), TIME_IMMEDIATE); out = sdReadTimeout(&SD3, out_buffer, sizeof(out_buffer), TIME_IMMEDIATE); } if (in > 0) { sdWriteTimeout(&SD3, in_buffer, in, MS2ST(10)); } if (out > 0) { chnWriteTimeout(&SDU1, out_buffer, out, MS2ST(10)); } } return; }
THD_FUNCTION(Thread1, arg) { (void)arg; /* * Activate the serial driver 0 using the driver default configuration. */ sdStart(&SD0, NULL); while (chnGetTimeout(&SD0, TIME_INFINITE)) { chnWrite(&SD0, (const uint8_t *)start_msg, strlen(start_msg)); chThdSleepMilliseconds(2000); /* Test 1 - use DMA engine to execute a word-wise memory-to-memory copy. */ chnWrite(&SD0, (const uint8_t *)test_1_msg, strlen(test_1_msg)); strcpy(instring, "After DMA test \r\n"); strcpy(outstring, "Before DMA test \r\n"); if (strcmp("Before DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } request = &test_1_req; chSysLock(); dmaRequestS(request, TIME_INFINITE); chSysUnlock(); if (strcmp("After DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } /* Test 2 - use DMA engine to execute a byte-wise memory-to-memory copy. */ chnWrite(&SD0, (const uint8_t *)test_2_msg, strlen(test_2_msg)); strcpy(instring, "After DMA test \r\n"); strcpy(outstring, "Before DMA test \r\n"); if (strcmp("Before DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } request = &test_2_req; chSysLock(); dmaRequestS(request, TIME_INFINITE); chSysUnlock(); if (strcmp("After DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } /* Test 3 - use DMA engine to execute a word-wise memory-to-memory set. */ chnWrite(&SD0, (const uint8_t *)test_3_msg, strlen(test_3_msg)); strcpy(instring, "After DMA test \r\n"); strcpy(outstring, "Before DMA test \r\n"); if (strcmp("Before DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } request = &test_3_req; chSysLock(); dmaRequestS(request, TIME_INFINITE); chSysUnlock(); if (strcmp("AAAAAAAAAAAAAAAA\r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } /* Test 4 - use DMA engine to execute a word-wise memory-to-memory copy, * then call a callback. */ chnWrite(&SD0, (const uint8_t *)test_4_msg, strlen(test_4_msg)); strcpy(instring, "After DMA test \r\n"); strcpy(outstring, "Before DMA test \r\n"); cb_arg = 1; if (strcmp("Before DMA test \r\n", outstring) || (cb_arg != 1)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } request = &test_4_req; chSysLock(); dmaRequestS(request, TIME_INFINITE); chSysUnlock(); if (strcmp("After DMA test \r\n", outstring) || cb_arg) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } /* Test 5 - use exclusive DMA channel 0 to execute a word-wise * memory-to-memory copy. */ chnWrite(&SD0, (const uint8_t *)test_5_msg, strlen(test_5_msg)); strcpy(instring, "After DMA test \r\n"); strcpy(outstring, "Before DMA test \r\n"); if (strcmp("Before DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } request = &test_5_req; chSysLock(); dmaAcquireI(&ch, 0); chSysUnlock(); dmaTransfer(&ch, request); if (strcmp("After DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } /* Test 6 - Attempt to claim DMA channel 0, fail, release it, attempt to * claim it again */ chnWrite(&SD0, (const uint8_t *)test_6_msg, strlen(test_6_msg)); chSysLock(); result = dmaAcquireI(&ch, 0); chSysUnlock(); if (!result) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } dmaRelease(&ch); chSysLock(); result = dmaAcquireI(&ch, 0); chSysUnlock(); if (result) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } dmaRelease(&ch); /* Test 7 - use exclusive DMA channel 1 to execute a word-wise * memory-to-memory copy. */ chnWrite(&SD0, (const uint8_t *)test_7_msg, strlen(test_7_msg)); strcpy(instring, "After DMA test \r\n"); strcpy(outstring, "Before DMA test \r\n"); if (strcmp("Before DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } request = &test_5_req; chSysLock(); dmaAcquireI(&ch, 1); chSysUnlock(); dmaTransfer(&ch, request); if (strcmp("After DMA test \r\n", outstring)) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } dmaRelease(&ch); /* Test 8 - Claim all 3 DMA channels, attempt dmaRequest, fail */ chnWrite(&SD0, (const uint8_t *)test_8_msg, strlen(test_8_msg)); chSysLock(); result = dmaAcquireI(&ch, 0); chSysUnlock(); if (result) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } chSysLock(); result = dmaAcquireI(&ch1, 1); chSysUnlock(); if (result) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } chSysLock(); result = dmaAcquireI(&ch2, 2); chSysUnlock(); if (result) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } chSysLock(); result_i = dmaRequestS(request, TIME_IMMEDIATE); chSysUnlock(); if (result_i > 0) { chnWrite(&SD0, (const uint8_t *)fail_string, strlen(fail_string)); } else { chnWrite(&SD0, (const uint8_t *)succeed_string, strlen(succeed_string)); } dmaRelease(&ch); dmaRelease(&ch1); dmaRelease(&ch2); } }
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) { unsigned i; gptcnt_t interval, threshold, worst; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); /* * Activates the serial driver 1, PA9 and PA10 are routed to USART1. */ sdStart(&SD1, NULL); palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(7)); /* USART1 TX. */ palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(7)); /* USART1 RX. */ /* * Activates GPTs. */ gptStart(&GPTD2, &gpt2cfg); gptStart(&GPTD3, &gpt3cfg); /* * Initializes the mailboxes and creates the worker threads. */ for (i = 0; i < NUM_THREADS; i++) { chMBInit(&mb[i], b[i], MAILBOX_SIZE); chThdCreateStatic(waWorkerThread[i], sizeof waWorkerThread[i], NORMALPRIO - 20, WorkerThread, (void *)i); } /* * Test procedure. */ println(""); println("*** ChibiOS/RT IRQ-STORM long duration test"); println("***"); print("*** Kernel: "); println(CH_KERNEL_VERSION); print("*** Compiled: "); println(__DATE__ " - " __TIME__); #ifdef CH_COMPILER_NAME print("*** Compiler: "); println(CH_COMPILER_NAME); #endif print("*** Architecture: "); println(CH_ARCHITECTURE_NAME); #ifdef CH_CORE_VARIANT_NAME print("*** Core Variant: "); println(CH_CORE_VARIANT_NAME); #endif #ifdef CH_PORT_INFO print("*** Port Info: "); println(CH_PORT_INFO); #endif #ifdef PLATFORM_NAME print("*** Platform: "); println(PLATFORM_NAME); #endif #ifdef BOARD_NAME print("*** Test Board: "); println(BOARD_NAME); #endif println("***"); print("*** System Clock: "); printn(STM32_SYSCLK); println(""); print("*** Iterations: "); printn(ITERATIONS); println(""); print("*** Randomize: "); printn(RANDOMIZE); println(""); print("*** Threads: "); printn(NUM_THREADS); println(""); print("*** Mailbox size: "); printn(MAILBOX_SIZE); println(""); println(""); worst = 0; for (i = 1; i <= ITERATIONS; i++){ print("Iteration "); printn(i); println(""); saturated = FALSE; threshold = 0; for (interval = 2000; interval >= 10; interval -= interval / 10) { gptStartContinuous(&GPTD2, interval - 1); /* Slightly out of phase.*/ gptStartContinuous(&GPTD3, interval + 1); /* Slightly out of phase.*/ chThdSleepMilliseconds(1000); gptStopTimer(&GPTD2); gptStopTimer(&GPTD3); if (!saturated) print("."); else { print("#"); if (threshold == 0) threshold = interval; } } /* Gives the worker threads a chance to empty the mailboxes before next cycle.*/ chThdSleepMilliseconds(20); println(""); print("Saturated at "); printn(threshold); println(" uS"); println(""); if (threshold > worst) worst = threshold; } gptStopTimer(&GPTD2); gptStopTimer(&GPTD3); print("Worst case at "); printn(worst); println(" uS"); println(""); println("Test Complete"); /* * Normal main() thread activity, nothing in this test. */ while (TRUE) { chThdSleepMilliseconds(5000); } }
/* * Application entry point. */ int main(void) { int8_t accelData[2]={0,0}; // Discovery Board's Accelerometer uint8_t receivedBuff[4]={0,0,0,0}; // Received request/information from PandaBoard uint8_t sentData[4] = {0,0,0,0}; // Returned Information (reply) to the PandaBoard float imuData[7]={0,0,0,0,0,0,0}; // IMU calculated data based on Razor Boad int* razorInfo; // Razor Board Data int steering = 0; int speed = 0; int ir_data[3]={0,0,0}; int16_t us_data[3]={0,0,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(); mypwmInit(); // Initializing Motor motorInit(); // Initializing IR Thread ADCinit(); // Initializing US Thread // myUltrasonicInit(); // Initializing Discovery Board's Accelerometer //mySPIinit(); // Initializing Razor Board myRazorInit(); // Activates the USB driver and then the USB bus pull-up on D+. myUSBinit(); // Initializing IMU Calculations. initIMU(); //Starting the usb configuration sdStart(&SDU1,&portConfig2); char receivedInfo[11]; /* * Main loop, it takes care of reciving the requests from Panda Board using USB protocol, * and reply with the requested data. */ while (TRUE) { receivedInfo[0]='T'; sdRead(&SDU1, receivedInfo, 10); // getImuValues(imuData); // getAccel(accelData); // getIR(ir_data); // getUS(us_data); if(receivedInfo[0] != 'T'){ receivedInfo[11]='\0'; parse(receivedInfo); //setMotorData(-(rcvData[1]-28),rcvData[2]-2); setMotorData(rcvData[1],1550); translate(rcvData[0],ir_data,us_data,razorInfo,imuData,accelData,sentData); sdWrite(&SDU1, sentData, 4); } } }