STM32F7xx基于HAL库的USB_CDC接收数据的函数调用

最新推荐文章于 2025-03-13 12:59:41 发布
最新推荐文章于 2025-03-13 12:59:41 发布
阅读量6.7k 收藏 31
点赞数 8
分类专栏： 嵌入式C/C++ 文章标签： STM32F7xx USB_CDC HAL库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Tanner_SL/article/details/119257213
版权
本文详细解析了STM32F7xx使用HAL库实现的USB通信中，数据接收的中断处理流程，包括OTG HS中断处理、HAL_PCD_IRQHandler函数、EP中断检查、DataOutStageCallback回调，以及USBD_CDC接收数据的具体步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在STM32F7xx的HAL库实现的USB通信中，里面存在着多个库文件和函数的调用，这一章节主要对USB接收数据的函数调用流程来进行分析，USB的数据发送部分相对来说比较容易分析。

在usb通信中，STM32F7xx作为从设备，当USB接收到数据时，从而产生中断；

/**
 * @File: stm32f7xx_it.c
 * @brief This function handles USB On the Go Hs global interrupt.
 */
extern PCD_HandleTypeDef hpcd_USB_OTG_HS;
void OTG_HS_IRQHandler(void)
{
  HAL_PCD_IRQHandler(&hpcd_USB_OTG_HS);
}

进入HAL_PCD_IRQHandler(&hpcd_USB_OTG_HS)函数，部分函数代码如下；

/**
 * @File: stm32f7xx_hal_pcd.c
 * @brief This function handles USB On the Go Hs global interrupt.
 */
void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
{
    //...
     /* Read in the device interrupt bits */
      ep_intr = USB_ReadDevAllOutEpInterrupt(hpcd->Instance);
      while (ep_intr != 0U)
      {
        if ((ep_intr & 0x1U) != 0U)
        {
          epint = USB_ReadDevOutEPInterrupt(hpcd->Instance, (uint8_t)epnum);
          if ((epint & USB_OTG_DOEPINT_XFRC) == USB_OTG_DOEPINT_XFRC)
          {
            CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_XFRC);
            (void)PCD_EP_OutXfrComplete_int(hpcd, epnum);
          }
            //...
        }
          //...
      }
    //...
}

读取device out endpoint interrupt寄存器后判断是否数据传输完成，然后清除传输完成中断标志位并进入函数PCD_EP_OutXfrComplete_int(hpcd, epnum)，其部分函数代码如下；

/**
 * @File: stm32f7xx_hal_pcd.c
 * @brief process EP OUT transfer complete interrupt.
 */
static HAL_StatusTypeDef PCD_EP_OutXfrComplete_int(PCD_HandleTypeDef *hpcd, uint32_t epnum)
{
    //...
#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
        hpcd->DataOutStageCallback(hpcd, (uint8_t)epnum);
#else
        HAL_PCD_DataOutStageCallback(hpcd, (uint8_t)epnum);
#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
    //...
}

然后会进入数据处理回调函数HAL_PCD_DataOutStageCallback，主要是调用USB的底层函数USBD_LL_DataOutStage；

/**
 * @File: usbd_conf.c
 * @brief Data Out stage callback.
 */
void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
  USBD_LL_DataOutStage((USBD_HandleTypeDef*)hpcd->pData, epnum, 
                       hpcd->OUT_ep[epnum].xfer_buff);
}

其函数USBD_LL_DataOutStage()的部分代码如下；

/**
 * @File: usbd_core.c
 * @brief USBD_LL_DataOutStage.
 */
USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev,
                                        uint8_t epnum, uint8_t *pdata)
{
    USBD_EndpointTypeDef *pep;
    USBD_StatusTypeDef ret;
    if(epnum == 0U)
    {
        //...
    }
   else if ((pdev->pClass->DataOut != NULL) &&
            (pdev->dev_state == USBD_STATE_CONFIGURED))
  {
    ret = (USBD_StatusTypeDef)pdev->pClass->DataOut(pdev, epnum);
    if (ret != USBD_OK)
    {
      return ret;
    }
  }
    //...
}

里面主要是通过pdev->pClass->DataOut(pdev, epnum)来调用函数USBD_CDC_DataOut；

通过对结构体USBD_HandleTypeDef的分析，在usbd_conf.c文件中定义了两个结构体USBD_HandleTypeDef和USBD_ClassTypeDef：

