libusb的异步也有这样的问题_libusb异步传输

1. 最近一直在关注异步机制，不管是网络库asio，libuv，还是libusb库，其实异步机制都是差不多的，都是基于回调函数、系统轮询实现的。

2. 下面是对一款USB产品做得测试结果，Windows环境下，用libusb异步API写的程序：

说明：用 Bus Hound 抓包，查看返回数值发现上面三个命令只有R是成功的（即有返回值），却对应在了B命令上，导致调用了B的回调。这就是异步容易导致的问题，也就是如果不停地发送命令，其中有一条命令失败，而这条命令的超时未过，回来的结果如果没有别的区分，会认为是该条命令的返回数据，而导致调用失败指令的回调函数，而导致比较严重的后果。

#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "libusb.h"
 
#define EP_IN           (6 | LIBUSB_ENDPOINT_IN)
#define EP_OUT		(2 | LIBUSB_ENDPOINT_OUT)
 
 
typedef enum {
    SAVE_IMAGE      = 0x55,
    UPLOAD_IMAGE    = 0xAA
}BULK_REQCODE;
 
typedef enum {
    SAVE_IMAGE_VAL  = 0x00,
    UPLOAD_B_VAL    = 0x00,
    UPLOAD_G_VAL    = 0x01,
    UPLOAD_R_VAL    = 0x02
}BULK_VALUE;
 
static struct libusb_device_handle *devh = NULL;
static unsigned char imgbuf_save[8];
static unsigned char imgbuf_upload[8];
static unsigned char imgbuf_R[2048*240];
static unsigned char imgbuf_G[2048*240];
static unsigned char imgbuf_B[2048*240];
static struct libusb_transfer *img_save = NULL;
static struct libusb_transfer *img_R = NULL;
static struct libusb_transfer *img_G = NULL;
static struct libusb_transfer *img_B = NULL;
static struct libusb_transfer *img_R_upload = NULL;
static struct libusb_transfer *img_G_upload = NULL;
static struct libusb_transfer *img_B_upload = NULL;
static int img_idx = 0;
static volatile sig_atomic_t do_exit = 0;
static int ii=0;
 
static pthread_t poll_thread;
static sem_t exit_sem;
 
static void request_exit(sig_atomic_t code)
{
	do_exit = code;
	sem_post(&exit_sem);
}
 
static void *poll_thread_main(void *arg)    //轮询是否main——thread结束
{
	int r = 0;
	printf("poll thread running\n");
 
	while (!do_exit) {
		struct timeval tv = { 1, 0 };
        r = libusb_handle_events_timeout(NULL, &tv);    //处理任何待以处理的事件
		if (r < 0) {
			request_exit(2);
			break;
		}
	}
 
	printf("poll thread shutting down\n");
	return NULL;
}
 
static int find_dpfp_device(void)
{
    devh = libusb_open_device_with_vid_pid(NULL, 0x04b4, 0x8623);
	return devh ? 0 : -EIO;
}
 
static void LIBUSB_CALL cb_img(struct libusb_transfer *transfer)
{
    if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
        fprintf(stderr, "img transfer status %d?\n", transfer->status);
        request_exit(2);
        return;
    }
 
    std::cout << "upload_img_R_over callback : " << transfer->status << std::endl;
}
 
static void LIBUSB_CALL save_img(struct libusb_transfer *transfer)
{
    if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
        fprintf(stderr, "img transfer status %d?\n", transfer->status);
        request_exit(2);
        return;
    }
 
    std::cout << "save Image callback : " << transfer->status << std::endl;
}
 
static void LIBUSB_CALL upload_img_B(struct libusb_transfer *transfer)
{
    if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
        fprintf(stderr, "img transfer status %d?\n", transfer->status);
        request_exit(2);
        return;
    }
 
    std::cout << "upload_img_B callback : " << transfer->status << std::endl;
}
 
static void LIBUSB_CALL upload_img_B_over(struct libusb_transfer *transfer)
{
    if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
        fprintf(stderr, "img transfer status %d?\n", transfer->status);
        request_exit(2);
        return;
    }
 
    std::cout << "upload_img_B_over callback : " << transfer->status << std::endl;
}
 
