UCHAR device_framework_full_speed_demo[] = {
    /* Device descriptor 设备描述符 */
    0x12,         // len(static)
    0x01,         // device(static)
    0x00, 0x02,    // USB2.0(static)
    0x00,        // DeviceClass(static)
    0x00,        // DeviceSubClass(static)
    0x00,        // bDeviceProtocol(static)
    0x40,        // bMaxPacketSize0
    0x69, 0x0A,    // idVendor (VID): 0x0A69
    0x8A, 0x08,    // idProduct (PID): 0x088A
    0x00, 0x01,    // bcdDevice: Device release number 0x0100
    0x01,        // iManufacturer 厂商字符串描述符的索引(static)
    0x02,        // iProduct 产品字符串描述符的索引(static)
    0x03,        // iSerialNumber 序列号字符串描述符的索引(static)
    0x01,        // bNumConfigurations(static)

    /* Device qualifier descriptor 设备限定符描述符 */
    0x0a,        // len(static)
    0x06,        // bDescriptorType: Device Qualifier Descriptor(static)
    0x00, 0x02,    // USB2.0(static)
    0x00,        // DeviceClass(static)
    0x00,        // DeviceSubClass(static)
    0x00,        // bDeviceProtocol(static)
    0x40,        // bMaxPacketSize0
    0x01,        // bNumConfigurations(static)
    0x00,        // reserve(static)

    /* Configuration descriptor 配置描述符 */
    0x09,         // len(static)
    0x02,         // bDescriptorType: Configuration Descriptor(static)
    0x20, 0x00,    // wTotalLength: Total length of data for this configuration (32 bytes)
    0x01,         // bNumInterfaces(static)
    0x01,         // bConfigurationValue(static)
    0x00,         // iConfiguration: Index of configuration string descriptor
    0x80,         // bmAttributes: Self-powered 自供电
    0x64,         // bMaxPower: 200 mA (0x64 * 2 mA)

    /* Interface descriptor 接口描述符 */
    0x09,         // len(static)
    0x04,         // bDescriptorType: Interface Descriptor(static)
    0x00,         // bInterfaceNumber: Interface 0
    0x00,         // bAlternateSetting
    0x02,         // bNumEndpoints: 2 endpoints(static)
    0xFE,         // bInterfaceClass: TMC(static)
    0x03,         // bInterfaceSubClass: USB488(static)
    0x01,         // bInterfaceProtocol(static)
    0x00,         // iInterface: Index of interface string descriptor(static)

    /* Endpoint descriptor 端点描述符(Bulk Out) */
    0x07,         // len(static)
    0x05,        // bDescriptorType: Endpoint Descriptor(static)
    0x81,        // bEndpointAddress: 端点地址（IN 方向，端点号 1）
    0x02,        // bmAttributes: 传输类型为批量（Bulk）
    0x40, 0x00,    // wMaxPacketSize: 最大包大小 64 字节
    0x00,        // bInterval: 查询间隔（用于批量传输时为 0）

    /* Endpoint descriptor 端点描述符(Bulk In) */
    0x07,        // len(static)
    0x05,        // bDescriptorType: Endpoint Descriptor(static)
    0x01,        // bEndpointAddress: 端点地址（OUT 方向，端点号 1）
    0x02,        // bmAttributes: 传输类型为批量（Bulk）
    0x40, 0x00,    // wMaxPacketSize: 最大包大小 64 字节
    0x00,        // bInterval: 查询间隔（用于批量传输时为 0）
};

uint8_t *data;                  // 原有报文buffer
uint32_t len =  OriginalLen;    // 原有长度

for(uint32_t i = len; i < ((len + 0x3) & ~0x3U); i++)
{
    data[i] = 0x00;
}

_write(data, ((len + 0x3) & ~0x3U));

#define UX_GET_STATUS                                                   0u
#define UX_CLEAR_FEATURE                                                1u
#define UX_SET_FEATURE                                                  3u 
#define UX_SET_ADDRESS                                                  5u
#define UX_GET_DESCRIPTOR                                               6u
#define UX_SET_DESCRIPTOR                                               7u
#define UX_GET_CONFIGURATION                                            8u
#define UX_SET_CONFIGURATION                                            9u
#define UX_GET_INTERFACE                                                10u
#define UX_SET_INTERFACE                                                11u
#define UX_SYNCH_FRAME                                                  12u

switch(descriptor_type)
{

case UX_INTERFACE_DESCRIPTOR_ITEM:
    ......
    break;

case UX_CONFIGURATION_DESCRIPTOR_ITEM:
    ......
    break;

default:
    break;
}

/* Check if USBx is in high speed mode to add qualifier descriptor */
if(Speed == USBD_HIGH_SPEED)
{
    pDevQualDesc                     = (USBD_DevQualiDescTypedef *)(pDevFrameWorkDesc + pdev->CurrDevDescSz);
    pDevQualDesc->bLength            = (uint8_t)sizeof(USBD_DevQualiDescTypedef);
    pDevQualDesc->bDescriptorType    = UX_DEVICE_QUALIFIER_DESCRIPTOR_ITEM;
    pDevQualDesc->bcdDevice          = 0x0200;
    pDevQualDesc->Class              = 0x00;
    pDevQualDesc->SubClass           = 0x00;
    pDevQualDesc->Protocol           = 0x00;
    pDevQualDesc->bMaxPacketSize     = 0x40;
    pDevQualDesc->bNumConfigurations = 0x01;
    pDevQualDesc->bReserved          = 0x00;
    pdev->CurrDevDescSz += (uint32_t)sizeof(USBD_DevQualiDescTypedef);
}

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    ux_device_descriptors.c
  * @author  MCD Application Team
  * @brief   USBX Device descriptor header file
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2020-2021 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "ux_device_descriptors.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
USBD_DevClassHandleTypeDef USBD_Device_FS, USBD_Device_HS;

