libusb-test.c

/********************************************************************************
*
*  File Name     : libusb-test.c
*  Author        : baoli
*  Create Date   : 2017.11.21
*  Version       : 1.0
*  Description   : libusb test
*                  compile command: gcc -o libusb libusb-test.c -lusb-1.0 -lpthread -lm             
*  History       : 1. Data:
*                     Author:
*                     Modification:
*
********************************************************************************/


#include <unistd.h>  
#include <stdio.h>  
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <signal.h>
#include <semaphore.h>

#include <libusb-1.0/libusb.h> 


typedef unsigned char uchar;
typedef unsigned int  uint;


#define VID 0x0471
#define PID 0x0999

#define BULK_RECV_EP    0x82
#define BULK_SEND_EP    0x02
#define INT_RECV_EP     0x81
#define INT_SEND_EP     0x01

#define SEND_BUFF_LEN    500
#define RECV_BUFF_LEN    500

#define BULK_TEST   1
#define INT_TEST    2

#define SAVE_FILE_PATH  "libusb_test_recv_data"


sem_t print_sem; //信号量
FILE *g_file_stream = NULL;
int g_no_device_flag = 0;
int g_file_save_en = 0; //文件保存使能标志
int g_send_flag = 0;    //调用数据发送函数标志

uchar rev_buf[SEND_BUFF_LEN];   //usb 接收缓冲区
uchar send_buf[SEND_BUFF_LEN];  //usb发送缓冲区 

libusb_device_handle *dev_handle;

char test_bytes[] = 
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n";   //37*15=555 bytes



int  bulk_send(char *buf, int num);
int  interrupt_send(char *buf, int num);
void *bulk_rev_thread(void *arg);
void *interrupt_rev_thread(void *arg);
int  LIBUSB_CALL usb_event_callback(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data);
void help(void);
int  str2hex(char *hex);
void hex2str(uchar *pbDest, uchar *pbSrc, ushort nLen);
void *usb_monitor_thread(void *arg);
int  save_to_file(FILE *file_stream, uchar *data, int length);
void print_devs(libusb_device **devs);
int  list_devices(void);
void print_endpoint(const struct libusb_endpoint_descriptor *endpoint);
void print_altsetting(const struct libusb_interface_descriptor *interface);
void print_interface(const struct libusb_interface *interface);
void print_configuration(struct libusb_config_descriptor *config);
void print_device(libusb_device *dev, struct libusb_device_descriptor *desc);
int  print_descriptor(libusb_device *dev);
int  get_descriptor_with_vid_pid(int vid, int pid);
void sigint_handler(int sig);


//采用bulk端点发送数据
int bulk_send(char *buf, int num)
{

    int size;
    int rec;    
    
    g_send_flag = 1;
    rec = libusb_bulk_transfer(dev_handle, BULK_SEND_EP, buf, num, &size, 0);  
    if(rec == 0) {
        printf("bulk send sucess,length: %d bytes\n", size);
        sem_post(&print_sem);
    }
    else{
        g_send_flag = 0;
        printf("bulk send faild, err: %s\n", libusb_error_name(rec));
    }

    return 0;   
    
}


//采用interrupt端点发送数据
int interrupt_send(char *buf, int num)
{

    int size;
    int rec;    
    
    g_send_flag = 1;
    rec = libusb_interrupt_transfer(dev_handle, INT_SEND_EP, buf, num, &size, 0);  
    if(rec == 0) {
        printf("interrupt send sucess, length: %d bytes\n", size);
        sem_post(&print_sem);
    }
    else{
        g_send_flag = 0;
        printf("interrupt send faild, err: %s\n", libusb_error_name(rec));
    }

    return 0;   
    
}


