基于libusb的无驱设计

http://www.rosoo.net/a/201004/9297.html
 
使用libusb之前你的linux系统必须装有usb文件系统，这里还介绍了使用hiddev设备文件来访问设备，目的在于不仅可以比较出usb的易用性，还提供了一个转化成libusb驱动的案例。

Libusb库的使用
 
使用libusb之前你的linux系统必须装有usb文件系统，这里还介绍了使用hiddev设备文件来访问设备，目的在于不仅可以比较出usb的易用性，还提供了一个转化成libusb驱动的案例。
3.1 find设备
 
任何驱动第一步首先是寻找到要操作的设备，我们先来看看HID驱动是怎样寻找到设备的。我们假设寻找设备的函数Device_Find(注：代码只是为了方便解说，不保证代码的健全)
 
  1. /* 我们简单看一下使用hid驱动寻找设备的实现，然后在看一下libusb是如何寻找设备的 */ 
  2. int Device_Find()  
  3. {  
  4.     char dir_str[100];   /* 这个变量我们用来保存设备文件的目录路径 */ 
  5.     char hiddev[100];    /* 这个变量用来保存设备文件的全路径 */ 
  6. DIR dir;                
  7.    
  8. /* 申请的字符串数组清空，这个编程习惯要养成 */ 
  9. memset (dir_str, 0 , sizeof(dir_str));  
  10. memset (hiddev, 0 , sizeof(hiddev));  
  11.    
  12.     /* hiddev 的设备描述符不在/dev/usb/hid下面，就在/dev/usb 下面  
  13. 这里我们使用opendir函数来检验目录的有效性  
  14. 打开目录返回的值保存在变量dir里，dir前面有声明  
  15. */ 
  16. dir=opendir("/dev/usb/hid");  
  17.     if(dir){  
  18.         /* 程序运行到这里，说明存在 /dev/usb/hid 路径的目录 */ 
  19.         sprintf(dir_str,"/dev/usb/hid/");  
  20.         closedir(dir);  
  21.     }else{  
  22.         /* 如果不存在hid目录，那么设备文件就在/dev/usb下 */ 
  23.         sprintf(dir_str,"/dev/usb/");  
  24.     }  
  25.    
  26.     /* DEVICE_MINOR 是指设备数，HID一般是16个 */ 
  27. for(i = 0; i < DEVICE_MINOR; i++) {  
  28.     /* 获得全路径的设备文件名，一般hid设备文件名是hiddev0 到 hiddev16 */ 
  29.         sprintf(hiddev, "%shiddev%d", dir_str,i);  
  30.    
  31.        /* 打开设备文件,获得文件句柄 */ 
  32.        fd = open(hiddev, O_RDWR);  
  33.        if(fd > 0) {  
  34.    
  35.            /* 操作设备获得设备信息 */ 
  36.           ioctl(fd, HIDIOCGDEVINFO, &info);  
  37.      
  38.               /* VENDOR_ID 和 PRODUCT_ID 是标识usb设备厂家和产品ID,
  39. 驱动都需要这两个参数来寻找设备,到此我们寻找到了设备 */ 
  40.            if(info.vendor== VENDOR_ID && info.product== PRODUCT_ID) {  
  41.                 /* 这里添加设备的初始化代码 */ 
  42.                     
  43.    
  44.                device_num++;   /* 找到的设备数 */ 
  45.            }  
  46.            close(fd);  
  47.        }  
  48.     }  
  49.     return device_num;         /* 返回寻找的设备数量 */ 
  50. } 
 
我们再来看libusb是如何来寻找和初始化设备
 
 
  1. int Device_Find()  
  2. {  
  3. struct usb_bus             *busses;  
  4.    
  5.     int                           device_num = 0;  
  6.    
  7.     device_num = 0;       /* 记录设备数量 */ 
  8.      
  9.     usb_init();            /* 初始化 */ 
  10.     usb_find_busses();   /* 寻找系统上的usb总线 */ 
  11.     usb_find_devices(); /* 寻找usb总线上的usb设备 */ 
  12.      
  13.     /* 获得系统总线链表的句柄 */ 
  14. busses = usb_get_busses();  
  15.    
  16.     struct usb_bus       *bus;  
  17.     /* 遍历总线 */ 
  18.     for (bus = busses; bus; bus = bus->next) {  
  19.         struct usb_device *dev;  
  20.         /* 遍历总线上的设备 */ 
  21.         for (dev = bus->devices; dev; dev = dev->next) {  
  22.    
  23.            /* 寻找到相关设备， */
  24. if(dev->descriptor.idVendor==VENDOR_ID&& dev->descriptor.idProduct == PRODUCT_ID){
  25.                 /* 这里添加设备的初始化代码 */ 
  26.                     
  27.                device_num++;   /* 找到的设备数 */ 
  28. }                
  29.         }         
  30.     }  
  31.     return device_num;        /* 返回设备数量 */ 
  32. } 
 