uint8_t                    UserClassInstance[USBD_MAX_CLASS_INTERFACES] = {
    CLASS_TYPE_TMC,
};

uint8_t UserTMCInterface[] = {
    INTERFACE_TMC_USB488,
};

/* The generic device descriptor buffer that will be filled by builder
   Size of the buffer is the maximum possible device FS descriptor size. */
#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN static uint8_t DevFrameWorkDesc_FS[USBD_FRAMEWORK_MAX_DESC_SZ] __ALIGN_END = {0};

/* The generic device descriptor buffer that will be filled by builder
   Size of the buffer is the maximum possible device HS descriptor size. */
#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN static uint8_t DevFrameWorkDesc_HS[USBD_FRAMEWORK_MAX_DESC_SZ] __ALIGN_END = {0};

static uint8_t              *pDevFrameWorkDesc_FS                                        = DevFrameWorkDesc_FS;

static uint8_t              *pDevFrameWorkDesc_HS                                        = DevFrameWorkDesc_HS;
/* USER CODE BEGIN PV0 */

/* USER CODE END PV0 */

/* String Device Framework :
 Byte 0 and 1 : Word containing the language ID : 0x0904 for US
 Byte 2       : Byte containing the index of the descriptor
 Byte 3       : Byte containing the length of the descriptor string
*/
#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN UCHAR USBD_string_framework[USBD_STRING_FRAMEWORK_MAX_LENGTH] __ALIGN_END = {0};

/* Multiple languages are supported on the device, to add
   a language besides English, the Unicode language code must
   be appended to the language_id_framework array and the length
   adjusted accordingly. */

#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN UCHAR USBD_language_id_framework[LANGUAGE_ID_MAX_LENGTH] __ALIGN_END = {0};

/* USER CODE BEGIN PV1 */

/* USER CODE END PV1 */

/* Private function prototypes -----------------------------------------------*/
static void     USBD_Desc_GetString(uint8_t *desc, uint8_t *Buffer, uint16_t *len);
static uint8_t  USBD_Desc_GetLen(uint8_t *buf);

static uint8_t *USBD_Device_Framework_Builder(USBD_DevClassHandleTypeDef *pdev, uint8_t *pDevFrameWorkDesc, uint8_t *UserClassInstance, uint8_t Speed);

static uint8_t  USBD_FrameWork_AddToConfDesc(USBD_DevClassHandleTypeDef *pdev, uint8_t Speed, uint8_t *pCmpstConfDesc);

static uint8_t  USBD_FrameWork_AddClass(USBD_DevClassHandleTypeDef *pdev, USBD_CompositeClassTypeDef class, uint8_t cfgidx, uint8_t Speed, uint8_t *pCmpstConfDesc);

static uint8_t  USBD_FrameWork_FindFreeIFNbr(USBD_DevClassHandleTypeDef *pdev);

static void     USBD_FrameWork_AddConfDesc(uint32_t Conf, uint32_t *pSze);

static void     USBD_FrameWork_AssignEp(USBD_DevClassHandleTypeDef *pdev, uint8_t Add, uint8_t Type, uint32_t Sze);

static void     USBD_FrameWork_TMC_Desc(USBD_DevClassHandleTypeDef *pdev, uint32_t pConf, uint32_t *Sze);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  USBD_Get_Device_Framework_Speed
  *         Return the device speed descriptor
  * @param  Speed : HIGH or FULL SPEED flag
  * @param  length : length of HIGH or FULL SPEED array
  * @retval Pointer to descriptor buffer
  */
uint8_t *USBD_Get_Device_Framework_Speed(uint8_t Speed, ULONG *Length)
{
    uint8_t *pFrameWork = NULL;
    /* USER CODE BEGIN Device_Framework0 */

    /* USER CODE END Device_Framework0 */

    if(USBD_FULL_SPEED == Speed)
    {
        USBD_Device_Framework_Builder(&USBD_Device_FS, pDevFrameWorkDesc_FS, UserClassInstance, Speed);

        /* Get the length of USBD_device_framework_full_speed */
        *Length    = (ULONG)(USBD_Device_FS.CurrDevDescSz + USBD_Device_FS.CurrConfDescSz);

        pFrameWork = pDevFrameWorkDesc_FS;
    }
    else
    {
        USBD_Device_Framework_Builder(&USBD_Device_HS, pDevFrameWorkDesc_HS, UserClassInstance, Speed);

        /* Get the length of USBD_device_framework_high_speed */
        *Length    = (ULONG)(USBD_Device_HS.CurrDevDescSz + USBD_Device_HS.CurrConfDescSz);

        pFrameWork = pDevFrameWorkDesc_HS;
    }
    /* USER CODE BEGIN Device_Framework1 */

    /* USER CODE END Device_Framework1 */
    return pFrameWork;
}

/**
  * @brief  USBD_Get_String_Framework
  *         Return the language_id_framework
  * @param  Length : Length of String_Framework
  * @retval Pointer to language_id_framework buffer
  */
