Library/DS_VirtualComPort
1
0
Fork 0
forked from stm/stm32-mw-usb-device
Code Pull Requests Activity

day2

Browse Source
This commit is contained in:
Mikhail
2025-05-21 22:44:23 +03:00
parent 1e00ea2791
commit 20ee676f01
6 changed files with 186 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Class/CDC/Inc/usbd_cdc_if.h
View File

@@ -29,11 +29,14 @@ extern "C" {
/* Exported types ------------------------------------------------------------*/ /* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/ /* Exported constants --------------------------------------------------------*/
#define APP_RX_DATA_SIZE 512
#define APP_TX_DATA_SIZE 512
extern USBD_CDC_ItfTypeDef USBD_CDC_Template_fops; extern USBD_CDC_ItfTypeDef USBD_CDC_Template_fops;
/* Exported macro ------------------------------------------------------------*/ /* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */ /* Exported functions ------------------------------------------------------- */
uint8_t TEMPLATE_Transmit(uint8_t* Buf, uint16_t Len);
#ifdef __cplusplus #ifdef __cplusplus
} }

37
Class/CDC/Src/usbd_cdc_if.c
View File

@@ -22,7 +22,7 @@
EndBSPDependencies */ EndBSPDependencies */
/* Includes ------------------------------------------------------------------*/ /* Includes ------------------------------------------------------------------*/
#include "usbd_cdc_if_template.h" #include "usbd_cdc_if.h"
/** @addtogroup STM32_USB_DEVICE_LIBRARY /** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{ * @{
@@ -86,6 +86,14 @@ USBD_CDC_LineCodingTypeDef linecoding =
0x08 /* nb. of bits 8*/ 0x08 /* nb. of bits 8*/
}; };
/* Create buffer for reception and transmission */
/* It's up to user to redefine and/or remove those define */
/** Received data over USB are stored in this buffer */
uint8_t UserRxBufferFS[APP_RX_DATA_SIZE];
/** Data to send over USB CDC are stored in this buffer */
uint8_t UserTxBufferFS[APP_TX_DATA_SIZE];
extern USBD_HandleTypeDef hUsbDeviceFS;
/* Private functions ---------------------------------------------------------*/ /* Private functions ---------------------------------------------------------*/
/** /**
@@ -96,9 +104,8 @@ USBD_CDC_LineCodingTypeDef linecoding =
*/ */
static int8_t TEMPLATE_Init(void) static int8_t TEMPLATE_Init(void)
{ {
/* USBD_CDC_SetTxBuffer(&hUsbDeviceFS, UserTxBufferFS, 0);
Add your initialization code here USBD_CDC_SetRxBuffer(&hUsbDeviceFS, UserRxBufferFS);
*/
return (0); return (0);
} }
@@ -209,7 +216,27 @@ static int8_t TEMPLATE_Receive(uint8_t *Buf, uint32_t *Len)
UNUSED(Buf); UNUSED(Buf);
UNUSED(Len); UNUSED(Len);
return (0); if(Buf[0] == '1')
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
else if(Buf[0] == '0')
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
USBD_CDC_ReceivePacket(&hUsbDeviceFS);
return (USBD_OK);
}
uint8_t TEMPLATE_Transmit(uint8_t* Buf, uint16_t Len)
{
uint8_t result = USBD_OK;
USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef*)hUsbDeviceFS.pClassData;
if (hcdc->TxState != 0){
return
USBD_BUSY;
}
USBD_CDC_SetTxBuffer(&hUsbDeviceFS, Buf, Len);
result = USBD_CDC_TransmitPacket(&hUsbDeviceFS);
return result;
} }
/** /**

10
Core/Inc/usbd_conf.h
View File

@@ -25,7 +25,7 @@ extern "C" {
#endif #endif
/* Includes ------------------------------------------------------------------*/ /* Includes ------------------------------------------------------------------*/
#include "stm32fxxx.h" /* replace 'stm32xxx' with your HAL driver header filename, ex: stm32f4xx.h */ #include "stm32f0xx_hal.h" /* replace 'stm32xxx' with your HAL driver header filename, ex: stm32f4xx.h */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@@ -47,15 +47,15 @@ extern "C" {
#define USBD_MAX_NUM_CONFIGURATION 1U #define USBD_MAX_NUM_CONFIGURATION 1U
#define USBD_MAX_STR_DESC_SIZ 0x100U #define USBD_MAX_STR_DESC_SIZ 0x100U
#define USBD_SELF_POWERED 1U #define USBD_SELF_POWERED 1U
#define USBD_DEBUG_LEVEL 2U #define USBD_DEBUG_LEVEL 0U
/* #define USBD_USER_REGISTER_CALLBACK 1U */ /* #define USBD_USER_REGISTER_CALLBACK 1U */
/* ECM, RNDIS, DFU Class Config */ /* ECM, RNDIS, DFU Class Config */
#define USBD_SUPPORT_USER_STRING_DESC 1U #define USBD_SUPPORT_USER_STRING_DESC 0U
/* BillBoard Class Config */ /* BillBoard Class Config */
#define USBD_CLASS_USER_STRING_DESC 1U #define USBD_CLASS_USER_STRING_DESC 0U
#define USBD_CLASS_BOS_ENABLED 1U #define USBD_CLASS_BOS_ENABLED 0U
#define USB_BB_MAX_NUM_ALT_MODE 0x2U #define USB_BB_MAX_NUM_ALT_MODE 0x2U
/* MSC Class Config */ /* MSC Class Config */

