libusb的使用教程和例子

墨蓝 2022-05-19 23:58 225阅读 0赞

驱动开发向来是内核开发中工作量最多的一块，随着USB设备的普及，大量的USB设备的驱动开发也成为驱动开发者手头上做的最多的事情。本文主要介绍 Linux平台下基于libusb的驱动开发，希望能够给从事Linux驱动开发的朋友带来些帮助，更希望能够给其他平台上的无驱设计带来些帮助。文章是我在工作中使用libusb的一些总结，难免有错误，如有不当的地方，还请指正。

Linux 平台上的usb驱动开发，主要有内核驱动的开发和基于libusb的无驱设计。

对于内核驱动的大部分设备，诸如带usb接口的hid设备，linux本身已经自带了相关的驱动，我们只要操作设备文件便可以完成对设备大部分的操作，而另外一些设备，诸如自己设计的硬件产品，这些驱动就需要我们驱动工程师开发出相关的驱动了。内核驱动有它的优点，然而内核驱动在某些情况下会遇到如下的一些问题：

1 当使用我们产品的客户有2.4内核的平台，同时也有2.6内核的平台，我们要设计的驱动是要兼容两个平台的，就连makefile 我们都要写两个。

2 当我们要把linux移植到嵌入平台上，你会发现原先linux自带的驱动移过去还挺大的，我的内核当然是越小越好拉，这样有必要么。这还不是最郁闷的地方，如果嵌入平台是客户的，客户要购买你的产品，你突然发现客户设备里的系统和你的环境不一样，它没有你要的驱动了，你的程序运行不了，你会先想：“没关系，我写个内核驱动加载一下不就行了“。却发现客户连insmod加载模块的工具都没移植，那时你就看看老天，说声我怎么那么倒霉啊，客户可不想你动他花了n时间移植的内核哦

3 花了些功夫写了个新产品的驱动，挺有成就感啊，代码质量也是相当的有水准啊。正当你沉醉在你的代码中时，客服不断的邮件来了，“客户需要2.6.5内核的驱动，config文件我已经发你了” “客户需要双核的 2.6.18-smp 的驱动” “客户的平台是自己定制的是2.6.12-xxx “ 你恨不得把驱动的源代码给客户，这样省得编译了。你的一部分工作时间编译内核，定制驱动

有问题产生必然会有想办法解决问题的人， libusb的出现给我们带来了某些方便，即节约了我们的时间，也降低了公司的成本。 所以在一些情况下，就可以考虑使用libusb的无驱设计了。

下面我们就来详细讨论一下libusb, 并以写一个hid设备的驱动来讲解如何运用libusb,至于文章中涉及的usb协议的知识，限于篇幅，就不详细讲解了，相关的可自行查看usb相关协议。

一 libusb 介绍

libusb 设计了一系列的外部API 为应用程序所调用，通过这些API应用程序可以操作硬件，从libusb的源代码可以看出，这些API 调用了内核的底层接口，和kernel driver中所用到的函数所实现的功能差不多，只是libusb更加接近USB 规范。使得libusb的使用也比开发内核驱动相对容易的多。

Libusb 的编译安装请查看Readme,这里不做详解

二 libusb 的外部接口

2.1 初始化设备接口

这些接口也可以称为核心函数，它们主要用来初始化并寻找相关设备。

usb\_init

函数定义： void usb\_init(void);

从函数名称可以看出这个函数是用来初始化相关数据的，这个函数大家只要记住必须调用就行了，而且是一开始就要调用的.

usb\_find\_busses

函数定义： int usb\_find\_busses(void);

寻找系统上的usb总线，任何usb设备都通过usb总线和计算机总线通信。进而和其他设备通信。此函数返回总线数。

usb\_find\_devices

函数定义： int usb\_find\_devices(void);

寻找总线上的usb设备，这个函数必要在调用usb\_find\_busses()后使用。以上的三个函数都是一开始就要用到的，此函数返回设备数量。

usb\_get\_busses