uint8_t *USBD_Get_String_Framework(ULONG *Length)
{
    uint16_t len   = 0U;
    uint8_t  count = 0U;

    /* USER CODE BEGIN String_Framework0 */

    /* USER CODE END String_Framework0 */

    /* Set the Manufacturer language Id and index in USBD_string_framework */
    USBD_string_framework[count++] = USBD_LANGID_STRING & 0xFF;
    USBD_string_framework[count++] = USBD_LANGID_STRING >> 8;
    USBD_string_framework[count++] = USBD_IDX_MFC_STR;

    /* Set the Manufacturer string in string_framework */
    USBD_Desc_GetString((uint8_t *)USBD_MANUFACTURER_STRING, USBD_string_framework + count, &len);

    /* Set the Product language Id and index in USBD_string_framework */
    count += len + 1;
    USBD_string_framework[count++] = USBD_LANGID_STRING & 0xFF;
    USBD_string_framework[count++] = USBD_LANGID_STRING >> 8;
    USBD_string_framework[count++] = USBD_IDX_PRODUCT_STR;

    /* Set the Product string in USBD_string_framework */
    USBD_Desc_GetString((uint8_t *)USBD_PRODUCT_STRING, USBD_string_framework + count, &len);

    /* Set Serial language Id and index in string_framework */
    count += len + 1;
    USBD_string_framework[count++] = USBD_LANGID_STRING & 0xFF;
    USBD_string_framework[count++] = USBD_LANGID_STRING >> 8;
    USBD_string_framework[count++] = USBD_IDX_SERIAL_STR;

    /* Set the Serial number in USBD_string_framework */
    USBD_Desc_GetString((uint8_t *)USBD_SERIAL_NUMBER, USBD_string_framework + count, &len);

    /* USER CODE BEGIN String_Framework1 */

    /* USER CODE END String_Framework1 */

    /* Get the length of USBD_string_framework */
    *Length = strlen((const char *)USBD_string_framework);

    return USBD_string_framework;
}

/**
  * @brief  USBD_Get_Language_Id_Framework
  *         Return the language_id_framework
  * @param  Length : Length of Language_Id_Framework
  * @retval Pointer to language_id_framework buffer
  */
uint8_t *USBD_Get_Language_Id_Framework(ULONG *Length)
{
    uint8_t count = 0U;

    /* Set the language Id in USBD_language_id_framework */
    USBD_language_id_framework[count++] = USBD_LANGID_STRING & 0xFF;
    USBD_language_id_framework[count++] = USBD_LANGID_STRING >> 8;

    /* Get the length of USBD_language_id_framework */
    *Length = strlen((const char *)USBD_language_id_framework);

    return USBD_language_id_framework;
}

/**
  * @brief  USBD_Get_Interface_Number
  *         Return interface number
  * @param  class_type : Device class type
  * @param  interface_type : Device interface type
  * @retval interface number
  */
uint16_t USBD_Get_Interface_Number(uint8_t class_type, uint8_t interface_type)
{
    uint8_t itf_num = 0U;
    uint8_t idx     = 0U;

    /* USER CODE BEGIN USBD_Get_Interface_Number0 */

    /* USER CODE END USBD_Get_Interface_Number0 */

    for(idx = 0; idx < USBD_MAX_SUPPORTED_CLASS; idx++)
    {
        if((USBD_Device_FS.tclasslist[idx].ClassType == class_type) && (USBD_Device_FS.tclasslist[idx].InterfaceType == interface_type))
        {
            itf_num = USBD_Device_FS.tclasslist[idx].Ifs[0];
        }
    }

    /* USER CODE BEGIN USBD_Get_Interface_Number1 */

    /* USER CODE END USBD_Get_Interface_Number1 */

    return itf_num;
}

/**
  * @brief  USBD_Get_Configuration_Number
  *         Return configuration number
  * @param  class_type : Device class type
  * @param  interface_type : Device interface type
  * @retval configuration number
  */
uint16_t USBD_Get_Configuration_Number(uint8_t class_type, uint8_t interface_type)
{
    uint8_t cfg_num = 1U;

    /* USER CODE BEGIN USBD_Get_CONFIGURATION_Number0 */

    /* USER CODE END USBD_Get_CONFIGURATION_Number0 */

    /* USER CODE BEGIN USBD_Get_CONFIGURATION_Number1 */

    /* USER CODE END USBD_Get_CONFIGURATION_Number1 */

    return cfg_num;
}

/**
  * @brief  USBD_Desc_GetString
  *         Convert ASCII string into Unicode one
  * @param  desc : descriptor buffer
  * @param  Unicode : Formatted string buffer (Unicode)
  * @param  len : descriptor length
  * @retval None
  */
static void USBD_Desc_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
{
    uint8_t  idx = 0U;
    uint8_t *pdesc;

    if(desc == NULL)
    {
        return;
    }

    pdesc          = desc;
    *len           = (uint16_t)USBD_Desc_GetLen(pdesc);

    unicode[idx++] = *(uint8_t *)len;

    while(*pdesc != (uint8_t)'\0')
    {
        unicode[idx++] = *pdesc;
        pdesc++;
    }
}

/**
  * @brief  USBD_Desc_GetLen
  *         return the string length
  * @param  buf : pointer to the ASCII string buffer
  * @retval string length
  */
