遍历 USB devcie，读取设备描述符 device descriptor

flyyyri flyyyri 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.5w累计阅读 1.6w+平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄17年
关注
转载 最新推荐文章于 2026-08-07 23:20:00 发布 1.5w 阅读 AI 写同款· GEO 优化 ›
设备描述符读取失败应对：操作指南详解 当电脑无法识别USB设备时，常因设备描述符读取失败导致。掌握正确的故障排查步骤，如更换接口、检查驱动，能有效解决连接问题，让设备恢复正常通信。 阅读详情

理论:
    对于USB接口的设备，现在越来越多了。本篇我们就通过获取一个USB扫描仪设备中的序列号，来介绍如何获取usb设备的一些硬件信息。对于usb设备都是采用HCD0,HCD1,HCD2,HCD3等符号描述的。如下图：


因此，有了这个名字，我们就可以使用CreateFile来打开usb设备。然后使用DeviceIoControl函数与usb设备通讯了。HCD是host controller driver的简写。需要了解详情的，还要仔细的阅读usb协议。
usb的通讯基本步骤如下图所示：
 

基本步骤：
    1）打开HCD%X
    2) 得到上面的USB root hub
    3) 遍历usb root hub上连接的usb 设备。获取信息
    4）如果有多个usb口，循环前3步。

 

下面介绍通讯用的几个IOCTL:
1)USB_HCD_DRIVERKEY_NAME ,用于获取USB设备驱动在注册表中的键名。相应的一个结构体是：
typedef struct _USB_HCD_DRIVERKEY_NAME
{
   ULONG   ActualLength;
   WCHAR   DriverKeyName[1];
} USB_HCD_DRIVERKEY_NAME, *PUSB_HCD_DRIVERKEY_NAME;

2）IOCTL_USB_GET_ROOT_HUB_NAME，用于获取root hub 键名。使用的结构体，跟上面一样。
typedef struct _USB_ROOT_HUB_NAME
{
    ULONG ActualLength;
    WCHAR RootHubName[1];
} USB_ROOT_HUB_NAME, *PUSB_ROOT_HUB_NAME;

3）IOCTL_USB_GET_NODE_INFORMATION，用于获取连接在root hub上的节点设备信息。也就是我们接在usb口上的所有usb设备的信息，对应的结构体：
typedef struct _USB_NODE_INFORMATION
{
    USB_HUB_NODE NodeType;   
    union {
        USB_HUB_INFORMATION HubInformation;
        USB_MI_PARENT_INFORMATION MiParentInformation;
    } u;
} USB_NODE_INFORMATION, *PUSB_NODE_INFORMATION;

typedef struct _USB_MI_PARENT_INFORMATION
{
    ULONG NumberOfInterfaces;
} USB_MI_PARENT_INFORMATION, *PUSB_MI_PARENT_INFORMATION;

typedef struct _USB_HUB_INFORMATION
{
    USB_HUB_DESCRIPTOR HubDescriptor;

    BOOLEAN HubIsBusPowered;

} USB_HUB_INFORMATION, *PUSB_HUB_INFORMATION;


typedef struct _USB_HUB_DESCRIPTOR
{
    UCHAR        bDescriptorLength;      // Length of this descriptor
    UCHAR        bDescriptorType;        // Hub configuration type
    UCHAR        bNumberOfPorts;         // number of ports on this hub
    USHORT       wHubCharacteristics;    // Hub Charateristics
    UCHAR        bPowerOnToPowerGood;    // port power on till power good in 2ms
    UCHAR        bHubControlCurrent;     // max current in mA
    //
    // room for 255 ports power control and removable bitmask
    UCHAR        bRemoveAndPowerMask[64];      
} USB_HUB_DESCRIPTOR, *PUSB_HUB_DESCRIPTOR;

4) IOCTL_USB_GET_NODE_CONNECTION_INFORMATION, 用于获取接在usb口上的单个usb设备的信息，对应的结构体：