函数定义： struct usb\_bus \*usb\_get\_busses(void);

这个函数返回总线的列表，在高一些的版本中已经用不到了，这在下面的实例中会有讲解

2.2 操作设备接口

usb\_open

函数定义： usb\_dev\_handle \*usb\_open(struct \*usb\_device dev);

打开要使用的设备，在对硬件进行操作前必须要调用usb\_open 来打开设备，这里大家看到有两个结构体 usb\_dev\_handle 和 usb\_device 是我们在开发中经常碰到的，有必要把它们的结构看一看。在libusb 中的usb.h和usbi.h中有定义。

这里我们不妨理解为返回的 usb\_dev\_handle 指针是指向设备的句柄，而行参里输入就是需要打开的设备。

usb\_close

函数定义： int usb\_close(usb\_dev\_handle \*dev);

与usb\_open相对应，关闭设备，是必须调用的, 返回0成功，<0 失败。

usb\_set\_configuration

函数定义： int usb\_set\_configuration(usb\_dev\_handle \*dev, int configuration);

设置当前设备使用的configuration，参数configuration 是你要使用的configurtation descriptoes中的bConfigurationValue, 返回0成功，<0失败( 一个设备可能包含多个configuration,比如同时支持高速和低速的设备就有对应的两个configuration,详细可查看usb标准)

usb\_set\_altinterface

函数定义： int usb\_set\_altinterface(usb\_dev\_handle \*dev, int alternate);

和名字的意思一样，此函数设置当前设备配置的interface descriptor，参数alternate是指interface descriptor中的bAlternateSetting。返回0成功，<0失败

usb\_resetep

函数定义： int usb\_resetep(usb\_dev\_handle \*dev, unsigned int ep);

复位指定的endpoint，参数ep 是指bEndpointAddress,。这个函数不经常用，被下面介绍的usb\_clear\_halt函数所替代。

usb\_clear\_halt

函数定义： int usb\_clear\_halt (usb\_dev\_handle \*dev, unsigned int ep);

复位指定的endpoint，参数ep 是指bEndpointAddress。这个函数用来替代usb\_resetep

usb\_reset

函数定义： int usb\_reset(usb\_dev\_handle \*dev);

这个函数现在基本不怎么用，不过这里我也讲一下，和名字所起的意思一样，这个函数reset设备，因为重启设备后还是要重新打开设备，所以用usb\_close就已经可以满足要求了。

usb\_claim\_interface

函数定义： int usb\_claim\_interface(usb\_dev\_handle \*dev, int interface);

注册与操作系统通信的接口，这个函数必须被调用，因为只有注册接口，才能做相应的操作。

Interface 指 bInterfaceNumber. (下面介绍的usb\_release\_interface 与之相对应，也是必须调用的函数)

usb\_release\_interface

函数定义： int usb\_release\_interface(usb\_dev\_handle \*dev, int interface);

注销被usb\_claim\_interface函数调用后的接口，释放资源，和usb\_claim\_interface对应使用。

2.3 控制传输接口

usb\_control\_msg

函数定义：int usb\_control\_msg(usb\_dev\_handle \*dev, int requesttype, int request, int value, int index, char \*bytes, int size, int timeout);

从默认的管道发送和接受控制数据

usb\_get\_string

函数定义： int usb\_get\_string(usb\_dev\_handle \*dev, int index, int langid, char \*buf, size\_t buflen);

usb\_get\_string\_simple

函数定义： int usb\_get\_string\_simple(usb\_dev\_handle \*dev, int index, char \*buf, size\_t buflen);

usb\_get\_descriptor

函数定义： int usb\_get\_descriptor(usb\_dev\_handle \*dev, unsigned char type, unsigned char index, void \*buf, int size);

usb\_get\_descriptor\_by\_endpoint

函数定义： int usb\_get\_descriptor\_by\_endpoint(usb\_dev\_handle \*dev, int ep, unsigned char type, unsigned char index, void \*buf, int size);