static uint8_t USBD_Desc_GetLen(uint8_t *buf)
{
    uint8_t  len   = 0U;
    uint8_t *pbuff = buf;

    while(*pbuff != (uint8_t)'\0')
    {
        len++;
        pbuff++;
    }

    return len;
}

/**
  * @brief  USBD_Device_Framework_Builder
  *         Device Framework builder
  * @param  pdev: device instance
  * @param  pDevFrameWorkDesc: Pointer to the device framework descriptor
  * @param  UserClassInstance: type of the class to be added
  * @param  Speed: Speed parameter HS or FS
  * @retval status
  */
static uint8_t *USBD_Device_Framework_Builder(USBD_DevClassHandleTypeDef *pdev, uint8_t *pDevFrameWorkDesc, uint8_t *UserClassInstance, uint8_t Speed)
{
    static USBD_DeviceDescTypedef   *pDevDesc;
    static USBD_DevQualiDescTypedef *pDevQualDesc;
    uint8_t                          Idx_Instance = 0U;

    /* Set Dev and conf descriptors size to 0 */
    pdev->CurrConfDescSz = 0U;
    pdev->CurrDevDescSz  = 0U;

    /* Set the pointer to the device descriptor area*/
    pDevDesc = (USBD_DeviceDescTypedef *)pDevFrameWorkDesc;

    /* Start building the generic device descriptor common part */
    pDevDesc->bLength            = (uint8_t)sizeof(USBD_DeviceDescTypedef);
    pDevDesc->bDescriptorType    = UX_DEVICE_DESCRIPTOR_ITEM;
    pDevDesc->bcdUSB             = USB_BCDUSB;
    pDevDesc->bDeviceClass       = 0x00;
    pDevDesc->bDeviceSubClass    = 0x00;
    pDevDesc->bDeviceProtocol    = 0x00;
    pDevDesc->bMaxPacketSize     = USBD_MAX_EP0_SIZE;
    pDevDesc->idVendor           = USBD_VID;
    pDevDesc->idProduct          = USBD_PID;
    pDevDesc->bcdDevice          = 0x0100;
    pDevDesc->iManufacturer      = USBD_IDX_MFC_STR;
    pDevDesc->iProduct           = USBD_IDX_PRODUCT_STR;
    pDevDesc->iSerialNumber      = USBD_IDX_SERIAL_STR;
    pDevDesc->bNumConfigurations = USBD_MAX_NUM_CONFIGURATION;
    pdev->CurrDevDescSz += (uint32_t)sizeof(USBD_DeviceDescTypedef);

    /* Check if USBx is in high speed mode to add qualifier descriptor */
    pDevQualDesc                     = (USBD_DevQualiDescTypedef *)(pDevFrameWorkDesc + pdev->CurrDevDescSz);
    pDevQualDesc->bLength            = (uint8_t)sizeof(USBD_DevQualiDescTypedef);
    pDevQualDesc->bDescriptorType    = UX_DEVICE_QUALIFIER_DESCRIPTOR_ITEM;
    pDevQualDesc->bcdDevice          = 0x0200;
    pDevQualDesc->Class              = 0x00;
    pDevQualDesc->SubClass           = 0x00;
    pDevQualDesc->Protocol           = 0x00;
    pDevQualDesc->bMaxPacketSize     = 0x40;
    pDevQualDesc->bNumConfigurations = 0x01;
    pDevQualDesc->bReserved          = 0x00;
    pdev->CurrDevDescSz += (uint32_t)sizeof(USBD_DevQualiDescTypedef);

    /* Build the device framework */
    while(Idx_Instance < USBD_MAX_SUPPORTED_CLASS)
    {
        if((pdev->classId < USBD_MAX_SUPPORTED_CLASS) && (pdev->NumClasses < USBD_MAX_SUPPORTED_CLASS) && (UserClassInstance[Idx_Instance] != CLASS_TYPE_NONE))
        {
            /* Call the composite class builder */
            (void)USBD_FrameWork_AddClass(pdev, (USBD_CompositeClassTypeDef)UserClassInstance[Idx_Instance], 0, Speed, (pDevFrameWorkDesc + pdev->CurrDevDescSz));

            /* Increment the ClassId for the next occurrence */
            pdev->classId++;
            pdev->NumClasses++;
        }

        Idx_Instance++;
    }

    /* Check if there is a composite class and update device class */
    if(pdev->NumClasses > 1)
    {
        pDevDesc->bDeviceClass    = 0xEF;
        pDevDesc->bDeviceSubClass = 0x02;
        pDevDesc->bDeviceProtocol = 0x01;
    }
    else
    {
        /* Check if the CDC ACM class is set and update device class */
        if(UserClassInstance[0] == CLASS_TYPE_CDC_ACM)
        {
            pDevDesc->bDeviceClass    = 0x02;
            pDevDesc->bDeviceSubClass = 0x02;
            pDevDesc->bDeviceProtocol = 0x00;
        }
    }

    return pDevFrameWorkDesc;
}

/**
  * @brief  USBD_FrameWork_AddToConfDesc
  *         Add a new class to the configuration descriptor
  * @param  pdev: device instance
  * @param  Speed: device speed
  * @param  pCmpstConfDesc: to composite device configuration descriptor
  * @retval status
  */
