枚举所有USB设备代码

最新推荐文章于 2024-07-28 18:05:16 发布
最新推荐文章于 2024-07-28 18:05:16 发布
阅读量5.8k 收藏 7
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tody_guo/article/details/77483532
版权

枚举所有连接的USB设备代码，编译环境VS2010

项目地址：https://gitee.com/tody_guo/ls_usb.git

// ls_usb.cpp : Defines the entry point for the console application.
#include "stdafx.h"
#include <windows.h>
#include <basetyps.h>
#include <winioctl.h>
#include <setupapi.h>
#include <initguid.h>
#include <string.h>
#include <stdio.h>
#include <tchar.h>
#include "usb100.h"
#include "usbdesc.h"
#include "usbioctl.h"
#include "usbiodef.h"

#define MAX_HCD 10

typedef struct _STRING_DESCRIPTOR_NODE
{
    struct _STRING_DESCRIPTOR_NODE *Next;
    UCHAR                           DescriptorIndex;
    USHORT                          LanguageID;
    USB_STRING_DESCRIPTOR           StringDescriptor[0];
} STRING_DESCRIPTOR_NODE, *PSTRING_DESCRIPTOR_NODE;

/******************************************************************/
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);
PCHAR GetExternalHubName(HANDLE Hub,ULONG ConnectionIndex);
bool EnumerateHostControllers();
void EnumerateHub(PCHAR HubName, PCHAR Msg);
void EnumerateHubPorts(HANDLE hHubDevice,ULONG NumPorts);
PUSB_DESCRIPTOR_REQUEST GetConfigDescriptor(HANDLE	hHubDevice, ULONG ConnectionIndex, UCHAR DescriptorIndex);
BOOL AreThereStringDescriptors(PUSB_DEVICE_DESCRIPTOR DeviceDesc,PUSB_CONFIGURATION_DESCRIPTOR ConfigDesc);
/******************************************************************/

void EnumerateHubPorts(HANDLE hHubDevice,ULONG NumPorts)
{
    ULONG       index;
    BOOL        success;
	PUSB_NODE_CONNECTION_INFORMATION    connectionInfo;
	PUSB_DESCRIPTOR_REQUEST             configDesc;

	//list ports of root hub
	 unsigned int port;
	 port=NumPorts;
	 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;
	     }
	
	     if (connectionInfo->ConnectionStatus == DeviceConnected)
	     {

            configDesc = GetConfigDescriptor(hHubDevice, index, 0);

			 if (connectionInfo->DeviceIsHub){
				PCHAR extHubName;
				extHubName = GetExternalHubName(hHubDevice,index);
				if (extHubName != NULL){
					EnumerateHub(extHubName," - External Hub");
					//continue;
				}
			 }

			// printf("configIndex:%d\n",configDesc->SetupPacket.);

			UCHAR nProduct = connectionInfo->DeviceDescriptor.iProduct;
			UCHAR nManuf = connectionInfo->DeviceDescriptor.iManufacturer;
			CHAR OutBuffPro[20] = {0};
			CHAR OutBuffMan[20] = {0};
			GetStringDescriptor(hHubDevice, connectionInfo->ConnectionIndex, nProduct, OutBuffPro);
			GetStringDescriptor(hHubDevice, connectionInfo->ConnectionIndex, nManuf, OutBuffMan);
			printf("\n\t[PORT%d]: %04X:%04X\t%04X\t%s - %s", index, connectionInfo->DeviceDescriptor.idVendor, connectionInfo->DeviceDescriptor.idProduct,
				connectionInfo->DeviceDescriptor.bcdUSB, OutBuffMan, OutBuffPro);
	     }

	}

end:	
	CloseHandle(hHubDevice);
}

