libusb使用指南

最新推荐文章于 2024-09-20 15:52:58 发布
最新推荐文章于 2024-09-20 15:52:58 发布
阅读量5.4k 收藏 30
点赞数 8
文章标签： linux kernel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doublegalaxy/article/details/117960648
版权
  1. 示例一 罗列设备列表：libusb库源码libusb-1.0.24\libusb-1.0.24\examples\listdevs.c
#include <stdio.h>

#include "libusb.h"

static void print_devs(libusb_device **devs)
{
	libusb_device *dev;
	int i = 0, j = 0;
	uint8_t path[8]; 

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

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

		r = libusb_get_port_numbers(dev, path, sizeof(path));
		if (r > 0) {
			printf(" path: %d", path[0]);
			for (j = 1; j < r; j++)
				printf(".%d", path[j]);
		}
		printf("\n");
	}
}

int main(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){
		libusb_exit(NULL);
		return (int) cnt;
	}

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

	libusb_exit(NULL);
	return 0;
}
int API_EXPORTED libusb_init(libusb_context **context)初始化 struct libusb_context *usbi_default_context，任何接口函数前调用
ssize_t API_EXPORTED libusb_get_device_list(libusb_context *ctx,
    libusb_device ***list)		读取&(ctx)->usb_devs中的每个设备，形成列表*list =discdevs.devices
void API_EXPORTED libusb_exit(libusb_context *ctx)

关闭usb

void API_EXPORTED libusb_free_device_list(libusb_device **list,
    int unref_devices)		释放各个设备
int API_EXPORTED libusb_get_device_descriptor(libusb_device *dev,
    struct libusb_device_descriptor *desc)		取值dev->device_descriptor
uint8_t API_EXPORTED libusb_get_bus_number(libusb_device *dev)取值dev->bus_number
uint8_t API_EXPORTED libusb_get_device_address(libusb_device *dev)取值dev->device_address
int API_EXPORTED libusb_get_port_numbers(libusb_device *dev,
    uint8_t *port_numbers, int port_numbers_len)		返回设备的端口列表

2.示例二

#include <config.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdarg.h>
#include <sys/types.h>
#include <getopt.h>

#include "libusb.h"
#include "ezusb.h"

#if !defined(_WIN32) || defined(__CYGWIN__)
#include <syslog.h>
static bool dosyslog = false;
#include <strings.h>
#define _stricmp strcasecmp
#endif

#ifndef FXLOAD_VERSION
#define FXLOAD_VERSION (__DATE__ " (libusb)")
#endif

#ifndef ARRAYSIZE
#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
#endif

void logerror(const char *format, ...)
{
	va_list ap;
	va_start(ap, format);

#if !defined(_WIN32) || defined(__CYGWIN__)
	if (dosyslog)
		vsyslog(LOG_ERR, format, ap);
	else
#endif
		vfprintf(stderr, format, ap);
	va_end(ap);
}

static int print_usage(int error_code) {
	fprintf(stderr, "\nUsage: fxload [-v] [-V] [-t type] [-d vid:pid] [-p bus,addr] [-s loader] -i firmware\n");
	fprintf(stderr, "  -i <path>       -- Firmware to upload\n");
	fprintf(stderr, "  -s <path>       -- Second stage loader\n");
	fprintf(stderr, "  -t <type>       -- Target type: an21, fx, fx2, fx2lp, fx3\n");
	fprintf(stderr, "  -d <vid:pid>    -- Target device, as an USB VID:PID\n");
	fprintf(stderr, "  -p <bus,addr>   -- Target device, as a libusb bus number and device address path\n");
	fprintf(stderr, "  -v              -- Increase verbosity\n");
	fprintf(stderr, "  -q              -- Decrease verbosity (silent mode)\n");
	fprintf(stderr, "  -V              -- Print program version\n");
	return error_code;
}