//bulk 端点接收线程
void *bulk_rev_thread(void *arg)
{
    int i=0;
    int size;
    int rec;  
    int save_bytes;
    char hex_buf[RECV_BUFF_LEN*5];

    printf("bulk_rev_thread started.\n");  

    while(1)
    {
        if(g_no_device_flag){
            usleep(50 * 1000);
            continue;
        }

        memset(rev_buf, 0, RECV_BUFF_LEN);
        rec = libusb_bulk_transfer(dev_handle, BULK_RECV_EP, rev_buf, RECV_BUFF_LEN, &size, 0);  
        if(rec == 0) 
        {
            if(g_send_flag == 1)  //考虑如果没有调用发送数据函数，接收到数据后调用sem_wait会一直等待直到调用了bulk_send，才会继续往下执行
            {
                g_send_flag = 0;
                sem_wait(&print_sem);
            }

            printf("\nbulk ep rev sucess, length: %d bytes. \n", size);

            if(g_file_save_en){
                save_bytes = save_to_file(g_file_stream, rev_buf, size);            
                printf("save %d bytes to file.\n", save_bytes);
            }

            hex2str(hex_buf, rev_buf, size);           
            printf("data is: \n%s\n", rev_buf);
            printf("hex is: \n%s\n", hex_buf);
        }
        else
        {
            printf("bulk ep rev faild, err: %s\n", libusb_error_name(rec));
            if(rec == LIBUSB_ERROR_IO)
                g_no_device_flag = 1; //防止一直输出err
        }
    }
    
}


//interrupt 端点接收线程
void *interrupt_rev_thread(void *arg)
{
    int i=0;
    int size;
    int rec;  
    int save_bytes;
    char hex_buf[RECV_BUFF_LEN*5];

    printf("interrupt_rev_thread started.\n");  

    while(1)
    {
        if(g_no_device_flag){
            usleep(50 * 1000);
            continue;
        }

        memset(rev_buf, 0, RECV_BUFF_LEN);
        rec = libusb_interrupt_transfer(dev_handle, INT_RECV_EP, rev_buf, RECV_BUFF_LEN, &size, 0);  
        if(rec == 0) 
        {
            if(g_send_flag == 1)  //考虑如果没有调用发送数据函数，接收到数据后调用sem_wait会一直等待直到调用了interrupt_send，才会继续往下执行
            {
                g_send_flag = 0;
                sem_wait(&print_sem);
            }

            printf("\ninterrupt ep rev sucess, length: %d bytes. \n", size);

            if(g_file_save_en){
                save_bytes = save_to_file(g_file_stream, rev_buf, size);            
                printf("save %d bytes to file.\n", save_bytes);
            }

            hex2str(hex_buf, rev_buf, size);            
            printf("data is: \n%s\n", rev_buf);
            printf("hex is: \n%s\n", hex_buf);
        }
        else
        {
            printf("interrupt ep rev faild, err: %s\n", libusb_error_name(rec));
            if(rec == LIBUSB_ERROR_IO)
                g_no_device_flag = 1; //防止一直输出err
        }
    }

    
}


//usb hotplugin callback function
int LIBUSB_CALL usb_event_callback(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data) 
{
    struct libusb_device_descriptor desc;
    int r;
    
    printf("\nusb hotplugin event.\n");

    r = libusb_get_device_descriptor(dev, &desc);
    if (LIBUSB_SUCCESS != r) {
        printf("error getting device descriptor.\n");
    }
    
    if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
        printf("usb device attached: %04x:%04x\n", desc.idVendor, desc.idProduct);
        
        if (dev_handle) {
            libusb_close(dev_handle);
            dev_handle = NULL;
        }
        
        r = libusb_open(dev, &dev_handle);
        if (LIBUSB_SUCCESS != r) {
            printf ("error opening device.\n");
        }
        else {
            if(libusb_kernel_driver_active(dev_handle, 0) == 1) { //find out if kernel driver is attached
                printf("kernel driver active\n");
                if(libusb_detach_kernel_driver(dev_handle, 0) == 0) //detach it
                    printf("kernel driver detach\n");
            }
            int r = libusb_claim_interface(dev_handle, 0); //claim interface 0 (the first) of device (mine had jsut 1)
            if (r < 0) {
                printf("libusb_claim_interface failed\n");
                return 0;
            }

            g_no_device_flag = 0;          
            printf("usb device open sucess\n\n");
            printf("input data to send or command:");
            fflush(stdout);
        }
    }
    else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
        g_no_device_flag = 1;
        printf("usb device removed: %04x:%04x\n", desc.idVendor, desc.idProduct);
        if (dev_handle) {           
            libusb_close(dev_handle);
            dev_handle = NULL;

        }
    }
    else
        ;

    return 0;
}


