使用libusb库的USB应用程序

我想使用libusb库为USB编写一些测试应用程序。 请任何人建议如何使用usb\u control\u msg调用设置控制传输

我在运行以下代码时遇到错误的描述符错误

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "usb.h"
static int vendor_id;
static int product_id;

typedef struct{
    int requesttype; 
    int request;
    int value;
    int index; 
    char *bytes;
    int size;
    int timeout;
}ctrlmsg_param;

void print_endpoint(struct usb_endpoint_descriptor *endpoint)
{
    printf("=====End point Information====\n");
    printf("bEndpointAddress: %x\n", endpoint->bEndpointAddress);
    printf("bmAttributes:     %x\n", endpoint->bmAttributes);
    printf("wMaxPacketSize:   %d\n", endpoint->wMaxPacketSize);
    printf("bInterval:        %d\n", endpoint->bInterval);
    printf("bRefresh:         %d\n", endpoint->bRefresh);
    printf("bSynchAddress:    %d\n", endpoint->bSynchAddress);
}

void print_altsetting(struct usb_interface_descriptor *interface)
{
    int i;

    printf("\n=====Alternate Setting Information====\n");
    printf("bInterfaceNumber:   %d\n", interface->bInterfaceNumber);
    printf("bAlternateSetting:  %d\n", interface->bAlternateSetting);
    printf("bNumEndpoints:      %d\n", interface->bNumEndpoints);
    printf("bInterfaceClass:    %d\n", interface->bInterfaceClass);
    printf("bInterfaceSubClass: %d\n", interface->bInterfaceSubClass);
    printf("bInterfaceProtocol: %d\n", interface->bInterfaceProtocol);
    printf("iInterface:         %d\n", interface->iInterface);

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

void print_interface(struct usb_interface *interface)
{
    int i;

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

void print_configuration(struct usb_config_descriptor *config)
{
    int i;

    printf("=====Configuration Information====\n");
    printf("wTotalLength:         %d\n", config->wTotalLength);
    printf("bNumInterfaces:       %d\n", config->bNumInterfaces);
    printf("bConfigurationValue:  %d\n", config->bConfigurationValue);
    printf("iConfiguration:       %d\n", config->iConfiguration);
    printf("bmAttributes:         %x\n", config->bmAttributes);
    printf("MaxPower:             %d\n", config->MaxPower);

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

int print_device(struct usb_device *dev)
{
    usb_dev_handle *udev;
    char str[100];
    int ret, i;
    udev = usb_open(dev);
    if (udev) {
        if (dev->descriptor.iManufacturer) {
            ret = usb_get_string_simple(udev, dev->descriptor.iManufacturer, str, sizeof(str));
            if (ret > 0)
            {
                printf("Manufacturer is %s\n",str);
            }
        }
        if (dev->descriptor.iProduct) {
            ret = usb_get_string_simple(udev, dev->descriptor.iProduct, str, sizeof(str));
            if (ret > 0)
            {
                printf("Product is %s\n",str);
            }
        } 

    }

    if (udev)
        usb_close(udev);
    printf("Possible configurations are %x\n",dev->descriptor.bNumConfigurations);
    sleep(2);
    for (i = 0; i < dev->descriptor.bNumConfigurations; i++)
        print_configuration(&dev->config[i]);

    return 0;
}
int htod( const char* str )
{
    int decimal;
    sscanf( str, "%x", &decimal);
    return decimal;
}
void set_data(struct usb_device *dev)
{

ctrlmsg_param  param;
param.requesttype= 0;
param.request=0;
param.value=0;
param.index=0;
param.bytes=10;
param.size=0;
param.timeout=5000;
usb_control_msg(dev, param.requesttype, param.request, param.value, param.index, param.bytes, param.size, param.timeout);
printf("error is %s\n",strerror(errno));
return;

}
int main(int argc, char *argv[])
{
    struct usb_bus *bus;
    struct usb_device *dev;

    if(argc != 3)
    {
        printf("Error in number of arguments\n");
        printf("Usage:./usb_info <vendor id> <product id>\n");
        exit(0);
    }

    vendor_id=htod(argv[1]);
    product_id=htod(argv[2]);

    printf("initializing USB library\n");
    usb_init();

    printf("Finding Buses and Devices\n");
    usb_find_busses();
    usb_find_devices();

    for (bus = usb_get_busses(); bus; bus = bus->next) {
        for (dev = bus->devices; dev; dev = dev->next) {
            if ((dev->descriptor.idProduct == product_id) && (dev->descriptor.idVendor == vendor_id)){           
                printf("Found device with produxt id %x and vendor id %x\n",product_id,vendor_id);
                print_device(dev);
                set_data(dev);
                print_device(dev);
            }
        }
    }
    return 0;
}

#包括
#包括
#包括
#包括“usb.h”
静态int供应商id；
静态int乘积_id；
类型定义结构{
int请求类型；
int请求；
int值；
整数指数；
字符*字节；
整数大小；
int超时；
}ctrlmsg_param；
无效打印\u终结点（结构usb\u终结点\u描述符*终结点）
{
printf（“===终点信息===\n”）；
printf（“bEndpointAddress:%x\n”，端点->bEndpointAddress）；
printf（“bmAttributes:%x\n”，端点->bmAttributes）；
printf（“wMaxPacketSize:%d\n”，端点->wMaxPacketSize）；
printf（“bInterval:%d\n”，端点->bInterval）；
printf（“刷新：%d\n”，端点->刷新）；
printf（“bSynchAddress:%d\n”，端点->bSynchAddress）；
}
无效打印设置（结构usb接口描述符*接口）
{
int i；
printf（“\n===备用设置信息==\n”）；
printf（“bInterfaceNumber:%d\n”，接口->bInterfaceNumber）；
printf（“bAlternateSetting:%d\n”，界面->bAlternateSetting）；
printf（“bNumEndpoints:%d\n”，界面->bNumEndpoints）；
printf（“bInterfaceClass:%d\n”，接口->bInterfaceClass）；
printf（“bInterfaceSubClass:%d\n”，接口->bInterfaceSubClass）；
printf（“bInterfaceProtocol:%d\n”，接口->bInterfaceProtocol）；
printf（“界面：%d\n”，界面->界面）；
对于（i=0；ibNumEndpoints；i++）
打印端点（&接口->端点[i]）；
}
无效打印接口（结构usb接口*接口）
{
int i；
对于（i=0；inum\altsetting；i++）
打印可选设置（&界面->可选设置[i]）；
}
无效打印配置（结构usb配置描述符*config）
{
int i；
printf（“===配置信息===\n”）；
printf（“wTotalLength:%d\n”，配置->wTotalLength）；
printf（“bNumInterfaces:%d\n”，配置->bNumInterfaces）；
printf（“b配置值：%d\n”，配置->b配置值）；
printf（“iConfiguration:%d\n”，配置->iConfiguration）；
printf（“bmAttributes:%x\n”，配置->bmAttributes）；
printf（“最大功率：%d\n”，配置->最大功率）；
对于（i=0；ibNuminInterfaces；i++）
打印接口（&config->接口[i]）；
}
int打印设备（结构usb设备*dev）
{
usb_dev_handle*udev；
char-str[100]；
int ret，i；
udev=usb_打开（dev）；
if（udev）{
if（dev->descriptor.imanFactoryr）{
ret=usb\u get\u string\u simple（udev，dev->descriptor.imanufactorr，str，sizeof（str））；
如果（ret>0）
{
printf（“制造商是%s\n”，str）；
}
}
if（dev->descriptor.ipproduct）{
ret=usb_get_string_simple（udev，dev->descriptor.ipproduct，str，sizeof（str））；
如果（ret>0）
{
printf（“产品是%s\n”，str）；
}
} 
}
if（udev）
usb_关闭（udev）；
printf（“可能的配置是%x\n”，dev->descriptor.bNumConfigurations）；
睡眠（2）；
对于（i=0；idescriptor.bNumConfigurations；i++）
打印配置（&dev->config[i]）；
返回0；
}
int htod（常量字符*str）
{
整数十进制；
sscanf（str、%x、&decimal）；
返回小数；
}
无效集_数据（结构usb_设备*dev）
{
ctrlmsg_param param；
参数requesttype=0；
参数请求=0；
参数值=0；
参数指数=0；
参数字节=10；
参数大小=0；
参数超时=5000；
usb_control_msg（dev，param.requesttype，param.request，param.value，param.index，param.bytes，param.size，param.timeout）；
printf（“错误为%s\n”，strerror（errno））；
返回；
}
int main（int argc，char*argv[]）
{
结构usb_总线*总线；
结构usb_设备*dev；
如果（argc！=3）
{
printf（“参数数量错误\n”）；
printf（“用法：./usb_信息\n”）；
出口（0）；
}
供应商id=htod（argv[1]）；
产品标识=htod（argv[2]）；
printf（“初始化USB库\n”）；
usb_init（）；
printf（“查找总线和设备”）；
usb_查找_总线（）；
usb_查找_设备（）；
用于（总线=usb_获取总线（）；总线；总线=总线->下一步）{
用于（dev=bus->devices；dev；dev=dev->next）{
如果（（dev->descriptor.idProduct==product\u id）&&（dev->descriptor.idVendor==vendor\u id））{
printf（“找到的设备具有产品id%x和供应商id%x\n”，产品id，供应商id）；
打印设备（dev）；
设置_数据（dev）；
打印设备（dev）；
}
}
}
返回0；
}

问候,，

---

Sandeep

我想你的意思是

usb\u control\u msg（）

is返回一个“错误描述符”的错误代码。如果这是错误的，请澄清

USB控制传输有一些非常特定的格式化规则，如果您正在形成的数据包被发送到任何兼容设备，它将返回总线上的请求错误/暂停

您正在发送控制传输：

bmRequestType = 0x00
bRequest      = 0x00
wValue        = 0x0000
wIndex        = 0x0000
wSize         = 0x0000

USB设备应将其解释为GET_状态请求，因此WLENGH要求为2，bmRequestType需要设置顶部位，表明这是一个正向请求（从主机的角度）。这些都来自USB规范1.1/2.0/3.1的第9章，可从www.USB.org获得

参数

char*bytes

（您的

param.bytes

）也需要是您正在进行的呼叫中的地址/指针

一个好的标准控制转移到测试将是：

bmRequestType = 0x80
bRequest      = 0x06
wValue        = 0x0001
wIndex        = 0x0000
wSize         = 0x0008

此请求将返回设备描述符的前8个字节，它对所有状态下的每个USB设备都有效

其他传输类型（大容量、中断）没有这些严格的格式规则，可以更容易地开始。我想你是h