【MCU实战经验】+stm32f407之usbhost自定义类开发

[复制链接]

鼻儿眼睛花发布时间：2014-4-1 12:30

文章
文章封面:	-
文章简介:	-

在很多stm32的单片机中，集成了usbhost功能，而且st官方还提供了非常易用的usb库，库里面还有好几个例子，如HID，MSC，DualCore。分别实现了鼠标键盘的读取，U盘的读取，高速和全速同时工作的例程。可是，朋友们如果想自己读取自己的USB设备该怎么办呢？下面我来给大家细细讲解。
st官方的usb采用的是分层的思想最底层是usb的驱动，然后是usb消息响应的核心库，上层是usb类库和用户消息处理回调函数。
对于usb设备的读取来说，当设备插入host接口的时候，枚举过程就已经由usb库自动完成了，接下来我们主要是编写usb自定义类来实现和设备进行通信。
在st官方usb库中，usb类是这样定义的：

typedef struct _USBH_Class_cb
{
  USBH_Status  (*Init)\
(USB_OTG_CORE_HANDLE *pdev , void *phost);//usb类初始化，包括判断设备是否支持，打开响应的通信管线
  void       (*DeInit)\
(USB_OTG_CORE_HANDLE *pdev , void *phost);//释放usb资源
  USBH_Status  (*Requests)\
(USB_OTG_CORE_HANDLE *pdev , void *phost);  //usb类请求
  USBH_Status  (*Machine)\
(USB_OTG_CORE_HANDLE *pdev , void *phost); //usb数据处理线程

} USBH_Class_cb_TypeDef;
那么，我们如果要实现一个USB类，就需要编写以上四个函数。
下面就是我自己写的一个自定义类：

typedef struct
{
  uint8_t             hc_num_in;
  uint8_t             hc_num_out;
  uint8_t             MSBulkOutEp;
  uint8_t             MSBulkInEp;
  uint16_t          MSBulkInEpSize;
  uint16_t          MSBulkOutEpSize;
}myClassTypedef;
myClassTypedef myClass;

USBH_Status Init(USB_OTG_CORE_HANDLE *pdev , void *phost)
{
      USBH_HOST *pphost = phost;
      short myi;
      char Buffer[50]={0};

      unsigned char status;

      sprintf(Buffer,"接口数目为：%d",pphost->device_prop.Cfg_Desc.bNumInterfaces);
      LHLFont_DebugString(Buffer);

      for(myi=1; myidevice_prop.Cfg_Desc.bNumInterfaces+1; myi++)
      {
            if(pphost->device_prop.Ep_Desc[myi-1][0].bEndpointAddress & 0x80)
            {
                     sprintf(Buffer,"接口%d的端点0为输入",myi);
            }
            else
            {
                     sprintf(Buffer,"接口%d的端点0为输出",myi);
            }
            LHLFont_DebugString(Buffer);

            sprintf(Buffer,"接口%d Size:%d,Type:%d",myi,pphost->device_prop.Ep_Desc[myi-1][0].wMaxPacketSize,
            pphost->device_prop.Ep_Desc[myi-1][0].bmAttributes);
            LHLFont_DebugString(Buffer);


            if(pphost->device_prop.Ep_Desc[myi-1][1].bEndpointAddress & 0x80)
            {
                     sprintf(Buffer,"接口%d的端点1为输入",myi);
            }
            else
            {
                     sprintf(Buffer,"接口%d的端点1为输出",myi);
            }
            LHLFont_DebugString(Buffer);

            sprintf(Buffer,"接口%d Size:%d,Type:%d",myi,pphost->device_prop.Ep_Desc[myi-1][1].wMaxPacketSize,
            pphost->device_prop.Ep_Desc[myi-1][1].bmAttributes);
            LHLFont_DebugString(Buffer);
  }

      myClass.MSBulkOutEp =  pphost->device_prop.Ep_Desc[0][1].bEndpointAddress;
      myClass.MSBulkInEp =  pphost->device_prop.Ep_Desc[0][0].bEndpointAddress;
      myClass.MSBulkOutEpSize =  pphost->device_prop.Ep_Desc[0][1].wMaxPacketSize;
      myClass.MSBulkInEpSize = pphost->device_prop.Ep_Desc[0][0].wMaxPacketSize;

  myClass.hc_num_out = USBH_Alloc_Channel(pdev, myClass.MSBulkOutEp);
  myClass.hc_num_in = USBH_Alloc_Channel(pdev, myClass.MSBulkInEp);

      status = USBH_Open_Channel  (pdev,
                                                                                    myClass.hc_num_out,
                                                                                    pphost->device_prop.address,
                                                                                    pphost->device_prop.speed,
                                                                                    EP_TYPE_BULK,
                                                                                    myClass.MSBulkOutEpSize);
      if(status == HC_OK)
      status = USBH_Open_Channel  (pdev,
                                                                                    myClass.hc_num_in,
                                                                                    pphost->device_prop.address,
                                                                                    pphost->device_prop.speed,
                                                                                    EP_TYPE_BULK,
                                                                                    myClass.MSBulkInEpSize);
      if(status == HC_OK)
      LHLFont_DebugString("USBH Open Channel Ok");

      Receive_Retry = 2;

      return USBH_OK;
}

void DeInit(USB_OTG_CORE_HANDLE *pdev , void *phost)
{
  if ( MSC_Machine.hc_num_out)
  {
USB_OTG_HC_Halt(pdev, myClass.hc_num_out);
USBH_Free_Channel  (pdev, myClass.hc_num_out);
myClass.hc_num_out = 0;    /* Reset the Channel as Free */
  }

  if ( MSC_Machine.hc_num_in)
  {
USB_OTG_HC_Halt(pdev, myClass.hc_num_in);
USBH_Free_Channel  (pdev, myClass.hc_num_in);
myClass.hc_num_in = 0;    /* Reset the Channel as Free */
  }
}
USBH_Status Requests(USB_OTG_CORE_HANDLE *pdev , void *phost)
{
      return USBH_OK;
}
unsigned char usbbuffer[70];
unsigned short usbbufferlen=0;

unsigned char SendMechine = 2;
int SendCount = 0;

unsigned char ReceiveMechine = 0;
int ReceiveCount = 0;
unsigned dataReceived = 0;

void usb_CopyDataToBuffer(unsigned char *pbuffer,unsigned short len)
{
      unsigned char *ptmp=usbbuffer;

      usbbufferlen = len;

      while(len--)
      {
            *ptmp++ = *pbuffer++;
      }
}
USBH_Status Machine(USB_OTG_CORE_HANDLE *pdev , void *phost)
{
      if(SendMechine==1)
      {
            SendMechine=0;
            USBH_BulkSendData (pdev,
                                                                                             (unsigned char *)usbbuffer,
                                                                                             usbbufferlen ,
                                                                                             myClass.hc_num_out);
            SendCount=0;
            while(HCD_GetURB_State(pdev, myClass.hc_num_out) != URB_DONE && SendCount0)
      {
            Receive_Retry--;
            ReceiveCount=0;
            USBH_BulkReceiveData (pdev,
                                                               (unsigned char *)usbbuffer+3,
                                                               64,
                                                               myClass.hc_num_in);

            while(HCD_GetURB_State(pdev, myClass.hc_num_in) != URB_DONE &&ReceiveCount