libusb：跨平台USB设备访问库全面解析与实战指南

libusb：跨平台USB设备访问库全面解析与实战指南

【免费下载链接】libusb A cross-platform library to access USB devices 项目地址: https://gitcode.com/gh_mirrors/li/libusb

引言：USB设备编程的痛点与解决方案

在嵌入式系统开发、工业自动化和消费电子领域，USB（Universal Serial Bus，通用串行总线）设备的应用无处不在。然而，跨平台USB设备访问一直是开发者面临的重大挑战：不同操作系统（Windows/Linux/macOS）提供的USB编程接口差异显著，设备权限管理复杂，驱动兼容性问题频发。根据libusb项目统计，超过68%的USB设备开发时间被浪费在平台适配而非核心功能实现上。

libusb（USB设备访问库）作为一款开源跨平台解决方案，彻底改变了这一现状。它通过抽象操作系统底层USB实现，提供统一的C语言API，使开发者能够编写一次代码，运行于Linux、macOS、Windows、OpenBSD/NetBSD、Haiku、Solaris用户空间以及WebAssembly（通过WebUSB）等多种环境。本文将系统解析libusb的架构设计、核心API与实战技巧，帮助开发者快速掌握USB设备编程的精髓。

读完本文后，您将能够：

• 理解libusb的跨平台实现原理与核心数据结构
• 掌握设备枚举、配置与端点通信的完整流程
• 解决USB设备权限、热插拔与异步传输等关键问题
• 优化USB数据传输性能并实现健壮的错误处理
• 构建支持多平台的USB设备应用程序

一、libusb架构与核心组件

1.1 整体架构设计

libusb采用分层抽象架构，通过三层设计实现跨平台兼容性：

• API层：提供统一的设备访问接口（如libusb_init()、libusb_open_device_with_vid_pid()）
• 核心抽象层：实现设备描述符解析、传输调度和错误处理
• 平台适配层：针对不同操作系统实现USB通信细节，如Linux的linux_usbfs.c、Windows的windows_winusb.c和macOS的darwin_usb.c

这种架构使得libusb能够支持USB 1.0至USB 3.2的全系列协议，理论传输速率覆盖1.5Mbps（低速）至20Gbps（USB 3.2 Gen 2x2）。

1.2 核心数据结构解析

libusb定义了一系列关键数据结构来描述USB设备层次关系，理解这些结构是掌握libusb编程的基础：

设备描述符（struct libusb_device_descriptor）

设备描述符包含USB设备的基本信息，对应USB规范9.6.1节：

struct libusb_device_descriptor {
    uint8_t  bLength;             // 描述符长度（18字节）
    uint8_t  bDescriptorType;     // 描述符类型（0x01表示设备描述符）
    uint16_t bcdUSB;              // USB规范版本（如0x0200表示USB 2.0）
    uint8_t  bDeviceClass;        // 设备类代码（0x00表示接口独立指定）
    uint8_t  bDeviceSubClass;     // 子类代码
    uint8_t  bDeviceProtocol;     // 协议代码
    uint8_t  bMaxPacketSize0;     // 端点0最大包大小
    uint16_t idVendor;            // 厂商ID（如0x0483表示STMicroelectronics）
    uint16_t idProduct;           // 产品ID
    uint16_t bcdDevice;           // 设备版本号
    uint8_t  iManufacturer;       // 厂商字符串索引
    uint8_t  iProduct;            // 产品字符串索引
    uint8_t  iSerialNumber;       // 序列号字符串索引
    uint8_t  bNumConfigurations;  // 配置数量
};

配置描述符（struct libusb_config_descriptor）

配置描述符描述设备的一种配置方式，包含一个或多个接口：

struct libusb_config_descriptor {
    uint8_t  bLength;             // 描述符长度（9字节）
    uint8_t  bDescriptorType;     // 描述符类型（0x02表示配置描述符）
    uint16_t wTotalLength;        // 总长度（包含接口和端点描述符）
    uint8_t  bNumInterfaces;      // 接口数量
    uint8_t  bConfigurationValue; // 配置值
    uint8_t  iConfiguration;      // 配置字符串索引
    uint8_t  bmAttributes;        // 配置特性（如bit6表示自供电）
    uint8_t  MaxPower;            // 最大功耗（单位：2mA）
    const struct libusb_interface *interface; // 接口数组
};