2
Core/Inc/usbd_desc_template.h → Core/Inc/usbd_desc.h
View File

@@ -59,7 +59,7 @@
/* Exported macro ------------------------------------------------------------*/ /* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */ /* Exported functions ------------------------------------------------------- */
extern USBD_DescriptorsTypeDef XXX_Desc; /* Replace 'XXX_Desc' with your active USB device class, ex: HID_Desc */ extern USBD_DescriptorsTypeDef Class_Desc; /* Replace 'XXX_Desc' with your active USB device class, ex: HID_Desc */
#endif /* __USBD_DESC_TEMPLATE_H*/ #endif /* __USBD_DESC_TEMPLATE_H*/

301
Core/Src/usbd_conf.c
View File

@@ -19,265 +19,212 @@
*/ */
/* Includes ------------------------------------------------------------------*/ /* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usbd_core.h" #include "usbd_core.h"
#include "usbd_hid.h" /* Include class header file */ #include "usbd_cdc.h" /* Include class header file */
//#include "usbd_hid.h" /* Include class header file */
/* Private typedef -----------------------------------------------------------*/ /* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/
extern PCD_HandleTypeDef hpcd_USB_FS;
/* Private function prototypes -----------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/
static USBD_StatusTypeDef USBD_Get_USB_Status(HAL_StatusTypeDef hal_status);
/* Private functions ---------------------------------------------------------*/ /* Private functions ---------------------------------------------------------*/
/** void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
* @brief Initializes the Low Level portion of the Device driver. {
* @param pdev: Device handle USBD_LL_SetupStage((USBD_HandleTypeDef*)hpcd->pData, (uint8_t *)hpcd->Setup);
* @retval USBD Status }
*/
void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBD_LL_DataOutStage((USBD_HandleTypeDef*)hpcd->pData, epnum, hpcd->OUT_ep[epnum].xfer_buff);
}
void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBD_LL_DataInStage((USBD_HandleTypeDef*)hpcd->pData, epnum, hpcd->IN_ep[epnum].xfer_buff);
}
void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_SOF((USBD_HandleTypeDef*)hpcd->pData);
}
void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
{
USBD_SpeedTypeDef speed = USBD_SPEED_FULL;
if ( hpcd->Init.speed != PCD_SPEED_FULL)
{
Error_Handler();
}
/* Set Speed. */
USBD_LL_SetSpeed((USBD_HandleTypeDef*)hpcd->pData, speed);
/* Reset Device. */
USBD_LL_Reset((USBD_HandleTypeDef*)hpcd->pData);
}
void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_DevConnected((USBD_HandleTypeDef*)hpcd->pData);
}
void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_DevDisconnected((USBD_HandleTypeDef*)hpcd->pData);
}
/* Private functions ---------------------------------------------------------*/
USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev) USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev)
{ {
UNUSED(pdev); pdev->pData = &hpcd_USB_FS;
HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x00 , PCD_SNG_BUF, 0x40);
HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , 0x80 , PCD_SNG_BUF, 0x80);
HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_IN_EP , PCD_SNG_BUF, 0xC0);
HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_OUT_EP , PCD_SNG_BUF, 0x100);
HAL_PCDEx_PMAConfig((PCD_HandleTypeDef*)pdev->pData , CDC_CMD_EP , PCD_SNG_BUF, 0x140);
return USBD_OK; return USBD_OK;
} }
/**
* @brief De-Initializes the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef *pdev) USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef *pdev)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
hal_status = HAL_PCD_DeInit(pdev->pData);
return USBD_OK; return USBD_Get_USB_Status(hal_status);
} }
/**
* @brief Starts the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev) USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
hal_status = HAL_PCD_Start(pdev->pData);
return USBD_OK; return USBD_Get_USB_Status(hal_status);
} }
/**
* @brief Stops the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef *pdev) USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef *pdev)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
hal_status = HAL_PCD_Stop(pdev->pData);
return USBD_OK; return USBD_Get_USB_Status(hal_status);
} }
/**
* @brief Opens an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param ep_type: Endpoint Type
* @param ep_mps: Endpoint Max Packet Size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr, USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr,
uint8_t ep_type, uint16_t ep_mps) uint8_t ep_type, uint16_t ep_mps)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(ep_addr); hal_status = HAL_PCD_EP_Open(pdev->pData, ep_addr, ep_mps, ep_type);
UNUSED(ep_type); return USBD_Get_USB_Status(hal_status);
UNUSED(ep_mps);
return USBD_OK;
} }
/**
* @brief Closes an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr) USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(ep_addr); hal_status = HAL_PCD_EP_Close(pdev->pData, ep_addr);
return USBD_Get_USB_Status(hal_status);
return USBD_OK;
} }
/**
* @brief Flushes an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr) USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(ep_addr); hal_status = HAL_PCD_EP_Flush(pdev->pData, ep_addr);
return USBD_Get_USB_Status(hal_status);
return USBD_OK;
} }
/**
* @brief Sets a Stall condition on an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr) USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(ep_addr); hal_status = HAL_PCD_EP_SetStall(pdev->pData, ep_addr);
return USBD_Get_USB_Status(hal_status);
return USBD_OK;
} }
/**
* @brief Clears a Stall condition on an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef *pdev, USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef *pdev,
uint8_t ep_addr) uint8_t ep_addr)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(ep_addr); hal_status = HAL_PCD_EP_ClrStall(pdev->pData, ep_addr);
return USBD_Get_USB_Status(hal_status);
return USBD_OK;
} }
/**
* @brief Returns Stall condition.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval Stall (1: Yes, 0: No)
*/
uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr) uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{ {
UNUSED(pdev); PCD_HandleTypeDef *hpcd = (PCD_HandleTypeDef*) pdev->pData;
UNUSED(ep_addr); if((ep_addr & 0x80) == 0x80)
{
return 0U; return hpcd->IN_ep[ep_addr & 0x7F].is_stall;
}
else
{
return hpcd->OUT_ep[ep_addr & 0x7F].is_stall;
}
} }
/**
* @brief Assigns a USB address to the device.
* @param pdev: Device handle
* @param dev_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef *pdev, USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef *pdev,
uint8_t dev_addr) uint8_t dev_addr)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(dev_addr); hal_status = HAL_PCD_SetAddress(pdev->pData, dev_addr);
return USBD_Get_USB_Status(hal_status);
return USBD_OK;
} }
/**
* @brief Transmits data over an endpoint.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param pbuf: Pointer to data to be sent
* @param size: Data size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef *pdev, uint8_t ep_addr, USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef *pdev, uint8_t ep_addr,
uint8_t *pbuf, uint32_t size) uint8_t *pbuf, uint32_t size)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(ep_addr); hal_status = HAL_PCD_EP_Transmit(pdev->pData, ep_addr, pbuf, size);
UNUSED(pbuf); return USBD_Get_USB_Status(hal_status);
UNUSED(size);
return USBD_OK;
} }
/**
* @brief Prepares an endpoint for reception.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param pbuf: Pointer to data to be received
* @param size: Data size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev, USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev,
uint8_t ep_addr, uint8_t *pbuf, uint8_t ep_addr, uint8_t *pbuf,
uint32_t size) uint32_t size)
{ {
UNUSED(pdev); HAL_StatusTypeDef hal_status;
UNUSED(ep_addr); hal_status = HAL_PCD_EP_Receive(pdev->pData, ep_addr, pbuf, size);
UNUSED(pbuf); return USBD_Get_USB_Status(hal_status);
UNUSED(size);
return USBD_OK;
} }
/**
* @brief Returns the last transferred packet size.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval Received Data Size
*/
uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t ep_addr) uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{ {
UNUSED(pdev); return HAL_PCD_EP_GetRxCount((PCD_HandleTypeDef*) pdev->pData, ep_addr);
UNUSED(ep_addr);
return 0U;
} }
#ifdef USBD_HS_TESTMODE_ENABLE
/**
* @brief Set High speed Test mode.
* @param pdev: Device handle
* @param testmode: test mode
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_SetTestMode(USBD_HandleTypeDef *pdev, uint8_t testmode)
{
UNUSED(pdev);
UNUSED(testmode);
return USBD_OK;
}
#endif /* USBD_HS_TESTMODE_ENABLE */
/**
* @brief Static single allocation.
* @param size: Size of allocated memory
* @retval None
*/
void *USBD_static_malloc(uint32_t size) void *USBD_static_malloc(uint32_t size)
{ {
UNUSED(size); UNUSED(size);
static uint32_t mem[(sizeof(USBD_HID_HandleTypeDef) / 4) + 1]; /* On 32-bit boundary */ static uint32_t mem[(sizeof(USBD_CDC_HandleTypeDef) / 4) + 1]; /* On 32-bit boundary */
return mem; return mem;
} }
/**
* @brief Dummy memory free
* @param p: Pointer to allocated memory address
* @retval None
*/
void USBD_static_free(void *p) void USBD_static_free(void *p)
{ {
UNUSED(p); UNUSED(p);
} }
/**
* @brief Delays routine for the USB Device Library.
* @param Delay: Delay in ms
* @retval None
*/
void USBD_LL_Delay(uint32_t Delay) void USBD_LL_Delay(uint32_t Delay)
{ {
UNUSED(Delay); HAL_Delay(Delay);
} }
USBD_StatusTypeDef USBD_Get_USB_Status(HAL_StatusTypeDef hal_status)
{
USBD_StatusTypeDef usb_status = USBD_OK;
switch (hal_status)
{
case HAL_OK :
usb_status = USBD_OK;
break;
case HAL_ERROR :
usb_status = USBD_FAIL;
break;
case HAL_BUSY :
usb_status = USBD_BUSY;
break;
case HAL_TIMEOUT :
usb_status = USBD_FAIL;
break;
default :
usb_status = USBD_FAIL;
break;
}
return usb_status;
}