注：在新版本的libusb中，usb_get_busses就可以不用了 ，这个函数是返回系统上的usb总线链表句柄
这里我们直接用usb_busses变量，这个变量在usb.h中被定义为外部变量
所以可以直接写成这样：
  1. struct usb_bus    *bus;  
  2.         for (bus = usb_busses; bus; bus = bus->next) {  
  3.                struct usb_device *dev;  
  4.         for (dev = bus->devices; dev; dev = dev->next) {  
  5.            /* 这里添加设备的初始化代码 */ 
  6.         }  
  7. } 
3.2 打开设备
 
假设我们定义的打开设备的函数名是device_open,
 
 
  1. /* 使用hid驱动打开设备 */ 
  2. int Device_Open()  
  3. {  
  4.     int handle;  
  5.     /* 传统HID驱动调用,通过open打开设备文件就可 */ 
  6. handle = open(“hiddev0”, O_RDONLY);  
  7. }  
  8.    
  9. /* 使用libusb打开驱动 */ 
  10.    
  11. int Device_Open()  
  12. {  
  13. /* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 */ 
  14. struct usb_device*    udev;  
  15. usb_dev_handle*        device_handle;  
  16.    
  17.    
  18. /* 当找到设备后，通过usb_open打开设备，这里的函数就相当open 函数 */ 
  19. device_handle = usb_open(udev);  
  20. } 
3.3 读写设备和操作设备
假设我们的设备使用控制传输方式，至于批处理传输和中断传输限于篇幅这里不介绍
我们这里定义三个函数，Device_Write, Device_Read, Device_Report
Device_Report 功能发送接收函数
Device_Write 功能写数据
Device_Read   功能读数据
 
Device_Write和Device_Read调用Device_Report发送写的信息和读的信息，开发者根据发送的命令协议来设计，我们这里只简单实现发送数据的函数。
 
假设我们要给设备发送72字节的数据，头8个字节是报告头，是我们定义的和设备相关的规则，后64位是数据。
 
HID驱动的实现(这里只是用代码来有助理解，代码是伪代码)
 
  1. int Device_Report(int fd, unsigned char *buffer72)  
  2. {  
  3. int       ret; /* 保存ioctl函数的返回值 */ 
  4. int      index;  
  5.     unsigned char send_data[72]; /* 发送的数据 */ 
  6. unsigned char recv_data[72]; /* 接收的数据 */ 
  7.     struct hiddev_usage_ref uref; /* hid驱动定义的数据包 */ 
  8.     struct hiddev_report_info rinfo; /* hid驱动定义的  
  9.    
  10.     memset(send_data, 0, sizeof(send_data));  
  11. memset(recv_data, 0, sizeof(recv_data));  
  12.    
  13.     memcpy(send_data, buffer72, 72);  
  14.    /* 这在发送数据之前必须调用的，初始化设备 */ 
  15.     ret = ioctl(fd, HIDIOCINITREPORT, 0);  
  16.     if( ret !=0) {  
  17.         return NOT_OPENED_DEVICE;/* NOT_OPENED_DEVICE 属于自己定义宏 */ 
  18.     }  
  19.     /* HID设备每次传输一个字节的数据包 */ 
  20.     for(index = 0; index < 72; index++) {  
  21.         /* 设置发送数据的状态 */ 
  22.     uref.report_type = HID_REPORT_TYPE_FEATURE;  
  23.     uref.report_id = HID_REPORT_ID_FIRST;  
  24.     uref.usage_index = index;  
  25.     uref.field_index = 0;  
  26.     uref.value = send_data[index];  
  27.     ioctl(fd, HIDIOCGUCODE, &uref);  
  28.     ret=ioctl(fd, HIDIOCSUSAGE, &uref);  
  29.     if(ret != 0 ){  
  30.            return UNKNOWN_ERROR;  
  31.     }  
  32. }  
  33. /* 发送数据 */ 
  34. rinfo.report_type = HID_REPORT_TYPE_FEATURE;  
  35. rinfo.report_id = HID_REPORT_ID_FIRST;  
  36. rinfo.num_fields = 1;  
  37. ret=ioctl(fd, HIDIOCSREPORT, &rinfo);   /* 发送数据 */ 
  38. if(ret != 0) {  
  39.         return WRITE_REPORT;  
  40. }  
  41.    
  42. /* 接受数据 */ 
  43. ret = ioctl(fd, HIDIOCINITREPORT, 0);  
  44. for(index = 0; index < 72; index++) {  
  45.     uref.report_type = HID_REPORT_TYPE_FEATURE;  
  46.     uref.report_id = HID_REPORT_ID_FIRST;  
  47.     uref.usage_index = index;  
  48.     uref.field_index = 0;  
  49.     ioctl(fd, HIDIOCGUCODE, &uref);  
  50.     ret = ioctl(fd, HIDIOCGUSAGE, &uref);  
  51.     if(ret != 0 ) {  
  52.         return UNKNOWN_ERROR;  
  53.     }  
  54.     recv_data[index] = uref.value;  
  55. }  
  56.    
  57. memcpy(buffer72, recv_data, 72);  
  58.    
  59. return SUCCESS;  
  60. } 