static void LIBUSB_CALL upload_img_G(struct libusb_transfer *transfer)
{
    if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
        fprintf(stderr, "img transfer status %d?\n", transfer->status);
        request_exit(2);
        return;
    }
 
    std::cout << "upload_img_G callback : " << transfer->status << std::endl;
}
 
static void LIBUSB_CALL upload_img_G_over(struct libusb_transfer *transfer)
{
    if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
        fprintf(stderr, "img transfer status %d?\n", transfer->status);
        request_exit(2);
        return;
    }
 
    std::cout << "upload_img_G_over callback : " << transfer->status << std::endl;
}
 
static void LIBUSB_CALL upload_img_R(struct libusb_transfer *transfer)
{
    if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
        fprintf(stderr, "img transfer status %d?\n", transfer->status);
        request_exit(2);
        return;
    }
 
    std::cout << "upload_img_R callback : " << transfer->status << std::endl;
 
}
 
//由于该设备处理多命令异步发送过来的时候，只处理最后一条
static int LIBUSB_CALL submit_trans()
{
    int r=0;
 
    r = libusb_submit_transfer(img_save);   //提交一个传输并立即返回
    if (r < 0) {
        libusb_cancel_transfer(img_save);   //异步取消之前提交传输
        printf("1");
    }
 
    r = libusb_submit_transfer(img_B_upload);   //提交一个传输并立即返回
    if (r < 0) {
        libusb_cancel_transfer(img_B_upload);   //异步取消之前提交传输
        printf("1");
    }
 
    r = libusb_submit_transfer(img_B);   //提交一个传输并立即返回
    if (r < 0) {
        libusb_cancel_transfer(img_B);   //异步取消之前提交传输
        printf("1");
    }
 
    r = libusb_submit_transfer(img_G_upload);   //提交一个传输并立即返回
    if (r < 0) {
        libusb_cancel_transfer(img_G_upload);   //异步取消之前提交传输
        printf("1");
    }
 
    r = libusb_submit_transfer(img_G);   //提交一个传输并立即返回
    if (r < 0) {
        libusb_cancel_transfer(img_G);   //异步取消之前提交传输
        printf("1");
    }
 
    r = libusb_submit_transfer(img_R_upload);   //提交一个传输并立即返回
    if (r < 0) {
        libusb_cancel_transfer(img_R_upload);   //异步取消之前提交传输
        printf("1");
    }
 
    r = libusb_submit_transfer(img_R);   //提交一个传输并立即返回
    if (r < 0) {
        libusb_cancel_transfer(img_R);   //异步取消之前提交传输
        printf("1");
    }
 
    return r;
}
 