2.4 批传输接口

usb\_bulk\_write

函数定义： int usb\_bulk\_write(usb\_dev\_handle \*dev, int ep, char \*bytes, int size, int timeout);

usb\_interrupt\_read

函数定义： int usb\_interrupt\_read(usb\_dev\_handle \*dev, int ep, char \*bytes, int size, int timeout);

2.5 中断传输接口

usb\_bulk\_write

函数定义： int usb\_bulk\_write(usb\_dev\_handle \*dev, int ep, char \*bytes, int size, int timeout);

usb\_interrupt\_read

函数定义： int usb\_interrupt\_read(usb\_dev\_handle \*dev, int ep, char \*bytes, int size, int timeout);

基本上libusb所经常用到的函数就有这些了，和usb协议确实很接近吧。下面我们实例在介绍一个应用。

//----------------===================================

**Libusb库的使用**

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

3.1 find 设备

任何驱动第一步首先是寻找到要操作的设备，我们先来看看HID驱动是怎样寻找到设备的。我们假设寻找设备的函数Device\_Find(注：代码只是为了方便解说，不保证代码的健全)

/\* 我们简单看一下使用hid驱动寻找设备的实现，然后在看一下libusb是如何寻找设备的 \*/

int Device\_Find()

char dir\_str\[100\]; /\* 这个变量我们用来保存设备文件的目录路径 \*/

char hiddev\[100\]; /\* 这个变量用来保存设备文件的全路径 \*/

DIR **dir;**

/\* 申请的字符串数组清空，这个编程习惯要养成 \*/

memset (dir\_str, 0 , sizeof(dir\_str));

memset (hiddev, 0 , sizeof(hiddev));

/\* hiddev 的设备描述符不在/dev/usb/hid下面，就在/dev/usb 下面

这里我们使用opendir函数来检验目录的有效性

打开目录返回的值保存在变量dir里，dir前面有声明

\*/

dir=opendir("/dev/usb/hid");