uint8_t USBD_FrameWork_AddToConfDesc(USBD_DevClassHandleTypeDef *pdev, uint8_t Speed, uint8_t *pCmpstConfDesc)
{
    uint8_t interface = 0U;

    pdev->Speed       = Speed;

    if(pdev->classId == 0U)
    {
        /* Add configuration and IAD descriptors */
        USBD_FrameWork_AddConfDesc((uint32_t)pCmpstConfDesc, &pdev->CurrConfDescSz);
    }

    switch(pdev->tclasslist[pdev->classId].ClassType)
    {
    case CLASS_TYPE_TMC:
        switch(pdev->tclasslist[pdev->classId].InterfaceType)
        {
        case INTERFACE_TMC_USB488:

            /* Find the first available interface slot and Assign number of interfaces */
            interface                              = USBD_FrameWork_FindFreeIFNbr(pdev);
            pdev->tclasslist[pdev->classId].NumIf  = 1U;
            pdev->tclasslist[pdev->classId].Ifs[0] = interface;

            /* Assign endpoint numbers */
            pdev->tclasslist[pdev->classId].NumEps = 2U; /* EP_IN, EP_OUT */

            /* Check the current speed to assign endpoints */
            if(pdev->Speed == USBD_HIGH_SPEED)
            {
                /* Assign IN Endpoint */
                USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPIN_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPIN_HS_MPS);

                /* Assign OUT Endpoint */
                USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPOUT_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPOUT_HS_MPS);
            }
            else
            {
                USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPIN_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPIN_FS_MPS);

                USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPOUT_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPOUT_FS_MPS);
            }

            USBD_FrameWork_TMC_Desc(pdev, (uint32_t)pCmpstConfDesc, &pdev->CurrConfDescSz);

            break;

        default:
            break;
        }
        break;

    default:
        break;
    }

    return UX_SUCCESS;
}

/**
  * @brief  USBD_FrameWork_AddClass
  *         Register a class in the class builder
  * @param  pdev: device instance
  * @param  class: type of the class to be added (from USBD_CompositeClassTypeDef)
  * @param  cfgidx: configuration index
  * @param  speed: device speed
  * @param  pCmpstConfDesc: to composite device configuration descriptor
  * @retval status
  */
uint8_t USBD_FrameWork_AddClass(USBD_DevClassHandleTypeDef *pdev, USBD_CompositeClassTypeDef class, uint8_t cfgidx, uint8_t Speed, uint8_t *pCmpstConfDesc)
{
    static uint8_t interface_idx = 0U;

    if((pdev->classId < USBD_MAX_SUPPORTED_CLASS) && (pdev->tclasslist[pdev->classId].Active == 0U))
    {
        /* Store the class parameters in the global tab */
        pdev->tclasslist[pdev->classId].ClassId   = pdev->classId;
        pdev->tclasslist[pdev->classId].Active    = 1U;
        pdev->tclasslist[pdev->classId].ClassType = class;

        if(class == CLASS_TYPE_TMC)
        {
            pdev->tclasslist[pdev->classId].InterfaceType = UserTMCInterface[interface_idx];

            interface_idx++;

            if(interface_idx == sizeof(UserTMCInterface))
            {
                interface_idx = 0U;
            }
        }

        /* Call configuration descriptor builder and endpoint configuration builder */
        if(USBD_FrameWork_AddToConfDesc(pdev, Speed, pCmpstConfDesc) != UX_SUCCESS)
        {
            return UX_ERROR;
        }
    }

    UNUSED(cfgidx);

    return UX_SUCCESS;
}

/**
  * @brief  USBD_FrameWork_FindFreeIFNbr
  *         Find the first interface available slot
  * @param  pdev: device instance
  * @retval The interface number to be used
  */
static uint8_t USBD_FrameWork_FindFreeIFNbr(USBD_DevClassHandleTypeDef *pdev)
{
    uint32_t idx = 0U;

    /* Unroll all already activated classes */
    for(uint32_t i = 0U; i < pdev->NumClasses; i++)
    {
        /* Unroll each class interfaces */
        for(uint32_t j = 0U; j < pdev->tclasslist[i].NumIf; j++)
        {
            /* Increment the interface counter index */
            idx++;
        }
    }

    /* Return the first available interface slot */
    return (uint8_t)idx;
}

/**
  * @brief  USBD_FrameWork_AddConfDesc
  *         Add a new class to the configuration descriptor
  * @param  Conf: configuration descriptor
  * @param  pSze: pointer to the configuration descriptor size
  * @retval none
  */
static void USBD_FrameWork_AddConfDesc(uint32_t Conf, uint32_t *pSze)
{
    /* Intermediate variable to comply with MISRA-C Rule 11.3 */
    USBD_ConfigDescTypedef *ptr = (USBD_ConfigDescTypedef *)Conf;

    ptr->bLength                = (uint8_t)sizeof(USBD_ConfigDescTypedef);
    ptr->bDescriptorType        = UX_CONFIGURATION_DESCRIPTOR_ITEM;
    ptr->wDescriptorLength      = 0x20;
    ptr->bNumInterfaces         = 1U;
    ptr->bConfigurationValue    = 1U;
    ptr->iConfiguration         = USBD_CONFIG_STR_DESC_IDX;
    ptr->bmAttributes           = USBD_CONFIG_BMATTRIBUTES;
    ptr->bMaxPower              = USBD_CONFIG_MAXPOWER;
    *pSze += sizeof(USBD_ConfigDescTypedef);
}