static int alloc_transfers(void)
{
    img_save = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
    if (!img_save)
		return -ENOMEM;
    img_R = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
    if (!img_R)
        return -ENOMEM;
    img_R_upload = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
    if (!img_R_upload)
        return -ENOMEM;
    img_G = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
    if (!img_G)
        return -ENOMEM;
    img_G_upload = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
    if (!img_G_upload)
        return -ENOMEM;
    img_B = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
    if (!img_B)
        return -ENOMEM;
    img_B_upload = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
    if (!img_B_upload)
        return -ENOMEM;
 
    imgbuf_save[0] = (u_char)(SAVE_IMAGE);
    imgbuf_save[1] = 0x00;
    imgbuf_save[2] = 0x00;
    imgbuf_save[3] = 0x00;
    imgbuf_save[4] = (uchar)((0xff00 & 0x00f0)>>8);
    imgbuf_save[5] = (uchar)(0x00ff & 0x00f0);
    imgbuf_save[6] = 0x00;
    imgbuf_save[7] = (u_char)(SAVE_IMAGE_VAL);
    libusb_fill_bulk_transfer(img_save, devh, EP_OUT, imgbuf_save,
        sizeof(imgbuf_save), save_img, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
 
    imgbuf_upload[0] = (u_char)UPLOAD_IMAGE;
    imgbuf_upload[1] = 0x00;
    imgbuf_upload[2] = 0x00;
    imgbuf_upload[3] = 0x00;
    imgbuf_upload[4] = (uchar)((0xff00 & 0x00f0)>>8);
    imgbuf_upload[5] = (uchar)(0x00ff & 0x00f0);
    imgbuf_upload[6] = 0x00;
    imgbuf_upload[7] = (u_char)UPLOAD_B_VAL;
    libusb_fill_bulk_transfer(img_B_upload, devh, EP_OUT, imgbuf_upload,
        sizeof(imgbuf_upload), upload_img_B, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
    libusb_fill_bulk_transfer(img_B, devh, EP_IN, imgbuf_B,
        sizeof(imgbuf_B), upload_img_B_over, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
 
    imgbuf_upload[0] = (u_char)UPLOAD_IMAGE;
    imgbuf_upload[1] = 0x00;
    imgbuf_upload[2] = 0x00;
    imgbuf_upload[3] = 0x00;
    imgbuf_upload[4] = (uchar)((0xff00 & 0x00f0)>>8);
    imgbuf_upload[5] = (uchar)(0x00ff & 0x00f0);
    imgbuf_upload[6] = 0x00;
    imgbuf_upload[7] = (u_char)UPLOAD_G_VAL;
    libusb_fill_bulk_transfer(img_G_upload, devh, EP_OUT, imgbuf_upload,
        sizeof(imgbuf_upload), upload_img_G, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
    libusb_fill_bulk_transfer(img_G, devh, EP_IN, imgbuf_G,
        sizeof(imgbuf_G), upload_img_G_over, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
 
    imgbuf_upload[0] = (u_char)UPLOAD_IMAGE;
    imgbuf_upload[1] = 0x00;
    imgbuf_upload[2] = 0x00;
    imgbuf_upload[3] = 0x00;
    imgbuf_upload[4] = (uchar)((0xff00 & 0x00f0)>>8);
    imgbuf_upload[5] = (uchar)(0x00ff & 0x00f0);
    imgbuf_upload[6] = 0x00;
    imgbuf_upload[7] = (u_char)UPLOAD_R_VAL;
    libusb_fill_bulk_transfer(img_R_upload, devh, EP_OUT, imgbuf_upload,
        sizeof(imgbuf_upload), upload_img_R, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
    libusb_fill_bulk_transfer(img_R, devh, EP_IN, imgbuf_R,
        sizeof(imgbuf_R), cb_img, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
 
	return 0;
}
 
int main(void)
{
    libusb_init(NULL);  //初始libusb库
 
    int r = find_dpfp_device();
    if(r!=0)
    {
        printf("%s\n", "not found dev" );
        return 0;
    }
 
    r = libusb_claim_interface(devh, 0);    //声明设备接口
    if (r < 0) {
        fprintf(stderr, "usb_claim_interface error %d %s\n", r, strerror(-r));
        goto out;
    }
    std::cout << "claimed interface" << std::endl;
 
    r = pthread_create(&poll_thread, NULL, poll_thread_main, NULL); //子线程poll_thread_main用来处理USB事件
    if (r)
        goto out;
 
    r = alloc_transfers();  //配置一个异步bulk传输和一个中断传输，先alloc然后fill_XX_transfer
    if (r < 0) {
        request_exit(1);
        pthread_join(poll_thread, NULL);    //函数pthread_join用来等待一个线程的结束
        goto out;
    }
 
    r = submit_trans(); //submit一个传输
    if (r < 0) {
        request_exit(1);
        pthread_join(poll_thread, NULL);    //失败等待线程结束
        goto out;
    }
 
    while (!do_exit)
        sem_wait(&exit_sem);    //等待退出信号量
 
    printf("shutting down...\n");
    pthread_join(poll_thread, NULL);
 
out_release:
    libusb_release_interface(devh, 0);
out:
    libusb_close(devh);
    libusb_exit(NULL);
    sem_destroy(&exit_sem);
    return r >= 0 ? r : -r;
}