/**
 * @File: usbd_conf.c
 *
 */
typedef struct _Device_cb
{
  uint8_t (*Init)(struct _USBD_HandleTypeDef *pdev, uint8_t cfgidx);
  uint8_t (*DeInit)(struct _USBD_HandleTypeDef *pdev, uint8_t cfgidx);
  /* Control Endpoints*/
  uint8_t (*Setup)(struct _USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef  *req);
  uint8_t (*EP0_TxSent)(struct _USBD_HandleTypeDef *pdev);
  uint8_t (*EP0_RxReady)(struct _USBD_HandleTypeDef *pdev);
  /* Class Specific Endpoints*/
  uint8_t (*DataIn)(struct _USBD_HandleTypeDef *pdev, uint8_t epnum);
  uint8_t (*DataOut)(struct _USBD_HandleTypeDef *pdev, uint8_t epnum);
  uint8_t (*SOF)(struct _USBD_HandleTypeDef *pdev);
  uint8_t (*IsoINIncomplete)(struct _USBD_HandleTypeDef *pdev, uint8_t epnum);
  uint8_t (*IsoOUTIncomplete)(struct _USBD_HandleTypeDef *pdev, uint8_t epnum);
  uint8_t  *(*GetHSConfigDescriptor)(uint16_t *length);
  uint8_t  *(*GetFSConfigDescriptor)(uint16_t *length);
  uint8_t  *(*GetOtherSpeedConfigDescriptor)(uint16_t *length);
  uint8_t  *(*GetDeviceQualifierDescriptor)(uint16_t *length);
} USBD_ClassTypeDef;
/* USB Device handle structure */
typedef struct _USBD_HandleTypeDef
{
  uint8_t                 id;
  uint32_t                dev_config;
  uint32_t                dev_default_config;
  uint32_t                dev_config_status;
  USBD_SpeedTypeDef       dev_speed;
  USBD_EndpointTypeDef    ep_in[16];
  USBD_EndpointTypeDef    ep_out[16];
  uint32_t                ep0_state;
  uint32_t                ep0_data_len;
  uint8_t                 dev_state;
  uint8_t                 dev_old_state;
  uint8_t                 dev_address;
  uint8_t                 dev_connection_status;
  uint8_t                 dev_test_mode;
  uint32_t                dev_remote_wakeup;
  uint8_t                 ConfIdx;
  USBD_SetupReqTypedef    request;
  USBD_DescriptorsTypeDef *pDesc;
  USBD_ClassTypeDef       *pClass;
  void                    *pClassData;
  void                    *pUserData;
  void                    *pData;
  void                    *pBosDesc;
  void                    *pConfDesc;
} USBD_HandleTypeDef;

并对结构体USBD_ClassTypeDef进行了实例化：

/**
 * @File: usbd_conf.c
 *@brief: CDC interface class callbacks structure.
 */
USBD_ClassTypeDef  USBD_CDC =
{
  USBD_CDC_Init,
  USBD_CDC_DeInit,
  USBD_CDC_Setup,
  NULL,                 /* EP0_TxSent, */
  USBD_CDC_EP0_RxReady,
  USBD_CDC_DataIn,
  USBD_CDC_DataOut,
  NULL,
  NULL,
  NULL,
  USBD_CDC_GetHSCfgDesc,
  USBD_CDC_GetFSCfgDesc,
  USBD_CDC_GetOtherSpeedCfgDesc,
  USBD_CDC_GetDeviceQualifierDescriptor,
};

而在USB进行设备初始化时，就会来调用函数USBD_RegisterClass(&hUsbDeviceHS, &USBD_CDC)来进行初始化，其函数USBD_RegisterClass()的部分代码如下；

/**
 * @File: usbd_conf.c
 *@brief: Link class driver to Device Core.
 */
USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, 
                                      USBD_ClassTypeDef *pclass)
{
    //...
    /* link the class to the USB Device handle */
    pdev->pClass = pclass;
    //...
}

所以在函数USBD_LL_DataOutStage()中的pdev->pClass->DataOut(pdev, epnum)就会来调用上面提到的函数USBD_CDC_DataOut，在文件usbd_conf.c中进行了定义；

/**
 * @File: usbd_conf.c
 * @brief Data received on non-control Out endpoint
 */
