libusb读取鼠标数据

通libusb我们可以在应用层对USB设备进行读写操作。本文以读取USB鼠标数据为例讲述libusb的使用流程。

通过源码安装libusb:

最新的版本为：libusb-1.0.24，GitHub上免费下载地址：

https://github.com/libusb/libusb/releases/tag/v1.0.24

ps: 优快云上很多人用这个公共的开源资源来赚积分，而且下载分还贼高，真不怎么地道。

解压源码:tar xjvf libusb-1.0.24.tar.bz2

在解压跟目录下输入命令：

./configure

注意：如果报以下错误

configure: error: udev support requested but libudev header not installed

不要慌，这是由于没安装libudev库，可以通过以下方式解决：

1、输入命令apt-get install libudev-dev安装libudev

2、运行configure脚本时输入：./configure  --disable-udev（这种方法本人还没验证）

编译：make

安装：make install

默认安装在/usr/local/lib目录下

以上是源码编译安装流程，在线通过以下命令安装也很简单：

a、apt-get install libudev-dev

b、apt-get install libusb-dev

c、apt-get install libusb-1.0-0-dev

安装完libusb库后就可以开发应用层程序对USB设备进行读写操作了，下面是参考libusb例子中的testlibusb.c文件编写的鼠标数据读取程序test_rw.c：

​
#include <config.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <getopt.h>
#include <ctype.h>
#include <signal.h>

#include "libusb.h"

int verbose = 1;

static volatile sig_atomic_t rcv_exit;


static void print_endpoint_comp(const struct libusb_ss_endpoint_companion_descriptor *ep_comp)
{
	printf("      USB 3.0 Endpoint Companion:\n");
	printf("        bMaxBurst:           %u\n", ep_comp->bMaxBurst);
	printf("        bmAttributes:        %02xh\n", ep_comp->bmAttributes);
	printf("        wBytesPerInterval:   %u\n", ep_comp->wBytesPerInterval);
}

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

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

	for (i = 0; i < endpoint->extra_length;) {
		if (LIBUSB_DT_SS_ENDPOINT_COMPANION == endpoint->extra[i + 1]) {
			struct libusb_ss_endpoint_companion_descriptor *ep_comp;

			ret = libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
			if (LIBUSB_SUCCESS != ret)
				continue;

			print_endpoint_comp(ep_comp);

			libusb_free_ss_endpoint_companion_descriptor(ep_comp);
		}

		i += endpoint->extra[i];
	}
}

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

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

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

static void print_2_0_ext_cap(struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext_cap)
{
	printf("    USB 2.0 Extension Capabilities:\n");
	printf("      bDevCapabilityType:    %u\n", usb_2_0_ext_cap->bDevCapabilityType);
	printf("      bmAttributes:          %08xh\n", usb_2_0_ext_cap->bmAttributes);
}

static void print_ss_usb_cap(struct libusb_ss_usb_device_capability_descriptor *ss_usb_cap)
{
	printf("    USB 3.0 Capabilities:\n");
	printf("      bDevCapabilityType:    %u\n", ss_usb_cap->bDevCapabilityType);
	printf("      bmAttributes:          %02xh\n", ss_usb_cap->bmAttributes);
	printf("      wSpeedSupported:       %u\n", ss_usb_cap->wSpeedSupported);
	printf("      bFunctionalitySupport: %u\n", ss_usb_cap->bFunctionalitySupport);
	printf("      bU1devExitLat:         %u\n", ss_usb_cap->bU1DevExitLat);
	printf("      bU2devExitLat:         %u\n", ss_usb_cap->bU2DevExitLat);
}

static void print_bos(libusb_device_handle *handle)
{
	struct libusb_bos_descriptor *bos;
	uint8_t i;
	int ret;

	ret = libusb_get_bos_descriptor(handle, &bos);
	if (ret < 0)
		return;

	printf("  Binary Object Store (BOS):\n");
	printf("    wTotalLength:            %u\n", bos->wTotalLength);
	printf("    bNumDeviceCaps:          %u\n", bos->bNumDeviceCaps);

	for (i = 0; i < bos->bNumDeviceCaps; i++) {
		struct libusb_bos_dev_capability_descriptor *dev_cap = bos->dev_capability[i];

		if (dev_cap->bDevCapabilityType == LIBUSB_BT_USB_2_0_EXTENSION) {
			struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension;

			ret = libusb_get_usb_2_0_extension_descriptor(NULL, dev_cap, &usb_2_0_extension);
			if (ret < 0)
				return;

			print_2_0_ext_cap(usb_2_0_extension);
			libusb_free_usb_2_0_extension_descriptor(usb_2_0_extension);
		} else if (dev_cap->bDevCapabilityType == LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
			struct libusb_ss_usb_device_capability_descriptor *ss_dev_cap;

			ret = libusb_get_ss_usb_device_capability_descriptor(NULL, dev_cap, &ss_dev_cap);
			if (ret < 0)
				return;

			print_ss_usb_cap(ss_dev_cap);
			libusb_free_ss_usb_device_capability_descriptor(ss_dev_cap);
		}
	}

	libusb_free_bos_descriptor(bos);
}

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

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

