linux libusb hid程序,libusb和HID设备

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

设备

任何驱动第一步首先是寻找到要操作的设备，我们先来看看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) {

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

}

}

打开设备

假设我们定义的打开设备的函数名是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);

}

读写设备和操作设备

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

我们这里定义三个函数，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,

0,

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,

0,

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;

}

关闭设备

假设我们定义的关闭设备的函数名是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函数的使用，这里我们把前面的内容归纳下：

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

Device_Find(); /* 寻找设备接口 */

Device_Open(); /* 打开设备接口 */

Device_Write(); /* 写设备接口 */

Device_Read(); /* 读设备接口 */

Device_Close(); /* 关闭设备接口 */

具体代码如下：

#include

/* 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 */

}