#define FIRMWARE 0
#define LOADER 1
int main(int argc, char*argv[])
{
	fx_known_device known_device[] = FX_KNOWN_DEVICES;
	const char *path[] = { NULL, NULL };
	const char *device_id = NULL;
	const char *device_path = getenv("DEVICE");
	const char *type = NULL;
	const char *fx_name[FX_TYPE_MAX] = FX_TYPE_NAMES;
	const char *ext, *img_name[] = IMG_TYPE_NAMES;
	int fx_type = FX_TYPE_UNDEFINED, img_type[ARRAYSIZE(path)];
	int opt, status;
	unsigned int i, j;
	unsigned vid = 0, pid = 0;
	unsigned busnum = 0, devaddr = 0, _busnum, _devaddr;
	libusb_device *dev, **devs;
	libusb_device_handle *device = NULL;
	struct libusb_device_descriptor desc;

	while ((opt = getopt(argc, argv, "qvV?hd:p:i:I:s:S:t:")) != EOF)
		switch (opt) {

		case 'd':
			device_id = optarg;
			if (sscanf(device_id, "%x:%x" , &vid, &pid) != 2 ) {
				fputs ("please specify VID & PID as \"vid:pid\" in hexadecimal format\n", stderr);
				return -1;
			}
			break;

		case 'p':
			device_path = optarg;
			if (sscanf(device_path, "%u,%u", &busnum, &devaddr) != 2 ) {
				fputs ("please specify bus number & device number as \"bus,dev\" in decimal format\n", stderr);
				return -1;
			}
			break;

		case 'i':
		case 'I':
			path[FIRMWARE] = optarg;
			break;

		case 's':
		case 'S':
			path[LOADER] = optarg;
			break;

		case 'V':
			puts(FXLOAD_VERSION);
			return 0;

		case 't':
			type = optarg;
			break;

		case 'v':
			verbose++;
			break;

		case 'q':
			verbose--;
			break;

		case '?':
		case 'h':
		default:
			return print_usage(-1);

	}

	if (path[FIRMWARE] == NULL) {
		logerror("no firmware specified!\n");
		return print_usage(-1);
	}
	if ((device_id != NULL) && (device_path != NULL)) {
		logerror("only one of -d or -p can be specified\n");
		return print_usage(-1);
	}

	/* determine the target type */
	if (type != NULL) {
		for (i=0; i<FX_TYPE_MAX; i++) {
			if (strcmp(type, fx_name[i]) == 0) {
				fx_type = i;
				break;
			}
		}
		if (i >= FX_TYPE_MAX) {
			logerror("illegal microcontroller type: %s\n", type);
			return print_usage(-1);
		}
	}

	/* open the device using libusb */
	status = libusb_init(NULL);
	if (status < 0) {
		logerror("libusb_init() failed: %s\n", libusb_error_name(status));
		return -1;
	}
	libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, verbose);

	/* try to pick up missing parameters from known devices */
	if ((type == NULL) || (device_id == NULL) || (device_path != NULL)) {
		if (libusb_get_device_list(NULL, &devs) < 0) {
			logerror("libusb_get_device_list() failed: %s\n", libusb_error_name(status));
			goto err;
		}
		for (i=0; (dev=devs[i]) != NULL; i++) {
			_busnum = libusb_get_bus_number(dev);
			_devaddr = libusb_get_device_address(dev);
			if ((type != NULL) && (device_path != NULL)) {
				// if both a type and bus,addr were specified, we just need to find our match
				if ((libusb_get_bus_number(dev) == busnum) && (libusb_get_device_address(dev) == devaddr))
					break;
			} else {
				status = libusb_get_device_descriptor(dev, &desc);
				if (status >= 0) {
					if (verbose >= 3) {
						logerror("examining %04x:%04x (%d,%d)\n",
							desc.idVendor, desc.idProduct, _busnum, _devaddr);
					}
					for (j=0; j<ARRAYSIZE(known_device); j++) {
						if ((desc.idVendor == known_device[j].vid)
							&& (desc.idProduct == known_device[j].pid)) {
							if (// nothing was specified
								((type == NULL) && (device_id == NULL) && (device_path == NULL)) ||
								// vid:pid was specified and we have a match
								((type == NULL) && (device_id != NULL) && (vid == desc.idVendor) && (pid == desc.idProduct)) ||
								// bus,addr was specified and we have a match
								((type == NULL) && (device_path != NULL) && (busnum == _busnum) && (devaddr == _devaddr)) ||
								// type was specified and we have a match
								((type != NULL) && (device_id == NULL) && (device_path == NULL) && (fx_type == known_device[j].type)) ) {
								fx_type = known_device[j].type;
								vid = desc.idVendor;
								pid = desc.idProduct;
								busnum = _busnum;
								devaddr = _devaddr;
								break;
							}
						}
					}
					if (j < ARRAYSIZE(known_device)) {
						if (verbose)
							logerror("found device '%s' [%04x:%04x] (%d,%d)\n",
								known_device[j].designation, vid, pid, busnum, devaddr);
						break;
					}
				}
			}
		}
		if (dev == NULL) {
			libusb_free_device_list(devs, 1);
			libusb_exit(NULL);
			logerror("could not find a known device - please specify type and/or vid:pid and/or bus,dev\n");
			return print_usage(-1);
		}
		status = libusb_open(dev, &device);
		libusb_free_device_list(devs, 1);
		if (status < 0) {
			logerror("libusb_open() failed: %s\n", libusb_error_name(status));
			goto err;
		}
	} else if (device_id != NULL) {
		device = libusb_open_device_with_vid_pid(NULL, (uint16_t)vid, (uint16_t)pid);
		if (device == NULL) {
			logerror("libusb_open() failed\n");
			goto err;
		}
	}

	/* We need to claim the first interface */
	libusb_set_auto_detach_kernel_driver(device, 1);
	status = libusb_claim_interface(device, 0);
	if (status != LIBUSB_SUCCESS) {
		libusb_close(device);
		logerror("libusb_claim_interface failed: %s\n", libusb_error_name(status));
		goto err;
	}

	if (verbose)
		logerror("microcontroller type: %s\n", fx_name[fx_type]);

	for (i=0; i<ARRAYSIZE(path); i++) {
		if (path[i] != NULL) {
			ext = path[i] + strlen(path[i]) - 4;
			if ((_stricmp(ext, ".hex") == 0) || (strcmp(ext, ".ihx") == 0))
				img_type[i] = IMG_TYPE_HEX;
			else if (_stricmp(ext, ".iic") == 0)
				img_type[i] = IMG_TYPE_IIC;
			else if (_stricmp(ext, ".bix") == 0)
				img_type[i] = IMG_TYPE_BIX;
			else if (_stricmp(ext, ".img") == 0)
				img_type[i] = IMG_TYPE_IMG;
			else {
				logerror("%s is not a recognized image type\n", path[i]);
				goto err;
			}
		}
		if (verbose && path[i] != NULL)
			logerror("%s: type %s\n", path[i], img_name[img_type[i]]);
	}

	if (path[LOADER] == NULL) {
		/* single stage, put into internal memory */
		if (verbose > 1)
			logerror("single stage: load on-chip memory\n");
		status = ezusb_load_ram(device, path[FIRMWARE], fx_type, img_type[FIRMWARE], 0);
	} else {
		/* two-stage, put loader into internal memory */
		if (verbose > 1)
			logerror("1st stage: load 2nd stage loader\n");
		status = ezusb_load_ram(device, path[LOADER], fx_type, img_type[LOADER], 0);
		if (status == 0) {
			/* two-stage, put firmware into internal memory */
			if (verbose > 1)
				logerror("2nd state: load on-chip memory\n");
			status = ezusb_load_ram(device, path[FIRMWARE], fx_type, img_type[FIRMWARE], 1);
		}
	}

	libusb_release_interface(device, 0);
	libusb_close(device);
	libusb_exit(NULL);
	return status;
