Libusb测试USB device(2)

因为测试的比较混乱，我就按照我的问题导向来描述我的过程吧

一. 提示libusb_context对象为NULL的错误：

　　在简化的过程中，我没有加入dev_handler判断为空就进行了具体的工作；

1 if( !dev_handler )

2     libusb_open(dev_obj, &dev_handler);

3 if( dev_handler )

4     // do your job

二. 如果不知道是什么原因（比如说ioctl之类的错误，那么可能是安装错误了驱动：

　　我使用了zadig-2.7.exe，来安装：

　　如果想要测试HID设备，安装成WinUSB会比较合适；

　　如果想要其他的usb设备安装成libusb会比较合适

　　如果想要测试等时传输（isoch）则libusbk会更合适一些（虽然我用的是WinUSB好像也可以）

三. 对于Windows中USB的驱动的了解也比较重要：

 1 libusb_bullk_transfer 是libusb提供的函数；

 2 do_syun_bulk_transfer 执行具体的工作

 3 // 在do_sync_bulk中

 4 {

 5     alloc_transfer();

 6     fill_bulk_transfer();

 7     submit_transfer();

 8     sync_transfer_wait_for_completion();

 9 }

10 // 其中submit又是重点：

11 submit_transfer(){

12     ref_device();

13     mutex_lock & transfer_lock;

14     set_itransfer_obj;

15     add_to_flying_list

16     usbi_backend->submit_transfer()

17 }

18 // 其中ubsi_backend表示的是具体的实现的

四. 对于device发送的Descriptor解析页非常重要：

　　其中我认为最重要的就是对断点endpoint descriptor属性的理解：

　　关系这个断电支持什么样的传输方式，已经最多穿多少（对于Isoch来说非常重要）

 1 static void print_endpoint(const struct libusb_endpoint_descriptor* endpoint)

 2 {

 3     int i, ret;

 4     printf("\t\t\tEndpoint:\n");

 5         // 可以看出endpoint是OUT(host->device)还是IN(device->host)

 6     printf("\t\t\t\tbEndpointAddress: %02xh\n", endpoint->bEndpointAddress);

 7         // 可以看出支持的操作：01：中断；02：bulk；03：isoch

 8     printf("\t\t\t\tbmAttributes:     %02xh\n", endpoint->bmAttributes);

 9     printf("\t\t\t\twMaxPacketSize:   %u\n", endpoint->wMaxPacketSize);

10     printf("\t\t\t\tTransfer Interval %u\n", endpoint->bInterval);

11 }

五. 关于等时传输isoch（困扰了我最久的一块儿）

　　Step1：根据微软的官方文档了解等是传输断点（endpoint）中具体的信息；

获得不连续数据包大小MaximumPacketSize	使用libusb提供的libusb_get_max_iso_packet_size方法就可以了全速设备：这是1帧发送的数据；对于高速设备，这个是1微帧发送的字节数；好像已经固定了：Full是1024；High是3072；Super是45000
确认帧包含多少微帧	根据断点提供的bInterval来计算：2^(Interval-1)
验证	需要连续包个数必须是每个帧数据包数的倍数；
分配结构体	也就是alloc_transfer
指定详细信息	也就是给transfer结构体添加缓冲区数据

　　　　最诡异的就是这个Interval：

　　　　根据Interval就可以计算出来轮询周期Polling Period = 2^(Interval-1); 轮询周期表示每轮询周期个总线间隔才会传输一次；

　　　　所以Interval == 4的时候就和Full Speed差不多；

　　　Step2：实践：使用等时传输函数：

　　　　首先上代码：

int do_sync_transfer()