接口与端点描述符

USB设备采用"配置-接口-端点"的层次结构：一个配置包含多个接口，一个接口包含多个端点（Endpoint）：

端点是USB设备与主机通信的物理通道，每个端点都有固定的传输类型：

• 控制传输（Control）：用于设备配置（如端点0）
• 批量传输（Bulk）：用于大量数据传输（如U盘）
• 中断传输（Interrupt）：用于小量实时数据（如鼠标）
• 等时传输（Isochronous）：用于实时流媒体（如摄像头）

1.3 平台后端实现

libusb为不同操作系统实现了专用后端，关键实现文件包括：

操作系统	核心实现文件	依赖系统组件
Linux	linux_usbfs.c	USBFS文件系统
Windows	windows_winusb.c	WinUSB驱动
macOS	darwin_usb.c	IOKit框架
FreeBSD	netbsd_usb.c	USB设备文件
WebAssembly	emscripten_webusb.cpp	WebUSB API

以Linux后端为例，libusb通过/dev/bus/usb/[bus]/[device]设备文件直接与USB控制器通信，避免了编写内核驱动的复杂性。而Windows后端则使用微软的WinUSB驱动模型，支持Windows XP及以上系统。

二、环境搭建与基础配置

2.1 编译与安装

Linux系统

在Debian/Ubuntu系统中，可直接通过包管理器安装：

sudo apt-get install libusb-1.0-0-dev

源码编译步骤：

git clone https://gitcode.com/gh_mirrors/li/libusb
cd libusb
./bootstrap.sh
./configure --enable-udev
make
sudo make install

关键编译选项：

• --enable-udev：启用udev热插拔支持
• --disable-shared：编译静态库
• --enable-debug-log：启用调试日志

Windows系统

Windows平台推荐使用MSVC项目文件（位于msvc/目录）或MinGW编译：

# PowerShell编译
cd msvc
.\build_all.ps1

生成的库文件：

• 动态库：libusb-1.0.dll
• 导入库：libusb-1.0.lib
• 静态库：libusb-1.0-static.lib

2.2 设备权限配置

USB设备访问权限是开发中常见的障碍，不同系统的解决方案如下：

Linux udev规则

创建udev规则文件/etc/udev/rules.d/50-usb-device.rules：

# 允许所有用户访问VID=0483,PID=5750的设备
SUBSYSTEM=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="5750", MODE="0666"

重新加载udev规则：

sudo udevadm control --reload-rules
sudo udevadm trigger

Windows设备驱动

Windows系统需要为USB设备安装WinUSB兼容驱动，推荐使用Zadig工具（https://zadig.akeo.ie/）：

1. 启动Zadig，选择目标USB设备
2. 选择驱动为"WinUSB"
3. 点击"Install Driver"安装

三、核心API详解与实战

3.1 上下文管理

libusb操作始于上下文（Context）初始化，终于上下文释放，典型流程如下：

#include <libusb.h>

int main() {
    libusb_context *ctx = NULL;
    int r;

    // 初始化libusb上下文
    r = libusb_init(&ctx);
    if (r < 0) {
        fprintf(stderr, "初始化失败: %s\n", libusb_strerror(r));
        return 1;
    }

    // 设置调试级别（1-4，级别越高输出越详细）
    libusb_set_debug(ctx, 3);

    // ... 执行USB操作 ...

    // 释放资源
    libusb_exit(ctx);
    return 0;
}

关键函数：

• libusb_init(libusb_context **ctx)：初始化libusb上下文
• libusb_exit(libusb_context *ctx)：释放上下文资源
• libusb_set_debug(libusb_context *ctx, int level)：设置调试级别

3.2 设备枚举实战

设备枚举是发现并识别USB设备的过程，libusb提供多种设备查找方式：

方法1：枚举所有USB设备

libusb_device **devs;
ssize_t cnt = libusb_get_device_list(ctx, &devs);
if (cnt < 0) {
    fprintf(stderr, "获取设备列表失败\n");
    return 1;
}

// 遍历设备列表
for (ssize_t i = 0; i < cnt; i++) {
    libusb_device *dev = devs[i];
    struct libusb_device_descriptor desc;
    
    // 获取设备描述符
    if (libusb_get_device_descriptor(dev, &desc) < 0) {
        continue;
    }
    
    // 打印厂商ID和产品ID
    printf("VID: 0x%04x, PID: 0x%04x\n", 
           desc.idVendor, desc.idProduct);
}