//usb hotplugin monitor thread
void * usb_monitor_thread(void *arg) 
{ 
    printf("usb monitor thread started.\n");

    int r = 0;
    while (1) {
        r = libusb_handle_events(NULL);
        if (r < 0)
            printf("libusb_handle_events() failed: %s\n", libusb_error_name(r));
    }  

}


void help(void)
{
    printf("usage: libusb-test [-h] [-b] [-i] [-v vid] [-p pid] [-ffile_path] [-l] [-a] \n");
    printf("   -h      : display usage\n");
    printf("   -b      : test bulk transfer\n");   
    printf("   -i      : test interrupt transfer\n"); 
    printf("   -v      : usb VID\n");
    printf("   -p      : usb PID\n"); 
    printf("   -f      : file path to save data\n"); 
    printf("   -l      : list usb devices\n");
    printf("   -a      : print descriptor for the usb(VID:PID)\n");

    return;  
 
}
 

//将char类型（0-255）的buf转换成以十六进制显示的字符串。
//使用这个函数可以避免多次循环调用printf("%x", buf[i]); 提高效率，并且能避免线程切换造成输出乱序的问题。
//buf={'1', '2', '3', 'a', 'b', 'c'} -> "0x31 0x32 0x33 0x61 0x62 0x63"
//buf={0,1,2,3} -> "0x00 0x01 0x02 0x03"
void hex2str(uchar *dest, uchar *src, ushort nLen)
{
    int i;

    for (i=0; i<nLen; i++)
    {
        sprintf(dest+5*i, "%#04x ", src[i]);    //string类函数，不会造成线程切换
    }

    dest[nLen*5] = '\0';
}


//十六进制数字字符串转数字（十六进制）
// "0x1234" -> 0x1234   or "1234" -> 0x1234
int str2hex(char *hex) 
{
    int sum = 0;
    int tmp = 0;
    char hex_str[5];

    if(strlen(hex) == 6)    //0x1234
        memcpy(hex_str, &hex[2], 4);
    else
        memcpy(hex_str, hex, 4);

    for(int i = 0; i < 4; i++)
    {
        tmp = hex_str[i] - (((hex_str[i] >= '0') && (hex_str[i] <= '9')) ? '0' : \
            ((hex_str[i] >= 'A') && (hex_str[i] <= 'Z')) ? 'A' - 10 : 'a' - 10);
        sum += tmp * pow(16, 3-i);
    }

    return sum;
}



//将接收到数据保存到文件中
int save_to_file(FILE *file_stream, uchar *data, int length)
{
    int write_num;
    write_num = fwrite(data, 1, length, file_stream);
    fputc('\n', file_stream);   //为每段数据换行，方便查看
    fflush(file_stream);

    return write_num;

}



void print_devs(libusb_device **devs)
{
    libusb_device *dev;
    int i = 0, j = 0;
    uint8_t path[8]; 
    libusb_device_handle *handle = NULL;
    char string[256];

    while ((dev = devs[i++]) != NULL) {
        struct libusb_device_descriptor desc;
        int r = libusb_get_device_descriptor(dev, &desc);
        if (r < 0) {
            printf("failed to get device descriptor\n");
            return;
        }

        printf("bus: %03d device: %03d, VID: %04x PID: %04x", 
            libusb_get_bus_number(dev), libusb_get_device_address(dev), desc.idVendor, desc.idProduct);

        int ret = libusb_open(dev, &handle);
        if (LIBUSB_SUCCESS == ret) {
            if (desc.iProduct) {
                ret = libusb_get_string_descriptor_ascii(handle, desc.iProduct, string, sizeof(string));    //显示产品信息
                if (ret > 0)   
                    printf(", %s", string);
            }

        }
        printf("\n");

        if (handle)
            libusb_close(handle);

    }
}