{

    int endpoint_num;

    int test_type;

    int interface_num = USB_INTERFACE;

    int ret;

    int packet_size;

    int transfer_length;

    int numberOfPackets;

    unsigned char* buff;

    int temp;

    int trans_time;

    printf("INFO: Enter the test type\n\t0: ISOC IN; 1: ISOC OUT\n");

    scanf_s("%d", &test_type);

    switch (test_type)

    {

    case 0:

        endpoint_num = ISOC_IN_ENDPOINT;

        dir = 1;

        break;

    case 1:

        endpoint_num = ISOC_OUT_ENDPOINT;

        dir = 0;

        break;

    default:printf("ERROR: Wrong test type\n");return;

    }

    if ((ret = libusb_clear_halt(g_handler, endpoint_num)) < 0)

    {

        printf("ERROR: clear halt failed\n\tReason: %s\n", libusb_strerror(ret));

        return -1;

    }

    printf("INFO: clear halt succeed\n");

    int number0fPacketPerFrame;

    // new ONE:

        // 计算缓冲区大小和长度最重要的地方：

        // 根据Interval 计算Polling Period

        // 缓冲区大小 = 最大不连续包大小 * 8/ Polling Period

    int win_interval = (ISOC_INTERVAL - 1);

    int min_buffer_size = MAX_BYTES_PER_INTERVAL * 8 / win_interval;

    buff = (unsigned char*)malloc(sizeof(unsigned char) * 3072);

    int temp_time = min_buffer_size / 16;

    for (int i = 0; i < temp_time; i++)

        memset(buff + (i * 16), temp_time, 16);

    libusb_set_debug(NULL, 4);

    if (endpoint_num == ISOC_OUT_ENDPOINT) {

        struct libusb_transfer* xfer;

        // 标识发送开始

                // 也是很重要的：设置异步的检测状态函数：

                // 注意使用detach分离

        is_send_over = 0;

        pthread_t my_thread;

        pthread_create(&my_thread, NULL, handle_isoc_transfer, g_ctx);

        pthread_detach(my_thread);

        for (trans_time = 0; trans_time < 15; trans_time++) {

            printf("TIME: %d\n", trans_time);

            printf("Enter Send transfer length:\n");

            scanf_s("%d", &transfer_length);

            numberOfPackets = ceil(transfer_length / min_buffer_size);

            printf("The number of packets is : %d\n", numberOfPackets);

            if (numberOfPackets % number0fPacketPerFrame != 0) {

                printf("Number of Packet should be a multiple of numberOf packet per frame\n");

                return;

            }

            for (int i = 0; i < numberOfPackets; i++) {

                int temp_translen = (transfer_length >= min_buffer_size) ? min_buffer_size : transfer_length;

                transfer_length -= temp_translen;

                xfer = libusb_alloc_transfer(number0fPacketPerFrame);

                if (!xfer) {

                    printf("ERROR: no memory for transfer\n");

                    libusb_set_debug(NULL, 0);

                    return -1;

                }

                libusb_fill_iso_transfer(xfer, g_handler, endpoint_num,

                    buff,

                    transfer_length,

                    number0fPacketPerFrame,

                    isoc_callback_send,NULL, 200);

                xfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;

                libusb_set_iso_packet_lengths(xfer, temp_translen);

                ret = libusb_submit_transfer(xfer);

                if (ret < 0) {

                    printf("ERROR: submit\n");

                    libusb_free_transfer(xfer);

                    libusb_set_debug(NULL, 0);

                    return -1;

                }

                Sleep(500);

                libusb_free_transfer(xfer);

            }

        }

        is_send_over = 1;

    }

    else {

        int receive_time;

        is_receive_over = 0;

        pthread_t my_thread;

        pthread_create(&my_thread, NULL, handle_isoc_transfer, g_ctx);

        pthread_detach(my_thread);

        for (trans_time = 0; trans_time < 15; trans_time++) {

            printf("TIME: %d\n", trans_time);

            printf("Enter Receive Time:\n");

            scanf_s("%d", &receive_time);

            for (int i = 0; i < receive_time; i++) {

                printf("Receive No.%d", i);

                if ((ret = libusb_clear_halt(g_handler, endpoint_num)) < 0)

                {

                    printf("ERROR: clear halt failed\n\tReason: %s\n", libusb_strerror(ret));

                    return -1;

                }

                printf("INFO: clear halt succeed\n");

                struct libusb_transfer* xfer;

                libusb_fill_iso_transfer(

                    xfer,

                    g_handler,

                    endpoint_num,

                    buff,

                    min_buffer_size,

                    number0fPacketPerFrame,

                    isoc_callback_receive,

                    NULL,

                    200);

                xfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;

                libusb_set_iso_packet_lengths(xfer, min_buffer_size);

                ret = libusb_submit_transfer(xfer);

                if (ret < 0) {

                    printf("ERROR: submit\n");

                    libusb_free_transfer(xfer);

                    libusb_set_debug(NULL, 0);

                    return -1;

                }

                Sleep(200);

                libusb_free_transfer(xfer);

            }

        }

        is_receive_over = 1;

    }

    libusb_set_debug(NULL, 0);

    return 0;

}

