/******************************************************************************* * Main Routine *******************************************************************************/ int main (void) { printf("\n\rInitializing SD Card...\r\n"); /* Initialize SPI driver and SD Card */ if(RES_OK != disk_initialize(SD)) { printf("Failed to initialize SD disk\r\n"); while(1); } if(FR_OK != fatdemo()) { printf("FAT Demo failed\r\n"); g_card_initialized = 0; } /* if the SD card is initialized, enable the USB MSD device */ if(g_card_initialized) { usbd_init(); usbd_connect(__TRUE); usb_state = USB_CONNECTING; while (!usbd_configured ()); /* Wait for device to configure */ } EnableInterrupts; while(1) { Delayms(500); } }
void test_dcd_init_failed(void) { dcd_init_ExpectAndReturn(TUSB_ERROR_FAILED); //------------- Code Under Test -------------// TEST_ASSERT_EQUAL(TUSB_ERROR_FAILED, usbd_init() ); }
/*===========================================================================* * main * *===========================================================================*/ int main(int UNUSED(argc), char * UNUSED(argv[])) { int ret_val; USB_MSG("Starting USBD"); USB_MSG("Built: %s %s", __DATE__, __TIME__); /* Basic SEF,DDE,... initialization */ usbd_init(); /* Assume failure unless usbd_start exits gracefully */ ret_val = EXIT_FAILURE; /* USB host controllers initialization */ if (EXIT_SUCCESS == usbd_init_hcd()) { /* Try initializing 'devman' */ if (EXIT_SUCCESS == devman_init()) { /* Run USB driver (actually DDEKit threads) * until this call returns: */ ret_val = usbd_start(); } else USB_MSG("Initializing devman, failed"); /* Clean whatever was initialized */ usbd_deinit_hcd(); } else USB_MSG("Initializing HCDs, failed"); return ret_val; }
void test_usbd_string_descriptor(void) { dcd_init_IgnoreAndReturn(TUSB_ERROR_FAILED); //------------- Code Under Test -------------// TEST_ASSERT_EQUAL( TUSB_ERROR_FAILED, usbd_init() ); //------------- manufacturer string descriptor -------------// uint32_t const manufacturer_len = sizeof(TUSB_CFG_DEVICE_STRING_MANUFACTURER) - 1; TEST_ASSERT_EQUAL(manufacturer_len*2 + 2, app_tusb_desc_strings.manufacturer.bLength); for(uint32_t i=0; i<manufacturer_len; i++) { TEST_ASSERT_EQUAL(TUSB_CFG_DEVICE_STRING_MANUFACTURER[i], app_tusb_desc_strings.manufacturer.unicode_string[i]); } //------------- product string descriptor -------------// uint32_t const product_len = sizeof(TUSB_CFG_DEVICE_STRING_PRODUCT) - 1; TEST_ASSERT_EQUAL(product_len*2 + 2, app_tusb_desc_strings.product.bLength); for(uint32_t i=0; i < product_len; i++) { TEST_ASSERT_EQUAL(TUSB_CFG_DEVICE_STRING_PRODUCT[i], app_tusb_desc_strings.product.unicode_string[i]); } //------------- serial string descriptor -------------// uint32_t const serial_len = sizeof(TUSB_CFG_DEVICE_STRING_SERIAL) - 1; TEST_ASSERT_EQUAL(serial_len*2 + 2, app_tusb_desc_strings.serial.bLength); for(uint32_t i=0; i<serial_len; i++) { TEST_ASSERT_EQUAL(TUSB_CFG_DEVICE_STRING_SERIAL[i], app_tusb_desc_strings.serial.unicode_string[i]); } }
void init_usb(void) { usbd_dev = usbd_init(&stm32f103_usb_driver, &dev, &config, usb_strings, 3, usbd_control_buffer, sizeof(usbd_control_buffer)); usbd_register_control_callback( usbd_dev, USB_REQ_TYPE_VENDOR, USB_REQ_TYPE_TYPE, control_request); }
void setup_usb_fullspeed() { gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9 | GPIO11 | GPIO12); gpio_set_af(GPIOA, GPIO_AF10, GPIO9 | GPIO11 | GPIO12); usbd_init(&otgfs_usb_driver, &dev, &config, usb_strings); usbd_register_set_config_callback(cdcacm_set_config); }
void test_usbd_init(void) { dcd_init_ExpectAndReturn(TUSB_ERROR_NONE); class_init_epxect(); dcd_controller_connect_Expect(0); //------------- Code Under Test -------------// TEST_ASSERT_STATUS( usbd_init() ); }
usbd_device* cmp_usb_setup(void) { int num_strings = sizeof(usb_strings)/sizeof(const char*); const usbd_driver* driver = target_usb_init(); usbd_device* usbd_dev = usbd_init(driver, &dev, &config, usb_strings, num_strings, usbd_control_buffer, sizeof(usbd_control_buffer)); usbd_register_set_config_callback(usbd_dev, cmp_usb_set_config); usbd_register_reset_callback(usbd_dev, cmp_usb_handle_reset); return usbd_dev; }
usbd_device *usbd_create(void) { usbd_device *usbd; if (!(usbd = usbd_init(&otgfs_usb_driver, &__usbdev_desc, &__usbconf_desc, __usb_strings, 3, __usbd_buf, sizeof(__usbd_buf)))) return NULL; usbd_register_set_config_callback(usbd, __cdcacm_set_config); return usbd; }
int main() { rcc_clock_setup_hsi(&hsi_8mhz[CLOCK_48MHZ]); rcc_usb_prescale_1(); rcc_peripheral_reset(&RCC_APB1RSTR, RCC_APB1RSTR_USBRST); rcc_peripheral_reset(&RCC_AHBRSTR, RCC_AHBRSTR_IOPARST); rcc_peripheral_clear_reset(&RCC_APB1RSTR, RCC_APB1RSTR_USBRST); rcc_peripheral_clear_reset(&RCC_AHBRSTR, RCC_AHBRSTR_IOPARST); rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_USBEN); rcc_peripheral_enable_clock(&RCC_AHBENR, RCC_AHBENR_IOPAEN); gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO11 | GPIO12); gpio_clear(GPIOA, GPIO11 | GPIO12); for (int i = 0; i < 0x800000; i++) __asm__ volatile("nop"); gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11 | GPIO12); gpio_set_af(GPIOA, GPIO_AF14, GPIO11| GPIO12); arm_bootloader::Dest dest = arm_bootloader::get_unique_dest(); char serial[10] = {0}; { uint32_t x = dest; char hex[] = "0123456789abcdef"; for(int i = 0; i < 8; i++) { serial[7-i] = hex[x & 0xF]; x = x >> 4; } } /* Buffer to be used for control requests. */ uint8_t usbd_control_buffer[128]; char const *usb_strings[] = { "uf-mil", "subbus", serial, }; usbd_device * usbd_dev = usbd_init(&stm32f103_usb_driver, &uf_subbus_protocol::usb::dev, &uf_subbus_protocol::usb::config, usb_strings, 3, usbd_control_buffer, sizeof(usbd_control_buffer)); usbd_register_set_config_callback(usbd_dev, cdcacm_set_config); uf_subbus_protocol::usb::Sink sink(usbd_dev); arm_bootloader::Handler handler( sink, dest, 2048); handlerp = &handler; while (1) usbd_poll(usbd_dev); }
void test_usbd_init_ok(void) { TEST_IGNORE_MESSAGE("pause device stack"); dcd_init_ExpectAndReturn(TUSB_ERROR_NONE); hidd_init_StubWithCallback(stub_hidd_init); dcd_controller_connect_Expect(0); //------------- Code Under Test -------------// TEST_ASSERT_EQUAL( TUSB_ERROR_NONE, usbd_init() ); }
void usb_tmc_init(usbd_device **usbd_dev, const char *serial_number) { strcpy(_our_serial_number, serial_number); usb_tmc_setup_pre_arch(); // 4 == ARRAY_LENGTH(usb_strings) *usbd_dev = usbd_init(&USB_DRIVER, &dev, &config, usb_strings, 4, usbd_control_buffer, sizeof (usbd_control_buffer)); tmc_dev = *usbd_dev; usbd_register_set_config_callback(tmc_dev, tmc_set_config); usb_tmc_setup_post_arch(); }
int main(void) { usbd_device *usbd_dev; usb_simple_target_init(); usbd_dev = usbd_init(usb_simple_target_usb_driver(), NULL, &info); usbd_register_setup_callback(usbd_dev, simple_setup_callback); while (1) { usbd_poll(usbd_dev, 0); } return 0; }
bool tusb_init(void) { // skip if already initialized if (_initialized) return true; #if TUSB_OPT_HOST_ENABLED TU_VERIFY( usbh_init() ); // init host stack #endif #if TUSB_OPT_DEVICE_ENABLED TU_VERIFY ( usbd_init() ); // init device stack #endif _initialized = true; return TUSB_ERROR_NONE; }
/** * Initializes the USB device composite device driver. * \param p_descriptors Pointer to Descriptors list for CDC Serial Device. */ void dual_cdcd_driver_initialize(const USBDDriverDescriptors *p_descriptors) { CDCDSerialPort *p_cdcd = &dual_cdcd_driver.cdcd_serial_port[0]; LIBUSB_TRACE("dual_cdcd_driver_initialize\n\r"); p_cdcd = &dual_cdcd_driver.cdcd_serial_port[0]; cdcd_serial_port_initialize(p_cdcd, 0, 0, DUALCDCDDriverDescriptors_INTERFACENUM0, 2); p_cdcd = &dual_cdcd_driver.cdcd_serial_port[1]; cdcd_serial_port_initialize(p_cdcd, 0, 0, DUALCDCDDriverDescriptors_INTERFACENUM1, 2); /* Initialize the standard USB driver */ usbd_driver_initialize(p_descriptors, 0); /* Initialize the USB driver */ usbd_init(); }
int main(void) { rcc_clock_setup_in_hse_8mhz_out_72mhz(); rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN); rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN); /* LED output */ gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO6); usbd_init(&stm32f107_usb_driver, &dev, &config, usb_strings); usbd_register_control_callback( USB_REQ_TYPE_VENDOR, USB_REQ_TYPE_TYPE, simple_control_callback); while (1) usbd_poll(); }
static int usb_fibre(fibre_t *fibre) { PT_BEGIN_FIBRE(fibre); rcc_periph_clock_enable(RCC_OTGFS); gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9 | GPIO11 | GPIO12); gpio_set_af(GPIOA, GPIO_AF10, GPIO9 | GPIO11 | GPIO12); usbd_dev = usbd_init(&otgfs_usb_driver, &dev, &config, usb_strings, 2, usbd_control_buffer, sizeof(usbd_control_buffer)); usbd_register_set_config_callback(usbd_dev, usb_set_config); while (true) { usbd_poll(usbd_dev); PT_YIELD(); } PT_END(); }
int main(void) { rcc_clock_setup_hse_3v3(&rcc_hse_8mhz_3v3[RCC_CLOCK_3V3_120MHZ]); rcc_periph_clock_enable(RCC_GPIOB); rcc_periph_clock_enable(RCC_OTGHS); gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO13 | GPIO14 | GPIO15); gpio_set_af(GPIOB, GPIO_AF12, GPIO13 | GPIO14 | GPIO15); msc_dev = usbd_init(&otghs_usb_driver, &dev_descr, &config_descr, usb_strings, 3, usbd_control_buffer, sizeof(usbd_control_buffer)); ramdisk_init(); usb_msc_init(msc_dev, 0x82, 64, 0x01, 64, "VendorID", "ProductID", "0.00", ramdisk_blocks(), ramdisk_read, ramdisk_write); for (;;) { usbd_poll(msc_dev); } }
int main(void) { usbd_device *usbd_dev; rcc_clock_setup_in_hse_25mhz_out_72mhz(); rcc_periph_clock_enable(RCC_GPIOA); rcc_periph_clock_enable(RCC_GPIOC); rcc_periph_clock_enable(RCC_OTGFS); /* LED output */ gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO6); usbd_dev = usbd_init(&stm32f107_usb_driver, &dev, &config, usb_strings, 3, usbd_control_buffer, sizeof(usbd_control_buffer)); usbd_register_control_callback( usbd_dev, USB_REQ_TYPE_VENDOR, USB_REQ_TYPE_TYPE, simple_control_callback); while (1) usbd_poll(usbd_dev); }
void usb_thread_entry(void* parameter) { int i; rt_thread_t tid; msd_msg_t msg; dev = rt_device_find(MOUNT_DEVICE); if(!dev) { rt_kprintf("no %s device found!\r\n", MOUNT_DEVICE); tid = rt_thread_self(); rt_thread_delete(tid); } rt_device_init(dev); rt_device_open(dev, RT_DEVICE_OFLAG_RDWR); usbd_init(); /* USB Device Initialization */ usbd_connect(__TRUE); /* USB Device Connect */ while (!usbd_configured ()) { rt_thread_delay(10); } rt_kprintf("usb enum complete\r\n"); while(1) { if(rt_mq_recv(msd_mq, &msg, sizeof(msd_msg_t), RT_WAITING_FOREVER) == RT_EOK) { if(msg.dir == 0) USBD_MSC_EP_BULKOUT_Event(0); else USBD_MSC_EP_BULKIN_Event (0); } } }
int main(void) { BoardInit(); SystemCoreClockUpdate(); LedConnectedOn(); if (UserAppDescriptor.UserInit != NULL) { pUserAppDescriptor = &UserAppDescriptor; pUserAppDescriptor->UserInit((CoreDescriptor_t *)&CoreDescriptor); } LedConnectedOff(); Delay_ms(100); /* led_count = 0; // Check for USB connected while ((GPIOA->IDR & GPIO_Pin_11) != 0) { if (led_count++ == 0) LedConnectedOn(); else if (led_count == 5) LedConnectedOff(); else if (led_count == 25) led_count = 0; Delay_ms(10); } LedConnectedOff(); */ // USB Device Initialization and connect usbd_init(); usbd_connect(__TRUE); led_count = 0; while (!usbd_configured()) // Wait for USB Device to configure { if (led_count++ == 0) LedConnectedOn(); else if (led_count == 5) LedConnectedOff(); else if (led_count == 50) led_count = 0; Delay_ms(10); } LedConnectedOff(); Delay_ms(100); // Wait for 100ms led_count = 0; led_timeout = TIMEOUT_DELAY; usb_rx_ch = -1; usb_tx_ch = -1; while (1) { if (pUserAppDescriptor == NULL) { // No user application if (led_count++ == 1000000) { led_count = 0; LedConnectedToggle(); } usbd_hid_process(); } else if (!usbd_hid_process()) { // No packet processing if (led_timeout == 1000) { LedConnectedOn(); } else if (led_timeout == 0) { LedConnectedOff(); led_timeout = TIMEOUT_DELAY; } led_timeout--; } else { led_timeout = TIMEOUT_DELAY; } #if (USBD_CDC_ACM_ENABLE == 1) NotifyOnStatusChange(); // USB -> UART if (usb_rx_ch == -1) usb_rx_ch = USBD_CDC_ACM_GetChar(); if (usb_rx_ch != -1) { if (UART_PutChar (usb_rx_ch) == usb_rx_ch) usb_rx_ch = -1; } // UART -> USB if (usb_tx_ch == -1) usb_tx_ch = UART_GetChar(); if (usb_tx_ch != -1) { if (USBD_CDC_ACM_PutChar(usb_tx_ch) == usb_tx_ch) usb_tx_ch = -1; } #endif } }
__task void main_task(void) { // State processing uint16_t flags = 0; // LED gpio_led_state_t hid_led_value = GPIO_LED_ON; gpio_led_state_t cdc_led_value = GPIO_LED_ON; gpio_led_state_t msc_led_value = GPIO_LED_ON; // USB uint32_t usb_state_count = USB_BUSY_TIME; // thread running after usb connected started uint8_t thread_started = 0; // button state main_reset_state_t main_reset_button_state = MAIN_RESET_RELEASED; // Initialize settings config_init(); // Initialize our serial mailbox os_mbx_init(&serial_mailbox, sizeof(serial_mailbox)); // Get a reference to this task main_task_id = os_tsk_self(); // leds gpio_init(); // Turn off LED gpio_set_hid_led(GPIO_LED_ON); gpio_set_cdc_led(GPIO_LED_ON); gpio_set_msc_led(GPIO_LED_ON); // do some init with the target before USB and files are configured prerun_target_config(); // Update versions and IDs info_init(); // USB usbd_init(); vfs_user_enable(true); usbd_connect(0); usb_state = USB_CONNECTING; usb_state_count = USB_CONNECT_DELAY; // Start timer tasks os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK); // Target running target_set_state(RESET_RUN); while(1) { os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state | FLAGS_MAIN_90MS // 90mS tick | FLAGS_MAIN_30MS // 30mS tick | FLAGS_MAIN_POWERDOWN // Power down interface | FLAGS_MAIN_DISABLEDEBUG // Disable target debug | FLAGS_MAIN_PROC_USB // process usb events ,NO_TIMEOUT); // Find out what event happened flags = os_evt_get(); if (flags & FLAGS_MAIN_PROC_USB) { USBD_Handler(); } if (flags & FLAGS_MAIN_RESET) { target_set_state(RESET_RUN); } if (flags & FLAGS_MAIN_POWERDOWN) { // Disable debug target_set_state(NO_DEBUG); // Disconnect USB usbd_connect(0); // Turn off LED gpio_set_hid_led(GPIO_LED_OFF); gpio_set_cdc_led(GPIO_LED_OFF); gpio_set_msc_led(GPIO_LED_OFF); // TODO: put the interface chip in sleep mode while(1); } if (flags & FLAGS_MAIN_DISABLEDEBUG) { // Disable debug target_set_state(NO_DEBUG); } if (flags & FLAGS_MAIN_90MS) { // Update USB busy status vfs_user_periodic(90); // FLAGS_MAIN_90MS // Update USB connect status switch (usb_state) { case USB_DISCONNECTING: usb_state = USB_DISCONNECTED; usbd_connect(0); break; case USB_CONNECTING: // Wait before connecting if (DECZERO(usb_state_count) == 0) { usbd_connect(1); usb_state = USB_CHECK_CONNECTED; } break; case USB_CHECK_CONNECTED: if(usbd_configured()) { if (!thread_started) { os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK); serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK); thread_started = 1; } usb_state = USB_CONNECTED; } break; case USB_CONNECTED: case USB_DISCONNECTED: default: break; } } // 30mS tick used for flashing LED when USB is busy if (flags & FLAGS_MAIN_30MS) { // handle reset button without eventing switch (main_reset_button_state) { default: case MAIN_RESET_RELEASED: if (0 == gpio_get_sw_reset()) { main_reset_button_state = MAIN_RESET_PRESSED; target_forward_reset(true); } break; case MAIN_RESET_PRESSED: // ToDo: add a counter to do a mass erase or target recovery after xxx seconds of being held if (1 == gpio_get_sw_reset()) { main_reset_button_state = MAIN_RESET_TARGET; } break; case MAIN_RESET_TARGET: target_forward_reset(false); main_reset_button_state = MAIN_RESET_RELEASED; break; } if (hid_led_usb_activity && ((hid_led_state == MAIN_LED_FLASH) || (hid_led_state == MAIN_LED_FLASH_PERMANENT))) { // Flash DAP LED ONCE if (hid_led_value) { hid_led_value = GPIO_LED_OFF; } else { hid_led_value = GPIO_LED_ON; // Turn on if (hid_led_state == MAIN_LED_FLASH) { hid_led_usb_activity = 0; } } // Update hardware gpio_set_hid_led(hid_led_value); } if (msc_led_usb_activity && ((msc_led_state == MAIN_LED_FLASH) || (msc_led_state == MAIN_LED_FLASH_PERMANENT))) { // Flash MSD LED ONCE if (msc_led_value) { msc_led_value = GPIO_LED_OFF; } else { msc_led_value = GPIO_LED_ON; // Turn on if (msc_led_state == MAIN_LED_FLASH) { msc_led_usb_activity = 0; } } // Update hardware gpio_set_msc_led(msc_led_value); } if (cdc_led_usb_activity && ((cdc_led_state == MAIN_LED_FLASH) || (cdc_led_state == MAIN_LED_FLASH_PERMANENT))) { // Flash CDC LED ONCE if (cdc_led_value) { cdc_led_value = GPIO_LED_OFF; } else { cdc_led_value = GPIO_LED_ON; // Turn on if (cdc_led_state == MAIN_LED_FLASH) { cdc_led_usb_activity = 0; } } // Update hardware gpio_set_cdc_led(cdc_led_value); } } } }
void usbmanager_init(void) { usbd_dev = usbd_init(&otgfs_usb_driver, &dev, &config, usb_strings, 3, (uint8_t*) controlBuffer, 128); usbd_register_set_config_callback(usbd_dev, usbmanager_set_config); }
__task void main_task(void) { // State processing uint16_t flags; // LED uint8_t dap_led_value = 1; uint8_t cdc_led_value = 1; uint8_t msd_led_value = 1; // USB uint32_t usb_state_count; // thread running after usb connected started uint8_t thread_started = 0; // button state char button_activated; // string containing unique ID uint8_t * id_str; // Initialize our serial mailbox os_mbx_init(&serial_mailbox, sizeof(serial_mailbox)); // Get a reference to this task main_task_id = os_tsk_self(); // leds gpio_init(); // Turn off LED gpio_set_dap_led(1); gpio_set_cdc_led(1); gpio_set_msd_led(1); #ifdef BOARD_UBLOX_C027 PORT_SWD_SETUP(); // wait until reset output to the target is pulled high while (!PIN_nRESET_IN()) { /* wait doing nothing */ } os_dly_wait(4); // if the reset input from button is low then enter isp programming mode if (!(LPC_GPIO->B[19/*RESET_PIN*/ + (1/*RESET_PORT*/ << 5)] & 1)) { enter_isp(); } #endif usbd_init(); swd_init(); // Setup reset button gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; // USB usbd_connect(0); usb_busy = USB_IDLE; usb_busy_count = 0; usb_state = USB_CONNECTING; usb_state_count = USB_CONNECT_DELAY; // Update HTML version information file update_html_file(); // Start timer tasks os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK); #ifndef BOARD_UBLOX_C027 // Target running //target_set_state(RESET_RUN_WITH_DEBUG); #endif #ifdef BOARD_NRF51822AA // Target running target_set_state(RESET_RUN); #endif // start semihost task semihost_init(); semihost_enable(); while(1) { os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state | FLAGS_MAIN_90MS // 90mS tick | FLAGS_MAIN_30MS // 30mS tick | FLAGS_MAIN_POWERDOWN // Power down interface | FLAGS_MAIN_DISABLEDEBUG // Power down interface #ifdef USE_USB_EJECT_INSERT | FLAGS_MAIN_USB_DISCONNECT // Disable target debug | FLAGS_MAIN_USB_MEDIA_EJECT, // Eject file system #else | FLAGS_MAIN_USB_DISCONNECT, // Disable target debug #endif NO_TIMEOUT); // Find out what event happened flags = os_evt_get(); if (flags & FLAGS_MAIN_USB_DISCONNECT) { usb_busy = USB_IDLE; // USB not busy usb_state_count = 4; usb_state = USB_DISCONNECT_CONNECT; // disconnect the usb } #ifdef USE_USB_EJECT_INSERT if (flags & FLAGS_MAIN_USB_MEDIA_EJECT) { EjectInsertMediaMode = EJECT_INSERT_WAIT_TO_EJECT; EjectInsertMediaCounter = EJECT_INSERT_DELAY_500MS; } #endif if (flags & FLAGS_MAIN_RESET) { cdc_led_state = LED_OFF; gpio_set_cdc_led(0); //usbd_cdc_ser_flush(); if (send_uID) { // set the target in reset to not receive char on the serial port target_set_state(RESET_HOLD); // send uid id_str = get_uid_string(); USBD_CDC_ACM_DataSend(id_str, strlen((const char *)id_str)); send_uID = 0; } // Reset target target_set_state(RESET_RUN); cdc_led_state = LED_FLASH; gpio_set_cdc_led(1); button_activated = 0; } if (flags & FLAGS_MAIN_POWERDOWN) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); // Disconnect USB usbd_connect(0); // Turn off LED gpio_set_dap_led(0); gpio_set_cdc_led(0); gpio_set_msd_led(0); // TODO: put the interface chip in sleep mode while (1) { } } if (flags & FLAGS_MAIN_DISABLEDEBUG) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); } if (flags & FLAGS_MAIN_90MS) { if (!button_activated) { gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; } #ifdef USE_USB_EJECT_INSERT if (EjectInsertMediaMode == EJECT_INSERT_WAIT_TO_EJECT) { if (--EjectInsertMediaCounter == 0) { // Have waited ~0.5 second, time to eject media EjectInsertMediaMode = EJECT_INSERT_WAIT_TO_INSERT; EjectInsertMediaCounter = EJECT_INSERT_DELAY_500MS; USBD_MSC_MediaReady = __FALSE; } } if ((EjectInsertMediaMode == EJECT_INSERT_WAIT_TO_INSERT) && !USBD_MSC_MediaReadyEx) { // The host computer have questioned the state and received // the message that the media has been removed if (--EjectInsertMediaCounter == 0) { // Have waited ~0.5 seconds after ejecting, time to insert media EjectInsertMediaMode = EJECT_INSERT_INACTIVE; USBD_MSC_MediaReady = __TRUE; } } #endif // Update USB busy status switch (usb_busy) { case USB_ACTIVE: if (DECZERO(usb_busy_count) == 0) { usb_busy=USB_IDLE; } break; case USB_IDLE: default: break; } // Update USB connect status switch (usb_state) { case USB_DISCONNECTING: // Wait until USB is idle before disconnecting if (usb_busy == USB_IDLE) { usbd_connect(0); usb_state = USB_DISCONNECTED; } break; case USB_DISCONNECT_CONNECT: // Wait until USB is idle before disconnecting if ((usb_busy == USB_IDLE) && (DECZERO(usb_state_count) == 0)) { usbd_connect(0); usb_state = USB_CONNECTING; // Update HTML file update_html_file(); // Delay the connecting state before reconnecting to the host - improved usage with VMs usb_state_count = 10; //(90ms * 10 = 900ms) } break; case USB_CONNECTING: // Wait before connecting if (DECZERO(usb_state_count) == 0) { usbd_connect(1); usb_state = USB_CHECK_CONNECTED; } break; case USB_CHECK_CONNECTED: if(usbd_configured()) { if (!thread_started) { os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK); serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK); thread_started = 1; } usb_state = USB_CONNECTED; } break; case USB_CONNECTED: case USB_DISCONNECTED: default: break; } } // 30mS tick used for flashing LED when USB is busy if (flags & FLAGS_MAIN_30MS) { if (dap_led_usb_activity && ((dap_led_state == LED_FLASH) || (dap_led_state == LED_FLASH_PERMANENT))) { // Flash DAP LED ONCE if (dap_led_value) { dap_led_value = 0; } else { dap_led_value = 1; // Turn on if (dap_led_state == LED_FLASH) { dap_led_usb_activity = 0; } } // Update hardware gpio_set_dap_led(dap_led_value); } if (msd_led_usb_activity && ((msd_led_state == LED_FLASH) || (msd_led_state == LED_FLASH_PERMANENT))) { // Flash MSD LED ONCE if (msd_led_value) { msd_led_value = 0; } else { msd_led_value = 1; // Turn on if (msd_led_state == LED_FLASH) { msd_led_usb_activity = 0; } } // Update hardware gpio_set_msd_led(msd_led_value); } if (cdc_led_usb_activity && ((cdc_led_state == LED_FLASH) || (cdc_led_state == LED_FLASH_PERMANENT))) { // Flash CDC LED ONCE if (cdc_led_value) { cdc_led_value = 0; } else { cdc_led_value = 1; // Turn on if (cdc_led_state == LED_FLASH) { cdc_led_usb_activity = 0; } } // Update hardware gpio_set_cdc_led(cdc_led_value); } } } }
__task void main_task(void) { // State processing uint16_t flags; // LED uint8_t dap_led_value = 1; uint8_t cdc_led_value = 1; uint8_t msd_led_value = 1; // USB uint32_t usb_state_count; // thread running after usb connected started uint8_t thread_started = 0; // button state char button_activated; // string containing unique ID uint8_t * id_str; // Get a reference to this task main_task_id = os_tsk_self(); // leds gpio_init(); usbd_init(); swd_init(); // Turn on LED gpio_set_dap_led(1); gpio_set_cdc_led(1); gpio_set_msd_led(1); // Setup reset button gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; // USB usbd_connect(0); usb_busy = USB_IDLE; usb_busy_count = 0; usb_state = USB_CONNECTING; usb_state_count = USB_CONNECT_DELAY; // Update HTML version information file update_html_file(); // Start timer tasks os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK); // Target running target_set_state(RESET_RUN_WITH_DEBUG); // start semihost task semihost_init(); semihost_enable(); while(1) { os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state | FLAGS_MAIN_90MS // 90mS tick | FLAGS_MAIN_30MS // 30mS tick | FLAGS_MAIN_POWERDOWN // Power down interface | FLAGS_MAIN_DISABLEDEBUG // Power down interface | FLAGS_MAIN_USB_DISCONNECT, // Disable target debug NO_TIMEOUT); // Find out what event happened flags = os_evt_get(); if (flags & FLAGS_MAIN_USB_DISCONNECT) { usb_busy = USB_IDLE; // USB not busy usb_state_count = 4; usb_state = USB_DISCONNECT_CONNECT; // disconnect the usb } if (flags & FLAGS_MAIN_RESET) { cdc_led_state = LED_OFF; gpio_set_cdc_led(0); //usbd_cdc_ser_flush(); if (send_uID) { // set the target in reset to not receive char on the serial port target_set_state(RESET_HOLD); // send uid id_str = get_uid_string(); USBD_CDC_ACM_DataSend(id_str, strlen((const char *)id_str)); send_uID = 0; } // Reset target target_set_state(RESET_RUN); cdc_led_state = LED_FLASH; gpio_set_cdc_led(1); button_activated = 0; } if (flags & FLAGS_MAIN_POWERDOWN) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); // Disconnect USB usbd_connect(0); // Turn off LED gpio_set_dap_led(0); gpio_set_cdc_led(0); gpio_set_msd_led(0); // TODO: put the interface chip in sleep mode while (1) { } } if (flags & FLAGS_MAIN_DISABLEDEBUG) { // Stop semihost task semihost_disable(); // Disable debug target_set_state(NO_DEBUG); } if (flags & FLAGS_MAIN_90MS) { if (!button_activated) { gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET); button_activated = 1; } // Update USB busy status switch (usb_busy) { case USB_ACTIVE: if (DECZERO(usb_busy_count) == 0) { usb_busy=USB_IDLE; } break; case USB_IDLE: default: break; } // Update USB connect status switch (usb_state) { case USB_DISCONNECTING: // Wait until USB is idle before disconnecting if (usb_busy == USB_IDLE) { usbd_connect(0); usb_state = USB_DISCONNECTED; } break; case USB_DISCONNECT_CONNECT: // Wait until USB is idle before disconnecting if ((usb_busy == USB_IDLE) && (DECZERO(usb_state_count) == 0)) { usbd_connect(0); usb_state = USB_CONNECTING; // Update HTML file update_html_file(); } break; case USB_CONNECTING: // Wait before connecting if (DECZERO(usb_state_count) == 0) { usbd_connect(1); usb_state = USB_CHECK_CONNECTED; } break; case USB_CHECK_CONNECTED: if(usbd_configured()) { if (!thread_started) { os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK); serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK); thread_started = 1; } usb_state = USB_CONNECTED; } break; case USB_CONNECTED: case USB_DISCONNECTED: default: break; } } // 30mS tick used for flashing LED when USB is busy if (flags & FLAGS_MAIN_30MS) { if (dap_led_usb_activity && ((dap_led_state == LED_FLASH) || (dap_led_state == LED_FLASH_PERMANENT))) { // Flash DAP LED ONCE if (dap_led_value) { dap_led_value = 0; } else { dap_led_value = 1; // Turn on if (dap_led_state == LED_FLASH) { dap_led_usb_activity = 0; } } // Update hardware gpio_set_dap_led(dap_led_value); } if (msd_led_usb_activity && ((msd_led_state == LED_FLASH) || (msd_led_state == LED_FLASH_PERMANENT))) { // Flash MSD LED ONCE if (msd_led_value) { msd_led_value = 0; } else { msd_led_value = 1; // Turn on if (msd_led_state == LED_FLASH) { msd_led_usb_activity = 0; } } // Update hardware gpio_set_msd_led(msd_led_value); } if (cdc_led_usb_activity && ((cdc_led_state == LED_FLASH) || (cdc_led_state == LED_FLASH_PERMANENT))) { // Flash CDC LED ONCE if (cdc_led_value) { cdc_led_value = 0; } else { cdc_led_value = 1; // Turn on if (cdc_led_state == LED_FLASH) { cdc_led_usb_activity = 0; } } // Update hardware gpio_set_cdc_led(cdc_led_value); } } } }