Alguien puede ver si estoy haciendo este derecho, por favor:

//DeviceManager.h
#include <windows.h>
//#include <hidsdi.h>
#include <setupapi.h>
#include <iostream>
#include <cfgmgr32.h>
#include <tchar.h>
#include <devpkey.h>
extern "C"{
#include <hidsdi.h>
}
//#pragma comment (lib, "setupapi.lib")
class DeviceManager
{
public:
DeviceManager();
~DeviceManager();
void ListAllDevices();
void GetDevice(std::string vid, std::string pid);
HANDLE PSMove;
byte reportBuffer;
private:
HDEVINFO deviceInfoSet;             //A list of all the devices
SP_DEVINFO_DATA deviceInfoData;     //A device from deviceInfoSet
SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
SP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailedData;
};
//DeviceManager.cpp
#include"DeviceManager.h"
DeviceManager::DeviceManager()
{
deviceInfoSet = SetupDiGetClassDevs(NULL, TEXT("USB"), NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES); //Gets all Devices
}
DeviceManager::~DeviceManager()
{
}
void DeviceManager::ListAllDevices()
{
DWORD deviceIndex = 0;
deviceInfoData.cbSize = sizeof(deviceInfoData);
while(SetupDiEnumDeviceInfo(deviceInfoSet, deviceIndex, &deviceInfoData))
{
deviceInfoData.cbSize = sizeof(deviceInfoData);
ULONG tcharSize;
CM_Get_Device_ID_Size(&tcharSize, deviceInfoData.DevInst, 0);
TCHAR* deviceIDBuffer = new TCHAR[tcharSize];   //the device ID will be stored in this array, so the tcharSize needs to be big enough to hold all the info.
//Or we can use MAX_DEVICE_ID_LEN, which is 200
CM_Get_Device_ID(deviceInfoData.DevInst, deviceIDBuffer, MAX_PATH, 0); //gets the devices ID - a long string that looks like a file path.
/*
//SetupDiGetDevicePropertyKeys(deviceInfoSet, &deviceInfoData, &devicePropertyKey, NULL, 0, 0);
if( deviceIDBuffer[8]=='8' && deviceIDBuffer[9]=='8' && deviceIDBuffer[10]=='8' && deviceIDBuffer[11]=='8' && //VID
deviceIDBuffer[17]=='0' && deviceIDBuffer[18]=='3' && deviceIDBuffer[19]=='0' && deviceIDBuffer[20]=='8') //PID
{
std::cout << deviceIDBuffer << "\t<-- Playstation Move" << std::endl;
}
else
{
std::cout << deviceIDBuffer << std::endl;
}*/
std::cout << deviceIDBuffer << std::endl;
deviceIndex++;
}
}
void DeviceManager::GetDevice(std::string vid, std::string pid)
{
DWORD deviceIndex = 0;
deviceInfoData.cbSize = sizeof(deviceInfoData);
while(SetupDiEnumDeviceInfo(deviceInfoSet, deviceIndex, &deviceInfoData))
{
deviceInfoData.cbSize = sizeof(deviceInfoData);
ULONG IDSize;
CM_Get_Device_ID_Size(&IDSize, deviceInfoData.DevInst, 0);
TCHAR* deviceID = new TCHAR[IDSize];
CM_Get_Device_ID(deviceInfoData.DevInst, deviceID, MAX_PATH, 0);
if( deviceID[8]==vid.at(0) && deviceID[9]==vid.at(1) && deviceID[10]==vid.at(2) && deviceID[11]==vid.at(3) && //VID
deviceID[17]==pid.at(0) && deviceID[18]==pid.at(1) && deviceID[19]==pid.at(2) && deviceID[20]==pid.at(3)) //PID
{
//DWORD requiredBufferSize;
//SetupDiGetDeviceInterfaceDetail(deviceInfoSet, &deviceInterfaceData, NULL, 0, &requiredBufferSize, 
HDEVINFO deviceInterfaceSet = SetupDiGetClassDevs(&deviceInfoData.ClassGuid, NULL, NULL, DIGCF_ALLCLASSES);
DWORD deviceInterfaceIndex = 0;
deviceInterfaceData.cbSize = sizeof(deviceInterfaceData);
while(SetupDiEnumDeviceInterfaces(deviceInterfaceSet, NULL, &deviceInterfaceData.InterfaceClassGuid, deviceInterfaceIndex, &deviceInterfaceData))
{
deviceInterfaceData.cbSize = sizeof(deviceInterfaceData);
std::cout << deviceInterfaceIndex << std::endl;
deviceInterfaceIndex++;
}
//std::cout << deviceInterfaceData.cbSize << std::endl;
break;
}
deviceIndex++;
}
}