static void print_configuration(struct libusb_config_descriptor *config)
{
	uint8_t i;

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

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


static void print_device(libusb_device *dev, libusb_device_handle *handle, uint16_t vid, uint16_t pid)
{
	struct libusb_device_descriptor desc;
	unsigned char string[256];
	const char *speed;
	int ret;
	uint8_t i;

	switch (libusb_get_device_speed(dev)) {
	case LIBUSB_SPEED_LOW:		speed = "1.5M"; break;
	case LIBUSB_SPEED_FULL:		speed = "12M"; break;
	case LIBUSB_SPEED_HIGH:		speed = "480M"; break;
	case LIBUSB_SPEED_SUPER:	speed = "5G"; break;
	case LIBUSB_SPEED_SUPER_PLUS:	speed = "10G"; break;
	default:			speed = "Unknown";
	}

	ret = libusb_get_device_descriptor(dev, &desc);
	if (ret < 0) {
		fprintf(stderr, "failed to get device descriptor");
		return;
	}

	
	if (!handle)
	libusb_open(dev, &handle);

	if((desc.idVendor == vid) && (desc.idProduct == pid))
	{
		printf("Dev (bus %u, device %u): %04X - %04X speed: %s\n",
				   libusb_get_bus_number(dev), libusb_get_device_address(dev),
				   desc.idVendor, desc.idProduct, speed);
		

		if (handle)
		{
			if (desc.iManufacturer) {
				ret = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, string, sizeof(string));
				if (ret > 0)
					printf("  Manufacturer:              %s\n", (char *)string);
			}

			if (desc.iProduct) {
				ret = libusb_get_string_descriptor_ascii(handle, desc.iProduct, string, sizeof(string));
				if (ret > 0)
					printf("  Product:                   %s\n", (char *)string);
			}

			if (desc.iSerialNumber && verbose) {
				ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, string, sizeof(string));
				if (ret > 0)
					printf("  Serial Number:             %s\n", (char *)string);
			}
						
		}

		if (verbose) {
			for (i = 0; i < desc.bNumConfigurations; i++) {
				struct libusb_config_descriptor *config;

				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);
			}

			if (handle && desc.bcdUSB >= 0x0201)
				print_bos(handle);
		}		

	}

	
	if(handle)
	{
		libusb_close(handle);
	}
}


static int test_wrapped_device(const char *device_name, uint16_t vendor_id, uint16_t product_id)
{
	libusb_device_handle *handle;
	int r, fd;

	fd = open(device_name, O_RDWR);
	if (fd < 0) {
		printf("Error could not open %s: %s\n", device_name, strerror(errno));
		return 1;
	}
	r = libusb_wrap_sys_device(NULL, fd, &handle);
	if (r) {
		printf("Error wrapping device: %s: %s\n", device_name, libusb_strerror(r));
		close(fd);
		return 1;
	}
	print_device(libusb_get_device(handle), handle, vendor_id, product_id);
	close(fd);
	return 0;
}



static void sig_handler(int signum)
{
	switch (signum) {
	case SIGTERM:
		rcv_exit = 1;
		break;
	case SIGINT:
		rcv_exit = 1;
		break;
	case SIGUSR1:
		break;
	}
}


static void usage(char *program)
{
	printf("%s - test usb data transfers to/from usb device\n",
			program);
	printf("Usage:\n");
	printf("  %s [options]\n", program);
	printf("options are:\n");
	printf("Common:\n");
	printf("  --help (or -h)\n");	
	printf("  -v vendor_id\n");
	printf("  -p product_id\n");
	printf("  -d device name\n");
}