//列出系统所有的USB设备.
//包括：bus number. device number, vid, pid, product info
int list_devices(void)
{
    libusb_device **devs;
    int r;
    ssize_t cnt;

    r = libusb_init(NULL);
    if (r < 0)
        return r;

    cnt = libusb_get_device_list(NULL, &devs);
    if (cnt < 0)
        return (int) cnt;

    print_devs(devs);
    libusb_free_device_list(devs, 1);

    libusb_exit(NULL);
    return 0;   
}



void print_endpoint(const struct libusb_endpoint_descriptor *endpoint)
{
    int i, ret;

    printf("      Endpoint descriptor:\n");
    printf("        bEndpointAddress: %02xh\n", endpoint->bEndpointAddress);
    printf("        bmAttributes:     %02xh\n", endpoint->bmAttributes);
    printf("        wMaxPacketSize:   %d\n", endpoint->wMaxPacketSize);
    printf("        bInterval:        %d\n", endpoint->bInterval);
    printf("        bRefresh:         %d\n", endpoint->bRefresh);
    printf("        bSynchAddress:    %d\n", endpoint->bSynchAddress);

}

void print_altsetting(const struct libusb_interface_descriptor *interface)
{
    int i;

    printf("    Interface descriptor:\n");
    printf("      bInterfaceNumber:   %d\n", interface->bInterfaceNumber);
    printf("      bAlternateSetting:  %d\n", interface->bAlternateSetting);
    printf("      bNumEndpoints:      %d\n", interface->bNumEndpoints);
    printf("      bInterfaceClass:    %d\n", interface->bInterfaceClass);
    printf("      bInterfaceSubClass: %d\n", interface->bInterfaceSubClass);
    printf("      bInterfaceProtocol: %d\n", interface->bInterfaceProtocol);
    printf("      iInterface:         %d\n", interface->iInterface);

    for (i = 0; i < interface->bNumEndpoints; i++)
        print_endpoint(&interface->endpoint[i]);
}


void print_interface(const struct libusb_interface *interface)
{
    int i;

    for (i = 0; i < interface->num_altsetting; i++)
        print_altsetting(&interface->altsetting[i]);
}

void print_configuration(struct libusb_config_descriptor *config)
{
    int i;

    printf("  Configuration descriptor:\n");
    printf("    wTotalLength:         %d\n", config->wTotalLength);
    printf("    bNumInterfaces:       %d\n", config->bNumInterfaces);
    printf("    bConfigurationValue:  %d\n", config->bConfigurationValue);
    printf("    iConfiguration:       %d\n", config->iConfiguration);
    printf("    bmAttributes:         %02xh\n", config->bmAttributes);
    printf("    MaxPower:             %d\n", config->MaxPower);

    for (i = 0; i < config->bNumInterfaces; i++)
        print_interface(&config->interface[i]);
}


void print_device(libusb_device *dev, struct libusb_device_descriptor *desc)
{
    int i;

    printf("Device descriptor:\n");
    printf("  bDescriptorType:         %d\n", desc->bDescriptorType);
    printf("  bcdUSB:                  %#06x\n", desc->bcdUSB);
    printf("  bDeviceClass:            %d\n", desc->bDeviceClass);
    printf("  bDeviceSubClass:         %d\n", desc->bDeviceSubClass);
    printf("  bDeviceProtocol:         %d\n", desc->bDeviceProtocol);
    printf("  bMaxPacketSize0:         %d\n", desc->bMaxPacketSize0);
    printf("  idVendor:                %#06x\n", desc->idVendor);
    printf("  idProduct:               %#06x\n", desc->idProduct);
    printf("  bNumConfigurations:      %d\n", desc->bNumConfigurations);


    for (i = 0; i < desc->bNumConfigurations; i++) {
        struct libusb_config_descriptor *config;
        int ret = libusb_get_config_descriptor(dev, i, &config);
        if (LIBUSB_SUCCESS != ret) {
            printf("Couldn't retrieve descriptors\n");
            continue;
        }

        print_configuration(config);
        libusb_free_config_descriptor(config);
    }
}