void EnumerateHub(PCHAR rootHubName, PCHAR Msg)
{
    ULONG	index;
    BOOL	success;

    PUSB_NODE_CONNECTION_INFORMATION    connectionInfo;
    HANDLE hHubDevice;

	PCHAR driverKeyName, deviceDesc;
	
	ULONG nBytes;

	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);
		
		printf("\n%s: %s", Msg, deviceName);
	    
		hHubDevice = CreateFileA(deviceName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
		if (hHubDevice == INVALID_HANDLE_VALUE){
			printf("\nCreateFile");
	        exit(1);
		}

	    free(deviceName);
	
	    success = DeviceIoControl(hHubDevice, IOCTL_USB_GET_NODE_INFORMATION, HubInfo, sizeof(USB_NODE_INFORMATION), HubInfo, sizeof(USB_NODE_INFORMATION), &nBytes, NULL);
	    if (!success){
			printf("\nDeviceIoControl");
			exit(1);
		}
	}
	
	// noew emuerate all ports 
	EnumerateHubPorts(hHubDevice, HubInfo->u.HubInformation.HubDescriptor.bNumberOfPorts);

}

bool EnumerateHostControllers()
{
    WCHAR       HCName[16];
	HANDLE      hHCDev;
	int         HCNum;
	PCHAR       driverKeyName;
	PCHAR       deviceDesc;
	PCHAR       rootHubName;

	for (HCNum = 0; HCNum < MAX_HCD; HCNum++){
        wsprintf(HCName, _T("\\\\.\\HCD%d"), HCNum);
        hHCDev = CreateFile(HCName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
        if (hHCDev == INVALID_HANDLE_VALUE){
            return false;
		}

		driverKeyName = GetHCDDriverKeyName(hHCDev);
		if (driverKeyName)
		{
			rootHubName=GetRootHubName(hHCDev);
			if(rootHubName!=NULL)
			{
				EnumerateHub(rootHubName, "Root Hub");
			}else{
				CloseHandle(hHCDev);
				return false;
			}
		}else{
			CloseHandle(hHCDev);
			return false;
		}

		CloseHandle(hHCDev);
	}

	return true;
}

PCHAR GetExternalHubName(HANDLE Hub,ULONG ConnectionIndex)
{
    BOOL                        success;
    ULONG                       nBytes;
    USB_NODE_CONNECTION_NAME    extHubName;
    PUSB_NODE_CONNECTION_NAME   extHubNameW;
    PCHAR                       extHubNameA;
	
    extHubNameW = NULL;
    extHubNameA = NULL;

    extHubName.ConnectionIndex = ConnectionIndex;
    success = DeviceIoControl(Hub, IOCTL_USB_GET_NODE_CONNECTION_NAME, &extHubName, sizeof(extHubName), &extHubName, sizeof(extHubName), &nBytes,NULL);
    if (!success)
        goto GetExternalHubNameError;
	

    nBytes = extHubName.ActualLength;
    if (nBytes <= sizeof(extHubName))
        goto GetExternalHubNameError;
	
    extHubNameW=(PUSB_NODE_CONNECTION_NAME)GlobalAlloc(GPTR,nBytes);
    if (extHubNameW == NULL)
        goto GetExternalHubNameError;

    extHubNameW->ConnectionIndex = ConnectionIndex;
    success = DeviceIoControl(Hub, IOCTL_USB_GET_NODE_CONNECTION_NAME, extHubNameW, nBytes, extHubNameW, nBytes, &nBytes, NULL);
    if (!success)
        goto GetExternalHubNameError;
	

    extHubNameA = WideStrToMultiStr(extHubNameW->NodeName);
	
    GlobalFree(extHubNameW);

    return extHubNameA;
	
GetExternalHubNameError:
    if (extHubNameW != NULL)
    {
        GlobalFree(extHubNameW);
        extHubNameW = NULL;
    }
	
    return NULL;
}

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

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 AreThereStringDescriptors(PUSB_DEVICE_DESCRIPTOR DeviceDesc,PUSB_CONFIGURATION_DESCRIPTOR ConfigDesc)
{
    PUCHAR                  descEnd;
    PUSB_COMMON_DESCRIPTOR  commonDesc;
	
    // Check Device Descriptor strings
    if(DeviceDesc->iManufacturer||DeviceDesc->iProduct||DeviceDesc->iSerialNumber)
        return TRUE;
	
    // Check the Configuration and Interface Descriptor strings
    descEnd = (PUCHAR)ConfigDesc + ConfigDesc->wTotalLength;
    commonDesc = (PUSB_COMMON_DESCRIPTOR)ConfigDesc;
	
    while ((PUCHAR)commonDesc + sizeof(USB_COMMON_DESCRIPTOR) < descEnd &&
		(PUCHAR)commonDesc + commonDesc->bLength <= descEnd)
    {
        switch (commonDesc->bDescriptorType)
        {
		case USB_CONFIGURATION_DESCRIPTOR_TYPE:
			if (commonDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR))
				break;
			
			if (((PUSB_CONFIGURATION_DESCRIPTOR)commonDesc)->iConfiguration)
				return TRUE;			
			continue;
			
		case USB_INTERFACE_DESCRIPTOR_TYPE:
			if (commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR) &&
				commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR2))
				break;			
			if (((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->iInterface)
				return TRUE;
			continue;
			
		default:
			continue;
        }
        break;
    }
	
    return FALSE;
}