　　　　然后对应的异步处理函数代码如下：

 1 static int LIBUSB_CALL usb_arrived_callback(libusb_context*, libusb_device*, libusb_hotplug_event, void*);

 2 // leave : left

 3 static int LIBUSB_CALL usb_left_callback(libusb_context*, libusb_device*, libusb_hotplug_event, void*);

 4 // Just get one handler (default by dev)

 5 void get_handle_and_device_by_vandp(uint16_t, uint16_t, libusb_device**, libusb_device_handle**);

 6 int print_all_device();

 7

 8 void* handle_isoc_transfer(void* param) {

 9     if (param == NULL) {

10         printf("PARAM Wrong\n");

11         return;

12     }

13     libusb_context* ctx = (libusb_context*)param;

14     while (1) {

15         if (is_send_over == 1) {

16             printf("This time already done");

17             break;

18         }

19         libusb_handle_events(ctx);

20     }

21 }

22

23 static void LIBUSB_CALL isoc_callback_send(struct libusb_transfer* xfer)

24 {

25     printf("INFO : in isoc_callback send\n");

26     if (xfer == NULL)

27         return;

28     printf("INFO : the transfer status is :%d\n", xfer->status);

29     switch(xfer->status)

30     {

31     case LIBUSB_TRANSFER_COMPLETED:

32         printf("INFO: transter complete\nDatas are:\n");

33         printf("The length : %d\n", xfer->actual_length);

34         break;

35     case LIBUSB_TRANSFER_ERROR:

36         printf("ERROR: transfer error\n");

37         break;

38     case LIBUSB_TRANSFER_TIMED_OUT:

39         printf("ERROR: transfer timeout\n");

40                 break;

41     case LIBUSB_TRANSFER_CANCELLED:

42         printf("ERROR: transfer is cancelled\n");

43                 break;

44     case LIBUSB_TRANSFER_STALL:

45         printf("ERROR: transfer stall\n");

46                 break;

47     case LIBUSB_TRANSFER_NO_DEVICE:

48         printf("ERROR: no device detected\n");

49                 break;

50     case  LIBUSB_TRANSFER_OVERFLOW:

51         printf("ERROR: transfer overflowed\n");

52                 break;

53     default:

54         printf("ERROR: UNKNOWN status\n");

55                 break;

56     }

57 }

58

59 static void LIBUSB_CALL isoc_callback_receive(struct libusb_transfer* xfer) {

60     if (xfer == NULL)

61         return;

62     printf("INFO: enter : %s and status is : %d\n", __func__, xfer->status);

63     switch (xfer->status)

64     {

65     case LIBUSB_TRANSFER_COMPLETED:

66         printf("INFO: transfer completed\n");

67         break;

68     case LIBUSB_TRANSFER_ERROR:

69         printf("ERROR: transfer error\n");

70         break;

71     case LIBUSB_TRANSFER_TIMED_OUT:

72         printf("ERROR: transfer timeout\n");

73         break;

74     case LIBUSB_TRANSFER_CANCELLED:

75         printf("ERROR: transfer is cancelled\n");

76         break;

77     case LIBUSB_TRANSFER_STALL:

78         printf("ERROR: transfer stall\n");

79         break;

80     case LIBUSB_TRANSFER_NO_DEVICE:

81         printf("ERROR: no device detected\n");

82         break;

83     case  LIBUSB_TRANSFER_OVERFLOW:

84         printf("ERROR: transfer overflowed\n");

85         break;

86     default:

87         printf("ERROR: UNKNOWN status\n");

88         break;

89     }

90 }

　　　　总是不确定到底该发送多少个数据才能被接收：

　　　　终于找到了windows_winusb.c中的winusbx_submit_iso_transfer函数：

 1 // For high-speed and SuperSpeed device, the interval is 2**(bInterval-1).

 2 if (transfer->dev_handle->dev->speed >= LIBUSB_SPEED_HIGH)

 3     interval = (1 << (pipe_info_ex.Interval - 1));

 4 if (transfer->dev_handle->dev->speed >= LIBUSB_SPEED_HIGH) {// Microframes (125us)

 5     printf("--------INFO: %d\n", (pipe_info_ex.MaximumBytesPerInterval * 8) / interval);

 6     iso_transfer_size_multiple = (pipe_info_ex.MaximumBytesPerInterval * 8) / interval;

 7 }

 8 else // Normal Frames (1ms)

 9     iso_transfer_size_multiple = pipe_info_ex.MaximumBytesPerInterval / interval;

10 if (transfer->length % iso_transfer_size_multiple != 0) {

11     usbi_err(TRANSFER_CTX(transfer), "length of isoch buffer must be a multiple of the MaximumBytesPerInterval * 8 / Interval");

12     return LIBUSB_ERROR_INVALID_PARAM;

13 }

　　　　可见：里面对interval也进行了计算：

　　　　在使用等时传输读的时候需要将buffer的长度设置为size_multiple；但是写的时候并不需要；

　　　　最后终于测试成功了

巴特西

Libusb测试USB device(2)

最新文章

热门文章