USB

USB Device BSP 移植异常——VCOM设备无法正确响应Get LineCoding...

发布于 2020-04-18 15:23:59 浏览：1715 订阅该版

2 个回答

jh442755 2020-04-18

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

jh442755 2020-04-18

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

如下是我对 setup 数据包处理的伪代码

```
switch (端点0控制传输阶段)
{
    // 空闲状态： 收到的数据包为 setup
    case 空闲阶段:
    {
        if (端点0 接收完成中断)
        {
            // 读 FIFO
            recv_len = read_ep_fifo(0,
                                     (u8 *)p_ctrl_req_buf,
                                     sizeof(标准Setup包));

if (recv_len == sizeof(标准Setup包))
            {
                log_udc_dbg("0 i: r su\r\n");

/* 如果没有数据过程，那么响应 0长度包 */
                if(p_ctrl_req_buf->wLength == 0)
                {
                    log_udc_dbg("su n d p\r\n");
                    响应 0 长度包，清中断
                }
                /* 有数据过程 */
                else
                {
                    log_udc_dbg("su h d p\r\n");
                    
                    // 如果数据过程的方向是 主机->设备，那么修改阶段位
                    if(ctrl_req_dir == CTRL_REQ_DIR_HOST_TO_DEVICE)
                    {
                        g_udc.ep0state = 数据OUT阶段;
                    }
                    响应 0长度包，清中断
                }
                log_udc_dbg("su t 0x%02x\r\n", p_ctrl_req_buf->bRequest);
                // 将setup请求回传给核心层进行处理
                rt_usbd_ep0_setup_handler(&g_mr100_udc,
                                          (struct urequest*)p_ctrl_req_buf);
            }
            else if(recv_len == 0)
            {
                log_udc_info("ep0_st idle: r zlp\r\n");
            }
            // 非预期的中断，发送 STALL
            else
            {
                log_udc_info("ep0_st idle: tx stall\r\n");
                发送 STALL
                goto stall;
            }
        }

break;
    }

// 数据 IN 阶段 -> 数据阶段发送数据到主机
    case 数据 IN 阶段:
    {
        if (数据发送完成)
        {
            max_pkt_size = _get_ep_max_packet_size(0);
            log_udc_dbg("0 d w c\r\n");
            
            // 发送完成的数据长度 < 最大包长，那么说明发送的是最后一个数据包
            if (g_udc.ep0.previous_write_len < max_pkt_size)
            {
                g_udc.ep0.previous_write_len = 0;
                log_udc_dbg("p w len<MPS\r\n");
                log_udc_info("\t0 st->idle\r\n");
                // 切换到传输阶段
                g_udc.ep0state = 空闲阶段;
            }

// 回传告知核心层
            rt_usbd_ep0_in_handler(&g_mr100_udc);
        }
        break;
    }

// 数据 OUT 阶段 -> 数据阶段接收主机的数据
    case 数据OUT阶段:
    {
        if (数据接收完成中断)
        {
            /**
             * 1. 如果上层指定了数据接收任务，那么将数据读出，进行后续处理
             * 否则，直接将数据丢弃
             */
            p_ep0 = &(g_xxx_udc.ep0);

if ((p_ep0->request.buffer != NULL) &&
                (p_ep0->request.remain_size > 0))
            {
                max_pkt_size = _get_ep_max_packet_size(0);

recv_len = read_ep_fifo(0, p_ep0->request.buffer, p_ep0->request.remain_size);
                /**
                 * 读到的数据包 < 最大包长，那么是最后一个数据包
                 * ....下一阶段回到 IDLE，准备接收主机的下一个 setup
                 * 否则，后续还可能需要继续接收数据
                 * ....下一阶段依然是 OUT_DATA，准备接收后续的数据包
                 */
                if (recv_len < max_pkt_size)
                {
                    g_udc.ep0state = 空闲阶段;
                    清中断标志位，硬件其余操作
                }
                else
                {
                    g_udc.ep0state = 数据OUT阶段;
                    清中断标志位，硬件其余操作
                }
                rt_usbd_ep0_out_handler(&g_xxx_udc, recv_len);
            }
        }

break;
    }

default:
        break;
}

static rt_size_t _ep_write(rt_uint8_t address, void *buffer, rt_size_t size)
{
    u8        ep_id             = address & 0x0f;
    bool      is_need_zlp       = false;
    u32       ep_max_pkt_size   = 0;
    u32       remain_byte       = 0;

if (ep_id == 0)
    {
        /* 存档本次发送的数据长度，以便在发送完成中断中进行状态机切换 */
        g_udc.ep0.previous_write_len = size;
        g_udc.ep0state = 数据 IN 阶段;

ep_max_pkt_size = _get_ep_max_packet_size(0);
        if (size < ep_max_pkt_size)
        {
            is_need_zlp = false;
        }
        else if (size == ep_max_pkt_size)
        {
            /* 本次传输总的剩余长度 == 当前传输长度
             * 那么当前传输的就是最后一个数据包，因此需要传输一个 zlp 作为结束
             * */
            remain_byte = g_xxx_udc.ep0.request.remain_size;
            if (remain_byte == size)
            {
                is_need_zlp = true;
            }
            else
            {
                is_need_zlp = false;
            }
        }
    }

write_ep_fifo(ep_id, buffer, size, is_need_zlp);

return size;
}
```