Mi SetupDiEnumDeviceInterfaces (en el GetDevice función ()) no está haciendo nada. No es incluso de entrar en el bucle while… por favor alguien Puede probar y señalar qué es lo que estoy haciendo mal por favor?

Gracias

EDITAR/MÁS INFO: he llamado el GetLastError() la función y se ha vuelto un 259 – ERROR_NO_MORE_ITEMS. Es incluso posible que un dispositivo para que no contienen interfaces?

SetupDiEnumDeviceInfo está devolviendo false entonces. Ver la documentación para determinar por qué esto podría ser y, a continuación, utilizar el depurador. Si usted todavía no puede averiguar, a continuación, pedir a un pregunta específica acerca de dónde estás atrapado a continuación.
A continuación, Podría, por favor, pregunte si el deviceInfoData.ClassGuid ha pasado correcta? Quiero decir, estoy suppost a pasar ese guid para obtener el deviceInterfaceSet? O soy yo suppost para pasar un GUID diferente?
Si usted nunca entrar en el bucle while, a continuación, nunca se llega a esa línea de código que significa que usted está usando la deviceInfoSet asignado en el constructor. Sugerencia: Utilice FormatMessage con GetLastError para determinar específicamente lo que salió mal después de la llamada a SetupDiEnumDeviceInfo podría ser simplemente que no hay presente activo dispositivos USB disponibles en el sistema.
se han compilado & ejecutar el código sin problemas; por ejemplo: DeviceManager::ListAllDevices devuelve para mí: 003796F8 00379800 ~creo que no tienen dispositivos 😉 ~mejor tapón en un cheque por el valor de retorno cuando llame SetupDiGetClassDevs
He creado un DeviceManager objeto y llamó a la ListAllDevices función y muestra una lista de dispositivos USB’ Id :S…

OriginalEl autor Danny | 2012-05-14

