STM32 USB学习笔记6

主机环境:Windows 7 SP1

开发环境:MDK5.14

目标板:STM32F103C8T6

开发库:STM32F1Cube库和STM32_USB_Device_Library

现在来分析哈USB器件库代码,先来看usbd_core文件,其头文件只有一些函数声明,没啥可说的,只有一点,之前分析usbd_conf.c文件时里面USB中断回调函数中调用的底层接口都是在usbd_core.h文件中声明的,同样由用户实现的底层接口也是在该文件中声明的,在usbd_core.c文件中实现,该文件是很重要的一个文件,因为所有上层操作最终都会调用该文件中的API来实现。在器件库文档中提到了核心库的作用,如下:

第一个分析的函数是USB栈的初始化以及重新初始化,如下:

/**
* @brief  USBD_Init
*         Initializes the device stack and load the class driver
* @param  pdev: device instance
* @param  pdesc: Descriptor structure address
* @param  id: Low level core index
* @retval None
*/
USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev, USBD_DescriptorsTypeDef *pdesc, uint8_t id)
{
  /* Check whether the USB Host handle is valid */
  if(pdev == NULL)
  {
    USBD_ErrLog("Invalid Device handle");
    return USBD_FAIL; 
  }
  
  /* Unlink previous class*/
  if(pdev->pClass != NULL)
  {
    pdev->pClass = NULL;
  }
  
  /* Assign USBD Descriptors */
  if(pdesc != NULL)
  {
    pdev->pDesc = pdesc;
  }
  
  /* Set Device initial State */
  pdev->dev_state  = USBD_STATE_DEFAULT;
  pdev->id = id;
  /* Initialize low level driver */
  USBD_LL_Init(pdev);
  
  return USBD_OK; 
}

/**
* @brief  USBD_DeInit 
*         Re-Initialize th device library
* @param  pdev: device instance
* @retval status: status
*/
USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev)
{
  /* Set Default State */
  pdev->dev_state  = USBD_STATE_DEFAULT;
  
  /* Free Class Resources */
  pdev->pClass->DeInit(pdev, pdev->dev_config);  
  
    /* Stop the low level driver  */
  USBD_LL_Stop(pdev); 
  
  /* Initialize low level driver */
  USBD_LL_DeInit(pdev);
  
  return USBD_OK;
}
USB初始化函数很简单,将USB句柄的设备类指针置NULL,同时将USB的描述符加载上去,将USB设备状态置为默认状态,该函数里面的id目前不清楚是作何用,最后调用USB_LL_Init()函数来初始化底层驱动。USB器件库中USB设备有四种状态,定义在usbd_def.h文件中,如下:

/*  Device Status */
#define USBD_STATE_DEFAULT                                1
#define USBD_STATE_ADDRESSED                              2
#define USBD_STATE_CONFIGURED                             3
#define USBD_STATE_SUSPENDED                              4
默认状态、地址状态、配置状态、挂起状态。在USB2.0协议文档的第9章节中规定了USB设备的6种状态:连接状态、上电状态、默认状态、地址状态、配置状态、挂起状态,六者之间的关系图如下所示:

在USB库中是省略了连接和上电两个状态,剩下四种状态的说明可以在USB2.0协议的第九章节找到,由此可以看出USB2.0协议中第九章节有多重要了。在USB分配地址之前其使用默认地址,处在默认状态下的USB设备不能响应正常的请求,当USB设备分配了唯一的地址后即进入地址状态,响应正常请求,USB设备配置完成后进入配置状态,USB设备在指定时间长度内没有检测到总线通信时会进入挂起状态,但会保持任何内部状态,包括地址和配置。在USB重新初始化函数中,需要释放类资源,且停止USB底层驱动,重新初始化底层驱动。接着是注册类函数:

/**
  * @brief  USBD_RegisterClass 
  *         Link class driver to Device Core.
  * @param  pDevice : Device Handle
  * @param  pclass: Class handle
  * @retval USBD Status
  */
USBD_StatusTypeDef  USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass)
{
  USBD_StatusTypeDef   status = USBD_OK;
  if(pclass != 0)
  {
    /* link the class to the USB Device handle */
    pdev->pClass = pclass;
    status = USBD_OK;
  }
  else
  {
    USBD_ErrLog("Invalid Class handle");
    status = USBD_FAIL; 
  }
  
  return status;
}

注册设备类函数也很简单,把设备类指针传递给USB设备句柄即可,通过指针USB句柄包含了我们所用的所有资源,接着来看USB的一些基本操作,如下:

/**
  * @brief  USBD_Start 
  *         Start the USB Device Core.
  * @param  pdev: Device Handle
  * @retval USBD Status
  */
USBD_StatusTypeDef  USBD_Start  (USBD_HandleTypeDef *pdev)
{
  
  /* Start the low level driver  */
  USBD_LL_Start(pdev); 
  
  return USBD_OK;  
}

/**
  * @brief  USBD_Stop 
  *         Stop the USB Device Core.
  * @param  pdev: Device Handle
  * @retval USBD Status
  */
USBD_StatusTypeDef  USBD_Stop   (USBD_HandleTypeDef *pdev)
{
  /* Free Class Resources */
  pdev->pClass->DeInit(pdev, pdev->dev_config);  

  /* Stop the low level driver  */
  USBD_LL_Stop(pdev); 
  
  return USBD_OK;  
}

/**
* @brief  USBD_RunTestMode 
*         Launch test mode process
* @param  pdev: device instance
* @retval status
*/
USBD_StatusTypeDef  USBD_RunTestMode (USBD_HandleTypeDef  *pdev) 
{
  return USBD_OK;
}


/**
* @brief  USBD_SetClassConfig 
*        Configure device and start the interface
* @param  pdev: device instance
* @param  cfgidx: configuration index
* @retval status
*/

USBD_StatusTypeDef USBD_SetClassConfig(USBD_HandleTypeDef  *pdev, uint8_t cfgidx)
{
  USBD_StatusTypeDef   ret = USBD_FAIL;
  
  if(pdev->pClass != NULL)
  {
    /* Set configuration  and Start the Class*/
    if(pdev->pClass->Init(pdev, cfgidx) == 0)
    {
      ret = USBD_OK;
    }
  }
  return ret; 
}

/**
* @brief  USBD_ClrClassConfig 
*         Clear current configuration
* @param  pdev: device instance
* @param  cfgidx: configuration index
* @retval status: USBD_StatusTypeDef
*/
USBD_StatusTypeDef USBD_ClrClassConfig(USBD_HandleTypeDef  *pdev, uint8_t cfgidx)
{
  /* Clear configuration  and De-initialize the Class process*/
  pdev->pClass->DeInit(pdev, cfgidx);  
  return USBD_OK;
}

/**
* @brief  USBD_LL_Reset 
*         Handle Reset event
* @param  pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_SetSpeed(USBD_HandleTypeDef  *pdev, USBD_SpeedTypeDef speed)
{
  pdev->dev_speed = speed;
  return USBD_OK;
}
其中USBD_Start和USBD_Stop跟USBD的初始化类似都是调用usbd_conf中的底层基本操作,USBD_RunTestMode()函数为空,表明不支持测试模式,测试模式在USB2.0协议文档有提及,既然这里不支持就么有去细研究该功能。另外两个函数USBD_SetClassConfig()、USBD_ClrClassConfig()函数则是跟USB设备类相关,这里我们还没有分析到USB设备类中,所以也略过,知道其功能即可。最后有一个USBD_LL_SetSpeed()函数,USB通信有三种通信速度:低速、全速、高速,STM32F103C8T6支持全速模式,USB速度的定义如下:

/* Following USB Device Speed */
typedef enum 
{
  USBD_SPEED_HIGH  = 0,
  USBD_SPEED_FULL  = 1,
  USBD_SPEED_LOW   = 2,  
}USBD_SpeedTypeDef;
usbd_core.c中剩下的一些函数体则是在usbd_conf.cUSB中断回调函数中调用的USB通信处理的真正实现者,如下:

/**
* @brief  USBD_SetupStage 
*         Handle the setup stage
* @param  pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_SetupStage(USBD_HandleTypeDef *pdev, uint8_t *psetup)
{

  USBD_ParseSetupRequest(&pdev->request, psetup);
  
  pdev->ep0_state = USBD_EP0_SETUP;
  pdev->ep0_data_len = pdev->request.wLength;
  
  switch (pdev->request.bmRequest & 0x1F) 
  {
  case USB_REQ_RECIPIENT_DEVICE:   
    USBD_StdDevReq (pdev, &pdev->request);
    break;
    
  case USB_REQ_RECIPIENT_INTERFACE:     
    USBD_StdItfReq(pdev, &pdev->request);
    break;
    
  case USB_REQ_RECIPIENT_ENDPOINT:        
    USBD_StdEPReq(pdev, &pdev->request);   
    break;
    
  default:           
    USBD_LL_StallEP(pdev , pdev->request.bmRequest & 0x80);
    break;
  }  
  return USBD_OK;  
}

/**
* @brief  USBD_DataOutStage 
*         Handle data OUT stage
* @param  pdev: device instance
* @param  epnum: endpoint index
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev , uint8_t epnum, uint8_t *pdata)
{
  USBD_EndpointTypeDef    *pep;
  
  if(epnum == 0) 
  {
    pep = &pdev->ep_out[0];
    
    if ( pdev->ep0_state == USBD_EP0_DATA_OUT)
    {
      if(pep->rem_length > pep->maxpacket)
      {
        pep->rem_length -=  pep->maxpacket;
       
        USBD_CtlContinueRx (pdev, 
                            pdata,
                            MIN(pep->rem_length ,pep->maxpacket));
      }
      else
      {
        if((pdev->pClass->EP0_RxReady != NULL)&&
           (pdev->dev_state == USBD_STATE_CONFIGURED))
        {
          pdev->pClass->EP0_RxReady(pdev); 
        }
        USBD_CtlSendStatus(pdev);
      }
    }
  }
  else if((pdev->pClass->DataOut != NULL)&&
          (pdev->dev_state == USBD_STATE_CONFIGURED))
  {
    pdev->pClass->DataOut(pdev, epnum); 
  }  
  return USBD_OK;
}

/**
* @brief  USBD_DataInStage 
*         Handle data in stage
* @param  pdev: device instance
* @param  epnum: endpoint index
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev ,uint8_t epnum, uint8_t *pdata)
{
  USBD_EndpointTypeDef    *pep;
    
  if(epnum == 0) 
  {
    pep = &pdev->ep_in[0];
    
    if ( pdev->ep0_state == USBD_EP0_DATA_IN)
    {
      if(pep->rem_length > pep->maxpacket)
      {
        pep->rem_length -=  pep->maxpacket;
        
        USBD_CtlContinueSendData (pdev, 
                                  pdata, 
                                  pep->rem_length);
        
        /* Prepare endpoint for premature end of transfer */
        USBD_LL_PrepareReceive (pdev,
                                0,
                                NULL,
                                0);  
      }
      else
      { /* last packet is MPS multiple, so send ZLP packet */
        if((pep->total_length % pep->maxpacket == 0) &&
           (pep->total_length >= pep->maxpacket) &&
             (pep->total_length < pdev->ep0_data_len ))
        {
          
          USBD_CtlContinueSendData(pdev , NULL, 0);
          pdev->ep0_data_len = 0;
          
        /* Prepare endpoint for premature end of transfer */
        USBD_LL_PrepareReceive (pdev,
                                0,
                                NULL,
                                0);
        }
        else
        {
          if((pdev->pClass->EP0_TxSent != NULL)&&
             (pdev->dev_state == USBD_STATE_CONFIGURED))
          {
            pdev->pClass->EP0_TxSent(pdev); 
          }          
          USBD_CtlReceiveStatus(pdev);
        }
      }
    }
    if (pdev->dev_test_mode == 1)
    {
      USBD_RunTestMode(pdev); 
      pdev->dev_test_mode = 0;
    }
  }
  else if((pdev->pClass->DataIn != NULL)&& 
          (pdev->dev_state == USBD_STATE_CONFIGURED))
  {
    pdev->pClass->DataIn(pdev, epnum); 
  }  
  return USBD_OK;
}

/**
* @brief  USBD_LL_Reset 
*         Handle Reset event
* @param  pdev: device instance
* @retval status
*/

USBD_StatusTypeDef USBD_LL_Reset(USBD_HandleTypeDef  *pdev)
{
  /* Open EP0 OUT */
  USBD_LL_OpenEP(pdev,
              0x00,
              USBD_EP_TYPE_CTRL,
              USB_MAX_EP0_SIZE);
  
  pdev->ep_out[0].maxpacket = USB_MAX_EP0_SIZE;
  
  /* Open EP0 IN */
  USBD_LL_OpenEP(pdev,
              0x80,
              USBD_EP_TYPE_CTRL,
              USB_MAX_EP0_SIZE);
  
  pdev->ep_in[0].maxpacket = USB_MAX_EP0_SIZE;
  /* Upon Reset call user call back */
  pdev->dev_state = USBD_STATE_DEFAULT;
  
  if (pdev->pClassData) 
    pdev->pClass->DeInit(pdev, pdev->dev_config);  
 
  
  return USBD_OK;
}

/**
* @brief  USBD_Suspend 
*         Handle Suspend event
* @param  pdev: device instance
* @retval status
*/