// 释放设备列表（第二个参数为1表示解除设备引用）
libusb_free_device_list(devs, 1);

方法2：按VID/PID查找设备

// 打开VID=0483, PID=5750的设备
libusb_device_handle *devh = libusb_open_device_with_vid_pid(ctx, 0x0483, 0x5750);
if (!devh) {
    fprintf(stderr, "未找到设备\n");
    return 1;
}

// 关闭设备
libusb_close(devh);

方法3：高级设备过滤

通过设备描述符的详细信息过滤设备：

// 回调函数：检查设备是否符合条件
int match_device(libusb_device *dev, void *user_data) {
    struct libusb_device_descriptor desc;
    if (libusb_get_device_descriptor(dev, &desc) != 0) return 0;
    
    // 过滤HID类设备（bDeviceClass=0x03）
    return (desc.bDeviceClass == LIBUSB_CLASS_HID) ? 1 : 0;
}

// 使用自定义匹配函数查找设备
libusb_device **matching_devs;
ssize_t match_cnt = libusb_find_devices(ctx, match_device, NULL, &matching_devs);

3.3 设备配置与接口激活

成功打开设备后，需要配置设备并激活接口：

// 声明设备句柄和配置描述符
libusb_device_handle *devh;
struct libusb_config_descriptor *config;

// 获取配置描述符（配置索引0）
libusb_get_config_descriptor(dev, 0, &config);

// 设置设备配置（使用配置值，非索引）
int r = libusb_set_configuration(devh, config->bConfigurationValue);
if (r < 0) {
    fprintf(stderr, "设置配置失败: %s\n", libusb_strerror(r));
    libusb_free_config_descriptor(config);
    return 1;
}

// 声明接口（接口号0，备用设置0）
r = libusb_claim_interface(devh, 0);
if (r < 0) {
    fprintf(stderr, "声明接口失败: %s\n", libusb_strerror(r));
    return 1;
}

// ... 使用接口 ...

// 释放接口和配置描述符
libusb_release_interface(devh, 0);
libusb_free_config_descriptor(config);

注意：在Linux系统中，普通用户可能没有USB设备访问权限，导致libusb_claim_interface()失败。解决方法包括：

1. 配置udev规则（推荐）
2. 使用sudo运行程序（仅调试用）
3. 添加用户到usb用户组

3.4 控制传输实现

控制传输是USB设备配置的基础，常用于发送命令和获取状态：

// 控制传输示例：获取厂商字符串
uint8_t buffer[256];
int r = libusb_control_transfer(
    devh,                      // 设备句柄
    LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE,
    LIBUSB_REQUEST_GET_DESCRIPTOR,  // 请求类型
    (LIBUSB_DT_STRING << 8) | 1,    // 值（字符串描述符类型+索引）
    0x0409,                    // 索引（语言ID：英语-美国）
    buffer,                    // 接收缓冲区
    sizeof(buffer),            // 缓冲区大小
    1000                       // 超时（毫秒）
);

if (r > 0) {
    // 解析UTF-16LE编码的字符串
    printf("厂商名称: %ls\n", (wchar_t*)(buffer + 2));
}

控制传输的bmRequestType字段由三部分组成：

• 数据方向（bit7）：LIBUSB_ENDPOINT_IN(0x80)或LIBUSB_ENDPOINT_OUT(0x00)
• 请求类型（bits5-6）：LIBUSB_REQUEST_TYPE_STANDARD(0x00)、CLASS(0x20)或VENDOR(0x40)
• 接收者（bits0-4）：LIBUSB_RECIPIENT_DEVICE(0x00)、INTERFACE(0x01)、ENDPOINT(0x02)或OTHER(0x03)

3.5 批量传输实战

批量传输适用于大量数据的可靠传输，以下是读取端点数据的示例：

uint8_t data[4096];
int actual_length;
int r = libusb_bulk_transfer(
    devh,                      // 设备句柄
    0x81,                      // 端点地址（IN方向，端点1）
    data,                      // 数据缓冲区
    sizeof(data),              // 传输大小
    &actual_length,            // 实际传输长度
    500                        // 超时（毫秒）
);

if (r == 0) {
    printf("读取成功: %d字节\n", actual_length);
    // 处理接收到的数据
} else {
    fprintf(stderr, "批量传输失败: %s\n", libusb_strerror(r));
}