typedef struct _USB_NODE_CONNECTION_INFORMATION
{
    ULONG ConnectionIndex;
    USB_DEVICE_DESCRIPTOR DeviceDescriptor;
    UCHAR CurrentConfigurationValue;
    BOOLEAN LowSpeed;

    BOOLEAN DeviceIsHub;

    USHORT DeviceAddress;

    ULONG NumberOfOpenPipes;

    USB_CONNECTION_STATUS ConnectionStatus;
    USB_PIPE_INFO PipeList[0];
} USB_NODE_CONNECTION_INFORMATION, *PUSB_NODE_CONNECTION_INFORMATION;

4）IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION， 用于获取usb设备的描述信息。
typedef struct _USB_DEVICE_DESCRIPTOR
{
    UCHAR bLength;
    UCHAR bDescriptorType;
    USHORT bcdUSB;
    UCHAR bDeviceClass;
    UCHAR bDeviceSubClass;
    UCHAR bDeviceProtocol;
    UCHAR bMaxPacketSize0;
    USHORT idVendor;
    USHORT idProduct;
    USHORT bcdDevice;
    UCHAR iManufacturer;
    UCHAR iProduct;
    UCHAR iSerialNumber;
    UCHAR bNumConfigurations;
} USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;

typedef struct _USB_DEVICE_DESCRIPTOR
{
    UCHAR bLength;
    UCHAR bDescriptorType;
    USHORT bcdUSB;
    UCHAR bDeviceClass;
    UCHAR bDeviceSubClass;
    UCHAR bDeviceProtocol;
    UCHAR bMaxPacketSize0;
    USHORT idVendor;
    USHORT idProduct;
    USHORT bcdDevice;
    UCHAR iManufacturer;
    UCHAR iProduct;
    UCHAR iSerialNumber;
    UCHAR bNumConfigurations;
} USB_DEVICE_DESCRIPTOR, *PUSB_DEVICE_DESCRIPTOR;

typedef enum _USB_CONNECTION_STATUS
{
    NoDeviceConnected,
    DeviceConnected,

    /* failure codes, these map to fail reasons */
    DeviceFailedEnumeration,
    DeviceGeneralFailure,
    DeviceCausedOvercurrent,
    DeviceNotEnoughPower,
    DeviceNotEnoughBandwidth,
    DeviceHubNestedTooDeeply,
    DeviceInLegacyHub
} USB_CONNECTION_STATUS, *PUSB_CONNECTION_STATUS;

typedef struct _USB_PIPE_INFO
{
    USB_ENDPOINT_DESCRIPTOR EndpointDescriptor;
    ULONG ScheduleOffset;
} USB_PIPE_INFO, *PUSB_PIPE_INFO;

typedef struct _USB_ENDPOINT_DESCRIPTOR
{
    UCHAR bLength;
    UCHAR bDescriptorType;
    UCHAR bEndpointAddress;
    UCHAR bmAttributes;
    USHORT wMaxPacketSize;
    UCHAR bInterval;
} USB_ENDPOINT_DESCRIPTOR, *PUSB_ENDPOINT_DESCRIPTOR;

需要注意一点，如果要得到pid,vid,则直接从USB_DEVICE_DESCRIPTOR结构中取出idVendor，idProduct这两项的值就行了。如果要得到序列号，则不是取出 iSerialNumber就可以的。这里的 iSerialNumber仅仅是一个索引值。如果想得到序列号，就需要定义一个结构，然后给设备发送个请求。请求的结构如下图：

 

代码参照GetStringDescriptor函数。可以根据iSerialNumber偏移，取出其对应的字符串，存放在上图USB_STRING_DESCRIPTOR结构中。
#include "windows.h"
#include "PlkUsbIo.h"
#include <malloc.h>

#define NUM_HCS_TO_CHECK 10