USBD_StatusTypeDef USBD_LL_Suspend(USBD_HandleTypeDef  *pdev)
{
  pdev->dev_old_state =  pdev->dev_state;
  pdev->dev_state  = USBD_STATE_SUSPENDED;
  return USBD_OK;
}

/**
* @brief  USBD_Resume 
*         Handle Resume event
* @param  pdev: device instance
* @retval status
*/

USBD_StatusTypeDef USBD_LL_Resume(USBD_HandleTypeDef  *pdev)
{
  pdev->dev_state = pdev->dev_old_state;  
  return USBD_OK;
}

/**
* @brief  USBD_SOF 
*         Handle SOF event
* @param  pdev: device instance
* @retval status
*/

USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef  *pdev)
{
  if(pdev->dev_state == USBD_STATE_CONFIGURED)
  {
    if(pdev->pClass->SOF != NULL)
    {
      pdev->pClass->SOF(pdev);
    }
  }
  return USBD_OK;
}

/**
* @brief  USBD_IsoINIncomplete 
*         Handle iso in incomplete event
* @param  pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef  *pdev, uint8_t epnum)
{
  return USBD_OK;
}

/**
* @brief  USBD_IsoOUTIncomplete 
*         Handle iso out incomplete event
* @param  pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_IsoOUTIncomplete(USBD_HandleTypeDef  *pdev, uint8_t epnum)
{
  return USBD_OK;
}

/**
* @brief  USBD_DevConnected 
*         Handle device connection event
* @param  pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DevConnected(USBD_HandleTypeDef  *pdev)
{
  return USBD_OK;
}

/**
* @brief  USBD_DevDisconnected 
*         Handle device disconnection event
* @param  pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DevDisconnected(USBD_HandleTypeDef  *pdev)
{
  /* Free Class Resources */
  pdev->dev_state = USBD_STATE_DEFAULT;
  pdev->pClass->DeInit(pdev, pdev->dev_config);  
   
  return USBD_OK;
}
虽然函数有些多,但看具体函数的代码量就可以知道哪些函数是重要的,第一个函数是USBD_LL_SetupStage(),USB请求分为三个阶段:Setup阶段、可选的数据阶段、状态阶段。该函数用于处理Setup阶段,解析USB主机发来的请求,调用USBD_ParseSetupRequest()函数来获取setup请求,并赋给pdev->request变量,该函数实现如下:

/**
* @brief  USBD_ParseSetupRequest 
*         Copy buffer into setup structure
* @param  pdev: device instance
* @param  req: usb request
* @retval None
*/

void USBD_ParseSetupRequest(USBD_SetupReqTypedef *req, uint8_t *pdata)
{
  req->bmRequest     = *(uint8_t *)  (pdata);
  req->bRequest      = *(uint8_t *)  (pdata +  1);
  req->wValue        = SWAPBYTE      (pdata +  2);
  req->wIndex        = SWAPBYTE      (pdata +  4);
  req->wLength       = SWAPBYTE      (pdata +  6);

}

#define  SWAPBYTE(addr)        (((uint16_t)(*((uint8_t *)(addr)))) + \
                               (((uint16_t)(*(((uint8_t *)(addr)) + 1))) << 8))
函数实现很简单即获取Setup的8个成员变量值,至于Setup包中8个数据来源在usbd_conf.c文件中传递的是hpcd->Setup,其数据来源是在Cube库中USB的实现的,因此在这里并没有关心。在获取完Setup包数据后将端点0状态置为USBD_EP0_SETUP,端点0比较重要是因为其是USB默认的控制端点用于接收USBSetup请求数据,在USB器件库中规定了端点0的几种状态,如下:
/*  EP0 State */    
#define USBD_EP0_IDLE                                     0
#define USBD_EP0_SETUP                                    1
#define USBD_EP0_DATA_IN                                  2
#define USBD_EP0_DATA_OUT                                 3
#define USBD_EP0_STATUS_IN                                4
#define USBD_EP0_STATUS_OUT                               5
#define USBD_EP0_STALL                                    6 