static int interrupt_data_rw(uint16_t vendor_id, uint16_t product_id)
{
	int kernelDriverDetached = 0;
	unsigned char data_in[64]={0};
	int length = 0;
	int r,j;
	libusb_device_handle *handle;

	handle = libusb_open_device_with_vid_pid(NULL, vendor_id, product_id);
	if (handle == NULL) 
	{
		printf("libusb_open() failed\n");
		return -1;;
	}

 
	/*驱动必须解绑定，否则数据由驱动程序处理*/	if(libusb_kernel_driver_active(handle, 0))
	{
		printf("Kernel Driver Active\n");
		r = libusb_detach_kernel_driver(handle, 0);
		if (r == 0)
		{
			printf("Detach Kernel Driver\n");
			kernelDriverDetached = 1;
		}
		else
		{
			fprintf(stderr, "Error detaching kernel driver.\n");
			return -1;;
		}
	}
	
	
 	/* 指定当前接口 */
	r = libusb_claim_interface(handle, 0);
	if (r != 0)
	{
		fprintf(stderr, "Error claiming interface.\n");
		goto exit;
	}
	

	while(!rcv_exit)
	{
		memset(data_in, 0, sizeof(data_in));
		/*中断方式读取断点数据，
		由端点描述符可知端点地址 0x81 为鼠标输入端点
		读取长度为5字节，超时时间为1000ms*/	

		r = libusb_interrupt_transfer(handle, 0x81, data_in, 5, &length, 1000);
		if ((r < 0) || (length == 0))
		{
			printf("bulk recive error,r:%d length:%d\n",r,length);
		}
		else
		{
			printf("receive data:\n");
			for(j=0; j<length; j++)
			{
				printf("0x%x ",data_in[j]);
			}
			printf("\n");
		}
		usleep(500000);
	}

	
 	/* 释放指定的接口 */
	r = libusb_release_interface(handle, 0);
	if (0 != r)
	{
		fprintf(stderr, "Error releasing interface.\n");
	}
	
	
exit:
	if(kernelDriverDetached)
	{
		//恢复驱动绑定，否则鼠标不可用
	    libusb_attach_kernel_driver(handle, 0);
	}

	
	libusb_close(handle);
	return r;
	

}


int main(int argc, char *argv[])
{
	char *program = argv[0];
	int option;
	const char *device_name = NULL; //"/dev/bus/usb/001/005"
	libusb_device **devs;
	ssize_t cnt;
	int r, i;
	uint16_t vid=0, pid=0;
	libusb_device_handle *handle = NULL;

	static const struct option options[] = {
			{ "vendid", required_argument, NULL, 'v' },
			{ "productid",  required_argument, NULL, 'p' },
			{ "devicename",   required_argument, NULL, 'd' },
			{ "help",   no_argument, NULL, 'h' },
	};

	/* Parse command line options, if any */
	while ((option = getopt_long_only(argc, argv,
			"hv:p:d:",options, NULL)))
	{
		if (option == -1)
			break;
		switch (option) {
		case 'v':
			vid = strtoul(optarg, NULL, 0);
			break;
		case 'p':
			pid = strtoul(optarg, NULL, 0);
			break;
		case 'd':
			device_name = optarg;
			break;
		case 'h':
			usage(program);
			exit(EXIT_SUCCESS);
			break;
		default:
			printf("ERROR: Invalid command line option\n");
			usage(program);
			exit(EXIT_FAILURE);
		}
	}


	printf("vid:0x%x pid:0x%x devicename:%s\n",vid,pid,device_name);

	

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

	if (device_name) {
		printf("test_wrapped_device\n");
		r = test_wrapped_device(device_name,vid,pid);
	} else {
		cnt = libusb_get_device_list(NULL, &devs);
		if (cnt < 0) {
			libusb_exit(NULL);
			return 1;
		}

		for (i = 0; devs[i]; i++)
			print_device(devs[i], handle,vid,pid);

		libusb_free_device_list(devs, 1);
	}


	signal(SIGINT, sig_handler);
	signal(SIGTERM, sig_handler);

	//read mouse data
	interrupt_data_rw(vid,pid);

	libusb_exit(NULL);
	return r;
}

​

编译命令：

gcc -o test_rw test_rw.c -I/usr/local/include/libusb-1.0/ -I../ -lusb-1.0

lsusb查看鼠标设备信息如下：

根权限运行程序，读取鼠标信息：./testrw -v 0x046d -p 0xc045，读取过程需要移动鼠标，否则会提示读取失败。