/**
  * @brief  USBD_FrameWork_AssignEp
  *         Assign and endpoint
  * @param  pdev: device instance
  * @param  Add: Endpoint address
  * @param  Type: Endpoint type
  * @param  Sze: Endpoint max packet size
  * @retval none
  */
static void USBD_FrameWork_AssignEp(USBD_DevClassHandleTypeDef *pdev, uint8_t Add, uint8_t Type, uint32_t Sze)
{
    uint32_t idx = 0U;

    /* Find the first available endpoint slot */
    while(((idx < (pdev->tclasslist[pdev->classId]).NumEps) && ((pdev->tclasslist[pdev->classId].Eps[idx].is_used) != 0U)))
    {
        /* Increment the index */
        idx++;
    }

    /* Configure the endpoint */
    pdev->tclasslist[pdev->classId].Eps[idx].add     = Add;
    pdev->tclasslist[pdev->classId].Eps[idx].type    = Type;
    pdev->tclasslist[pdev->classId].Eps[idx].size    = (uint16_t)Sze;
    pdev->tclasslist[pdev->classId].Eps[idx].is_used = 1U;
}

/**
  * @brief  USBD_FrameWork_TMC_Desc
  *         Configure and Append the TMC Descriptor
  * @param  pdev: device instance
  * @param  pConf: Configuration descriptor pointer
  * @param  Sze: pointer to the current configuration descriptor size
  * @retval None
  */
static void USBD_FrameWork_TMC_Desc(USBD_DevClassHandleTypeDef *pdev, uint32_t pConf, uint32_t *Sze)
{
    static USBD_IfDescTypedef *pIfDesc;
    static USBD_EpDescTypedef *pEpDesc;

    switch(pdev->tclasslist[pdev->classId].InterfaceType)
    {
    case INTERFACE_TMC_USB488:

        /* Append Interface descriptor to Configuration descriptor */
        __USBD_FRAMEWORK_SET_IF(pdev->tclasslist[pdev->classId].Ifs[0], 0U, (uint8_t)(pdev->tclasslist[pdev->classId].NumEps), UX_DEVICE_CLASS_TMC_CLASS, UX_DEVICE_SUB_CLASS_USB488_CLASS, INTERFACE_TMC_USB488, 0U);

        if(pdev->Speed == USBD_HIGH_SPEED)
        {
            /* Append Endpoint descriptor to Configuration descriptor */
            __USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[0].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[0].size, USBD_TMC_NONE_EPIN_FS_BINTERVAL, USBD_TMC_NONE_EPIN_HS_BINTERVAL);

            __USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[1].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[1].size, USBD_TMC_NONE_EPOUT_HS_BINTERVAL, USBD_TMC_NONE_EPOUT_FS_BINTERVAL);
        }
        else
        {
            /* Append Endpoint descriptor to Configuration descriptor */
            __USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[0].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[0].size, USBD_TMC_NONE_EPIN_FS_BINTERVAL, USBD_TMC_NONE_EPIN_HS_BINTERVAL);

            __USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[1].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[1].size, USBD_TMC_NONE_EPOUT_HS_BINTERVAL, USBD_TMC_NONE_EPOUT_FS_BINTERVAL);
        }

        break;

    default:
        break;
    }
}

/********************************************************************************


 **** Copyright (C), 2024, Yuanlong Xu <Yono233@outlook.com>    ****
 **** All rights reserved                                       ****

 ********************************************************************************
 * File Name     : ux_device_tmc.c
 * Author        : yono
 * Date          : 2025-01-07
 * Version       : 1.0
********************************************************************************/
/**************************************************************************/
/*
    tmc用户解析
*/

/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include "ux_api.h"
#include "ux_device_class_dpump.h"
/* Private types -------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/
#define UX_HOST_CLASS_DPUMP_PACKET_SIZE 255
extern UX_SLAVE_CLASS_DPUMP *TMC_Dpump;

/* 信道buffer */
uint8_t device_buffer[UX_HOST_CLASS_DPUMP_PACKET_SIZE];
/* 帧信息 */
uint8_t TransferEMO = 0; // 传输结束标志 0x00继续传输 0x01传输结束
uint8_t TransferTag = 0; // 传输令牌，回复时复制
/* 信息buffer */
uint8_t  SCPI_Read[255];
uint32_t SCPI_Read_Length = 0;
uint8_t  SCPI_Write[255];
uint32_t SCPI_Write_Length = 0;

/* Private Constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
uint32_t    TMC_Write(uint8_t *data, uint32_t len);
extern UINT _ux_device_class_dpump_tmc_read(UX_SLAVE_CLASS_DPUMP *dpump, UCHAR *buffer, ULONG requested_length, ULONG *actual_length);
/* Private functions ---------------------------------------------------------*/