static uint8_t USBD_CDC_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
{
    USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *)pdev->pClassData;
​
  if (pdev->pClassData == NULL)
  {
    return (uint8_t)USBD_FAIL;
  }
  /* Get the received data length */
  hcdc->RxLength = USBD_LL_GetRxDataSize(pdev, epnum);
  /* USB data will be immediately processed, this allow next USB traffic being
  NAKed till the end of the application Xfer */
  ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcdc->RxBuffer, &hcdc->RxLength);
    
  return (uint8_t)USBD_OK;
}

函数中的((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcdc->RxBuffer, &hcdc->RxLength)就会调用到函数CDC_Receive_HS。

同样，在文件usbd_conf.c中定义了结构体USBD_CDC_ItfTypeDef并进行了实例化;

/**
 * @File: usbd_conf.c
 *
 */
typedef struct _USBD_CDC_Itf
{
  int8_t (* Init)(void);
  int8_t (* DeInit)(void);
  int8_t (* Control)(uint8_t cmd, uint8_t *pbuf, uint16_t length);
  int8_t (* Receive)(uint8_t *Buf, uint32_t *Len);
  int8_t (* TransmitCplt)(uint8_t *Buf, uint32_t *Len, uint8_t epnum);
} USBD_CDC_ItfTypeDef;
/*
*CD  Interface callback
*/
USBD_CDC_ItfTypeDef USBD_Interface_fops_HS =
{
  CDC_Init_HS,
  CDC_DeInit_HS,
  CDC_Control_HS,
  CDC_Receive_HS,
  CDC_TransmitCplt_HS
};

并在usb的设备初始化中调用函数USBD_CDC_RegisterInterface(&hUsbDeviceHS, &USBD_Interface_fops_HS)进行了初始化，其USBD_CDC_RegisterInterface()函数代码如下；

/**
 * @File: usbd_conf.c
 *@brief: USBD_CDC_RegisterInterface.
 */
uint8_t USBD_CDC_RegisterInterface(USBD_HandleTypeDef *pdev,USBD_CDC_ItfTypeDef *fops)
{
  if (fops == NULL)
  {
    return (uint8_t)USBD_FAIL;
  }
  pdev->pUserData = fops;
  return (uint8_t)USBD_OK;
}

所以((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcdc->RxBuffer, &hcdc->RxLength)就会调用到函数CDC_Receive_HS，在文件usbd_cdc_if.c中进行了定义；

/**
 * @File: usbd_cdc_if.c
 * @brief Data received over USB OUT endpoint are sent over CDC interface
 *         through this function.
 * @param  Buf: Buffer of data to be received
 * @param  Len: Number of data received (in bytes)
 */
static int8_t CDC_Receive_HS(uint8_t* Buf, uint32_t *Len)
{
  /* USER CODE BEGIN 11 */
  USBD_CDC_SetRxBuffer(&hUsbDeviceHS, &Buf[0]);
  USBD_CDC_ReceivePacket(&hUsbDeviceHS);
  return (USBD_OK);
  /* USER CODE END 11 */
}

前面提到的USB初始化函数，在文件usb_device.c中进行了定义，主要是通过函数MX_USB_DEVICE_Init()来对USB设备进行初始化；

/**
 * @File: usb_device.c
 *@brief: Init USB device Library, add supported class and start the library.
 */
void MX_USB_DEVICE_Init(void)
{
  /* Init Device Library, add supported class and start the library. */
  if (USBD_Init(&hUsbDeviceHS, &HS_Desc, DEVICE_HS) != USBD_OK)
  {
    Error_Handler();
  }
  if (USBD_RegisterClass(&hUsbDeviceHS, &USBD_CDC) != USBD_OK)
  {
    Error_Handler();
  }
  if (USBD_CDC_RegisterInterface(&hUsbDeviceHS, &USBD_Interface_fops_HS) != USBD_OK)
  {
    Error_Handler();
  }
  if (USBD_Start(&hUsbDeviceHS) != USBD_OK)
  {
    Error_Handler();
  }
}
​文件usbd_cdc_if.c中的函数CDC_Receive_HS()就可以在里面进行对USB主设备发来的数据进行接收，指针uint8_t* Buf指向数据内容，指针uint32_t *Len指向数据的长度。

接下来在函数CDC_Receive_HS()中就会调用文件usbd_conf.c中的函数USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev)和USBD_LL_PrepareReceive()函数；

/**
 * @File: usbd_cdc.c
 *@brief: prepare OUT Endpoint for reception.
 */
uint8_t USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev)
{
    //...
    if (pdev->dev_speed == USBD_SPEED_HIGH)
    {
            /* Prepare Out endpoint to receive next packet */
           (void)USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer,
                                 CDC_DATA_HS_OUT_PACKET_SIZE);
    }
    //...
}
/**
 * @brief  Prepares an endpoint for reception.
 */
USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev, uint8_t ep_addr, uint8_t *pbuf, uint32_t size)
{
  HAL_StatusTypeDef hal_status = HAL_OK;
  USBD_StatusTypeDef usb_status = USBD_OK;
​
  hal_status = HAL_PCD_EP_Receive(pdev->pData, ep_addr, pbuf, size);
​
  usb_status =  USBD_Get_USB_Status(hal_status);
​
  return usb_status;
}

文件stm32f7xx_hal_pcd.c中的函数HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)；

/**
 * @File: stm32f7xx_hal_pcd.c
 *@brief: Receive an amount of data.
 */
HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint8_t *pBuf, uint32_t len)
{
  PCD_EPTypeDef *ep;
  ep = &hpcd->OUT_ep[ep_addr & EP_ADDR_MSK];
  /*setup and start the Xfer */
  ep->xfer_buff = pBuf;
  ep->xfer_len = len;
  ep->xfer_count = 0U;
  ep->is_in = 0U;
  ep->num = ep_addr & EP_ADDR_MSK;
  if (hpcd->Init.dma_enable == 1U)
  {
    ep->dma_addr = (uint32_t)pBuf;
  }
  if ((ep_addr & EP_ADDR_MSK) == 0U)
  {
    (void)USB_EP0StartXfer(hpcd->Instance, ep, (uint8_t)hpcd->Init.dma_enable);
  }
  else
  {
    (void)USB_EPStartXfer(hpcd->Instance, ep, (uint8_t)hpcd->Init.dma_enable);
  }
  return HAL_OK;
}

接着就会调用文件stm32f7xx_ll_usb.c中的函数USB_EPStartXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep, uint8_t dma);

/**
 * @File: stm32f7xx_ll_usb.c
 *@brief: setup and starts a transfer over an EP.
 */
HAL_StatusTypeDef USB_EPStartXfer(USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep, uint8_t dma)
{
   //...
      /* IN endpoint */
  if (ep->is_in == 1U)
  {
      //...
  }
  else /* OUT endpoint */
  {
    /* Program the transfer size and packet count as follows:
    * pktcnt = N
    * xfersize = N * maxpacket
    */
    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_XFRSIZ);
    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_PKTCNT);
    if (ep->xfer_len == 0U)
    {
      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_XFRSIZ & ep->maxpacket);
      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
    }
    else
    {
      pktcnt = (uint16_t)((ep->xfer_len + ep->maxpacket - 1U) / ep->maxpacket);
      USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_PKTCNT & ((uint32_t)pktcnt << 19);
      USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_XFRSIZ & (ep->maxpacket * pktcnt);
    }
    //...
    /* EP enable */
    USBx_OUTEP(epnum)->DOEPCTL |= (USB_OTG_DOEPCTL_CNAK | USB_OTG_DOEPCTL_EPENA);
  }
​
  return HAL_OK;
}

该函数主要是对USB接收中最底层的寄存器来进行配置。至此，这就是整个USB数据接收的函数调用流程。