//打印USB设备的描述符
int print_descriptor(libusb_device *dev)
{
    struct libusb_device_descriptor desc;
    int ret, i;

    ret = libusb_get_device_descriptor(dev, &desc);
    if (ret < 0) {
        printf("failed to get device descriptor\n");
        return -1;
    }

    print_device(dev, &desc);       

}


//根据VID:PID，打印特定USB设备的描述符
int get_descriptor_with_vid_pid(int vid, int pid)
{
    libusb_device **devs;
    libusb_device *found = NULL;
    libusb_device *dev;
    ssize_t cnt;
    int r, i;

    r = libusb_init(NULL);
    if (r < 0)
        return -1;

    cnt = libusb_get_device_list(NULL, &devs);
    if (cnt < 0)
        return -1;

    while ((dev = devs[i++]) != NULL) {
        struct libusb_device_descriptor desc;
        r = libusb_get_device_descriptor(dev, &desc);
        if (r < 0)
            return -1;
        if (desc.idVendor == vid && desc.idProduct == pid) {
            found = dev;
            break;
        }
    }

    print_descriptor(found);

    libusb_free_device_list(devs, 1);

    libusb_exit(NULL);
    return 0;    
}


//ctrl+c 信号处理函数
void sigint_handler(int sig)
{
    if(g_file_stream)
        fclose(g_file_stream);

    printf("\nlibusb test quit.\n");
    exit(0);
}