2 Comentarios

  1. 7

    Tener un ir con esto.


    He tratado de hackear su código original acerca de como poco como sea posible; los códigos siguientes (al menos para mí) llegar hasta el interior de la while(SetupDiEnumDeviceInterfaces..):

    void DeviceManager::GetDeviceUSB(std::string vid, std::string pid)
    {
    DWORD deviceIndex = 0;
    deviceInfoData.cbSize = sizeof(deviceInfoData);
    //buried somewhere deep in the ddk
    static GUID GUID_DEVINTERFACE_USB_HUB={ 0xf18a0e88, 0xc30c, 0x11d0, {0x88, 0x15, 0x00, 0xa0, 0xc9, 0x06, 0xbe, 0xd8} };
    static GUID GUID_DEVINTERFACE_USB_DEVICE ={ 0xA5DCBF10L, 0x6530, 0x11D2, { 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED } };
    static GUID GUID_DEVINTERFACE_USB_HOST_CONTROLLER={ 0x3abf6f2d, 0x71c4, 0x462a, {0x8a, 0x92, 0x1e, 0x68, 0x61, 0xe6, 0xaf, 0x27}};
    //get usb device interfaces
    HDEVINFO deviceInterfaceSet=SetupDiGetClassDevs(&GUID_DEVINTERFACE_USB_DEVICE, NULL, NULL, DIGCF_DEVICEINTERFACE);
    while(SetupDiEnumDeviceInfo(deviceInterfaceSet, deviceIndex, &deviceInfoData))
    {
    deviceInfoData.cbSize = sizeof(deviceInfoData);
    ULONG IDSize;
    CM_Get_Device_ID_Size(&IDSize, deviceInfoData.DevInst, 0);
    TCHAR* deviceID = new TCHAR[IDSize];
    CM_Get_Device_ID(deviceInfoData.DevInst, deviceID, MAX_PATH, 0);
    if( deviceID[8]==vid.at(0) && deviceID[9]==vid.at(1) && deviceID[10]==vid.at(2) && deviceID[11]==vid.at(3) && //VID
    deviceID[17]==pid.at(0) && deviceID[18]==pid.at(1) && deviceID[19]==pid.at(2) && deviceID[20]==pid.at(3)) //PID
    {
    DWORD deviceInterfaceIndex = 0;
    deviceInterfaceData.cbSize = sizeof(deviceInterfaceData);
    while(SetupDiEnumDeviceInterfaces(deviceInterfaceSet, &deviceInfoData, &GUID_DEVINTERFACE_USB_DEVICE, deviceInterfaceIndex, &deviceInterfaceData))
    {
    deviceInterfaceData.cbSize = sizeof(deviceInterfaceData);
    std::cout << deviceInterfaceIndex << std::endl;
    //get some more details etc
    //DWORD requiredBufferSize;
    //SetupDiGetDeviceInterfaceDetail(deviceInterfaceSet, &deviceInterfaceData, NULL, 0, &requiredBufferSize, 
    deviceInterfaceIndex++;
    }
    }
    deviceIndex++;
    }
    }

    afaik, este método recoge los mismos dispositivos como con su OP llamada al constructor:

    (NOTA: he incluido algunas otras útiles interfaz guid)

    deviceInfoSet = SetupDiGetClassDevs(NULL, TEXT("USB"), NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES); //Gets all Devices

    pero estoy haciendo esto para obtener el dispositivo interfaces:

    ///coughs/you might want to put back the DIGCF_PRESENT flag i removed for testing
    HDEVINFO deviceInterfaceSet=SetupDiGetClassDevs(&GUID_DEVINTERFACE_USB_DEVICE, NULL, NULL, DIGCF_DEVICEINTERFACE); 


    yo también pase la deviceInfoData a SetupDiEnumDeviceInterfaces ya que de acuerdo a la documentación:


    Un puntero a una estructura SP_DEVINFO_DATA que especifica un dispositivo
    elemento de información en DeviceInfoSet. Este parámetro es opcional y
    puede ser NULL. Si se especifica este parámetro,
    SetupDiEnumDeviceInterfaces limita a la enumeración de los
    las interfaces que son compatibles con el dispositivo especificado. Si esta
    parámetro es NULL, llamadas repetidas a SetupDiEnumDeviceInterfaces
    devolver información acerca de las interfaces que están asociados con todos los
    el dispositivo de elementos de información en DeviceInfoSet. Este puntero es
    normalmente devueltos por SetupDiEnumDeviceInfo.

      [Edit: notas adicionales (; como se pide 😉 ]

    El dispositivo USB tiene asociado un el programa de instalación de clase y interfaz clase(s):

    De la clases de instalación de dispositivos de documentación:

    La configuración del dispositivo de clase define el instalador de clase y de la clase co-instaladores que están involucrados en la instalación del dispositivo

    De la clases de interfaz de dispositivo de documentación:

    Una clase de interfaz de dispositivo es una manera de exportación de dispositivo y de la funcionalidad del controlador a otros componentes del sistema, incluyendo a los otros conductores, como
    así como aplicaciones de modo de usuario

    También, vea este práctico comparación

    También, esta relacionado con el doc es útil

    Así:

    deviceInfoSet = SetupDiGetClassDevs(NULL, TEXT("USB"), NULL,DIGCF_PRESENT|DIGCF_ALLCLASSES);

    esta es la recuperación de todas las el programa de instalación de de la clase de los conjuntos de información y filtrado en «USB»

    Podría hacer esto:

    deviceInfoSet = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES|DIGCF_DEVICEINTERFACE);`

    esta forma, se recupera la clase de los conjuntos de información para los dispositivos que soportan una de interfaz de dispositivo de cualquier clase. (La aplicación de un emumerator ID s/a «USB» parece tener ningún efecto)
    Sin embargo: The function adds to the device information set a device information element that represents such a device and then adds to the device information element a device interface list that contains all the device interfaces that the device supports.

    (Y nota: SP_DEVINFO_DATA.ClassGuid es siempre el GUID del dispositivo el programa de instalación de clase)

    Afaik:

    pero usted todavía necesita para proporcionar un InterfaceClassGuid al invocar SetupDiEnumDeviceInterfaces()
    ~tbh, yo realmente no entiendo por qué esto sería necesario si la persona que está proporcionando el opcional DeviceInfoData
    pero ya que todo es de código cerrado, ¿cómo iba yo a saber !? 🙂


    &Aquí es información sobre GUID_DEVINTERFACE_USB_DEVICE


    (; descargo de responsabilidad: yo no trabajo para el M$; hacer el tratamiento de la anterior información con la sospecha 🙂 && por supuesto dyoRs 😉

    espero que esto ayude, la mejor de las suertes!

    que funciona y que es exactamente lo que necesito! Gracias mucho :D. Si no te importa, ¿puedo pedirle que nos explique un poco más sobre el GUID que hayas declarado en la parte superior?? ¿Por qué necesitamos de ellos cuando he utilizado el TEXTO(«USB»)? ¿Cuál es la diferencia? O puede que al menos me dan un link en donde puedo buscar más información sobre el Guid que has declarado?? Gracias 😀
    noP, ver revisado respuesta,, por cierto, lol, yo soy *no es una mucho XD
    Me gustaría poder hasta votar más de una vez. Usted debe haber puesto mucho esfuerzo en esta respuesta. Tengo una pieza más de información para agregar, después de haber peleó por más de un día que busca es: Si su dispositivo es un WinUSB dispositivo, entonces el GUID de pasar a SetupDiEnumDeviceInterfaces() será el «DeviceInterfaceGUIDs» el valor de registro/archivo inf. Yo dudo mucho de esto está documentado en ninguna parte.
    recogió sus amables palabras! thx grande 🙂

    OriginalEl autor violet313

  2. 3

    El problema comienza con la forma en SetupDiGetClassDevs se llama.

    Si usted está buscando para obtener una ruta de dispositivo, utilice
    SetupDiGetClassDevs(&GUID_DEVINTERFACE_USB_DEVICE ,,,)

    SetupDiEnumDeviceInterfaces error 259 si SetupDiGetClassDevs es dado el mal GUID en
    ClassGuid que MS Ayuda dice que es
    Un puntero para el GUID de un dispositivo de clase de instalación o una clase de interfaz de dispositivo.

    Incluyen el archivo devguid.h contiene un conjunto de GUID_DEVCLASS valores. Estos son NO la misma como GUID_DEVINTERFACE_* los valores, que son los que usted necesita.

    Utilizar #include <uuid.h> que incluye ksuuids.h donde encontrarás GUID_DEVINTERFACE_* valores.

    Hay una explicación más detallada en mi sitio web, con algo de código fuente que debe ayudar en enumerar correctamente los dispositivos USB.

    Ver http://pixcl.com/SetupDiEnumInterfaces_Fail.htm

    OriginalEl autor stewart DIBBS

Dejar respuesta

Please enter your comment!
Please enter your name here