void pyb_usb_dev_init(usb_device_mode_t mode, usb_storage_medium_t medium) { #ifdef USE_DEVICE_MODE if (!dev_is_enabled) { // only init USB once in the device's power-lifetime if (mode == USB_DEVICE_MODE_CDC_MSC) { USBD_SelectMode(USBD_MODE_CDC_MSC); } else { USBD_SelectMode(USBD_MODE_CDC_HID); } USBD_Init(&hUSBDDevice, (USBD_DescriptorsTypeDef*)&VCP_Desc, 0); USBD_RegisterClass(&hUSBDDevice, &USBD_CDC_MSC_HID); USBD_CDC_RegisterInterface(&hUSBDDevice, (USBD_CDC_ItfTypeDef*)&USBD_CDC_fops); #if MICROPY_HW_HAS_SDCARD if (medium == USB_STORAGE_MEDIUM_FLASH) { USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops); } else { USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_SDCARD_STORAGE_fops); } #else USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops); #endif USBD_Start(&hUSBDDevice); } dev_is_enabled = 1; // create an exception object for interrupting by VCP mp_const_vcp_interrupt = mp_obj_new_exception_msg(&mp_type_OSError, "VCPInterrupt"); #endif }
void pyb_usb_dev_init(usb_device_mode_t mode, usb_storage_medium_t medium) { #ifdef USE_DEVICE_MODE if (!dev_is_enabled) { // only init USB once in the device's power-lifetime // Windows needs a different PID to distinguish different device // configurations, so we set it here depending on mode. if (mode == USB_DEVICE_MODE_CDC_MSC) { USBD_SelectMode(USBD_MODE_CDC_MSC); USBD_SetPID(0x9800); } else { USBD_SelectMode(USBD_MODE_CDC_HID); USBD_SetPID(0x9801); } USBD_Init(&hUSBDDevice, (USBD_DescriptorsTypeDef*)&VCP_Desc, 0); USBD_RegisterClass(&hUSBDDevice, &USBD_CDC_MSC_HID); USBD_CDC_RegisterInterface(&hUSBDDevice, (USBD_CDC_ItfTypeDef*)&USBD_CDC_fops); #if MICROPY_HW_HAS_SDCARD if (medium == USB_STORAGE_MEDIUM_FLASH) { USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops); } else { USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_SDCARD_STORAGE_fops); } #else USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops); #endif USBD_Start(&hUSBDDevice); } dev_is_enabled = 1; #endif }
bool pyb_usb_dev_init(uint16_t vid, uint16_t pid, usb_device_mode_t mode, USBD_HID_ModeInfoTypeDef *hid_info) { #ifdef USE_DEVICE_MODE if (!(pyb_usb_flags & PYB_USB_FLAG_DEV_ENABLED)) { // only init USB once in the device's power-lifetime USBD_SetVIDPIDRelease(vid, pid, 0x0200, mode == USBD_MODE_CDC); if (USBD_SelectMode(mode, hid_info) != 0) { return false; } USBD_Init(&hUSBDDevice, (USBD_DescriptorsTypeDef*)&USBD_Descriptors, 0); USBD_RegisterClass(&hUSBDDevice, &USBD_CDC_MSC_HID); USBD_CDC_RegisterInterface(&hUSBDDevice, (USBD_CDC_ItfTypeDef*)&USBD_CDC_fops); switch (pyb_usb_storage_medium) { #if MICROPY_HW_HAS_SDCARD case PYB_USB_STORAGE_MEDIUM_SDCARD: USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_SDCARD_STORAGE_fops); break; #endif default: USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops); break; } USBD_Start(&hUSBDDevice); } pyb_usb_flags |= PYB_USB_FLAG_DEV_ENABLED; #endif return true; }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F446xx HAL library initialization */ HAL_Init(); /* Configure the system clock to 180 MHz */ SystemClock_Config(); /* Initialize IO expander */ BSP_IO_Init(); /* Init Device Library */ USBD_Init(&USBD_Device, &MSC_Desc, 0); /* Add Supported Class */ USBD_RegisterClass(&USBD_Device, USBD_MSC_CLASS); /* Add Storage callbacks for MSC Class */ USBD_MSC_RegisterStorage(&USBD_Device, &USBD_DISK_fops); /* Start Device Process */ USBD_Start(&USBD_Device); /* Run Application (Interrupt mode) */ while (1) { } }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F469xx HAL library initialization */ HAL_Init(); /* Configure the System clock to have a frequency of 180 MHz */ SystemClock_Config(); /* Configure LED1, LED2, LED3 and LED4 */ BSP_LED_Init(LED1); BSP_LED_Init(LED2); BSP_LED_Init(LED3); BSP_LED_Init(LED4); /* Init Device Library */ USBD_Init(&USBD_Device, &MSC_Desc, 0); /* Add Supported Class */ USBD_RegisterClass(&USBD_Device, USBD_MSC_CLASS); /* Add Storage callbacks for MSC Class */ USBD_MSC_RegisterStorage(&USBD_Device, &USBD_DISK_fops); /* Start Device Process */ USBD_Start(&USBD_Device); /* Run Application (Interrupt mode) */ while (1) { } }
bool pyb_usb_dev_init(uint16_t vid, uint16_t pid, usb_device_mode_t mode, USBD_HID_ModeInfoTypeDef *hid_info) { bool high_speed = (mode & USBD_MODE_HIGH_SPEED) != 0; mode &= 0x7f; usb_device_t *usb_dev = &usb_device; if (!usb_dev->enabled) { // only init USB once in the device's power-lifetime // set up the USBD state USBD_HandleTypeDef *usbd = &usb_dev->hUSBDDevice; usbd->id = MICROPY_HW_USB_MAIN_DEV; usbd->dev_state = USBD_STATE_DEFAULT; usbd->pDesc = (USBD_DescriptorsTypeDef*)&USBD_Descriptors; usbd->pClass = &USBD_CDC_MSC_HID; usb_dev->usbd_cdc_msc_hid_state.pdev = usbd; usb_dev->usbd_cdc_msc_hid_state.cdc = &usb_dev->usbd_cdc_itf.base; #if MICROPY_HW_USB_ENABLE_CDC2 usb_dev->usbd_cdc_msc_hid_state.cdc2 = &usb_dev->usbd_cdc2_itf.base; #endif usb_dev->usbd_cdc_msc_hid_state.hid = &usb_dev->usbd_hid_itf.base; usbd->pClassData = &usb_dev->usbd_cdc_msc_hid_state; // configure the VID, PID and the USBD mode (interfaces it will expose) USBD_SetVIDPIDRelease(&usb_dev->usbd_cdc_msc_hid_state, vid, pid, 0x0200, mode == USBD_MODE_CDC); if (USBD_SelectMode(&usb_dev->usbd_cdc_msc_hid_state, mode, hid_info) != 0) { return false; } switch (pyb_usb_storage_medium) { #if MICROPY_HW_ENABLE_SDCARD case PYB_USB_STORAGE_MEDIUM_SDCARD: USBD_MSC_RegisterStorage(&usb_dev->usbd_cdc_msc_hid_state, (USBD_StorageTypeDef*)&USBD_SDCARD_STORAGE_fops); break; #endif default: USBD_MSC_RegisterStorage(&usb_dev->usbd_cdc_msc_hid_state, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops); break; } // start the USB device USBD_LL_Init(usbd, high_speed); USBD_LL_Start(usbd); usb_dev->enabled = true; } return true; }
/* init function */ void MX_USB_DEVICE_Init(void) { /* Init Device Library,Add Supported Class and Start the library*/ USBD_Init(&hUsbDeviceFS, &FS_Desc, DEVICE_FS); USBD_RegisterClass(&hUsbDeviceFS, &USBD_MSC); USBD_MSC_RegisterStorage(&hUsbDeviceFS, &USBD_Storage_Interface_fops_FS); USBD_Start(&hUsbDeviceFS); }
void pyb_usb_dev_init(usbd_device_kind_t device_kind, usbd_storage_medium_kind_t medium_kind) { #ifdef USE_DEVICE_MODE if (!dev_is_enabled) { // only init USB once in the device's power-lifetime switch (device_kind) { case USBD_DEVICE_CDC: // XXX USBD_CDC_Init (called by one of these functions below) uses malloc, // so the memory is invalid after a soft reset (which resets the GC). USBD_Init(&hUSBDDevice, &VCP_Desc, 0); USBD_RegisterClass(&hUSBDDevice, &USBD_CDC); USBD_CDC_RegisterInterface(&hUSBDDevice, (USBD_CDC_ItfTypeDef*)&USBD_CDC_fops); USBD_Start(&hUSBDDevice); //USBD_Init(&USB_OTG_Core, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_PYB_cb, &USR_cb); break; case USBD_DEVICE_MSC: // XXX USBD_CDC_Init (called by one of these functions below) uses malloc, // so the memory is invalid after a soft reset (which resets the GC). USBD_Init(&hUSBDDevice, &MSC_Desc, 0); USBD_RegisterClass(&hUSBDDevice, &USBD_MSC); if (medium_kind == USBD_STORAGE_MEDIUM_FLASH) { USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_FLASH_STORAGE_fops); } else { USBD_MSC_RegisterStorage(&hUSBDDevice, (USBD_StorageTypeDef*)&USBD_SDCARD_STORAGE_fops); } USBD_Start(&hUSBDDevice); break; case USBD_DEVICE_HID: //USBD_Init(&USB_OTG_Core, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_PYB_HID_cb, &USR_cb); // TODO break; } } dev_is_enabled = 1; // create an exception object for interrupting by VCP mp_const_vcp_interrupt = mp_obj_new_exception_msg(&mp_type_OSError, "VCPInterrupt"); #endif }
/** * @brief Start USBD * @param None. * @retval USBD status. */ USBD_ErrorTypdef USBDSTOR_Start(void) { /* Init MSC Application */ USBD_Init(&USBD_Device, &MSC_Desc, 0); /* Add Supported Class */ USBD_RegisterClass(&USBD_Device, &USBD_MSC); /* Add Storage callbacks for MSC Class */ USBD_MSC_RegisterStorage(&USBD_Device, &USBD_DISK_fops); return USBD_ERROR_NONE; }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F4xx HAL library initialization: - Configure the Flash prefetch, instruction and Data caches - Configure the Systick to generate an interrupt each 1 msec - Set NVIC Group Priority to 4 - Global MSP (MCU Support Package) initialization */ HAL_Init(); /* Configure the system clock to 168 Mhz */ SystemClock_Config(); /* Configure the LEDs */ BSP_LED_Init(LED1); BSP_LED_Init(LED2); BSP_LED_Init(LED3); BSP_LED_Init(LED4); /*Initialize Joystick */ BSP_JOY_Init(JOY_MODE_GPIO); /* Init MSC Application */ USBD_Init(&USBD_Device_HS, &MSC_Desc, 1); /* Init HID Application */ USBD_Init(&USBD_Device_FS, &HID_Desc, 0); /* Add Supported Classes */ USBD_RegisterClass(&USBD_Device_HS, &USBD_MSC); USBD_RegisterClass(&USBD_Device_FS, &USBD_HID); /* Add Storage callbacks for MSC Class */ USBD_MSC_RegisterStorage(&USBD_Device_HS, &USBD_DISK_fops); /* Start Device Process */ USBD_Start(&USBD_Device_FS); USBD_Start(&USBD_Device_HS); /* Run Application (Interrupt mode)*/ while (1) { GetPointerData(HID_Buffer); if((HID_Buffer[1] != 0) || (HID_Buffer[2] != 0)) { USBD_HID_SendReport(&USBD_Device_FS, HID_Buffer, 4); } } }
/* init function */ void MX_USB_DEVICE_Init(void) { /* Init Device Library,Add Supported Class and Start the library*/ USBD_Init(&hUsbDeviceFS, &FS_Desc, DEVICE_FS); USBD_RegisterClass(&hUsbDeviceFS, &USBD_MSC); USBD_MSC_RegisterStorage(&hUsbDeviceFS, &USBD_Storage_Interface_fops_FS); /* Verify if the Battery Charging Detection mode (BCD) is used : */ /* If yes, the USB device is started in the HAL_PCDEx_BCD_Callback */ /* upon reception of PCD_BCD_DISCOVERY_COMPLETED message. */ /* If no, the USB device is started now. */ if (USBD_LL_BatteryCharging(&hUsbDeviceFS) != USBD_OK) { USBD_Start(&hUsbDeviceFS); } }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F3xx HAL library initialization: - Configure the Flash prefetch - Systick timer is configured by default as source of time base, but user can eventually implement his proper time base source (a general purpose timer for example or other time source), keeping in mind that Time base duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and handled in milliseconds basis. - Set NVIC Group Priority to 4 - Low Level Initialization */ HAL_Init(); /* Configure the system clock to 72 Mhz */ SystemClock_Config(); /* Configure LED1, LED2, LED3 and LED4 */ BSP_LED_Init(LED_GREEN); BSP_LED_Init(LED_ORANGE); BSP_LED_Init(LED_RED); BSP_LED_Init(LED_BLUE); /* Init Device Library */ USBD_Init(&USBD_Device, &MSC_Desc, 0); /* Register the MSC class */ USBD_RegisterClass(&USBD_Device, &USBD_MSC); /* Add Storage callbacks for MSC Class */ USBD_MSC_RegisterStorage(&USBD_Device, &USBD_DISK_fops); /* Start Device Process */ USBD_Start(&USBD_Device); while (1) { } }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* STM32F4xx HAL library initialization: - Configure the Flash prefetch, instruction and Data caches - Configure the Systick to generate an interrupt each 1 msec - Set NVIC Group Priority to 4 - Global MSP (MCU Support Package) initialization */ HAL_Init(); /* Configure the system clock to 168 MHz */ SystemClock_Config(); /* Configure LED1, LED2, LED3 and LED4 */ BSP_LED_Init(LED1); BSP_LED_Init(LED2); BSP_LED_Init(LED3); BSP_LED_Init(LED4); /* Init MSC Application */ USBD_Init(&USBD_Device, &MSC_Desc, 0); /* Add Supported Class */ USBD_RegisterClass(&USBD_Device, USBD_MSC_CLASS); /* Add Storage callbacks for MSC Class */ USBD_MSC_RegisterStorage(&USBD_Device, &USBD_DISK_fops); /* Start Device Process */ USBD_Start(&USBD_Device); /* Run Application (Interrupt mode) */ while (1) { } }
/** * @brief Main program * @param None * @retval None */ int main(void) { /* Enable the CPU Cache */ CPU_CACHE_Enable(); /* STM32F7xx HAL library initialization: - Configure the Flash ART accelerator on ITCM interface - Configure the Systick to generate an interrupt each 1 msec - Set NVIC Group Priority to 4 - Low Level Initialization */ HAL_Init(); /* Configure the System clock to have a frequency of 216 MHz */ SystemClock_Config(); /* Configure LED1 */ BSP_LED_Init(LED1); /* Init Device Library */ USBD_Init(&USBD_Device, &MSC_Desc, 0); /* Add Supported Class */ USBD_RegisterClass(&USBD_Device, USBD_MSC_CLASS); /* Add Storage callbacks for MSC Class */ USBD_MSC_RegisterStorage(&USBD_Device, &USBD_DISK_fops); /* Start Device Process */ USBD_Start(&USBD_Device); /* Run Application (Interrupt mode) */ while (1) { } }