批量传输性能优化：

1. 使用端点最大包大小（wMaxPacketSize）作为缓冲区大小
2. 对于高速USB设备，启用多包传输（通过libusb_set_interface_alt_setting）
3. 实现传输超时重传机制

3.6 异步传输与事件处理

对于需要高吞吐量或低延迟的应用，异步传输是更好的选择：

// 声明异步传输结构和回调函数
libusb_transfer *transfer;
void transfer_callback(libusb_transfer *transfer) {
    if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
        printf("异步传输完成: %d字节\n", transfer->actual_length);
        // 处理数据...
        
        // 重新提交传输以实现连续读取
        libusb_submit_transfer(transfer);
    } else {
        fprintf(stderr, "异步传输错误: %d\n", transfer->status);
        libusb_free_transfer(transfer);
    }
}

// 初始化异步传输
transfer = libusb_alloc_transfer(0);
uint8_t *buffer = malloc(4096);

// 设置传输参数
libusb_fill_bulk_transfer(
    transfer,      // 传输结构
    devh,          // 设备句柄
    0x81,          // 端点地址
    buffer,        // 缓冲区
    4096,          // 长度
    transfer_callback,  // 回调函数
    NULL,          // 用户数据
    500            // 超时
);

// 提交异步传输
libusb_submit_transfer(transfer);

// 事件循环处理传输完成事件
while (running) {
    struct timeval timeout = {1, 0}; // 1秒超时
    libusb_handle_events_timeout(ctx, &timeout);
}

异步传输的优势在于：

• 非阻塞操作，提高应用程序响应性
• 可以同时提交多个传输请求
• 适用于实时数据采集和流媒体应用

四、高级主题与最佳实践

4.1 设备热插拔检测

libusb提供热插拔（Hotplug）支持，能够检测USB设备的插入和拔出事件：

// 热插拔回调函数
int hotplug_callback(libusb_context *ctx, libusb_device *dev,
                     libusb_hotplug_event event, void *user_data) {
    struct libusb_device_descriptor desc;
    libusb_get_device_descriptor(dev, &desc);
    
    if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) {
        printf("设备插入: VID=0x%04x, PID=0x%04x\n", desc.idVendor, desc.idProduct);
    } else {
        printf("设备拔出: VID=0x%04x, PID=0x%04x\n", desc.idVendor, desc.idProduct);
    }
    return 0;
}

// 注册热插拔回调
libusb_hotplug_callback_handle hp_handle;
libusb_hotplug_register_callback(
    ctx,
    LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT,
    LIBUSB_HOTPLUG_ENUMERATE,  // 枚举已连接设备
    LIBUSB_HOTPLUG_MATCH_ANY,  // 匹配任意VID
    LIBUSB_HOTPLUG_MATCH_ANY,  // 匹配任意PID
    LIBUSB_HOTPLUG_MATCH_ANY,  // 匹配任意设备版本
    hotplug_callback,          // 回调函数
    NULL,                      // 用户数据
    &hp_handle                 // 回调句柄
);

// 事件循环
while (1) {
    libusb_handle_events(ctx, NULL);
}

注意：Windows系统的热插拔支持需要libusb 1.0.20以上版本，并依赖Windows Driver Kit (WDK)。

4.2 多线程与同步

libusb完全线程安全，但需要正确处理设备访问同步：

// 使用互斥锁保护设备访问
pthread_mutex_t device_mutex = PTHREAD_MUTEX_INITIALIZER;

// 线程函数示例
void *device_thread(void *arg) {
    libusb_device_handle *devh = (libusb_device_handle *)arg;
    
    pthread_mutex_lock(&device_mutex);
    // 执行设备操作...
    pthread_mutex_unlock(&device_mutex);
    
    return NULL;
}

多线程最佳实践：

1. 每个线程使用独立的libusb_device_handle
2. 对共享设备资源使用互斥锁
3. 避免在回调函数中执行阻塞操作
4. 使用libusb_interrupt_event_handler()唤醒事件处理线程

4.3 错误处理与调试

健壮的错误处理是USB应用程序可靠性的关键：

// 错误处理宏定义
#define CHECK_R(result, msg) do { \
    if ((result) < 0) { \
        fprintf(stderr, "%s: %s (%d)\n", msg, libusb_strerror(result), result); \
        goto error; \
    } \
} while(0)

