/******************************************************************************* * 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 USBD_Error_Event(void) { LedConnectedOn(); LedRunningOn(); usbd_connect(__FALSE); usbd_reset_core(); HardFault_Handler(); }
/* devices ( see devi_register_hid_client) */ int devi_usb_server_connect(char * serv_path_name) { int rc = EOK; usbd_funcs_t funcs = { _USBDI_NFUNCS, insertion, removal, NULL }; usbd_device_ident_t interest = { USBD_CONNECT_WILDCARD, USBD_CONNECT_WILDCARD, USBD_CONNECT_WILDCARD, USBD_CONNECT_WILDCARD, USBD_CONNECT_WILDCARD }; usbd_connect_parm_t parm = { NULL, USB_VERSION, USBD_VERSION, 0, 0, NULL, 0, &interest, &funcs, USBD_CONNECT_WAIT }; parm.path = serv_path_name; if(EOK != ( rc = usbd_connect( &parm, &pGlbConnection ) ) ) { char * pMsgTxt = "Error: cannot connect to USB server (error code = %d).\nDriver is terminating\n"; fprintf(stderr, pMsgTxt, rc); slogf(_SLOG_SETCODE(_SLOGC_INPUT, 0), _SLOG_ERROR, pMsgTxt, rc); exit(-2); } return EOK; }
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); } } }
__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); } } } }
__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); } } } }
__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); } } } }
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 } }