电子头条

STEP BY STEP设计一个USB调试助手之九:基于异步传输的简单USB测试工具

2024-04-12
    阅读数:

一. 前言

前面我们实现了批量和中断传输的功能 , 至此工具已经初步具备了实用价值 , 可以进行控制传输和批量 / 中断传输的测试了。但是目前是基于同步接口实现的 , 也就是点击按钮 , 进行传输,等待传输完再显示 , 这样效率不高 , 也不适合应用。这一篇就来利用 libusb 的异步接口,实现新的收发框架,后面再将新的框架应用到我们的测试工具,所以本文先实现一个命令行的工具,先不带 GUI ,主要是测试异步框架,后面再应用的带 GUI 的测试工具中。

二. 异步传输编程框架

异步传输参考官方文档

https://libusb.sourceforge.io/api-1.0/group__libusb__asyncio.html

我这里做了个总结 , 画出了应用框图,看图更直观。

首先传输是针对端点的,所以前面需要一段初始化过程 , 过程即对应 USB 的框架层次

设备 -> 接口 -> 端点。当然这里还有 libusb 的运行环境初始化,

所以初始化过程就是

libusb_init_context ->libusb_open_device_with_vid_pid->libusb_claim_interface

对应的释放过程和上述初始化过程完全相反。

初始化之后,至此就可以进行端点的操作了,异步操作分为以下几个步骤

分配传输 libusb_alloc_transfer ->

填充传输参数 libusb_fill_bulk_transfer->

提交传输 libusb_submit_transfer->

等待传输完回调 cb->

释放传输 libusb_free_transfer

当然以上不是所有过程都需要走一遍,比如不需要重复分配传输,可以一直反复用。

当然是否传输完也是需要去检查的,所以这个实际是通过 libusb_handle_events 来实现的,该函数实现事件消息循环处理。周期调用该函数即可,可以使用一个线程单独运行它。此时 cb 就是在该线程运行,那么要注意和传输处理所在的线程不是同一个线程注意多线程问题。

如上框图,我这里设计的是用三个线程,主线程实现初始化,然后创建事件处理线程和传输处理线程,等待传输处理线程和事件处理线程运行完再执行释放过程。

事件处理线程只做一件事就是调用 libusb_handle_events 执行 libusb 的事件消息循环。

处理线程实现异步传输的处理 : 分配传输,填充传输,提交传输等。

处理线程如果执行完,我这里设置的是收到指定长度的内容之后,就发送信号量给事件处理线程,并退出线程,事件处理线程收到信号也退出线程。这样主线程等到他们都退出则执行释放过程。

以上仅作为一般框架建议,实际使用一个线程也可以。

三. 接口

实际上面已经介绍了相关的接口,具体可以参考官方文档,这里再总结下

1. 运行环境初始化与反初始化

libusb_init_context/libusb_exit

2. 设备打开与关闭

libusb_open_device_with_vid_pid /libusb_close

3. 接口申请与释放

libusb_claim_interface /libusb_claim_interface

4. 异步传输

libusb_alloc_transfer /libusb_fill_bulk_transfer/libusb_submit_transfer/libusb_free_transfer

5. 事件循环

libusb_handle_events

四. 基于异步传输框架的测试

4.1 实现

实际上述框架已经介绍的差不多了,实现起来就很简单了,直接上代码,代码里也有注释,就不再赘述了

我这里是用的是 mingw qt 环境,开发环境搭建参考前面的系列文章。

Usb_test.c 实现如下