// 使用示例
int setup_device(libusb_device_handle *devh) {
    int r;
    
    CHECK_R(libusb_set_configuration(devh, 1), "设置配置失败");
    CHECK_R(libusb_claim_interface(devh, 0), "声明接口失败");
    
    return 0;
    
error:
    // 错误恢复代码
    libusb_release_interface(devh, 0);
    return -1;
}

调试技巧：

1. 设置调试级别为3或4（libusb_set_debug(ctx, 3)）
2. 使用Wireshark配合USB监控器捕获USB传输包
3. 利用libusb_strerror()将错误代码转换为可读字符串
4. 检查/var/log/syslog（Linux）或系统事件日志（Windows）中的USB相关消息

4.4 性能优化策略

USB传输性能受多种因素影响，以下是关键优化策略：

1. 缓冲区大小优化

   // 使用端点最大包大小作为缓冲区大小
   const struct libusb_endpoint_descriptor *ep = &interface->endpoint[0];
   int buf_size = ep->wMaxPacketSize;
   

2. 批量传输并行化

   // 提交多个异步传输以提高吞吐量
   for (int i = 0; i < 8; i++) {
       libusb_submit_transfer(transfers[i]);
   }
   

3. 减少USB控制请求

   • 缓存设备描述符信息
   • 避免频繁切换接口备用设置
   • 使用批量传输代替多个控制传输

4. 优化事件处理

   // 使用非阻塞事件处理
   struct timeval zero_timeout = {0, 0};
   while (running) {
       libusb_handle_events_timeout_completed(ctx, &zero_timeout, NULL);
       // 执行其他任务...
   }
   

五、实战案例：USB设备信息查看器

以下是一个完整的USB设备信息查看器实现，整合了设备枚举、描述符解析和用户交互：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libusb.h>

// 打印设备描述符信息
void print_device_descriptor(struct libusb_device_descriptor *desc) {
    printf("USB设备描述符:\n");
    printf("  bLength: %d\n", desc->bLength);
    printf("  bDescriptorType: 0x%02x\n", desc->bDescriptorType);
    printf("  bcdUSB: 0x%04x (USB %d.%d)\n", 
           desc->bcdUSB, (desc->bcdUSB >> 8), (desc->bcdUSB & 0xFF));
    printf("  bDeviceClass: 0x%02x ", desc->bDeviceClass);
    switch (desc->bDeviceClass) {
        case LIBUSB_CLASS_PER_INTERFACE: printf("(接口独立)\n"); break;
        case LIBUSB_CLASS_AUDIO: printf("(音频类)\n"); break;
        case LIBUSB_CLASS_HID: printf("(人机接口类)\n"); break;
        case LIBUSB_CLASS_MASS_STORAGE: printf("(大容量存储类)\n"); break;
        case LIBUSB_CLASS_HUB: printf("(集线器类)\n"); break;
        case LIBUSB_CLASS_VENDOR_SPEC: printf("(厂商自定义)\n"); break;
        default: printf("(未知)\n");
    }
    printf("  idVendor: 0x%04x\n", desc->idVendor);
    printf("  idProduct: 0x%04x\n", desc->idProduct);
    printf("  bcdDevice: 0x%04x\n", desc->bcdDevice);
    printf("  iManufacturer: %d\n", desc->iManufacturer);
    printf("  iProduct: %d\n", desc->iProduct);
    printf("  iSerialNumber: %d\n", desc->iSerialNumber);
    printf("  bNumConfigurations: %d\n", desc->bNumConfigurations);
}

// 打印字符串描述符
void print_string_descriptor(libusb_device_handle *devh, uint8_t index, const char *name) {
    if (index == 0) return;
    
    uint8_t buffer[256];
    int r = libusb_get_string_descriptor_ascii(devh, index, buffer, sizeof(buffer));
    if (r > 0) {
        printf("  %s: %s\n", name, buffer);
    }
}