/******************************************************************/
bool EnumUsbDevice();
PCHAR GetDriverKeyName(HANDLE Hub, ULONG ConnectionIndex);
PCHAR GetHCDDriverKeyName(HANDLE HCD);
PCHAR GetRootHubName(HANDLE HostController);
PCHAR WideStrToMultiStr(PWCHAR WideStr);
bool GetStringDescriptor (
        HANDLE hHubDevice,
        ULONG   ConnectionIndex,
        UCHAR   DescriptorIndex    ,
        CHAR * outBuff);
   
/******************************************************************/

int main(int argc, char* argv[])
{
    EnumUsbDevice()；
    return 0;
}

bool EnumUsbDevice()
{
    char        HCName[16];
    int         HCNum;
    HANDLE      hHCDev;
    PCHAR       rootHubName;

    ULONG       index;
    BOOL        success;

    PUSB_NODE_CONNECTION_INFORMATION    connectionInfo;
    HANDLE hHubDevice;

    for (HCNum = 0; HCNum < NUM_HCS_TO_CHECK; HCNum++)
    {
        wsprintf(HCName, "////.//HCD%d", HCNum);
        hHCDev = CreateFile(HCName,
            GENERIC_WRITE,
            FILE_SHARE_WRITE,
            NULL,
            OPEN_EXISTING,
            0,
            NULL);
        if (hHCDev == INVALID_HANDLE_VALUE)   
            break;
       
        PCHAR driverKeyName, deviceDesc;
        driverKeyName = GetHCDDriverKeyName(hHCDev);
        if(driverKeyName == NULL)
            goto end;   
       
   
        ULONG nBytes;
        rootHubName =(char*) GetRootHubName(hHCDev);
        if(rootHubName==NULL)
            goto end;
   
        PUSB_NODE_INFORMATION HubInfo;
        HubInfo = (PUSB_NODE_INFORMATION)malloc(sizeof(USB_NODE_INFORMATION));
        PCHAR deviceName;
        deviceName = (PCHAR)malloc(strlen(rootHubName) + sizeof("////.//"));
        if (rootHubName != NULL)
        {
            strcpy(deviceName, "////.//");
            strcpy(deviceName + sizeof("////.//") - 1, rootHubName);
            hHubDevice = CreateFile(deviceName,
                GENERIC_WRITE,
                FILE_SHARE_WRITE,
                NULL,
                OPEN_EXISTING,
                0,
                NULL);
            free(deviceName);
            if (hHubDevice == INVALID_HANDLE_VALUE)
                goto end;
           
            success = DeviceIoControl(hHubDevice,
                IOCTL_USB_GET_NODE_INFORMATION,
                HubInfo,
                sizeof(USB_NODE_INFORMATION),
                HubInfo,
                sizeof(USB_NODE_INFORMATION),
                &nBytes,
                NULL);
            if (!success)
                goto end;
           

        }

        int port;
        port=HubInfo->u.HubInformation.HubDescriptor.bNumberOfPorts;
        for (index=1; index <= port; index++)
        {
            ULONG nBytes;
            nBytes = sizeof(USB_NODE_CONNECTION_INFORMATION) +
                sizeof(USB_PIPE_INFO) * 30;
            connectionInfo = (PUSB_NODE_CONNECTION_INFORMATION)malloc(nBytes);
            if (connectionInfo == NULL)
                goto end;
           
            connectionInfo->ConnectionIndex = index;
            success = DeviceIoControl(hHubDevice,
                IOCTL_USB_GET_NODE_CONNECTION_INFORMATION,
                connectionInfo,
                nBytes,
                connectionInfo,
                nBytes,
                &nBytes,
                NULL);
            if (!success)
            {
                free(connectionInfo);
                goto end;
            }
       

            deviceDesc = NULL;
            if (connectionInfo->ConnectionStatus != NoDeviceConnected)
            {
                driverKeyName = GetDriverKeyName(hHubDevice,
                    index);
                if (driverKeyName)
                {
                    free(driverKeyName);
                }
            }

            if (connectionInfo->ConnectionStatus == DeviceConnected)
            {
                //取出序列号索引
                UCHAR nSerialno = connectionInfo->DeviceDescriptor.iSerialNumber;
                CHAR OutBuff[20] = {0};
                GetStringDescriptor(hHubDevice,connectionInfo->ConnectionIndex,nSerialno,OutBuff);

                //判断序列号是否有效
                if(序列号是否有效)
                {
                      CloseHandle(hHubDevice);
                      CloseHandle(hHCDev);
                     return true;
                }
            }

        }
end:;
    }

    CloseHandle(hHubDevice);
    CloseHandle(hHCDev);
    return false;
}