22
Core/Src/usbd_desc_template.c → Core/Src/usbd_desc.c
View File

@@ -26,15 +26,15 @@
/* Private typedef -----------------------------------------------------------*/ /* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/
#define USBD_VID 0x0483 #define USBD_VID 0x0483
#define USBD_PID 0xaaaa /* Replace '0xaaaa' with your device product ID */ #define USBD_PID 22336 /* Replace '0xaaaa' with your device product ID */
#define USBD_LANGID_STRING 0xbbb /* Replace '0xbbb' with your device language ID */ #define USBD_LANGID_STRING 1033 /* Replace '0xbbb' with your device language ID */
#define USBD_MANUFACTURER_STRING "xxxxx" /* Add your manufacturer string */ #define USBD_MANUFACTURER_STRING "STMicroelectronics" /* Add your manufacturer string */
#define USBD_PRODUCT_HS_STRING "xxxxx" /* Add your product High Speed string */ #define USBD_PRODUCT_HS_STRING "STM32 Virtual ComPort" /* Add your product High Speed string */
#define USBD_PRODUCT_FS_STRING "xxxxx" /* Add your product Full Speed string */ #define USBD_PRODUCT_FS_STRING "STM32 Virtual ComPort" /* Add your product Full Speed string */
#define USBD_CONFIGURATION_HS_STRING "xxxxx" /* Add your configuration High Speed string */ #define USBD_CONFIGURATION_HS_STRING "CDC Config" /* Add your configuration High Speed string */
#define USBD_INTERFACE_HS_STRING "xxxxx" /* Add your Interface High Speed string */ #define USBD_INTERFACE_HS_STRING "CDC Interface" /* Add your Interface High Speed string */
#define USBD_CONFIGURATION_FS_STRING "xxxxx" /* Add your configuration Full Speed string */ #define USBD_CONFIGURATION_FS_STRING "CDC Config" /* Add your configuration Full Speed string */
#define USBD_INTERFACE_FS_STRING "xxxxx" /* Add your Interface Full Speed string */ #define USBD_INTERFACE_FS_STRING "CDC Interface" /* Add your Interface Full Speed string */
/* Private macro -------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/
@@ -88,8 +88,8 @@ __ALIGN_BEGIN uint8_t USBD_DeviceDesc[USB_LEN_DEV_DESC] __ALIGN_END =
0x00, /* bcdUSB */ 0x00, /* bcdUSB */
#endif /* (USBD_LPM_ENABLED == 1) || (USBD_CLASS_BOS_ENABLED == 1) */ #endif /* (USBD_LPM_ENABLED == 1) || (USBD_CLASS_BOS_ENABLED == 1) */
0x02, 0x02,
0x00, /* bDeviceClass */ 0x02, /* bDeviceClass */
0x00, /* bDeviceSubClass */ 0x02, /* bDeviceSubClass */
0x00, /* bDeviceProtocol */ 0x00, /* bDeviceProtocol */
USB_MAX_EP0_SIZE, /* bMaxPacketSize */ USB_MAX_EP0_SIZE, /* bMaxPacketSize */
LOBYTE(USBD_VID), /* idVendor */ LOBYTE(USBD_VID), /* idVendor */