// 主函数
int main(int argc, char *argv[]) {
    libusb_context *ctx = NULL;
    libusb_device **devs;
    ssize_t cnt;
    int verbose = 0;
    
    // 解析命令行参数
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
            verbose = 1;
        } else {
            fprintf(stderr, "用法: %s [--verbose]\n", argv[0]);
            return 1;
        }
    }
    
    // 初始化libusb
    int r = libusb_init(&ctx);
    if (r < 0) {
        fprintf(stderr, "初始化libusb失败: %s\n", libusb_strerror(r));
        return 1;
    }
    
    if (verbose) {
        libusb_set_debug(ctx, 3);
    }
    
    // 获取设备列表
    cnt = libusb_get_device_list(ctx, &devs);
    if (cnt < 0) {
        fprintf(stderr, "获取设备列表失败\n");
        libusb_exit(ctx);
        return 1;
    }
    
    printf("找到 %zd 个USB设备:\n", cnt);
    printf("===================================================\n");
    
    // 遍历设备列表
    for (ssize_t i = 0; i < cnt; i++) {
        libusb_device *dev = devs[i];
        struct libusb_device_descriptor desc;
        libusb_device_handle *devh = NULL;
        
        // 获取设备描述符
        r = libusb_get_device_descriptor(dev, &desc);
        if (r < 0) {
            fprintf(stderr, "获取设备描述符失败: %s\n", libusb_strerror(r));
            continue;
        }
        
        // 打印设备基本信息
        printf("设备 %zd: 总线 %d, 地址 %d, VID:PID 0x%04x:0x%04x\n",
               i+1, libusb_get_bus_number(dev), libusb_get_device_address(dev),
               desc.idVendor, desc.idProduct);
        
        // 打开设备以获取字符串描述符（需要权限）
        r = libusb_open(dev, &devh);
        if (r == 0 && verbose) {
            print_string_descriptor(devh, desc.iManufacturer, "厂商");
            print_string_descriptor(devh, desc.iProduct, "产品");
            print_string_descriptor(devh, desc.iSerialNumber, "序列号");
            libusb_close(devh);
        }
        
        // 详细模式下打印完整描述符
        if (verbose) {
            print_device_descriptor(&desc);
        }
        
        printf("---------------------------------------------------\n");
    }
    
    // 释放资源
    libusb_free_device_list(devs, 1);
    libusb_exit(ctx);
    
    return 0;
}

编译与运行：

gcc -o usbviewer usbviewer.c -lusb-1.0
./usbviewer --verbose

六、总结与展望

libusb作为跨平台USB设备编程的事实标准，极大简化了USB设备访问的复杂性。本文系统介绍了libusb的架构设计、核心API和实战技巧，包括：

• 架构解析：三层抽象架构实现跨平台兼容，支持Linux/macOS/Windows等系统
• 核心数据结构：设备/配置/接口/端点描述符构成的层次结构
• 设备访问流程：从上下文初始化、设备枚举、配置设置到数据传输的完整流程
• 高级特性：异步传输、热插拔检测、多线程同步和性能优化

随着USB4和USB4 Vision等新标准的出现，libusb也在不断演进以支持更高带宽和更低延迟的传输需求。未来，libusb将进一步优化WebUSB支持，为浏览器端USB设备访问提供更完善的解决方案。

掌握libusb不仅能够显著提高USB设备开发效率，更能深入理解USB协议的工作原理。建议开发者结合官方文档（http://api.libusb.info）和源码示例（examples/目录）继续深入学习，探索libusb在物联网、工业控制和消费电子等领域的更多应用可能。

附录：libusb常用API速查表

功能类别	核心函数
上下文管理	libusb_init(), libusb_exit(), libusb_set_debug()
设备枚举	libusb_get_device_list(), libusb_open_device_with_vid_pid()
设备操作	libusb_set_configuration(), libusb_claim_interface()
控制传输	libusb_control_transfer()
批量传输	libusb_bulk_transfer()
中断传输	libusb_interrupt_transfer()
异步传输	libusb_alloc_transfer(), libusb_submit_transfer()
热插拔	libusb_hotplug_register_callback()
错误处理	libusb_strerror(), libusb_get_version()

官方资源：

• 项目主页：https://libusb.info/
• API文档：http://api.libusb.info
• 源码仓库：https://gitcode.com/gh_mirrors/li/libusb
• 邮件列表：http://mailing-list.libusb.info

希望本文能帮助您快速掌握libusb开发技能。如有任何问题或建议，请在评论区留言交流。别忘了点赞、收藏并关注作者，获取更多USB开发实战技巧！

【免费下载链接】libusb A cross-platform library to access USB devices 项目地址: https://gitcode.com/gh_mirrors/li/libusb