stm32 drv_usbh驱动中延时的疑惑

发布于 2021-03-23 09:25:13 浏览：2054 订阅该版

```c
static int drv_pipe_xfer(upipe_t pipe, rt_uint8_t token, void *buffer, int nbytes, int timeouts)
{
    int timeout = timeouts;
    while (1)
    {
        if (!connect_status)
        {
            return -1;
        }
        rt_completion_init(&urb_completion);
        HAL_HCD_HC_SubmitRequest(&stm32_hhcd_fs,
                                 pipe->pipe_index,
                                 (pipe->ep.bEndpointAddress & 0x80) >> 7,
                                 pipe->ep.bmAttributes,
                                 token,
                                 buffer,
                                 nbytes,
                                 0);
        rt_completion_wait(&urb_completion, timeout);
        rt_thread_mdelay(1);
        if (HAL_HCD_HC_GetState(&stm32_hhcd_fs, pipe->pipe_index) == HC_NAK)
        {
            RT_DEBUG_LOG(RT_DEBUG_USB, ("nak\n"));
            if (pipe->ep.bmAttributes == USB_EP_ATTR_INT)
            {
                rt_thread_delay((pipe->ep.bInterval * RT_TICK_PER_SECOND / 1000) > 0 ? (pipe->ep.bInterval * RT_TICK_PER_SECOND / 1000) : 1);
            }
            HAL_HCD_HC_Halt(&stm32_hhcd_fs, pipe->pipe_index);
            HAL_HCD_HC_Init(&stm32_hhcd_fs,
                            pipe->pipe_index,
                            pipe->ep.bEndpointAddress,
                            pipe->inst->address,
                            USB_OTG_SPEED_FULL,
                            pipe->ep.bmAttributes,
                            pipe->ep.wMaxPacketSize);
            continue;
        }
        else if (HAL_HCD_HC_GetState(&stm32_hhcd_fs, pipe->pipe_index) == HC_STALL)
        {
            RT_DEBUG_LOG(RT_DEBUG_USB, ("stall\n"));
            pipe->status = UPIPE_STATUS_STALL;
            if (pipe->callback != RT_NULL)
            {
                pipe->callback(pipe);
            }
            return -1;
        }
        else if (HAL_HCD_HC_GetState(&stm32_hhcd_fs, pipe->pipe_index) == URB_ERROR)
        {
            RT_DEBUG_LOG(RT_DEBUG_USB, ("error\n"));
            pipe->status = UPIPE_STATUS_ERROR;
            if (pipe->callback != RT_NULL)
            {
                pipe->callback(pipe);
            }
            return -1;
        }
        else if(URB_DONE == HAL_HCD_HC_GetURBState(&stm32_hhcd_fs, pipe->pipe_index))
        {
            RT_DEBUG_LOG(RT_DEBUG_USB, ("ok\n"));
            pipe->status = UPIPE_STATUS_OK;
            if (pipe->callback != RT_NULL)
            {
                pipe->callback(pipe);
            }
            size_t size = HAL_HCD_HC_GetXferCount(&stm32_hhcd_fs, pipe->pipe_index);
            if (pipe->ep.bEndpointAddress & 0x80)
            {
                return size;
            }
            else if (pipe->ep.bEndpointAddress & 0x00)
            {
                return size;
            }
            return nbytes;
        }
        continue;
    }
}`
```
stm32 drv_usbh.c驱动中收到完成量后加的rt_thread_mdelay(1),这个感觉很占用时间呀，每64字节1ms，2M的数据占用30多s

cxhxy12345 2021-03-23

这家伙很懒，什么也没写！

anqi 2021-03-23

这家伙很懒，什么也没写！

cxhxy12345 2021-03-24

这家伙很懒，什么也没写！

请登录后再发布评论，点击登录

追加回复

6 个回答

出出啊 2021-07-07

恃人不如自恃，人之为己者不如己之自为也

zjh1205772876 2021-08-20

这家伙很懒，什么也没写！

请登录后再发布评论，点击登录

追加回复

Jone 2021-03-23

写了还是懒

anqi 2021-03-23

这家伙很懒，什么也没写！

请登录后再发布评论，点击登录

追加回复

anqi 2021-10-29

这家伙很懒，什么也没写！

去掉1ms延时，我修改成如下代码，目前枚举正常，速度一下子就上来了
```c
static int drv_pipe_xfer(upipe_t pipe, rt_uint8_t token, void *buffer, int nbytes, int timeouts)
{
    int timeout = timeouts;
    
    int status = 0;
    while (1)
    {
        if (!connect_status)
        {
            return -1;
        }

switch(status)
        {
        case 0:
            rt_completion_init(&urb_completion);
            RT_DEBUG_LOG(RT_DEBUG_USB, ("pipe xfer:%d\n", nbytes));
            rt_base_t lvl = rt_hw_interrupt_disable();
            HAL_HCD_HC_SubmitRequest(&stm32_hhcd_fs,
                                 pipe->pipe_index,
                                 (pipe->ep.bEndpointAddress & 0x80) >> 7,
                                 pipe->ep.bmAttributes,
                                 token,
                                 buffer,
                                 nbytes,
                                 0);
            rt_hw_interrupt_enable(lvl);
            status = 1;                     
        case 1:
            RT_DEBUG_LOG(RT_DEBUG_USB, ("wait_comp\n"));
            if(rt_completion_wait(&urb_completion, timeout) != RT_EOK)
            {
                rt_kprintf("pipe xfer timeout:%d\n", timeout);
                return -1;
            }
            status = 2;
            break;
        case 2:
            HCD_URBStateTypeDef urbstate = HAL_HCD_HC_GetURBState(&stm32_hhcd_fs, pipe->pipe_index);
            if(URB_DONE == urbstate){
                pipe->status = UPIPE_STATUS_OK;
                if (pipe->callback != RT_NULL)
                {
                    pipe->callback(pipe);
                }
                size_t size = HAL_HCD_HC_GetXferCount(&stm32_hhcd_fs, pipe->pipe_index);
                RT_DEBUG_LOG(RT_DEBUG_USB, ("HC_XFRC:%d\n", size));
                if (pipe->ep.bEndpointAddress & 0x80)
                {
                    return size;
                }
                return nbytes;
            }
            else if(URB_IDLE == urbstate){
                HCD_HCStateTypeDef usbstate = HAL_HCD_HC_GetState(&stm32_hhcd_fs, pipe->pipe_index);
                RT_DEBUG_LOG(RT_DEBUG_USB, ("urb_state:%d,%d\n", urbstate, usbstate));
                if(usbstate == HC_IDLE)
                {
                    HAL_HCD_HC_Halt(&stm32_hhcd_fs, pipe->pipe_index);
                    status = 0;
                    continue;
                }
                rt_completion_init(&urb_completion);
                status = 1;
            }
            else if(URB_NOTREADY == urbstate)
            {
                RT_DEBUG_LOG(RT_DEBUG_USB, ("URB_NOTREADY:%d\n", HAL_HCD_HC_GetState(&stm32_hhcd_fs, pipe->pipe_index)));
                status = 0;
            }
            else if(URB_NYET == urbstate)
            {
                RT_DEBUG_LOG(RT_DEBUG_USB, ("URB_NYET:%d\n", HAL_HCD_HC_GetState(&stm32_hhcd_fs, pipe->pipe_index)));
                status = 0;
            }
            else if(URB_ERROR == urbstate)
            {
                RT_DEBUG_LOG(RT_DEBUG_USB, ("URB_ERROR:%d\n", HAL_HCD_HC_GetState(&stm32_hhcd_fs, pipe->pipe_index)));
                status = 0;
            }
            else{
                rt_kprintf("urb_state:%d\n", urbstate);
                return -1;
            }
            break;
        }
    }
}

```