PCHAR GetDriverKeyName(HANDLE Hub, ULONG ConnectionIndex)
{
    BOOL                                success;
    ULONG                               nBytes;
    USB_NODE_CONNECTION_DRIVERKEY_NAME driverKeyName;
    PUSB_NODE_CONNECTION_DRIVERKEY_NAME driverKeyNameW;
    PCHAR                               driverKeyNameA;

    driverKeyNameW = NULL;
    driverKeyNameA = NULL;

    driverKeyName.ConnectionIndex = ConnectionIndex;

    success = DeviceIoControl(Hub,
        IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME,
        &driverKeyName,
        sizeof(driverKeyName),
        &driverKeyName,
        sizeof(driverKeyName),
        &nBytes,
        NULL);

    if (!success)
    {
        goto GetDriverKeyNameError;
    }

    nBytes = driverKeyName.ActualLength;

    if (nBytes <= sizeof(driverKeyName))
    {
        goto GetDriverKeyNameError;
    }

    driverKeyNameW = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME)malloc(nBytes);

    if (driverKeyNameW == NULL)
    {
        goto GetDriverKeyNameError;
    }

    driverKeyNameW->ConnectionIndex = ConnectionIndex;

    success = DeviceIoControl(Hub,
        IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME,
        driverKeyNameW,
        nBytes,
        driverKeyNameW,
        nBytes,
        &nBytes,
        NULL);

    if (!success)
    {
        goto GetDriverKeyNameError;
    }
    driverKeyNameA = WideStrToMultiStr(driverKeyNameW->DriverKeyName);
    free(driverKeyNameW);

    return driverKeyNameA;