可以看出端点0的状态跟USB请求息息相关。接着使用ep0_data_len来存储该Setup请求的数据长度,并根据bmRequest数据值来检测该请求的接收者,在USB2.0协议中规定了请求的接收者有三个:设备、接口、端点。根据接收者的不同调用不同的函数实现体,这些实现体在另一个文件usbd_ctlreq.c中实现,所以这里不细说,等分析usbd_ctlreq.c文件时再细说,如果接收者不是以上三种则调用USBD_LL_StallEP()来将端点设置一个停止条件。USBD_LL_DataOutStage()和USBD_LL_DataInStage()是最重要的两个函数且代码行数较多,放到最后分析,先分析另外几个比较简单的函数,USBD_LL_Reset()函数是重新初始化,这里是重新设置了端点0的属性,并把设备状态置为默认状态,并调用相应类的DeInit()函数来重新初始化设备类。USB的挂起和唤醒函数更简单,只是设置设备状态即可。USBD_LL_SOF()函数是发出起始帧信号,SOF是一个数据包,而EOF是一种电平状态。后面有一个设备断开连接的实现,跟复位有些类似,将设备状态置为默认状态,并重新初始化设备类。现在来分析两个重要的函数,首先是USBD_LL_DataOutStage(),需要注意的是Setup阶段是只跟端点0相关,而数据阶段是可以跟每一个端点相关的,因为任何端点都可以传输数据,所以该函数的参数中有epnum来传递传输数据的端点号,在函数实现中可以看到如果传递的epnum不是0,则表明是设备类中的端点传递数据,如果设备处于配置状态且设备类的DataOut指针非空则执行设备类中的DataOut函数,如果epnum为0则是端点0上的数据,DataOutStage上的数据是USB模块接收USB主机发来的,要明白其数据传输的方向。每个端点都有设置其最大包大小即maxpacket,端点接收的数据大小一定是小于等于maxpacket的,当需要接收远多于maxpacket的数据时是需要分包发送/接收的,一个很形象的例子如下:


该图是STM32论坛中培训资料中得到的,根据该图可以方便于我们分析DataOutStage以及DataInStage,在DataOutStage的处理中是获取该0号端点,且该端点处于DATA_OUT状态,端点的rem_length变量存储的是当次接收的数据总长度即在Setup函数中request.wLength,而maxpacket的值是在打开该端点时传递进来的,当我们接收到的数据长度大于自身的最大包大小时,表明我们还有数据需要继续接收,这里要注意的是该函数实际是USB中断函数中的DataStage的回调函数,即该函数执行时已经接收到了一包数据,因此这里才调用USBD_CtlContinueRx()即继续接收,这个跟串口的接收中断较类似,也由此,调用USBD_CtlContinueRx()中的参数是rem_length和maxpacket中的小值,当最后数据接收完毕时rem_length的值是小于等于maxpacket,就看传输的数据量是否是maxpacket的整数倍了。数据接收完成时这里调用了设备类的EP0_RxReady回调函数即交由对应的设备类对所收到的数据进行处理,对于本例的VCP类说即交由CDC类的接口文件中的CDC_Itf_Control()函数来处理(设置设备串口属性),最后调用USBD_CtlSendStatus()函数来执行请求的第三阶段:状态阶段。该函数我们在后面另分析。

有了分析DataOutStage的基础,DataInStage就容易分析多了,两者是相反的过程,该函数是发送数据到USB主机,首先当传输数据的端点是非0端点时调用相应设备类的DataIn函数进行处理,当传输数据的端点是0端点时且端点0处于DATA_IN状态,同理此处的rem_length同样和Setup阶段的request.wLength相等,且该函数执行时已经有一包数据发送出去,因此这里更新完rem_length后继续发送数据且使用USBD_LL_PrepareReceive()接收USB主机发来的应答信息。当rem_length小于等于maxpacket时表明数据已经发送完毕,如果所需要发送的数据量是maxpacket的整数倍这里需要发送一个0字节数据包来通知USB主机数据发送完毕。这里一直不理解的是下面这条语句

(pep->total_length < pdev->ep0_data_len )
因为按个人理解这两个值应该是相等的,通过检索可知ep0_data_len只有一处赋值即Setup阶段的request.wLength,而total_length的值在最开始的发送时与rem_length值相等也即为本次发送的数据长度值,无论怎么想二者都应该是相等才对。ep0_data_len的值只有在这里清零,下次进入该函数时total_length值即大于ep0_data_len(因此个人觉得这里应该是ep0_data_len和0的判断而不是和total_length判断),数据发送完毕后,如果EP0_TxSent回调函数不为空则执行该回调,最后接收USB主机发来的状态信息。当端点0的状态不为DATA_IN时这里有个测试模式的调用,由于没有使能测试模式,所以这里不关心,如果有兴趣的话可以研究哈。至此,usbd_core文件分析完毕,USB器件库的核心文件还剩下两个usbd_ioreq和usbd_ctlreq。







©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值