libusb驱动的实现
 
  1. int Device_Report(int fd, unsigned char *buffer72)  
  2. {  
  3.     /* 定义设备句柄 */ 
  4.     usb_dev_handle* Device_handle;  
  5.      
  6.     /* save the data of send and receive */ 
  7.     unsigned char   send_data[72];  
  8.     unsigned char   recv_data[72];  
  9.      
  10.     int              send_len;  
  11.     int             recv_len;  
  12.      
  13.     /* 数据置空 */ 
  14.     memset(send_data, 0 , sizeof(send_data));  
  15.     memset(recv_data, 0 , sizeof(recv_data));  
  16.      
  17.     /* 这里的g_list是全局的数据变量，里面可以存储相关设备的所需信息，
  18. 当然我们 也可以从函数形参中传输进来，设备的信息在打开设备时初始化
  19. ，我们将在后面的总结中详细描述一下 */ 
  20.     Device_handle = (usb_dev_handle*)(g_list[fd].device_handle);  
  21.     if (Device_handle == NULL) {  
  22.         return NOT_OPENED_DEVICE;  
  23. }  
  24.    
  25. /* 这个函数前面已经说过，在操作设备前是必须调用的, 0是指用默认的设备 */ 
  26. usb_claim_interface(Device_handle, 0);  
  27.    
  28. /* 发送数据，所用到的宏定义在usb.h可以找到，我列出来大家看一下  
  29.         #define USB_ENDPOINT_OUT       0x00  
  30.        #define USB_TYPE_CLASS     (0x01 << 5)  
  31.        #define USB_RECIP_INTERFACE 0x01  
  32.         
  33.        #define HID_REPORT_SET       0x09 */ 
  34. send_len = usb_control_msg(Device_handle,  
  35. USB_ENDPOINT_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,  
  36.                                HID_REPORT_SET,  
  37.                                0x300,  
  38.                                0,  
  39.                                send_data, 72, USB_TIMEOUT);  
  40.    
  41. /* 发送数据有错误 */ 
  42. if (send_len < 0) {  
  43.         return WRITE_REPORT;  
  44. }  
  45.    
  46. if (send_len != 72) {  
  47.         return send_len;  
  48. }  
  49.    
  50. /* 接受数据  
  51.        #define USB_ENDPOINT_IN         0x80  
  52.        #define USB_TYPE_CLASS          (0x01 << 5)  
  53.        #define USB_RECIP_INTERFACE        0x01  
  54.        #define HID_REPORT_GET          0x01  
  55.     */ 
  56. recv_len = usb_control_msg(Device_handle,  
  57. USB_ENDPOINT_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE,  
  58.                                HID_REPORT_GET,  
  59.                                0x300,  
  60.                                  0,  
  61.                                recv_data, 72, USB_TIMEOUT);  
  62.                                                      
  63.     if (recv_len < 0) {  
  64.         printf("failed to retrieve report from USB device!\n");  
  65.         return READ_REPORT;  
  66.     }  
  67.      
  68.     if (recv_len != 72) {  
  69.         return recv_len;  
  70.     }  
  71.      
  72.      
  73.     /* 和usb_claim_interface对应 */ 
  74.     usb_release_interface(RY2_handle, 0);  
  75.     memcpy(buffer72, recv_data, 72);  
  76.    
  77. return SUCCESS;  
  78. } 
 