GetDriverKeyNameError:
    if (driverKeyNameW != NULL)
    {
        free(driverKeyNameW);
        driverKeyNameW = NULL;
    }

    return NULL;
}
PCHAR GetRootHubName(HANDLE HostController)
{
    BOOL                success;
    ULONG               nBytes;
    USB_ROOT_HUB_NAME   rootHubName;
    PUSB_ROOT_HUB_NAME rootHubNameW;
    PCHAR               rootHubNameA;

    rootHubNameW = NULL;
    rootHubNameA = NULL;

    success = DeviceIoControl(HostController,
        IOCTL_USB_GET_ROOT_HUB_NAME,
        0,
        0,
        &rootHubName,
        sizeof(rootHubName),
        &nBytes,
        NULL);

    if (!success)
    {
        goto GetRootHubNameError;
    }

    nBytes = rootHubName.ActualLength;

    rootHubNameW =(PUSB_ROOT_HUB_NAME) malloc(nBytes);

    if (rootHubNameW == NULL)
    {

        goto GetRootHubNameError;
    }

    success = DeviceIoControl(HostController,
        IOCTL_USB_GET_ROOT_HUB_NAME,
        NULL,
        0,
        rootHubNameW,
        nBytes,
        &nBytes,
        NULL);

    if (!success)
    {
        goto GetRootHubNameError;
    }

    rootHubNameA = WideStrToMultiStr(rootHubNameW->RootHubName);
    free(rootHubNameW);

    return rootHubNameA;


GetRootHubNameError:
    if (rootHubNameW != NULL)
    {
        free(rootHubNameW);
        rootHubNameW = NULL;
    }

    return NULL;
}
PCHAR GetHCDDriverKeyName(HANDLE HCD)
{
    BOOL                    success;
    ULONG                   nBytes;
    USB_HCD_DRIVERKEY_NAME driverKeyName;
    PUSB_HCD_DRIVERKEY_NAME driverKeyNameW;
    PCHAR                   driverKeyNameA;

    driverKeyNameW = NULL;
    driverKeyNameA = NULL;

    success = DeviceIoControl(HCD,
        IOCTL_GET_HCD_DRIVERKEY_NAME,
        &driverKeyName,
        sizeof(driverKeyName),
        &driverKeyName,
        sizeof(driverKeyName),
        &nBytes,
        NULL);

    if (!success)
    {
        goto GetHCDDriverKeyNameError;
    }

    nBytes = driverKeyName.ActualLength;

    if (nBytes <= sizeof(driverKeyName))
    {
        goto GetHCDDriverKeyNameError;
    }

    driverKeyNameW =(PUSB_HCD_DRIVERKEY_NAME) malloc(nBytes);

    if (driverKeyNameW == NULL)
    {
        goto GetHCDDriverKeyNameError;
    }

    success = DeviceIoControl(HCD,
        IOCTL_GET_HCD_DRIVERKEY_NAME,
        driverKeyNameW,
        nBytes,
        driverKeyNameW,
        nBytes,
        &nBytes,
        NULL);

    if (!success)
    {
        goto GetHCDDriverKeyNameError;
    }

    driverKeyNameA = WideStrToMultiStr(driverKeyNameW->DriverKeyName);
    free(driverKeyNameW);

    return driverKeyNameA;


GetHCDDriverKeyNameError:
    if (driverKeyNameW != NULL)
    {
        free(driverKeyNameW);
        driverKeyNameW = NULL;
    }

    return NULL;
}

PCHAR WideStrToMultiStr(PWCHAR WideStr)
{
    ULONG nBytes;
    PCHAR MultiStr;
    nBytes = WideCharToMultiByte(
        CP_ACP,
        0,
        WideStr,
        -1,
        NULL,
        0,
        NULL,
        NULL);

    if (nBytes == 0)
    {
        return NULL;
    }
    MultiStr =(PCHAR) malloc(nBytes);

    if (MultiStr == NULL)
    {
        return NULL;
    }
    nBytes = WideCharToMultiByte(
        CP_ACP,
        0,
        WideStr,
        -1,
        MultiStr,
        nBytes,
        NULL,
        NULL);

    if (nBytes == 0)
    {
        free(MultiStr);
        return NULL;
    }

    return MultiStr;
}


bool    GetStringDescriptor (
        HANDLE hHubDevice,
        ULONG   ConnectionIndex,
        UCHAR   DescriptorIndex    ,
        CHAR * outBuff
        )
    {
        BOOL    success;
        ULONG   nBytes;
        ULONG   nBytesReturned;

        UCHAR   stringDescReqBuf[sizeof(USB_DESCRIPTOR_REQUEST) + MAXIMUM_USB_STRING_LENGTH];

        PUSB_DESCRIPTOR_REQUEST stringDescReq;
        PUSB_STRING_DESCRIPTOR stringDesc;

        nBytes = sizeof(stringDescReqBuf);

        stringDescReq = (PUSB_DESCRIPTOR_REQUEST)stringDescReqBuf;
        stringDesc = (PUSB_STRING_DESCRIPTOR)(stringDescReq+1);

   
        ::ZeroMemory(stringDescReq,nBytes);
        stringDescReq->ConnectionIndex = ConnectionIndex;
        stringDescReq->SetupPacket.wValue = (USB_STRING_DESCRIPTOR_TYPE << 8) | DescriptorIndex;
        stringDescReq->SetupPacket.wIndex = GetSystemDefaultLangID();
        stringDescReq->SetupPacket.wLength = (USHORT)(nBytes - sizeof(USB_DESCRIPTOR_REQUEST));

        success = DeviceIoControl(hHubDevice,IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                                stringDescReq,nBytes,
                                stringDescReq,nBytes,
                                &nBytesReturned,NULL);

        if (!success || nBytesReturned < 2)
            return false;

        if (stringDesc->bDescriptorType != USB_STRING_DESCRIPTOR_TYPE)
            return false;

        if (stringDesc->bLength != nBytesReturned - sizeof(USB_DESCRIPTOR_REQUEST))
            return false;

        if (stringDesc->bLength % 2 != 0)
            return false;

        WCHAR * wChar = new WCHAR[stringDesc->bLength + 1];
        memcpy(wChar,stringDesc->bString,stringDesc->bLength);
        char *szTemp = WideStrToMultiStr(wChar);
        lstrcpy(outBuff, szTemp);
       
        if(szTemp)
        delete []szTemp;
       
        if(wChar)
        delete []wChar;
        return true;
    }