void TMC_Engine(void)
{
    UINT  status;
    ULONG actual_length;

    if(TMC_Dpump != UX_NULL)
    {
        /* 收取部分  */
        status = _ux_device_class_dpump_tmc_read(TMC_Dpump, device_buffer, UX_HOST_CLASS_DPUMP_PACKET_SIZE, &actual_length);
        if(status == UX_SUCCESS)
        {
            if((0xff ^ device_buffer[1] ^ device_buffer[2]) || device_buffer[3] != 0)
                return; // 不良报文

            switch(device_buffer[0]) // 命令
            {
            case 0x01:
                // 接收分支
                ux_utility_memory_copy(&SCPI_Read[0 + SCPI_Read_Length],  // 兼容分包传输，以前一次传输的长度为起始
                                       &device_buffer[12],                // 真实携带数据的起始位置
                                       *(uint32_t *)(&device_buffer[4])); // 4~7字节以小端组成数据长度
                SCPI_Read_Length += *(uint32_t *)(&device_buffer[4]);

                TransferEMO = device_buffer[8] & 0x01;

                if(TransferEMO)
                {
                    /* 回环测试 */
                    TMC_Write(SCPI_Read, SCPI_Read_Length);
                    /* 结尾兼容 */
                    // 传输结束 触发解析
                    SCPI_Read_Length = 0;
                }
                else
                {
                    // 传输未结束 不处理
                }
                break;

            case 0x02:
                TransferTag = device_buffer[1]; // 寄存令牌

                /* 0~3 是请求及令牌，无需更改*/
                *(uint32_t *)(&device_buffer[4]) = SCPI_Write_Length; // 4~7字节以小端组成数据长度

                /* 成功固定数据 */
                device_buffer[8]  = 0x1; // 成功回复
                device_buffer[9]  = 0x00;
                device_buffer[10] = 0x00;
                device_buffer[11] = 0x00;

                /* 填充发送数据 */
                ux_utility_memory_copy(&device_buffer[12], SCPI_Write, SCPI_Write_Length);

                /* 填充0x00 此处如果原本就是4字节对齐，将多补4个0 */
                for(uint32_t i = 12 + SCPI_Write_Length; i < ((12 + SCPI_Write_Length + 0x3) & ~0x3U); i++)
                {
                    device_buffer[i] = 0x00;
                }

                /* 请求发送 */
                status = _ux_device_class_dpump_write(TMC_Dpump, device_buffer, ((12 + SCPI_Write_Length + 0x3) & ~0x3U), &actual_length);

                /* 清理发送请求 */
                SCPI_Write_Length = 0;
                break;
            default:
                break;
            }
        }
    }
}

uint32_t TMC_Write(uint8_t *data, uint32_t len)
{
    if(sizeof(SCPI_Write) < (SCPI_Write_Length + len))
        return 1;

    ux_utility_memory_copy(&SCPI_Write[0 + SCPI_Write_Length], // 兼容分包填充
                           data,
                           len);
    SCPI_Write_Length += len;

    return 0;
}

/**************************************************************************/
/*                                                                        */
/*       Copyright (c) Microsoft Corporation. All rights reserved.        */
/*                                                                        */
/*       This software is licensed under the Microsoft Software License   */
/*       Terms for Microsoft Azure RTOS. Full text of the license can be  */
/*       found in the LICENSE file at https://aka.ms/AzureRTOS_EULA       */
/*       and in the root directory of this software.                      */
/*                                                                        */
/**************************************************************************/

/**************************************************************************/
/**************************************************************************/
/**                                                                       */
/** USBX Component                                                        */
/**                                                                       */
/**   Device Data Pump Class                                              */
/**                                                                       */
/**************************************************************************/
/**************************************************************************/

#define UX_SOURCE_CODE

/* Include necessary system files.  */

#include "ux_api.h"
#include "ux_device_class_dpump.h"

#define UX_SLAVE_CLASS_DPUMP_TMC_CLASS 0xFE