//#include //#include #include #include #include #include "libusb.h"
#define TRANSFER_SIZE 64 /* 一次传输的大小 */#define VID 0x1999#define PID 0x0101#define USB_ITF_ID 0#define USB_IN_EP 0x81#define USB_OUT_EP 0x01
static void* usb_event_thread(void *arg); /* USB事件线程处理函数 */static void* usb_handle_thread(void *arg); /* USB业务线程处理函数 */pthread_t s_usb_event_thread; /* USB事件处理线程句柄 */pthread_t s_usb_handle_thread; /* USB业务处理线程句柄 */
libusb_device_handle *s_opened_handle = NULL; /* USB打开的设备句柄 */
struct libusb_transfer* s_tx_transfer = NULL; /* 发送传输 */struct libusb_transfer* s_rx_transfer = NULL; /* 接收传输 */static uint8_t s_tx_buffer[TRANSFER_SIZE]; /* 发送数据 */static uint8_t s_rx_buffer[TRANSFER_SIZE]; /* 接收数据 */static int s_tx_busy = 0; /* 发送忙标志 */static int s_rx_busy = 0; /* 接收忙标志 */static int s_tx_len = 0;static int s_rx_len = 0;sem_t s_sem;
int16_t vid = VID;int16_t pid = PID;int16_t itf = USB_ITF_ID;int16_t in_ep = USB_IN_EP;int16_t out_ep = USB_OUT_EP;
#define MAX_TX_LEN (sizeof(s_tx_buffer)*100)
int usb_test_main(int argc, char *argv[]){ int r; /* 解析参数 */ if(argc != 6) { printf("usage:usb_test.exe vid pid itf inep outep"); }
sscanf("%*s %#x %#x %d %#x %#x",&vid,&pid,&itf,&in_ep,&out_ep); for(size_t i=0 ;i<sizeof(s_tx_buffer); i++) { s_tx_buffer[i] = i; }
r = libusb_init_context(/*ctx=*/NULL, /*options=*/NULL, /*num_options=*/0); if (r < 0) { printf("failed to init context %d\r\n",r); return r; }
s_opened_handle = libusb_open_device_with_vid_pid(NULL, vid, pid); if (s_opened_handle == NULL) { printf("open dev err\r\n"); libusb_exit(NULL); return r; }
r = libusb_claim_interface(s_opened_handle,itf); if (r < 0) { printf("failed to claim interface %d\r\n",r); libusb_close(s_opened_handle); libusb_exit(NULL); return r; }
sem_init(&s_sem, 0, 0);
/* 创建usb事件处理线程 */ r = pthread_create(&s_usb_event_thread,0,usb_event_thread,0); if (r != 0) { printf("failed to create usb event thread:%d\r\n",r); libusb_release_interface(s_opened_handle,itf); libusb_close(s_opened_handle); libusb_exit(NULL); return r; }
/* 创建usb业务处理线程 */ r = pthread_create(&s_usb_handle_thread,0,usb_handle_thread,0); if (r != 0) { printf("failed to create usb handle thread:%d\r\n",r); libusb_release_interface(s_opened_handle,itf); libusb_close(s_opened_handle); libusb_exit(NULL); return r; }
/* 等待线程结束 */ void *res; pthread_join(s_usb_event_thread,&res); pthread_join(s_usb_handle_thread,&res); sem_destroy(&s_sem);
if(s_tx_len != s_rx_len) { printf("err send_len:%d,rx_len:%d!\r\n",s_tx_len,s_rx_len); } else { printf("ok send_len:%d,rx_len:%d!\r\n",s_tx_len,s_rx_len); }
libusb_release_interface(s_opened_handle,USB_ITF_ID); libusb_close(s_opened_handle); libusb_exit(NULL);
return 0;}
void tx_cb(struct libusb_transfer *transfer){ if (transfer->status == LIBUSB_TRANSFER_COMPLETED) { /* 成功 */ printf("tx_cb ok\r\n"); } else { /* 失败 */ printf("tx_cb err %d\r\n",transfer->status); //libusb_submit_transfer(transfer); } s_tx_len += transfer->actual_length; libusb_free_transfer(transfer); s_tx_busy = 0;}
void rx_cb(struct libusb_transfer *transfer){ if (transfer->status == LIBUSB_TRANSFER_COMPLETED) { /* 成功 */ printf("rx_cb ok\r\n"); } else { /* 失败 */ printf("rx_cb err %d\r\n",transfer->status); //libusb_submit_transfer(transfer); }
if(transfer->actual_length > 0) { printf("rx len %d\r\n",transfer->actual_length); } s_rx_len += transfer->actual_length; libusb_free_transfer(transfer);
s_rx_busy = 0;}
static void* usb_event_thread(void *arg){ while(1) { if(0 == sem_trywait(&s_sem)) { return 0; } libusb_handle_events(0); const struct timespec interval= { .tv_nsec = 1000000, .tv_sec = 0, }; pthread_delay_np(&interval); } return 0;}
static void* usb_handle_thread(void *arg){ while(1) { int rc; if(s_rx_len >= MAX_TX_LEN) { sem_post(&s_sem); return 0; }
/* 发送处理 */ s_tx_transfer = libusb_alloc_transfer(0); libusb_fill_bulk_transfer(s_tx_transfer,s_opened_handle,out_ep,s_tx_buffer,sizeof(s_tx_buffer),&tx_cb,0,100); rc = libusb_submit_transfer(s_tx_transfer); if(rc < 0) { s_tx_busy = 0; libusb_free_transfer(s_tx_transfer); s_tx_transfer = 0; }
/* 接收处理 */ s_rx_transfer = libusb_alloc_transfer(0); libusb_fill_bulk_transfer(s_rx_transfer,s_opened_handle,in_ep,s_rx_buffer,sizeof(s_rx_buffer),&rx_cb,0,100); rc = libusb_submit_transfer(s_rx_transfer); if(rc < 0) { s_rx_busy = 0; libusb_free_transfer(s_rx_transfer); s_rx_transfer = 0; }
const struct timespec interval= { .tv_nsec = 1000000, .tv_sec = 0, }; pthread_delay_np(&interval); }
return 0;}

Usb_test.h 如下

#ifndef USB_TEST_H#define USB_TEST_H
#if defined(__cplusplus)extern "C" {#endif
int usb_test_main(int argc, char *argv[]);
#if defined(__cplusplus)}#endif
#endif // USB_TEST_H

Main.cpp 如下

#include #include "usb_test.h"
int main(int argc, char *argv[]){ QCoreApplication a(argc, argv); usb_test_main(argc, argv); return a.exec();}

整个工程如下

4.2 发布程序

这里顺便提一下发布代码,直接拷贝 usb_tool.exe 到其他地方是不能直接运行的,因为依赖一些库 , 需要使用工具发布。

build-usb_tool-Desktop_Qt_6_6_1_MinGW_64_bit-Debug\debug 下的

Usb_tool.exe 放到某个文件夹下

开始菜单搜索打开如下命令行

Cd usb_tool.exe 所在目录

执行 windeployqt usb_tool.exe

会自动添加对应的依赖库

生成文件如下,在这里就可以直接点击 exe 运行了,发布就复制整个文件夹即可。

4.3 测试

命令行输入

usb_tool.exe 0x1999 0x0101 0 0x81 0x01

我这里接的是一个 winusb 设备, vid pid 0x1999 0x0101

接口 0 下有 0x81 IN 端点和 0x01 OUT 端点,设备代码逻辑是收到 01 端点的数据原样从 0x81 端点返回。

4.4 工程和可执行代码

完整的代码 , 框图和可执行文件可以从以下地址下载

链接: https://pan.baidu.com/s/1CfWEpmxFS4NAweZpWd3slw?pwd=pzj7

提取码: pzj7

五. 总结

以上只是简单的 demo ,还有一些可改进的地方

1. 以上 demo 处理线程 中提交传输 , 回调中进行处理 , 等回调处理完设置标志 , 处理线程再提交下一次传输,实际并没有 pipeline 流水起来 , 因为处理线程需要等到回调中处理完才提交下一次传输,这里中间会有间隔。实际 libusb 支持 pipeline ,提交传输实际是动态分配资源并挂载 描述符 的,所以可以一次提交多个,这样在一个传输完成时,后续还有多个传输正在进行,此时处理线程又可以继续提交传输,这样流水起来 , 才能高效。

2. 以上 demo 仅仅作为演示 , 实际应用 , 需要提供给应用层更简单的读写接口,此时需要借助 FIFO ,即处理线程负责接收数据到 RX FIFO ,负责从 TX FIFO 取数据发送 , 这样应用层读写数据只需要读 RX FIFO ,写 TX FIFO ,实现和底层解耦。



最新有关嵌入式Lee的文章
展开↓