/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#if !defined _WIN32 && !defined __CYGWIN__
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <asm/types.h>
#include <fcntl.h>
#include <linux/hiddev.h>
#include <linux/input.h>
#include <sys/timeb.h>
#else
#include <windows.h>
#include <setupapi.h>
#include <hidusage.h>
#include <hidpi.h>
#include <math.h>
#include <sys/timeb.h>
#include <wchar.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <ctype.h>
#include <getopt.h>
#include <string.h>
int FindDevice();
#if !defined _WIN32 && !defined __CYGWIN__
DWORD GetTickCount();
struct hiddev_report_info rep_info_i,rep_info_u;
struct hiddev_usage_ref_multi ref_multi_i,ref_multi_u;
struct hiddev_devinfo device_info;
#else
#define write() Result = WriteFile(WriteHandle,bufferU,n,&BytesWritten,NULL);
#define read() Result = ReadFile(ReadHandle,bufferI,n,&NumberOfBytesRead,(LPOVERLAPPED) &HIDOverlapped);\
Result = WaitForSingleObject(hEventObject,50);\
ResetEvent(hEventObject);\
if(Result!=WAIT_OBJECT_0){\
printf("communication timeout\r\n");\
}
unsigned char bufferU[128],bufferI[128];
DWORD NumberOfBytesRead,BytesWritten;
ULONG Result;
HANDLE WriteHandle,ReadHandle;
OVERLAPPED HIDOverlapped;
HANDLE hEventObject;
#endif
int vid=0x1209,pid=0x5432,info=0;
int main (int argc, char **argv) {
#define L_IT 0
#define L_EN 1
int d=0,v=0,q=0,r=1,lang=L_EN,c,i,j,block=0,R=0;
char path[512]="";
char buf[256];
for(i=0;i<256;i++) buf[i]=0;
#if defined _WIN32
int n=65;
int langID=GetUserDefaultLangID();
if((langID&0xFF)==0x10) lang=L_IT;
#else
int n=64;
if(getenv("LANG")&&strstr(getenv("LANG"),"it")!=0) lang=L_IT;
#endif
opterr = 0;
int option_index = 0;
struct option long_options[] =
{
{"b", no_argument, &block, 1},
{"block", no_argument, &block, 1},
{"verbose", no_argument, &v, 1},
{"v", no_argument, &v, 1},
{"quiet", no_argument, &q, 1},
{"q", no_argument, &q, 1},
{"info", no_argument, &info, 1},
{"i", no_argument, &info, 1},
{"help", no_argument, 0, 'h'},
{"path", required_argument, 0, 'p'},
{"read", required_argument, 0, 'R'},
{"repeat", required_argument, 0, 'r'},
{"delay", required_argument, 0, 'd'},
{0, 0, 0, 0}
};
while ((c = getopt_long_only (argc, argv, "n:d:p:hr:R:",long_options,&option_index)) != -1)
switch (c)
{
case 'h': //guida
if(!lang) printf("hid_test [opzioni] [dati]\n"
"opzioni: \n"
"-b, block\tusa lettura bloccante\n"
"-d, delay\tritardo lettura (ms) [0]\n"
"-h, help\tguida\n"
"-i, info\tinformazioni sul dispositivo [no]\n"
"-n\t\tdimensione report [64]\n"
"-p, path\tpercorso dispositivo [/dev/usb/hiddev0] \n"
"-q, quiet\tmostra solo risposta [no]\n"
"-R, read\tripeti lettura N volte [0]\n\n"
"-r, repeat\tripeti scrittura-lettura N volte [1]\n\n"
"-v, verbose\tmostra funzioni [no]\n"
"es. hid_test -i 1 2 3 4\n");
else printf("hid_test [otions] [data]\n"
"options: \n"
"-b, block\tuse blocking read\n"
"-d, delay\tread delay (ms) [0]\n"
"-h, help\thelp\n"
"-i, info\tdevice info [no]\n"
"-n\t\treport size [64]\n"
"-p, path\tdevice path [/dev/usb/hiddev0]\n"
"-q, quiet\tprint response only [no]\n"
"-R, repeat\trepeat read N times [0]\n\n"
"-r, repeat\trepeat N times [1]\n\n"
"-v, verbose\tshow functions [no]\n"
"e.g. hid_test -i 1 2 3 4\n");
exit(1);
break;
case 'n': //dim report
n = atoi(optarg);
break;
case 'd': //ritardo lettura
d = atoi(optarg);
break;
case 'p': //percorso hiddev
strncpy(path,optarg,sizeof(path));
break;
case 'r': //ripeti IO
r = atoi(optarg);
break;
case 'R': //ripeti lettura
R = atoi(optarg);
break;
case '?':
if (optopt == 'c')
fprintf (stderr, "Option -%c requires an argument.\n", optopt);
else if (isprint (optopt))
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf (stderr, "Unknown option character 0x%02x\n", optopt);
return 1;
default:
//abort ();
break;
}
for (j=0,i = optind; i < argc&&i<128; i++,j++) sscanf(argv[i], "%x", &buf[j]);
for (;j<n;j++) buf[j]=0;
int fd = -1;
if(FindDevice()<0) exit(1);
if(!q){
printf("-> ");
for(i=0;i<j;i++) printf("%02X ",(unsigned char)buf[i]);
printf("\n");
}
if(v) printf("%slocking read\n",block?"B":"Non b");
#if !defined _WIN32 && !defined __CYGWIN__
struct hiddev_event ev[80];
rep_info.report_type=HID_REPORT_TYPE_OUTPUT;
rep_info.report_id=HID_REPORT_ID_FIRST;
rep_info.num_fields=1;
ref_multi.uref.report_type=HID_REPORT_TYPE_OUTPUT;
ref_multi.uref.report_id=HID_REPORT_ID_FIRST;
ref_multi.uref.field_index=0;
ref_multi.uref.usage_index=0;
ref_multi.num_values=n;
for(i=0;i<n;i++) ref_multi.values[i]=buf[i];
int res;
res=ioctl(fd, HIDIOCSUSAGES, &ref_multi);
if(v) printf("HIDIOCSUSAGES:%d\n",res);
res=ioctl(fd,HIDIOCSREPORT, &rep_info);
if(v) printf("HIDIOCSREPORT:%d\n",res);
if(!block) for(j=0;j<r;j++){
usleep(d*1000);
rep_info.report_type=HID_REPORT_TYPE_INPUT;
res=ioctl(fd,HIDIOCGREPORT, &rep_info);
if(v) printf("HIDIOCGREPORT:%d\n",res);
ref_multi.uref.report_type=HID_REPORT_TYPE_INPUT;
res=ioctl(fd, HIDIOCGUSAGES, &ref_multi);
if(v) printf("HIDIOCGUSAGES:%d\n",res);
if(!q) printf("<- ");
for(i=0;i<n;i++) printf("%02X ",ref_multi.values[i]);
printf("\n");
}
else for(j=0;j<r;j++){
usleep(d*1000);
res=read(fd, ev,sizeof(struct hiddev_event) *n);
if(!q) printf("<- ");
for(i=0;i<n;i++) printf("%02X ",ev[i].value);
printf("\n");
}
else for(j=0;j<R;j++){
usleep(d*1000);
res=read(fd, ev,sizeof(struct hiddev_event) *n);
if(!q) printf("<- ");
for(i=0;i<n;i++) printf("%02X ",ev[i].value);
printf("\n");
}
close(fd);
#else
__int64 start,stop,freq;
QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
bufferU[0]=0;
for(i=0;i<n;i++) bufferU[i+1]=buf[i];
for(j=0;j<r;j++){
QueryPerformanceCounter((LARGE_INTEGER *)&start);
write();
Sleep(d);
read();
QueryPerformanceCounter((LARGE_INTEGER *)&stop);
if(!q) printf("<- ");
for(i=1;i<n;i++) printf("%02X ",bufferI[i]);
printf("\nT=%.2fms\n",(stop-start)*1000.0/freq);
}
for(j=0;j<R;j++){
QueryPerformanceCounter((LARGE_INTEGER *)&start);
read();
QueryPerformanceCounter((LARGE_INTEGER *)&stop);
if(!q) printf("<- ");
for(i=1;i<n;i++) printf("%02X ",bufferI[i]);
printf("\nT=%.2fms\n",(stop-start)*1000.0/freq);
}
#endif
return 0;
}
DWORD GetTickCount(){
struct timeb now;
ftime(&now);
return now.time*1000+now.millitm;
}
int FindDevice(){
#if !defined _WIN32 && !defined __CYGWIN__
struct hiddev_devinfo device_info;
int i;
if(path[0]==0){ //search all devices
for(i=0;i<16;i++){
sprintf(path,"/dev/usb/hiddev%d",i);
if((fd = open(path, O_RDONLY ))>0){
ioctl(fd, HIDIOCGDEVINFO, &device_info);
if(device_info.vendor==vid&&device_info.product==pid) break;
else close(fd);
}
}
if(i==16){
printf(strings[S_noprog]);
return -1;
}
}
else{ //user supplied path
if ((fd = open(path, O_RDONLY )) < 0) {
printf(strings[S_DevPermission],path);
exit(1);
}
ioctl(fd, HIDIOCGDEVINFO, &device_info);
if(device_info.vendor!=vid||device_info.product!=pid){
printf(strings[S_noprog]);
return -1;
}
}
printf(strings[S_progDev],path);
rep_info_u.report_type=HID_REPORT_TYPE_OUTPUT;
rep_info_i.report_type=HID_REPORT_TYPE_INPUT;
rep_info_u.report_id=rep_info_i.report_id=HID_REPORT_ID_FIRST;
rep_info_u.num_fields=rep_info_i.num_fields=1;
ref_multi_u.uref.report_type=HID_REPORT_TYPE_OUTPUT;
ref_multi_i.uref.report_type=HID_REPORT_TYPE_INPUT;
ref_multi_u.uref.report_id=ref_multi_i.uref.report_id=HID_REPORT_ID_FIRST;
ref_multi_u.uref.field_index=ref_multi_i.uref.field_index=0;
ref_multi_u.uref.usage_index=ref_multi_i.uref.usage_index=0;
ref_multi_u.num_values=ref_multi_i.num_values=DIMBUF;
if(info){
ioctl(fd, HIDIOCGDEVINFO, &device_info);
printf("vendor 0x%04hx product 0x%04hx version 0x%04hx ",
device_info.vendor, device_info.product, device_info.version);
printf("has %i application%s ", device_info.num_applications,
(device_info.num_applications==1?"":"s"));
printf("and is on bus: %d devnum: %d ifnum: %d\n",
device_info.busnum, device_info.devnum, device_info.ifnum);
char name[256]= "Unknown";
if(ioctl(fd, HIDIOCGNAME(sizeof(name)), name) < 0) perror("evdev ioctl");
printf("The device on %s says its name is %s\n", path, name);
}
#else
char string[256];
PSP_DEVICE_INTERFACE_DETAIL_DATA detailData;
HANDLE DeviceHandle;
HANDLE hDevInfo;
GUID HidGuid;
int MyDeviceDetected;
char MyDevicePathName[1024];
ULONG Length;
ULONG Required;
typedef struct _HIDD_ATTRIBUTES {
ULONG Size;
USHORT VendorID;
USHORT ProductID;
USHORT VersionNumber;
} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
typedef void (__stdcall*GETHIDGUID) (OUT LPGUID HidGuid);
typedef BOOLEAN (__stdcall*GETATTRIBUTES)(IN HANDLE HidDeviceObject,OUT PHIDD_ATTRIBUTES Attributes);
typedef BOOLEAN (__stdcall*SETNUMINPUTBUFFERS)(IN HANDLE HidDeviceObject,OUT ULONG NumberBuffers);
typedef BOOLEAN (__stdcall*GETNUMINPUTBUFFERS)(IN HANDLE HidDeviceObject,OUT PULONG NumberBuffers);
typedef BOOLEAN (__stdcall*GETFEATURE) (IN HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
typedef BOOLEAN (__stdcall*SETFEATURE) (IN HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
typedef BOOLEAN (__stdcall*GETREPORT) (IN HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
typedef BOOLEAN (__stdcall*SETREPORT) (IN HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
typedef BOOLEAN (__stdcall*GETMANUFACTURERSTRING) (IN HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
typedef BOOLEAN (__stdcall*GETPRODUCTSTRING) (IN HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
typedef BOOLEAN (__stdcall*GETINDEXEDSTRING) (IN HANDLE HidDeviceObject, IN ULONG StringIndex, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
HIDD_ATTRIBUTES Attributes;
SP_DEVICE_INTERFACE_DATA devInfoData;
int LastDevice = FALSE;
int MemberIndex = 0;
LONG Result;
//char UsageDescription[256];
Length=0;
detailData=NULL;
DeviceHandle=NULL;
HMODULE hHID=0;
GETHIDGUID HidD_GetHidGuid=0;
GETATTRIBUTES HidD_GetAttributes=0;
SETNUMINPUTBUFFERS HidD_SetNumInputBuffers=0;
GETNUMINPUTBUFFERS HidD_GetNumInputBuffers=0;
GETFEATURE HidD_GetFeature=0;
SETFEATURE HidD_SetFeature=0;
GETREPORT HidD_GetInputReport=0;
SETREPORT HidD_SetOutputReport=0;
GETMANUFACTURERSTRING HidD_GetManufacturerString=0;
GETPRODUCTSTRING HidD_GetProductString=0;
hHID = LoadLibrary("hid.dll");
if(!hHID){
printf("Can't find hid.dll");
return 0;
}
HidD_GetHidGuid=(GETHIDGUID)GetProcAddress(hHID,"HidD_GetHidGuid");
HidD_GetAttributes=(GETATTRIBUTES)GetProcAddress(hHID,"HidD_GetAttributes");
HidD_SetNumInputBuffers=(SETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_SetNumInputBuffers");
HidD_GetNumInputBuffers=(GETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_GetNumInputBuffers");
HidD_GetFeature=(GETFEATURE)GetProcAddress(hHID,"HidD_GetFeature");
HidD_SetFeature=(SETFEATURE)GetProcAddress(hHID,"HidD_SetFeature");
HidD_GetInputReport=(GETREPORT)GetProcAddress(hHID,"HidD_GetInputReport");
HidD_SetOutputReport=(SETREPORT)GetProcAddress(hHID,"HidD_SetOutputReport");
HidD_GetManufacturerString=(GETMANUFACTURERSTRING)GetProcAddress(hHID,"HidD_GetManufacturerString");
HidD_GetProductString=(GETPRODUCTSTRING)GetProcAddress(hHID,"HidD_GetProductString");
if(HidD_GetHidGuid==NULL\
||HidD_GetAttributes==NULL\
||HidD_GetFeature==NULL\
||HidD_SetFeature==NULL\
||HidD_GetInputReport==NULL\
||HidD_SetOutputReport==NULL\
||HidD_GetManufacturerString==NULL\
||HidD_GetProductString==NULL\
||HidD_SetNumInputBuffers==NULL\
||HidD_GetNumInputBuffers==NULL) return -1;
HMODULE hSAPI=0;
hSAPI = LoadLibrary("setupapi.dll");
if(!hSAPI){
printf("Can't find setupapi.dll");
return 0;
}
typedef HDEVINFO (WINAPI* SETUPDIGETCLASSDEVS) (CONST GUID*,PCSTR,HWND,DWORD);
typedef BOOL (WINAPI* SETUPDIENUMDEVICEINTERFACES) (HDEVINFO,PSP_DEVINFO_DATA,CONST GUID*,DWORD,PSP_DEVICE_INTERFACE_DATA);
typedef BOOL (WINAPI* SETUPDIGETDEVICEINTERFACEDETAIL) (HDEVINFO,PSP_DEVICE_INTERFACE_DATA,PSP_DEVICE_INTERFACE_DETAIL_DATA_A,DWORD,PDWORD,PSP_DEVINFO_DATA);
typedef BOOL (WINAPI* SETUPDIDESTROYDEVICEINFOLIST) (HDEVINFO);
SETUPDIGETCLASSDEVS SetupDiGetClassDevsA=0;
SETUPDIENUMDEVICEINTERFACES SetupDiEnumDeviceInterfaces=0;
SETUPDIGETDEVICEINTERFACEDETAIL SetupDiGetDeviceInterfaceDetailA=0;
SETUPDIDESTROYDEVICEINFOLIST SetupDiDestroyDeviceInfoList=0;
SetupDiGetClassDevsA=(SETUPDIGETCLASSDEVS) GetProcAddress(hSAPI,"SetupDiGetClassDevsA");
SetupDiEnumDeviceInterfaces=(SETUPDIENUMDEVICEINTERFACES) GetProcAddress(hSAPI,"SetupDiEnumDeviceInterfaces");
SetupDiGetDeviceInterfaceDetailA=(SETUPDIGETDEVICEINTERFACEDETAIL) GetProcAddress(hSAPI,"SetupDiGetDeviceInterfaceDetailA");
SetupDiDestroyDeviceInfoList=(SETUPDIDESTROYDEVICEINFOLIST) GetProcAddress(hSAPI,"SetupDiDestroyDeviceInfoList");
if(SetupDiGetClassDevsA==NULL\
||SetupDiEnumDeviceInterfaces==NULL\
||SetupDiDestroyDeviceInfoList==NULL\
||SetupDiGetDeviceInterfaceDetailA==NULL) return -1;
/*
The following code is adapted from Usbhidio_vc6 application example by Jan Axelson
for more information see see http://www.lvr.com/hidpage.htm
*/
/*
API function: HidD_GetHidGuid
Get the GUID for all system HIDs.
Returns: the GUID in HidGuid.
*/
HidD_GetHidGuid(&HidGuid);
/*
API function: SetupDiGetClassDevs
Returns: a handle to a device information set for all installed devices.
Requires: the GUID returned by GetHidGuid.
*/
hDevInfo=SetupDiGetClassDevs(&HidGuid,NULL,NULL,DIGCF_PRESENT|DIGCF_INTERFACEDEVICE);
devInfoData.cbSize = sizeof(devInfoData);
//Step through the available devices looking for the one we want.
//Quit on detecting the desired device or checking all available devices without success.
MemberIndex = 0;
LastDevice = FALSE;
do
{
/*
API function: SetupDiEnumDeviceInterfaces
On return, MyDeviceInterfaceData contains the handle to a
SP_DEVICE_INTERFACE_DATA structure for a detected device.
Requires:
The DeviceInfoSet returned in SetupDiGetClassDevs.
The HidGuid returned in GetHidGuid.
An index to specify a device.
*/
Result=SetupDiEnumDeviceInterfaces (hDevInfo, 0, &HidGuid, MemberIndex, &devInfoData);
if (Result != 0)
{
//A device has been detected, so get more information about it.
/*
API function: SetupDiGetDeviceInterfaceDetail
Returns: an SP_DEVICE_INTERFACE_DETAIL_DATA structure
containing information about a device.
To retrieve the information, call this function twice.
The first time returns the size of the structure in Length.
The second time returns a pointer to the data in DeviceInfoSet.
Requires:
A DeviceInfoSet returned by SetupDiGetClassDevs
The SP_DEVICE_INTERFACE_DATA structure returned by SetupDiEnumDeviceInterfaces.
The final parameter is an optional pointer to an SP_DEV_INFO_DATA structure.
This application doesn't retrieve or use the structure.
If retrieving the structure, set
MyDeviceInfoData.cbSize = length of MyDeviceInfoData.
and pass the structure's address.
*/
//Get the Length value.
//The call will return with a "buffer too small" error which can be ignored.
Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, NULL, 0, &Length, NULL);
//Allocate memory for the hDevInfo structure, using the returned Length.
detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(Length);
//Set cbSize in the detailData structure.
detailData -> cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
//Call the function again, this time passing it the returned buffer size.
Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, detailData, Length,&Required, NULL);
// Open a handle to the device.
// To enable retrieving information about a system mouse or keyboard,
// don't request Read or Write access for this handle.
/*
API function: CreateFile
Returns: a handle that enables reading and writing to the device.
Requires:
The DevicePath in the detailData structure
returned by SetupDiGetDeviceInterfaceDetail.
*/
DeviceHandle=CreateFile(detailData->DevicePath,
0, FILE_SHARE_READ|FILE_SHARE_WRITE,
(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING, 0, NULL);
/*
API function: HidD_GetAttributes
Requests information from the device.
Requires: the handle returned by CreateFile.
Returns: a HIDD_ATTRIBUTES structure containing
the Vendor ID, Product ID, and Product Version Number.
Use this information to decide if the detected device is
the one we're looking for.
*/
//Set the Size to the number of bytes in the structure.
Attributes.Size = sizeof(Attributes);
Result = HidD_GetAttributes(DeviceHandle,&Attributes);
//Is it the desired device?
MyDeviceDetected = FALSE;
if (Attributes.VendorID == vid)
{
if (Attributes.ProductID == pid)
{
//Both the Vendor ID and Product ID match.
MyDeviceDetected = TRUE;
strcpy(MyDevicePathName,detailData->DevicePath);
// Get a handle for writing Output reports.
WriteHandle=CreateFile(detailData->DevicePath,
GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING,0,NULL);
//Get a handle to the device for the overlapped ReadFiles.
ReadHandle=CreateFile(detailData->DevicePath,
GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,(LPSECURITY_ATTRIBUTES)NULL,
OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
if (hEventObject) CloseHandle(hEventObject);
hEventObject = CreateEvent(NULL,TRUE,TRUE,"");
//Set the members of the overlapped structure.
HIDOverlapped.hEvent = hEventObject;
HIDOverlapped.Offset = 0;
HIDOverlapped.OffsetHigh = 0;
Result=HidD_SetNumInputBuffers(DeviceHandle,64);
}
else
//The Product ID doesn't match.
CloseHandle(DeviceHandle);
}
else
//The Vendor ID doesn't match.
CloseHandle(DeviceHandle);
//Free the memory used by the detailData structure (no longer needed).
free(detailData);
}
else
//SetupDiEnumDeviceInterfaces returned 0, so there are no more devices to check.
LastDevice=TRUE;
//If we haven't found the device yet, and haven't tried every available device,
//try the next one.
MemberIndex = MemberIndex + 1;
} //do
while ((LastDevice == FALSE) && (MyDeviceDetected == FALSE));
//Free the memory reserved for hDevInfo by SetupDiClassDevs.
SetupDiDestroyDeviceInfoList(hDevInfo);
if (MyDeviceDetected == FALSE){
printf("Can't find device\n");
return -1;
}
if(info){
printf("Device detected: vid=0x%04X pid=0x%04X\nPath: %s\n",vid,pid,MyDevicePathName);
if(HidD_GetManufacturerString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Manufacturer string: %s\n",string);
if(HidD_GetProductString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Product string: %s\n",string);
}
#endif
return 0;
}