/**************************************************************************/
/*                                                                        */
/*  FUNCTION                                               RELEASE        */
/*                                                                        */
/*    _ux_device_class_dpump_tmc_entry                 PORTABLE C         */
/*                                                           6.1          */
/*  AUTHOR                                                                */
/*                                                                        */
/*    yono, yono233.cn                                                    */
/*                                                                        */
/*  DESCRIPTION                                                           */
/*                                                                        */
/*    This function is the entry point of the device dpump class. It      */
/*    will be called by the device stack enumeration module when the      */
/*    host has sent a SET_CONFIGURATION command and the dpump interface   */
/*    needs to be mounted.                                                */
/*                                                                        */
/*  INPUT                                                                 */
/*                                                                        */
/*    command                               Pointer to class command      */
/*                                                                        */
/*  OUTPUT                                                                */
/*                                                                        */
/*    Completion Status                                                   */
/*                                                                        */
/*  CALLS                                                                 */
/*                                                                        */
/*    _ux_device_class_dpump_initialize      Initialize dpump class       */
/*    _ux_device_class_dpump_activate        Activate dpump class         */
/*    _ux_device_class_dpump_deactivate      Deactivate dpump class       */
/*    _ux_device_class_dpump_change          Alternate setting change     */
/*                                                                        */
/*  CALLED BY                                                             */
/*                                                                        */
/*    Device Data Pump Class                                              */
/*                                                                        */
/*  RELEASE HISTORY                                                       */
/*                                                                        */
/*    DATE              NAME                      DESCRIPTION             */
/*                                                                        */
/*  05-19-2020     Chaoqiong Xiao           Initial Version 6.0           */
/*  09-30-2020     Chaoqiong Xiao           Modified comment(s),          */
/*                                            resulting in version 6.1    */
/*  01-07-2025     yono                     Initial                       */
/*                                                                        */
/**************************************************************************/
UINT _ux_device_class_dpump_tmc_entry(UX_SLAVE_CLASS_COMMAND *command)
{
    UINT status;

    /* The command request will tell us we need to do here, either a enumeration
       query, an activation or a deactivation.  */
    switch(command->ux_slave_class_command_request)
    {
    case UX_SLAVE_CLASS_COMMAND_INITIALIZE:

        /* Call the init function of the DPUMP class.  */
        status = _ux_device_class_dpump_initialize(command);

        /* Return the completion status.  */
        return (status);

    case UX_SLAVE_CLASS_COMMAND_QUERY:

        /* Check the CLASS definition in the interface descriptor. */
        if(command->ux_slave_class_command_class == UX_SLAVE_CLASS_DPUMP_TMC_CLASS)
            return (UX_SUCCESS);
        else
            return (UX_NO_CLASS_MATCH);

    case UX_SLAVE_CLASS_COMMAND_ACTIVATE:

        /* The activate command is used when the host has sent a SET_CONFIGURATION command
           and this interface has to be mounted. Both Bulk endpoints have to be mounted
           and the dpump thread needs to be activated.  */
        status = _ux_device_class_dpump_activate(command);

        /* Return the completion status.  */
        return (status);

    case UX_SLAVE_CLASS_COMMAND_CHANGE:

        /* The change command is used when the host has sent a SET_INTERFACE command
           to go from Alternate Setting 0 to 1 or revert to the default mode.  */
        status = _ux_device_class_dpump_change(command);

        /* Return the completion status.  */
        return (status);

    case UX_SLAVE_CLASS_COMMAND_DEACTIVATE:

        /* The deactivate command is used when the device has been extracted.
           The device endpoints have to be dismounted and the dpump thread canceled.  */
        status = _ux_device_class_dpump_deactivate(command);

        /* Return the completion status.  */
        return (status);

    case UX_SLAVE_CLASS_COMMAND_REQUEST:

        { // my request begin
            status = UX_SUCCESS;

            UX_SLAVE_DEVICE   *device;
            UX_SLAVE_TRANSFER *transfer_request;
            UX_SLAVE_ENDPOINT *endpoint;
            ULONG              length;

            /* Get the pointer to the device.  */
            device = &_ux_system_slave->ux_system_slave_device;

            /* Get the control endpoint associated with the device.  */
            endpoint = &device->ux_slave_device_control_endpoint;

            /* Get the pointer to the transfer request associated with the endpoint.  */
            transfer_request = &endpoint->ux_slave_endpoint_transfer_request;

            switch(transfer_request->ux_slave_transfer_request_setup[0])
            {
            case 0xA1: /* Use case of memcpy is verified. */
                length = transfer_request->ux_slave_transfer_request_setup[6] + (transfer_request->ux_slave_transfer_request_setup[7] << 8);

                /* Set the direction to OUT.  */
                transfer_request->ux_slave_transfer_request_phase = UX_TRANSFER_PHASE_DATA_OUT;

                switch(transfer_request->ux_slave_transfer_request_setup[1])
                {
                case 0x07:
                    /* Copy the device descriptor into the transfer request memory.  */
                    _ux_utility_memory_copy(transfer_request->ux_slave_transfer_request_data_pointer,                                           //
                                            "\x01\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", //
                                            0x18);
                    break;

                default:
                    break;
                }

                _ux_device_stack_transfer_request(transfer_request, length, length);
                break;
            case 0xA2:
                length = transfer_request->ux_slave_transfer_request_setup[6] + (transfer_request->ux_slave_transfer_request_setup[7] << 8);

                /* Set the direction to IN.  */
                transfer_request->ux_slave_transfer_request_phase = UX_TRANSFER_PHASE_DATA_OUT;

                switch(transfer_request->ux_slave_transfer_request_setup[1])
                {
                case 0x01:
                    transfer_request->ux_slave_transfer_request_data_pointer[0] = 0x01;                                                 // USBTMC_status values
                    transfer_request->ux_slave_transfer_request_data_pointer[1] = transfer_request->ux_slave_transfer_request_setup[2]; // 复制令牌
                    length                                                      = 2;
                    break;

                case 0x02:
                    transfer_request->ux_slave_transfer_request_data_pointer[0] = 0x01; // USBTMC_status values

                    transfer_request->ux_slave_transfer_request_data_pointer[1] = 0x00; // fixed segment
                    transfer_request->ux_slave_transfer_request_data_pointer[2] = 0x00;
                    transfer_request->ux_slave_transfer_request_data_pointer[3] = 0x00;

                    transfer_request->ux_slave_transfer_request_data_pointer[4] = 0x00; // 剩余未处理的字节数
                    transfer_request->ux_slave_transfer_request_data_pointer[5] = 0x00;
                    transfer_request->ux_slave_transfer_request_data_pointer[6] = 0x00;
                    transfer_request->ux_slave_transfer_request_data_pointer[7] = 0x00;

                    break;

                default:
                    break;
                }

                /* Receive the data from the host. */
                _ux_device_stack_transfer_request(transfer_request, length, length);
                break;
            default:
                break;
            }

        } // my request end

        return (UX_SUCCESS);

    default:

        /* Error trap. */
        _ux_system_error_handler(UX_SYSTEM_LEVEL_THREAD, UX_SYSTEM_CONTEXT_CLASS, UX_FUNCTION_NOT_SUPPORTED);

        /* If trace is enabled, insert this event into the trace buffer.  */
        UX_TRACE_IN_LINE_INSERT(UX_TRACE_ERROR, UX_FUNCTION_NOT_SUPPORTED, 0, 0, 0, UX_TRACE_ERRORS, 0, 0)

        /* Return an error.  */
        return (UX_FUNCTION_NOT_SUPPORTED);
    }
}