int main(int argc, char **argv) 
{  
    int r;  
    int opt;
    int test_mode;
    int vid, pid;
    int send_length;

    libusb_context *ctx = NULL;

    struct sigaction act;
   
    pthread_t bulk_rev_thread_id;
    pthread_t int_rev_thread_id;
    pthread_t usb_monitor_thread_id;
    
    test_mode = BULK_TEST;
    vid = VID;
    pid = PID;
    g_file_save_en = 0;
    g_send_flag = 0;

    act.sa_handler = sigint_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, NULL);
   
    //命令行参数解析
    while((opt = getopt(argc, argv, "bif::hv:p:la")) != -1)
    {
        switch(opt)
        {
            case 'b' :
                test_mode = BULK_TEST;
                break;
            case 'i' :
                test_mode = INT_TEST;
                break;
            case 'f' :
                g_file_stream = fopen(optarg == NULL ? SAVE_FILE_PATH : optarg, "wb");    //写打开，并将文件长度截为0，没有则新建
                if(g_file_stream)  
                    g_file_save_en = 1;
                else
                    perror("file open faild: ");    
                break;                
            case 'v' :
                vid = str2hex(optarg);
                break;
            case 'p' :
                pid = str2hex(optarg);
                break;
            case 'l' :
                list_devices();
                exit(0);
                break; 
            case 'a' :
                get_descriptor_with_vid_pid(vid, pid);
                exit(0);
                break;                                               
            case 'h' :
                help();
                return 0;
                break;
            default  :
                printf("unkonw option.\n");
                help();
                return 0;
        }
    }


    printf("\nlibusb test\n");
    if(test_mode == BULK_TEST)
        printf("test bulk transfer\n");
    else if(test_mode == INT_TEST)
        printf("test interrupt transfer\n");
    else{
        printf("unkonw test mode.\n");
        return 0;
    }
    printf("usb device: VID:%#06x PID:%#06x\n\n", vid, pid);    //#:输出0x，06:vid或pid第一个数字为0时，输出0x0471而不是0x471

    r = sem_init(&print_sem, 0, 0); //初始化信号量，用于解决多线程下printf输出乱序的问题
    if(r != 0)
        perror("sem_init faild: ");

    r = libusb_init(&ctx); //initialize the library for the session we just declared  
    if(r < 0) {  
        printf("libusb init faild, err:%s\n", libusb_error_name(r)); //there was an error  
        return -1;  
    } 

    libusb_set_debug(ctx, LIBUSB_LOG_LEVEL_WARNING); 

    if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) {
        printf("hotplug capabilites are not supported on this platform.\n");
        libusb_exit (NULL);
        return -1;
    }

    r = libusb_hotplug_register_callback(ctx, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_NO_FLAGS, vid, pid, LIBUSB_HOTPLUG_MATCH_ANY, usb_event_callback, NULL, NULL);
    if (LIBUSB_SUCCESS != r) {
        printf("error registering callback: %s\n", libusb_error_name(r));
        libusb_exit(ctx);
        return -1;
    }   
    
    dev_handle = libusb_open_device_with_vid_pid(ctx, vid, pid);  //open a usb device with VID&PID
    if(dev_handle == NULL)  {
        printf("cannot open device\n");  
        return -1;
    }
    else  
        printf("usb device opened.\n");  
  
    r = libusb_kernel_driver_active(dev_handle, 0);
    if(r == 0)  //ok
        ;
    else if(r == 1) { 
        printf("Kernel driver is active, now try detached\n");  
        if(libusb_detach_kernel_driver(dev_handle, 0) == 0) //detach it  
            printf("Kernel driver is detached!\n");
        else{
            printf("libusb_detach_kernel_driver, err:%s\n", libusb_error_name(r));
            return -1;
        }  
    }
    else{
        printf("libusb_kernel_driver_active, err:%s\n", libusb_error_name(r));
        return -1;
    } 

    r = libusb_claim_interface(dev_handle, 0); //claim interface 0 ,stm32采用接口0
    if(r < 0) {  
        printf("cannot claim interface, err:%s\n", libusb_error_name(r));
        return -1;  
    }  

    //热插拔监听
   r = pthread_create(&usb_monitor_thread_id, 0, usb_monitor_thread, 0); 
    if(r != 0 )
    {
        perror("usb_monitor_thread creation faild\n");
    } 

    //new thread,usb rev data
    if(test_mode == BULK_TEST){
        r = pthread_create(&bulk_rev_thread_id, NULL, bulk_rev_thread, NULL);
        if(r != 0 )
        {
            perror("thread creation faild\n");
        }
    }
    else if(test_mode == INT_TEST){
        r = pthread_create(&int_rev_thread_id, NULL, interrupt_rev_thread, NULL);
        if(r != 0 )
        {
            perror("thread creation faild\n");
        }       
    }


    while(1)
    {
        usleep(10 * 1000);
        printf("\ninput data to send or command:");

        memset(send_buf, 0, SEND_BUFF_LEN);
        fgets(send_buf, SEND_BUFF_LEN, stdin);
        send_length = strlen(send_buf)-1;
        send_buf[send_length] = '\0' ;   //将读入的换行符转为\0

        //用于快捷发送数据，如输入test64，会自动发送64字节数据，输入test100则会自动发送100字节数据
        if(strncmp(send_buf, "test", 4) == 0){
            send_length = atoi(&send_buf[4]);
            if(send_length > strlen(test_bytes)){
                printf("send_length:%d should less than max_length:%ld\n", send_length, strlen(test_bytes));
                continue;
            }
            printf("test sending %d bytes.\n", send_length);
            memcpy(send_buf, test_bytes, send_length);
        }

        if(test_mode == BULK_TEST)
            bulk_send(send_buf, send_length);
        else if(test_mode == INT_TEST)
            interrupt_send(send_buf, send_length);
        else
            ;
    }  
     
}