if(dir)\{

/\* 程序运行到这里，说明存在 /dev/usb/hid 路径的目录 \*/

sprintf(dir\_str,"/dev/usb/hid/");

closedir(dir);

\}else\{

/\* 如果不存在hid目录，那么设备文件就在/dev/usb下 \*/

sprintf(dir\_str,"/dev/usb/");

/\* DEVICE\_MINOR 是指设备数，HID一般是16个 \*/

for(i = 0; i < DEVICE\_MINOR; i++) \{

/\* 获得全路径的设备文件名，一般hid设备文件名是hiddev0 到 hiddev16 \*/

sprintf(hiddev, "%shiddev%d", dir\_str,i);

/\* 打开设备文件,获得文件句柄 \*/

fd = open(hiddev, O\_RDWR);

if(fd > 0) \{

/\* 操作设备获得设备信息 \*/

ioctl(fd, HIDIOCGDEVINFO, &info);

/\* VENDOR\_ID 和 PRODUCT\_ID 是标识usb设备厂家和产品ID,驱动都需要这两个参数来寻找设备,到此我们寻找到了设备 \*/

if(info.vendor== VENDOR\_ID && info.product== PRODUCT\_ID) \{

/\* 这里添加设备的初始化代码 \*/

device\_num++; /\* 找到的设备数 \*/

close(fd);

return device\_num; /\* 返回寻找的设备数量 \*/

我们再来看libusb是如何来寻找和初始化设备

int Device\_Find()

struct usb\_bus \*busses;

int device\_num = 0;

device\_num = 0; /\* 记录设备数量 \*/

usb\_init(); /\* 初始化 \*/

usb\_find\_busses(); /\* 寻找系统上的usb总线 \*/

usb\_find\_devices(); /\* 寻找usb总线上的usb设备 \*/

/\* 获得系统总线链表的句柄 \*/

busses = usb\_get\_busses();

struct usb\_bus \*bus;

/\* 遍历总线 \*/

for (bus = busses; bus; bus = bus->next) \{

struct usb\_device \*dev;

/\* 遍历总线上的设备 \*/

for (dev = bus->devices; dev; dev = dev->next) \{

/\* 寻找到相关设备， \*/

if(dev->descriptor.idVendor==VENDOR\_ID&& dev->descriptor.idProduct == PRODUCT\_ID) \{

/\* 这里添加设备的初始化代码 \*/

device\_num++; /\* 找到的设备数 \*/

return device\_num; /\* 返回设备数量 \*/

注：在新版本的libusb中，usb\_get\_busses就可以不用了 ，这个函数是返回系统上的usb总线链表句柄

这里我们直接用usb\_busses变量，这个变量在usb.h中被定义为外部变量

所以可以直接写成这样：

struct usb\_bus \*bus;

for (bus = usb\_busses; bus; bus = bus->next) \{

struct usb\_device \*dev;

for (dev = bus->devices; dev; dev = dev->next) \{

/\* 这里添加设备的初始化代码 \*/

3.2  打开设备

假设我们定义的打开设备的函数名是device\_open,

/\* 使用hid驱动打开设备 \*/

int Device\_Open()

int handle;

/\* 传统HID驱动调用,通过open打开设备文件就可 \*/

handle = open(“hiddev0”, O\_RDONLY);

/\* 使用libusb打开驱动 \*/

int Device\_Open()

/\* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 \*/

struct usb\_device\* udev;

usb\_dev\_handle\* device\_handle;

/\* 当找到设备后，通过usb\_open打开设备，这里的函数就相当open 函数 \*/

device\_handle = usb\_open(udev);

3.3  读写设备和操作设备

假设我们的设备使用控制传输方式，至于批处理传输和中断传输限于篇幅这里不介绍

我们这里定义三个函数，Device\_Write, Device\_Read, Device\_Report

Device\_Report 功能发送接收函数

Device\_Write 功能写数据

Device\_Read 功能读数据

Device\_Write和Device\_Read调用Device\_Report发送写的信息和读的信息，开发者根据发送的命令协议来设计，我们这里只简单实现发送数据的函数。

假设我们要给设备发送72字节的数据，头8个字节是报告头，是我们定义的和设备相关的规则，后64位是数据。

HID驱动的实现(这里只是用代码来有助理解，代码是伪代码)

int Device\_Report(int fd, unsigned char \*buffer72)

int ret; /\* 保存ioctl函数的返回值 \*/

int index;

unsigned char send\_data\[72\]; /\* 发送的数据 \*/

unsigned char recv\_data\[72\]; /\* 接收的数据 \*/

struct hiddev\_usage\_ref uref; /\* hid驱动定义的数据包 \*/

struct hiddev\_report\_info rinfo; /\* hid驱动定义的

memset(send\_data, 0, sizeof(send\_data));

memset(recv\_data, 0, sizeof(recv\_data));

memcpy(send\_data, buffer72, 72);

/\* 这在发送数据之前必须调用的，初始化设备 \*/

ret = ioctl(fd, HIDIOCINITREPORT, 0);

if( ret !=0) \{

return NOT\_OPENED\_DEVICE;/\* NOT\_OPENED\_DEVICE 属于自己定义宏 \*/

/\* HID设备每次传输一个字节的数据包 \*/

for(index = 0; index < 72; index++) \{

/\* 设置发送数据的状态 \*/

uref.report\_type = HID\_REPORT\_TYPE\_FEATURE;

uref.report\_id = HID\_REPORT\_ID\_FIRST;

uref.usage\_index = index;

uref.field\_index = 0;

uref.value = send\_data\[index\];

ioctl(fd, HIDIOCGUCODE, &uref);

ret=ioctl(fd, HIDIOCSUSAGE, &uref);

if(ret != 0 )\{

return UNKNOWN\_ERROR;

/\* 发送数据 \*/

rinfo.report\_type = HID\_REPORT\_TYPE\_FEATURE;

rinfo.report\_id = HID\_REPORT\_ID\_FIRST;

rinfo.num\_fields = 1;

ret=ioctl(fd, HIDIOCSREPORT, &rinfo); /\* 发送数据 \*/

if(ret != 0) \{

return WRITE\_REPORT;

/\* 接受数据 \*/

ret = ioctl(fd, HIDIOCINITREPORT, 0);

for(index = 0; index < 72; index++) \{

uref.report\_type = HID\_REPORT\_TYPE\_FEATURE;

uref.report\_id = HID\_REPORT\_ID\_FIRST;

uref.usage\_index = index;

uref.field\_index = 0;

ioctl(fd, HIDIOCGUCODE, &uref);

ret = ioctl(fd, HIDIOCGUSAGE, &uref);

if(ret != 0 ) \{

return UNKNOWN\_ERROR;

recv\_data\[index\] = uref.value;

memcpy(buffer72, recv\_data, 72);

return SUCCESS;

libusb驱动的实现

int Device\_Report(int fd, unsigned char \*buffer72)

/\* 定义设备句柄 \*/

usb\_dev\_handle\* Device\_handle;

/\* save the data of send and receive \*/

unsigned char send\_data\[72\];

unsigned char recv\_data\[72\];

int send\_len;

int recv\_len;

/\* 数据置空 \*/

memset(send\_data, 0 , sizeof(send\_data));

memset(recv\_data, 0 , sizeof(recv\_data));

/\* 这里的g\_list是全局的数据变量，里面可以存储相关设备的所需信息，当然我们 也可以从函数形参中传输进来，设备的信息在打开设备时初始化，我们将在后面的总结中详细描述一下 \*/

Device\_handle = (usb\_dev\_handle\*)(g\_list\[fd\].device\_handle);

if (Device\_handle == NULL) \{

return NOT\_OPENED\_DEVICE;

/\* 这个函数前面已经说过，在操作设备前是必须调用的, 0是指用默认的设备 \*/

usb\_claim\_interface(Device\_handle, 0);

/\* 发送数据，所用到的宏定义在usb.h可以找到，我列出来大家看一下

\#define USB\_ENDPOINT\_OUT 0x00

\#define USB\_TYPE\_CLASS (0x01 << 5)

\#define USB\_RECIP\_INTERFACE 0x01

\#define HID\_REPORT\_SET 0x09 \*/

send\_len = usb\_control\_msg(Device\_handle,

USB\_ENDPOINT\_OUT + USB\_TYPE\_CLASS + USB\_RECIP\_INTERFACE,

HID\_REPORT\_SET,

0x300,

send\_data, 72, USB\_TIMEOUT);

/\* 发送数据有错误 \*/

if (send\_len < 0) \{

return WRITE\_REPORT;

if (send\_len != 72) \{

return send\_len;

/\* 接受数据

\#define USB\_ENDPOINT\_IN 0x80

\#define USB\_TYPE\_CLASS (0x01 << 5)

\#define USB\_RECIP\_INTERFACE 0x01

\#define HID\_REPORT\_GET 0x01

\*/

recv\_len = usb\_control\_msg(Device\_handle,

USB\_ENDPOINT\_IN + USB\_TYPE\_CLASS + USB\_RECIP\_INTERFACE,

HID\_REPORT\_GET,

0x300,

recv\_data, 72, USB\_TIMEOUT);

if (recv\_len < 0) \{

printf("failed to retrieve report from USB device!\\n");

return READ\_REPORT;

if (recv\_len != 72) \{

return recv\_len;

/\* 和usb\_claim\_interface对应 \*/

usb\_release\_interface(RY2\_handle, 0);

memcpy(buffer72, recv\_data, 72);

return SUCCESS;

3.4  关闭设备

假设我们定义的关闭设备的函数名是Device\_Close()

/\* 使用hid驱动关闭设备 \*/

int Device\_Close()

int handle;

handle = open(“hiddev0”, O\_RDONLY);

/\* 传统HID驱动调用,通过close()设备文件就可 \*/

close( handle );

/\* 使用libusb关闭驱动 \*/

int Device\_Close()

/\* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 \*/

struct usb\_device\* udev;

usb\_dev\_handle\* device\_handle;

device\_handle = usb\_open(udev);

/\* libusb库使用usb\_close关闭程序 \*/

usb\_close(device\_handle);

**libusb的驱动框架**

前面我们看了些主要的libusb函数的使用，这里我们把前面的内容归纳下：

一般的驱动应该都包含如下接口：

Device\_Find(); /\* 寻找设备接口 \*/

Device\_Open(); /\* 打开设备接口 \*/

Device\_Write(); /\* 写设备接口 \*/

Device\_Read(); /\* 读设备接口 \*/

Device\_Close(); /\* 关闭设备接口 \*/

具体代码如下：

`#include <usb.h>`

`/* usb.h` `这个头文件是要包括的，里面包含了必须要用到的数据结构` `*/`

`/*` `我们将一个设备的属性用一个结构体来概括` `*/`

`typedef struct`

`{`

`struct usb_device* udev;`

`usb_dev_handle* device_handle;`

`/*` `这里可以添加设备的其他属性，这里只列出每个设备要用到的属性` `*/`

`} device_descript;`

`/*` `用来设置传输数据的时间延迟` `*/`

`#define USB_TIMEOUT 10000`

`/*` `厂家` `ID` `和产品` `ID */`

`#define VENDOR_ID 0xffff`

`#define PRODUCT_ID 0xffff`

`/*` `这里定义数组来保存设备的相关属性，` `DEVICE_MINOR` `可以设置能够同时操作的设备数量，用全局变量的目的在于方便保存属性` `*/`

`#define DEVICE_MINOR 16`

`int g_num;`

`device_descript g_list[ DEVICE_MINOR ];`

`/*` `我们写个设备先找到设备，并把相关信息保存在` `g_list` `中` `*/`

`int Device_Find()`

`{`

`struct usb_bus *bus;`

`struct usb_device *dev;`

`g_num = 0;`

`usb_find_busses();`

`usb_find_devices();`

`/*` `寻找设备` `*/`

`for (bus = usb_busses; bus; bus = bus->next) {`

`for (dev = bus->devices; dev; dev = dev->next) {`

`if(dev->descriptor.idVendor==VENDOR_ID&& dev->descriptor.idProduct == PRODUCT_ID) {`

`/*` `保存设备信息` `*/`

`if (g_num < DEVICE_MINOR) {`

`g_list[g_num].udev = dev;`

`g_num ++;`

`}`

`return g_num;`

`}`

`/*` `找到设备后，我们根据信息打开设备` `*/`

`int Device_Open()`

`{`

`/*` `根据情况打开你所需要操作的设备，这里我们仅列出伪代码` `*/`

`if(g_list[g_num].udev != NULL) { g_list[g_num].device_handle = usb_open(g_list[g_num].udev);`

`}`

`/*` `下面就是操作设备的函数了，我们就不列出来拉，大家可以参考上面的介绍` `*/`

`int DeviceWite(int handle)`

`{`

`/*` `填写相关代码，具体查看设备协议` `*/`

`}`

`int DeviceOpen(int handle)`

`{`

`/*` `填写相关代码，具体查看设备协议` `*/`

`}`

`/*` `最后不要忘记关闭设备` `*/`

`void Device_close(int handle)`

`{`

`/*` `调用` `usb_close */`

`}`

libusb的使用教程和例子

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Android Studio 使用libusb（Cmake）

相关 libusb1.0在android内的移植和使用方法

相关 linux下交叉编译libusb的方法及编译一个使用了libusb库的test程序的方法

相关 Libusb库在Android下的使用例程

相关 libusb移植

相关 Libusb库的使用

相关 libusb的使用教程和例子

相关 Git revert使用和例子

相关 CacheManager的使用和例子[源码]

相关 Git revert使用和例子