分析：

1）首先假定有10个usb接口
    #define NUM_HCS_TO_CHECK 10

2）循环打开这10个usb端口，如果端口没有这么多，调用CreateFile，就会返回 INVALID_HANDLE_VALUE。
    for (HCNum = 0; HCNum < NUM_HCS_TO_CHECK; HCNum++)
    {
        wsprintf(HCName, "////.//HCD%d", HCNum);
        hHCDev = CreateFile(HCName,
            GENERIC_WRITE,
            FILE_SHARE_WRITE,
            NULL,
            OPEN_EXISTING,
            0,
            NULL);
        if (hHCDev == INVALID_HANDLE_VALUE)   
            break;

3）获取root hub
       ULONG nBytes;
        rootHubName =(char*) GetRootHubName(hHCDev);
        if(rootHubName==NULL)
            goto end;

4) 遍历连接在root hub上的节点
        int port;
        port=HubInfo->u.HubInformation.HubDescriptor.bNumberOfPorts;
        for (index=1; index <= port; index++)
        {
            ULONG nBytes;
            nBytes = sizeof(USB_NODE_CONNECTION_INFORMATION) +
                sizeof(USB_PIPE_INFO) * 30;
            connectionInfo = (PUSB_NODE_CONNECTION_INFORMATION)malloc(nBytes);
            if (connectionInfo == NULL)
                goto end;
           
            connectionInfo->ConnectionIndex = index;
            success = DeviceIoControl(hHubDevice,
                IOCTL_USB_GET_NODE_CONNECTION_INFORMATION,
                connectionInfo,
                nBytes,
                connectionInfo,
                nBytes,
                &nBytes,
                NULL);
            if (!success)
            {
                free(connectionInfo);
                goto end;
            }

5）根据节点的连接状态，获取节点信息，得到序列号。
    if (connectionInfo->ConnectionStatus == DeviceConnected)
            {
                //取出序列号索引
                UCHAR nSerialno = connectionInfo->DeviceDescriptor.iSerialNumber;
                CHAR OutBuff[20] = {0};
                GetStringDescriptor(hHubDevice,connectionInfo->ConnectionIndex,nSerialno,OutBuff);

6）得到序列号的方法在理论部分已经详细说明了，对应的函数是GetStringDescriptor，这里不再重复。


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jtujtujtu/archive/2009/11/19/4836900.aspx

收录于
C++

当前文章被收录于：

C++
5 篇文章 0 人学习
订阅专栏 查看详情
标签
#descriptor #null #struct #string #delete
#通讯
C# 获取USB设备列表 窗体设计及运行效果图 添加CyUSB.dll引用（如果需要识别由CyUSB.sys提供设备驱动的USB设备） 源码： public partial class Form1 : Form { USBDeviceList usbDevices; CyUSBDevice myDevice; public Form1() ... 阅读详情

相关推荐

华为海思IC设计岗位笔试全解析：物理、电路与工艺三大方向备考指南

本文全面解析华为海思IC设计岗位笔试的物理、电路与工艺三大方向备考要点。针对物理设计方向，重点讲解半导体能带理论、载流子输运机制等核心考点；电路设计方向涵盖Verilog语法、UVM验证等关键技术；工艺方向则深入探讨FinFET工艺、光刻技术等前沿知识。提供高效备考策略和应试技巧，助力考生提升通过率。

weixin_29196613的博客 852

未知USB设备（设备描述符请求失败）解决方法

问题如图： 第一步: windows键+r键 -》输入：service.msc 第二步： 在服务窗口中找到Plug and Play服务，双击Plug and Play，打开Plug and Play的属性窗口： 首先将Plug and Play服务的启动类型为：禁用，停止服务，点击应用，确定，此时启动类型为：禁用，服务状态为：已停止， 然后再点击 Plug and Play服...

qq_40233706的博客 33万+

Android 获取 USB 设备类型

接下来，在我们的 Activity 或 Fragment 中，我们需要注册一个 BroadcastReceiver 来接收 USB 设备的连接和断开事件。我们可以通过 Intent.ACTION_UMS_CONNECTED 和 Intent.ACTION_UMS_DISCONNECTED 来监听 USB 设备的连接和断开。为了正确处理不同类型的 USB 设备，我们需要获取 USB 设备的类型信息。根据 USB 设备的类型，我们可以执行不同的操作。根据实际需求，您可以根据不同的设备类型执行相应的逻辑。

pytorchCode的博客 1076

zz: 遍历 USB devcie，读取设备描述符 device descriptor

 理论:    对于USB接口的设备，现在越来越多了。本篇我们就通过获取一个USB扫描仪设备中的序列号，来介绍如何获取usb设备的一些硬件信息。对于usb设备都是采用HCD0,HCD1,HCD2,HCD3等符号描述的。如下图：因此，有了这个名字，我们就可以使用CreateFile来打开usb设备。然后使用DeviceIoControl函数与usb设备通讯了。HCD是host controlle

jtujtujtu的专栏 7957

遍历USB devcie,读取设备描述符 device descriptor

http://blog.csdn.net/jtujtujtu/article/details/4836900 理论: 对于USB接口的设备，现在越来越多了。本篇我们就通过获取一个USB扫描仪设备中的序列号，来介绍如何获取usb设备的一些硬件信息。对于usb设备都是采用HCD0,HCD1,HCD2,HCD3等符号描述的。如下图： 因此，有了这个名字，我们就可以使用CreateFile来

danming60520的专栏 4972

遍历 USB devcie，读取设备描述符 device descriptor【转】

转自：http://blog.csdn.net/flyyyri/article/details/5480347 理论: 对于USB接口的设备，现在越来越多了。本篇我们就通过获取一个USB扫描仪设备中的序列号，来介绍如何获取usb设备的一些硬件信息。对于usb设备都是采用HCD0,HCD1,HCD2,HCD3等符号描述的。如下图： 因此，有了这个名字...

weixin_33860528的博客 230

基于RK3568的UBoot实战：持续更新

基于正点原子RK3568开发板进行UBoot实战

weixin_43390831的博客 283

【USB笔记】 设备描述符Device Descriptor

USB笔记 设备描述符(Device Descriptor) 设备描述符（Device Descriptor）说明了USB设备的通用信息，包含应用到全部设备和所有设备配置的信息。USB设备只有一个设备描述符。设备描述符是在设备连接时主机读取的第一个描述字。此描述字所含的信息,被主机用来取得设备的额外内容。主机通过发送Get Descriptor 请求,并使设置事务中wValue 字段的高字节等于01h,来取得一个设备描述字。设备描述字提供了关于设备、设备的配置以及任何设备所归属的类的信息。 Device D

2万+

一问解决设备管理器里面提示：未知usb设备(设备描述符请求失败) 或者是“Unknown USB Device（Device Descriptor Request Sailed）”错误

哈喽！大家好，我是IT技术猿猴，最爱海贼王💞💞💞 是一位爱好技术的【技术宅男】！😜😜😜 💞💞💞 如果有对技术感兴趣的宅友，欢迎关注💞💞💞 ❤️❤️❤️感谢各位❤️❤️❤️ ———————————————— 🏳️‍🌈问题描述： 偶尔连接USB接口在设备管理器出现位置USB错误如图 下面给出几种解决办法 🏳️‍🌈最重要的一点：数据线坏了的可能性很大 建议换根线（UBS与设备的连接线），吃过这个亏，在尝试下面各种方法都不行，最后问产品的客服，建议换根线就好了，你说气不气人； 📢机箱...

IT技术猿猴的博客 2万+

遍历Windows USB设备树的几种方法

遍历Windows设备树的几种方法1. 设备信息1.1. 设备实例ID1.2. 设备树2. 使用CM系列函数枚举所有设备2.1. 常用的函数2.2. 示例3. 使用SetupAPI枚举所有设备3.1. 常用的函数3.2. 示例4. 使用DeviceIOControl枚举所有设备4.1. 枚举基本流程4.2. 示例5. 几种方式的关系5.1. SetupAPI与CM5.2. DeviceIoCont......

飞鹤的程序员人生 1万+

全志USB驱动提示位置USB设备,设备描述符请求失败

之后重新插拔USB设备，检查设备管理器中的“通用串行总线控制器”下是否有未知USB设备的错误提示消失‌。‌2.更新或重新安装驱动程序‌：驱动程序是连接电脑和USB设备的桥梁，如果驱动程序过时、损坏或缺失，可能导致USB设备无法被电脑识别或使用。如果问题依旧，可以尝试将USB设备连接到其他电脑，以确定问题是否出在电脑上还是USB设备本身‌。3‌.调整电源管理设置‌：在“设备管理器”中，找到“USB Root Hub”属性的“电源管理”选项卡，取消“允许计算机关闭此设备以节约电源”的选项。

tecoes的博客 5961

未知usb设备(设备描述请求失败)_灵动微课堂（第105讲） | MM32 USB功能学习笔记 —— USB HID设备...

腊八节快乐转眼间来到了2020年，新年伊始，小编将和大家一起学习使用MM32 MCU的USB功能。对于USB来说，主要应用是HID、CDC、MSC以及WINUSB等功能，此讲先介绍如何使用MM32 MCU的HID功能。对于USB设备来说，其中有一大类就是HID设备，即Human Interface Devices，人机接口设备。这类设备包括鼠标、键盘等，其主要用于人与计算机进行交互。它是...

weixin_39863161的博客 1374

未知USB设备（设备描述符请求失败）解决办法

问题如图所示网上方法很多，我就不再赘述了。但是我试了网上说的所有方法，包括但是不限于1.更新驱动，旧的新的CH340驱动都尝试。2.更换USB数据线3.重启plug and play4.电脑的强制驱动签名也关了，还是无法识别。

2403_87069802的博客 8128

2、获取device信息的方法

1、adb devices 2、利用工具 UI automator viewer

Rinalin 852

LangChain面试内容整理-知识点27：LangChain性能调优

LLM应用可能面临响应慢、成本高等性能问题。LangChain提供了一些优化方法和经验来提升性能和效率。

不务正业的猿 306

广联达办公大厦施工设计方案.pdf

广联达办公大厦施工设计方案.pdf
上一篇： 梅举设备信息的DDK函数
下一篇： VS2008搭建驱动开发环境
点赞 3
评论 0
书签 书签 15
flyyyri
flyyyri
博客等级 码龄17年 29粉丝 5原创
+ 关注 专栏目录 订阅专栏
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值