err:
	libusb_exit(NULL);
	return -1;
}

DEFAULT_VISIBILITY const char * LIBUSB_CALL libusb_error_name(int error_code)

定位错误代码号

int API_EXPORTED libusb_set_option(libusb_context *ctx,
    enum libusb_option option, ...)

设置运行消息打印选项

int API_EXPORTED libusb_open(libusb_device *dev,
    libusb_device_handle **dev_handle)

拿到设备句柄执行读写操作

DEFAULT_VISIBILITY
libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev)

设备引用数加一

void API_EXPORTED libusb_unref_device(libusb_device *dev)

设备引用数减一

DEFAULT_VISIBILITY
libusb_device_handle * LIBUSB_CALL libusb_open_device_with_vid_pid(
    libusb_context *ctx, uint16_t vendor_id, uint16_t product_id)

 打开vid，pid对应的设备

int API_EXPORTED libusb_set_auto_detach_kernel_driver(
    libusb_device_handle *dev_handle, int enable)

 使能自动解绑设备

int API_EXPORTED libusb_claim_interface(libusb_device_handle *dev_handle,   int interface_number)

 声明使用端口。必须在使用任何终端前声明

void API_EXPORTED libusb_close(libusb_device_handle *dev_handle)

 

int API_EXPORTED libusb_release_interface(libusb_device_handle *dev_handle, int interface_number)

 