PUSB_DESCRIPTOR_REQUEST GetConfigDescriptor(HANDLE	hHubDevice, ULONG ConnectionIndex, UCHAR DescriptorIndex)
{
    BOOL    success;
    ULONG   nBytes;
    ULONG   nBytesReturned;
    UCHAR   configDescReqBuf[sizeof(USB_DESCRIPTOR_REQUEST)+sizeof(USB_CONFIGURATION_DESCRIPTOR)];

    PUSB_DESCRIPTOR_REQUEST         configDescReq;
    PUSB_CONFIGURATION_DESCRIPTOR   configDesc;

    // Request the Configuration Descriptor the first time using our
    // local buffer, which is just big enough for the Cofiguration
    // Descriptor itself.
    nBytes = sizeof(configDescReqBuf);
    configDescReq = (PUSB_DESCRIPTOR_REQUEST)configDescReqBuf;
    configDesc = (PUSB_CONFIGURATION_DESCRIPTOR)(configDescReq+1);
    memset(configDescReq, 0, nBytes);
	//是此hub上的哪个port需要被request
    configDescReq->ConnectionIndex = ConnectionIndex;

    // USBHUB uses URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE to process this
    // IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION request.
    // USBD will automatically initialize these fields:
    //     bmRequest = 0x80
    //     bRequest  = 0x06
    // We must inititialize these fields:
    //     wValue    = Descriptor Type (high) and Descriptor Index (low byte)
    //     wIndex    = Zero (or Language ID for String Descriptors)
    //     wLength   = Length of descriptor buffer
    configDescReq->SetupPacket.wValue=(USB_CONFIGURATION_DESCRIPTOR_TYPE<<8)|DescriptorIndex;
    configDescReq->SetupPacket.wLength=(USHORT)(nBytes-sizeof(USB_DESCRIPTOR_REQUEST));

    success=DeviceIoControl(hHubDevice, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, configDescReq, nBytes, configDescReq, nBytes, &nBytesReturned, NULL);
    if(!success)
        return NULL;

    if(nBytes!=nBytesReturned)
        return NULL;

    if(configDesc->wTotalLength<sizeof(USB_CONFIGURATION_DESCRIPTOR))
        return NULL;

	//用一个动态申请的足够放置全部descriptor的buffer来请求全部configuration descriptor
    nBytes=sizeof(USB_DESCRIPTOR_REQUEST)+configDesc->wTotalLength;
    configDescReq=(PUSB_DESCRIPTOR_REQUEST)GlobalAlloc(GPTR,nBytes);
    if (configDescReq==NULL)
        return NULL;

    configDesc = (PUSB_CONFIGURATION_DESCRIPTOR)(configDescReq+1);
    // Indicate the port from which the descriptor will be requested
    configDescReq->ConnectionIndex = ConnectionIndex;

    // USBHUB uses URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE to process this
    // IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION request.
    // USBD will automatically initialize these fields:
    //     bmRequest = 0x80
    //     bRequest  = 0x06
    // We must inititialize these fields:
    //     wValue    = Descriptor Type (high) and Descriptor Index (low byte)
    //     wIndex    = Zero (or Language ID for String Descriptors)
    //     wLength   = Length of descriptor buffer
    configDescReq->SetupPacket.wValue=(USB_CONFIGURATION_DESCRIPTOR_TYPE<<8)|DescriptorIndex;

    configDescReq->SetupPacket.wLength=(USHORT)(nBytes-sizeof(USB_DESCRIPTOR_REQUEST));

    // Now issue the get descriptor request.
    success = DeviceIoControl(hHubDevice, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, configDescReq, nBytes, configDescReq, nBytes, &nBytesReturned, NULL);
    if(!success)
	{
        GlobalFree(configDescReq);
        return NULL;
    }

    if(nBytes!=nBytesReturned)
    {
        GlobalFree(configDescReq);
        return NULL;
    }

    if(configDesc->wTotalLength!=(nBytes-sizeof(USB_DESCRIPTOR_REQUEST)))
    {
        GlobalFree(configDescReq);
        return NULL;
    }

    return configDescReq;
}

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

	lstrcpyA(outBuff, szTemp);

	if(szTemp)
		delete []szTemp;
	
	if(wChar)
		delete []wChar;

	return true;
}

 