STM32 之三 标准外设版USB驱动库详解（架构+文件+函数+使用说明+示例程序）
技术干货
12-30 8万+
写在前面 目前，ST的USB驱动有两套，一套是早期的独立版的驱动，最新版为2.2.0；一套为针对其Cube系列的驱动，根据芯片不同可能有区别，具体见对应芯片的Cube驱动包 。 本文使用的为独立版的USB驱动 本文多出自于ST的官方文档 及 2016~2017的培训文档，读者也可以直接去ST官网查阅相关文档。 稍有涉及USB 2.0 规范的内容，关于USB规范去官网或自行Google。 本文不...
STMicroelectronics 系列：STM32F7 系列_（4）.STM32F7系列外设介绍
2401_87715305的博客
02-11 676
在上一节中，我们已经对STM32F7系列的基本架构和特性进行了详细的介绍。本节将重点介绍STM32F7系列的外设，包括常见的外设类型、功能和使用方法。STM32F7系列外设种类丰富，功能强大，能够满足各种嵌入式应用的需求。我们将详细介绍以下外设：GPIO（通用输入输出）UART（通用异步收发传输器）SPI（串行外设接口）I2C（内部集成电路总线）ADC（模数转换器）DAC（数模转换器）TIM（定时器）CAN（控制器区域网络）USB（通用串行总线）Ethernet（以太网）
Visual Studio 开发STM32实现USB虚拟串口功能——方法3 Keil工程移植到Visual Studio
王纯配的博客
08-22 2444
方法2的方法是visual studio直接导进来keil工程，这样做的一个缺点就是： 1、生成是vs工程目录太乱； 2、keil在编译后.c文件下都会包括用到的.h文件，可以查看到.h文件的内容，但是vs编译后.c文件下并不会包括.h文件，这样在vs里是看不到导进来的.h文件。而且在.h路径方面，vs跟keil设置的路径是一样的，导致vs工程不能单独移动，得带着整个CubeMX工程一起移动，...
STM32 USB开发实战_C/C++语言
weixin_32661831的博客
03-13 813
自1996年第一代USB（通用串行总线）接口问世以来，其设计初衷是为了解决各种外围设备与计算机之间的连接问题。其易用性和即插即用的特性迅速获得了市场的认可。在随后的几十年间，USB技术经历了多个版本的迭代，从最初支持1.5 Mbps的USB 1.0，到支持480 Mbps的USB 2.0，再到最新的USB 3.2标准，已经能够提供高达20 Gbps的传输速度。
HAL库 USB_CDC数据流收发函数分析
zoe的博客
07-20 7817
接收自顶而下： ----------------------------------------------------------------------------- 设备接收数据流图： ----------------------------------------------------------------------------- 文件usbd_cdc_if.c，函数如下： 函数描述：USB输出端点接收的数据通过此函数发送给CDC接口。 注意事项：此函数将阻止USB端点上的所.
STM32虚拟串口usb_printf函数及接收函数
sudaroot的博客
01-25 1万+
官方库例程： ..\STM32Cube\Repository\STM32Cube_FW_F4_V1.23.0\Projects\STM324xG_EVAL\Applications\USB_Device\CDC_Standalone\MDK-ARM 环境：STM32CubeMX STM32F429IGT6 STlink 首先要确保硬件电路USB部分没问题；USB相关的概念知识大概...
STM32F7以太网HAL库源文件（stm32f7xx_hal_eth.c）笔记
豚
04-12 1万+
观察stm32f7xx_hal_eth.c，源文件的开头部分描述了这个库文件的使用说明。 目录 1. (#)Declare a ETH_HandleTypeDef handle structure 2. (#)Fill parameters of Init structure in heth handle 3.(#)Call HAL_ETH_Init() API to initialize...
STM32第二十一课（USB SLAVE， HAL）
Huskar_Liu的博客
12-24 3388
STM32F407 的 USB OTG FS 是一款双角色设备 (DRD) 控制器，同时支持从机功能和主机 功能，完全符合 USB 2.0 规范的 On-The-Go 补充标准。此外，该控制器也可配置为“仅主机” 模式或“仅从机” 模式，完全符合 USB 2.0 规范。 从机模式下则仅支持全速（FS， 12 Mb/s）收发器。 ST 提供了我们一个完整的 USB OTG 驱动库（包括主机和设备），通过这个库， 我们可以很方便的实现我们所要的功能， 对于USB OTG FS功能模块， STM32F4通过AHB
STM32F407 USB通信与虚拟串口CDC类开发实战
weixin_36212459的博客
11-16 1928
本文还有配套的精品资源，点击获取 简介：本项目详细介绍如何使用STM32F407微控制器，通过USB接口实现设备通信并模拟虚拟串口。项目涵盖了USB Device模式的配置、CDC类设置、以及利用Cubemx生成初始化代码的完整流程。最终实现STM32F407作为USB CDC设备，与PC或其他USB主机之间的高速数据交换，具有广泛的实际应用潜力。 1. STM3...
STM32 CDC高速数据传输 VS2022编程
最新发布
03-24
比如基于HAL库的USB_CDC例子。需要指导用户如何用CubeMX配置USB外设为CDC类，设置正确的描述符，特别是端点配置。高速传输可能需要更大的数据包大小，比如将端点大小设置为512字节，并且使用Bulk传输类型而不是默认...
STM32 UVC学习笔记3
小人物专栏
06-16 7721
主机环境：Windows 7 SP1 开发环境：MDK5.18 目标板：STM32F103C8T6 开发库：STM32F1Cube库和STM32_USB_Device_Library 继续昨天的学习笔记，之前提到从USBTrace软件中抓取的数据跟图像原始数据做对比是没有丢失数据的，只是在传输过程中有一半的数据包出现了错误，由此导致我们在PC上一直无法获取到正常的图像，从而
stm32 虚拟U盘
12-28
如果使用的是特定板子（如STM32F746G Discovery），可以直接基于现有的模板项目开始，路径类似于`STM32Cube_FW_F7_V1.3.0\Projects\STM32746G-Discovery\Applications\USB_Host\MSC_Standalone\Src`[^3]。...
【国产MCU移植】手把手教你使用RT-Thread制作GD32F103系列BSP
rtthreadiotos的博客
05-10 2389
本文由RT-Thread论坛用户@爱玩的小赵 原创发布：https://club.rt-thread.org/ask/article/ee67f1b59306ada8.html 【国产MCU移植】手把手教你使用RT-Thread制作GD32系列BSP 熟悉RT-Thread的朋友都知道，RT-Thread提供了许多BSP，但不是所有的板子都能找到相应的BSP，这时就需要移植新的BSP。RT-Thread的所有BSP中，最完善的BSP就是STM32系列，但从2020年下半年开始，国内出现史无前例的芯片缺货潮，
STM32 USB-CDC实现虚拟串口
cat_milk的博客
03-04 1018
使用STM32的usb功能做虚拟串口功能实现收发数据
STM32系列 USBCDC（ 虚拟串口）详解（二）
qingqingerer的博客
01-09 5444
本质原因就是发送数据长度恰好是DataIn端点的最大包数整数倍的时候，最后一包数据长度必须是零长度的数据包（ZLP）。注意：最后特别强调下在我们接收处理函数中void cdc_vcp_data_rx (uint8_t *buf, uint32_t Len)函数里面的g_usb_rx_buffer_my一定不要和我前面提到的CDC_Itf_Init（）函数中设置的usbcdc接受缓冲区的指针是一样的，如果你设置成了同一个buf，那么在接受数据>64字节的时候 ，他会在缓冲区中刷新覆盖你的接受数据多余的部分。
USB接口实现CDC（usb转串口功能）
weixin_53384447的博客
12-26 1711
ac1219/test_cdc
USB中CDC-ECM的了解和配置
热门推荐
Android/Linux的专栏
07-09 4万+
USB中典型类及子类： 类别 解释 子类 典型应用 IC芯片 备注 UVC 视频类   免驱USB摄像头     CDC 通讯类 RNDIS       ECM(p24)
基于小华例程3.2版本USB之usb_dev_cdc_msc工程深入代码详解
weixin_41579872的博客
04-15 1266
USB如何区分CDC和MSC的呢？ USB（通用串行总线）设备可以通过其设备类和子类来区分不同的功能，例如CDC（通信设备类）和MSC（大规模存储设备类）。以下是USB设备如何区分CDC和MSC功能的基本原理： 1. **描述符**：USB设备通过其描述符来告诉主机它的功能和属性。描述符是一系列数据结构，包括设备描述符、配置描述符、接口描述符和端点描述符等。 2. **设备类**：在设备描述符中，有一个字段指定了设备的类别。CDC和MSC分别有不同的类代码。
学习STM32的USB通信
qq_67153941的博客
07-09 3929
学习STM32的USB通信需要掌握的内容包括以下几个部分：USB基础知识、STM32 USB库的使用、USB设备工作模式的选择、USB设备描述符的配置、USB传输的实现。接下来将会详细介绍这些内容，并附上相关的示例代码。二、STM32 USB库的使用 ST公司提供了丰富的USB库，可在STM32微控制器上实现USB通信功能。使用前需要下载并安装对应的USB库文件。三、USB设备工作模式的选择。四、USB设备描述符的配置。五、USB传输的实现。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值