1. Linux中USB协议栈的框架简介  https://www.cnblogs.com/nju347/p/7858388.html

2. Libusb开发者指南  

3. linux内核container_of宏定义分析

Emilin Amy
关注
libusb开源库使用说明
fhb1922702569的博客
03-13 2835
libusb是一个跨平台的用户空间USB库，允许用户编写基于USB的应用程序，而无需了解底层的USB协议。它提供了一个可移植的、抽象的接口来访问USB设备，支持多个操作系统，包括Linux、macOS、Windows和其他类Unix系统。通过使用libusb，开发人员可以以设备为中心，而不是以系统为中心来开发USB应用程序，从而获得更好的可移植性和开发效率。libusb还包括用于设备描述符解析、传输、同步、异步传输、控制传输等功能的API。
libusb使用说明 libusb使用说明
04-06
libusb使用说明 libusb使用说明 libusb使用说明
libusb 简介和使用方法
Yasin Lee
05-07 3728
以下内容转自：http://www.jollen.org/blog/2008/01/libusb_hello_world.html 更多关于usblib的信息可以参考：http://libusb.sourceforge.net/doc/index.html jollen 發表於 January 25, 2008 3:49 PM [libusb] 是一個 user-sp
error: /usr/lib/x86_64-linux-gnu/libpcl_io.so: undefined reference to “libusb_set_option“
最新发布
baidu_38165415的博客
09-20 411
这里的/usr/lib/x86_64-linux-gnu是本地libusb库对应的路径。
libusb的使用教程
weixin_42275611的博客
06-01 4079
libusb的使用教程 文章目录libusb的使用教程一 libusb 介绍二 libusb 的外部接口2.1 初始化设备接口2.2 操作设备接口2.3 控制传输接口2.4 批传输接口2.5 中断传输接口3 Libusb库的使用3.1 find设备3.2 打开设备3.3 读写设备和操作设备3.4 关闭设备 Linux 平台上的usb驱动开发，主要有内核驱动的开发和基于libusb的无驱设计。 对于内核驱动的大部分设备，诸如带usb接口的hid设备，linux本身已经自带了相关的驱动，我们只要操作设备文件便
libusb使用
Posix 的专栏
06-27 5415
首先声明，这是看到国外论坛上的学习文章后，独立翻译过来作为笔记用，加入部分自我理解，并且全部原创。 介绍： libusb是一个开源库，可以帮助开发者在用户空间的层面上与UBS设备进行通讯。如果想了解更多，可以查看他们的主页：http://libusb.org/ 在其文档中，建议首先阅读USB2的规格说明：http://www.usb.org/developers/docs/，这可以帮助真正地
通用usb驱动libusb介绍和使用示例
07-16 7238
 sudo insmod /lib/modules/2.6.22-14-generic/kernel/drivers/usb/serial/usbserial.ko vendor=0x8086 product=0xd001同时插上ttyUSB0和ttyUSB1(ch341)，obm可以将dkb下载下去，但是自动重起之后,就不能下载接下来的东西了,所以应该,需要close(ttyUSB0_handl
libsub libsub
04-12
综上所述，"libsub libsub"（应为libusb）是一个强大的跨平台USB库，提供与USB设备交互的API，而"git"标签则意味着这个压缩包可能包含了一个使用Git管理的libusb相关项目。通过理解和使用这些工具，开发者可以更有效...
嵌入式linux下基于libusb的USB驱动开发.pdf
09-06
本文将介绍如何在嵌入式 Linux 系统下使用 libusb 库开发 USB 驱动程序，并详细讨论 libusb 库的使用方法和 USB 驱动开发的实现原理。 1. libusb 库简介 libusb 是一个跨平台的 USB 编程库，提供了一个统一的 API...
libusb-1.0.23_libusb_beat4yg_
09-30
5. **文档（Documentation）**：包括手册页和开发者指南，解释库的使用方法和API。 6. **配置文件（Configuation Files）**：用于构建库的脚本，如`configure`和`Makefile`，这些文件在Unix-like系统中用于编译和...
c# 使用libusb
12-29
libusb之c#使用， libusb之c#使用。 libusb之c#使用 libusb之c#使用 libusb之c#使用 libusb之c#使用
Libusb Developers Guide
05-18
Libusb 开发帮助指南，函数使用说明，chm格式帮助文档
libusb-compat-0.1.4.zip
06-27
libusb-compat-0.1.4.zip是一个包含libusb-compat库的版本0.1.4的压缩包，主要用于解决在使用libusb时遇到的兼容性问题。libusb是一个开源的C语言库，它允许程序员与USB设备进行低级交互，而无需依赖操作系统特定的...
libusb .NET平台
12-27
3. **Docs**：这个目录可能包含项目的文档，如API参考、使用指南等，帮助开发者理解和使用LibUsbDotNet。 4. **Utility**：这是一个可能包含各种辅助工具或实用程序的目录，用于帮助开发、测试或管理LibUsbDotNet。...
libusb的用法和使用步骤（整理）
菜鸟笔记
09-07 1366
libusb 是一个使用 C 编写的库，它提供 USB 设备的通用的访问方法。APP 通过它，可以方便地访问 USB 设备，无需编写 USB 设备驱动程序。可移植性：支持 Linux、macOS、Windows、Android、OpenBSD 等用户模式：APP 不需要特权模式、也不需要提升自己的权限即可访问 USB 设备支持所有 USB 协议：从 1.0 到 3.1 都支持。
USB学习4-libusb的使用
天使之翼
10-17 1万+
libusb是一个使用C编写的库，它提供USB设备的通用的访问方法。APP通过它，可以方便地访问USB设备，无需编写USB设备驱动程序。可移植性：支持Linux、macOS、Windows、Android、OpenBSD等用户模式：APP不需要特权模式、也不需要提升自己的权限即可访问USB设备支持所有USB协议：从1.0到3.1都支持libusb支持所有的传输类型(控制/批量/中断/实时)，有两类API接口：同步(Synchronous，简单)，异步(Asynchronous，复杂但是更强大)
libusb介绍及简单使用
热门推荐
网络资源是无限的
04-23 4万+
libusb是一个开源的用C实现的，应用程序与用户的USB设备进行通信的库。它是可移植的，对外使用统一的API，支持Windows、macOS、Linux、Android。它是用户模式(user-mode)，应用程序与USB设备通信不需要高权限，但是在Android下好像有些接口需要root权限才能调用成功。它支持所有版本的USB协议。它的License是LGPL，源码地址在https://git...
libusb不同环境下的安装和使用
dmf_fff的博客
08-24 6244
libusb使用c实现， 具有的跨平台的特性，目前支持的操作系统有：Linux、macOS、Windows、OpenBSD/NetBSD、Haiku、Solaris。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Emilin Amy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值