Tody Guo
关注
专栏目录
Windows下USB磁盘开发系列二：枚举系统中所有USB设备
weixin_33672109的博客
01-08 320
现在介绍下如何枚举系统中所有USB设备（不光是U盘）。主要调用的API如下： 1，调用SetupDiGetClassDevs()获取指定设备类型的句柄； 2，调用SetupDiEnumDeviceInfo()枚举设备信息； 3，调用SetupDiGetDeviceRegistryProperty()获取设备信息。 具体实现函数如下： int enum_usb_device_info(...
枚举USB设备接口(C++源代码)
11-12
c++ 实现枚举USB设备接口 涉及函数: SetupDiGetClassDevs SetupDiEnumDeviceInterfaces SetupDiGetDeviceInterfaceDetail
USB 2.0 协议专栏之 USB 2.0 连接与枚举（二）
最新发布
black_sneak的博客
07-28 1123
本篇博客为手把手教学的 USB 2.0 协议栈的第 2 篇博客，详细讲述了 USB 设备的连接与枚举过程，且以沁恒微 CH32V307 作为核心 MCU 进行讲解分析！
WIN10+VS2017环境下对USB HID设备进行枚举的程序（含源码）
热门推荐
不积跬步，无以至千里！
02-20 1万+
前段时间在WIN10系统+VS2017环境下安装了USB开发的驱动环境（详见我的博客【如何在win10+VS2017环境下安装USB驱动开发套件WDK】），今天介绍一下如何建立一个简单的HID设备枚举工程。文中的工程使用VS2017社区版建立和编译，文中对整个工程的建立、配置、编码过程进行了详细的介绍，大家可以参照自己执行。如果觉得麻烦，也可以点击此处直接下载我编辑好的整个工程。 步骤1、新建工程...
获取当前电脑所有插入USB设备的PID和VID
05-24
获取当前电脑所有插入USB设备的PID和VID，检测设备，识别不同的厂商。
枚举HUB设备
liyuchao11的博客
10-22 381
Enum.h #include <vector> #include<map> #include "stdafx.h" #include <set> #define NUM_HCD_TO_CHECK 10 using namespace std; #define MAX_DEVICE_NUMS 25 #define NUM_HCD_TO_CHECK 10 typedef struct _INITIO_MODE_INFO { USHORT n
枚举USB设备的vc 代码.zip
08-26
在本文中，我们将深入探讨如何使用VC++（Visual C++）来枚举USB设备，并将主要关注提供的两个压缩包文件中的代码示例：USBView_VC和91708153USBTest。这两个项目都是关于如何通过编程方式检测、访问和管理连接到...
USB.rar_usb连接设备_枚举USB设备
09-21
枚举USB设备则是指在操作系统中识别并列出所有已连接或已注册的USB设备的过程，这通常由操作系统内部的驱动程序来完成。 在给定的“USB.rar”压缩包中，包含了几个关键文件，它们是用于开发一个能够枚举USB设备的...
usb.rar_USB 枚举_usb_usb共享_加密设备
09-19
综上所述，这个“usb.rar”压缩包可能包含了与USB设备枚举、读取CPU信息、实现USB共享以及加密设备相关的代码示例或工具，供开发者参考学习。通过理解和应用这些技术，可以提升对USB设备的管理和安全使用能力。
USB.zip_USB HUB _USB 枚举_usb_usb端口的枚举_枚举HUB
09-21
文件“USBDetection”可能包含了有关如何检测和枚举USB设备，特别是在涉及USB Hub时的详细过程，例如可能包含代码示例或工具说明，用于帮助用户理解并操作USB设备的枚举流程。 总之，USB枚举是USB系统正常运行的...
USB头文件devioctl.h
01-18
包含USB开发需要的头文件devioctl.h cyioctl.h(21) : fatal error C1083: Cannot open include file: 'devioctl.h': No such file or directory
枚举系统中已经安装的所有硬件设备.rar_枚举 设备_枚举所有设备
09-24
开发者可以使用SetupDiGetClassDevs函数来获取特定类别设备的详细信息，例如，获取所有USB设备或所有网络适配器。 2. **WMI（Windows Management Instrumentation）**：WMI是Windows操作系统内置的管理系统资源的...
windows下枚举USB设备
qq_23867503的博客
12-31 2605
在网上看到很多是通过枚举卷来枚举USB的，但是一个USB设备可能有多个卷，若想获取一个USB设备的描述符，就行不通了。 我这里使用的方法是先枚举所有的hub设备，然后再遍历每个hub下port所连接的设备。因为所有的port都是在hub下的，所有不会有遗漏。   1. 构建hub的GUID     DEFINE_GUID(GUID_DEVINTERFACE_USB_HUB,     0x...
Libusb添加盘符,hub设备port个数功能(windows)
lookfuyao的专栏
09-02 3330
请尊重原创作品,转载请保留原文链接(转来转去,搜索到的都一样,非常不利于资料搜索,可能原文有错误更新了,转载的又没同步). 原文链接:http://blog.csdn.net/lookfuyao/article/details/52405554 先放上源码https://gitee.com/lookfuyao/Libusb_Custom 最近接触到window...
识别USB端口程序开发感想
lizuonan的专栏
07-05 3661
程序功能：识别USB设备插在左边的U口还是右边的U口。准备工作：1.下载资源：因为这个功能设计到驱动级别的编程（本人才疏学浅，可能对这一点的认识有偏差），所以windows自带的  API中没有实现此功能的函数，需要下载一套新的开发包。大家熟知的是Win_DDK，它里面有我们需要的API，  这个软件XP版的非常不好下，因为微软是收费的，而且用它开发的人少，我记得当初是在某个ftp服务器上  下的
USB枚举过程（Enumeration）
Allen.Yao的专栏
07-03 4476
USB架构中，hub负责检测设备的连接和断开，利用其中断IN端点(Interrupt INEndpoint)来向主机（Host）报告。在系统启动时，主机轮询它的根hub（RootHub）的状态看是否有设备（包括子hub和子hub上的设备）连接。USB总线拓扑结构见下图（最顶端为主机的Root Hub）：   USB总线拓扑结构 （USB Bus Topology） 一旦获
实现ifconfig配置功能基础框架
weixin_42271802的博客
05-31 651
因为要实现类似ifconfig工具的作用，所以我们先要了解下argc和argv，接触linux系统，我们往往就需要用命令行的方式来编译和执行程序。那么在命令行方式下，此时这两个参数就很有作用了，能够非常方便地帮助我们实现一些功能。
USB设备枚举与Mass Storage类协议实现
论文详细介绍了USB设备的枚举过程，这是USB设备接入主机后的重要步骤，主机通过执行一系列标准USB请求命令（如Set Address、Get Descriptor和Set Configuration）来识别和配置设备。枚举过程中，设备需提供诸如批量...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值