3.4 关闭设备
假设我们定义的关闭设备的函数名是Device_Close()
 
  1. /* 使用hid驱动关闭设备 */ 
  2. int Device_Close()  
  3. {  
  4.     int handle;  
  5.      
  6. handle = open(“hiddev0”, O_RDONLY);  
  7. /* 传统HID驱动调用,通过close()设备文件就可 */ 
  8.    
  9. close( handle );  
  10. }  
  11.    
  12. /* 使用libusb关闭驱动 */ 
  13. int Device_Close()  
  14. {  
  15. /* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 */ 
  16. struct usb_device*    udev;  
  17. usb_dev_handle*        device_handle;  
  18.    
  19. device_handle = usb_open(udev);  
  20.    
  21. /* libusb库使用usb_close关闭程序 */ 
  22. usb_close(device_handle);  
  23. } 
libusb的驱动框架
前面我们看了些主要的libusb函数的使用，这里我们把前面的内容归纳下：
一般的驱动应该都包含如下接口：
Device_Find(); /* 寻找设备接口 */
Device_Open(); /* 打开设备接口 */
Device_Write(); /* 写设备接口 */
Device_Read(); /* 读设备接口 */
Device_Close(); /* 关闭设备接口 */
 
具体代码如下：
 
  1. #include <usb.h>  
  2. /* usb.h这个头文件是要包括的，里面包含了必须要用到的数据结构 */ 
  3.    
  4. /* 我们将一个设备的属性用一个结构体来概括 */ 
  5. typedef struct 
  6. {  
  7.     struct usb_device*    udev;  
  8.     usb_dev_handle*        device_handle;  
  9.     /* 这里可以添加设备的其他属性，这里只列出每个设备要用到的属性 */ 
  10. } device_descript;  
  11.    
  12. /* 用来设置传输数据的时间延迟 */ 
  13. #define USB_TIMEOUT     10000  
  14.    
  15. /* 厂家ID 和产品 ID */ 
  16. #define VENDOR_ID    0xffff      
  17. #define PRODUCT_ID   0xffff  
  18.    
  19. /* 这里定义数组来保存设备的相关属性，DEVICE_MINOR可以设置能够同
  20. 时操作的设备数量，用全局变量的目的在于方便保存属性 */ 
  21. #define DEVICE_MINOR 16  
  22. int     g_num;  
  23. device_descript g_list[ DEVICE_MINOR ];  
  24.    
  25. /* 我们写个设备先找到设备，并把相关信息保存在 g_list 中 */ 
  26. int Device_Find()  
  27. {  
  28.     struct usb_bus       *bus;  
  29.     struct usb_device *dev;  
  30.    
  31.     g_num = 0;  
  32.     usb_find_busses();  
  33.     usb_find_devices();  
  34.      
  35.     /* 寻找设备 */ 
  36.     for (bus = usb_busses; bus; bus = bus->next) {  
  37.         for (dev = bus->devices; dev; dev = dev->next) {  
  38. if(dev->descriptor.idVendor==VENDOR_ID&& dev->descriptor.idProduct == PRODUCT_ID) {  
  39.                     /* 保存设备信息 */ 
  40.                     if (g_num < DEVICE_MINOR) {  
  41.                      g_list[g_num].udev = dev;    
  42.                      g_num ++;  
  43.                      }                
  44.             }         
  45.         }  
  46.     }  
  47.     return g_num;  
  48. }  
  49. /* 找到设备后，我们根据信息打开设备 */ 
  50. int Device_Open()  
  51. {  
  52.     /* 根据情况打开你所需要操作的设备，这里我们仅列出伪代码 */ 
  53.     if(g_list[g_num].udev != NULL) {  
  54.         g_list[g_num].device_handle = usb_open(g_list[g_num].udev);  
  55. }  
  56. }  
  57. /* 下面就是操作设备的函数了，我们就不列出来拉，大家可以参考上面的介绍 */ 
  58. int DeviceWite(int handle)  
  59. {  
  60.     /* 填写相关代码，具体查看设备协议*/ 
  61. }  
  62. int DeviceOpen(int handle)  
  63. {  
  64.     /* 填写相关代码，具体查看设备协议 */ 
  65. }  
  66. /* 最后不要忘记关闭设备 */ 
  67. void Device_close(int handle)  
  68. {  
  69.     /* 调用usb_close */ 
  70. } 
小结
 

   到此，使用libusb进行驱动开发介绍完了，通过对库所提供的API的使用可以体会到libusb的易用性。 

(chenzhuoyou)
 

 

本站文章除注明转载外，均为本站原创或编译欢迎任何形式的转载，但请务必注明出处，尊重他人劳动，同学习共成长。转载请注明：文章转载自：罗索实验室 [http://www.rosoo.net/a/201004/9297.html]
posted @ 2013-03-04 08:19  绿萼梅  阅读(108)  评论(0)    收藏  举报