이운국 님이 쓰신 글 :
: WDK 를 설치하고 HidSdi.H 를 열면 Hidpi.H 가 불리면서 Error  가 주루룩 뜨네여...
: 빌더에서 이 화일들을 대치할수 있는게 있는지 ㅠㅠ
:
: 아니면 빌더에서 HID 는 다르게 접근하는지 ....
: 고수님들 조언좀 주세여.......

빌더든 VC++이든 똑같습니다.
HID 디바이스는 65바이트씩 끊어서 Write해야됩니다.
그것만 빼고는 usb open하는거라든가 read, write하는거는 같구요.
아래는 hid usb 쓸때 썼던 코드입니다. 이 위에 클래스가 더 있긴 하지만
이정도면 기본은 될거라 생각되네요.

#include 

#include 

#include 
#include 
#include 
#include 
#include 

#include "devioctl.h"
#include 
#include 
#include "usbdi.h"


char completeDeviceName[256] = "";  //generated from the GUID registered by the driver itself
GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30};

//-------------------------------------------------------------------------------
//① 설       명  :
//    Given the HardwareDeviceInfo, representing a handle to the plug and
//    play information, and deviceInfoData, representing a specific usb device,
//    open that device and fill in all the relevant information in the given
//    USB_DEVICE_DESCRIPTOR structure.
//② 인       수  :
//    HardwareDeviceInfo:  handle to info obtained from Pnp mgr via SetupDiGetClassDevs()
//    DeviceInfoData:      ptr to info obtained via SetupDiEnumInterfaceDevice()
//③ 리       턴  :
//    return HANDLE if the open and initialization was successfull,
//	  else INVLAID_HANDLE_VALUE.
//-------------------------------------------------------------------------------
HANDLE OpenOneDevice (
                      IN       HDEVINFO                    HardwareDeviceInfo,
                      IN       PSP_INTERFACE_DEVICE_DATA   DeviceInfoData,
                      IN	   char *devName
                      )
{
    PSP_INTERFACE_DEVICE_DETAIL_DATA     functionClassDeviceData = NULL;
    ULONG                                predictedLength = 0;
    ULONG                                requiredLength = 0;
	HANDLE								 hOut = INVALID_HANDLE_VALUE;

    //
    // allocate a function class device data structure to receive the
    // goods about this particular device.
    //
    SetupDiGetInterfaceDeviceDetail (
            HardwareDeviceInfo,
            DeviceInfoData,
            NULL, // probing so no output buffer yet
            0, // probing so output buffer length of zero
            &requiredLength,
            NULL); // not interested in the specific dev-node


    predictedLength = requiredLength;
    // sizeof (SP_FNCLASS_DEVICE_DATA) + 512;

    functionClassDeviceData = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc (predictedLength);
    functionClassDeviceData->cbSize = sizeof (SP_INTERFACE_DEVICE_DETAIL_DATA);

    //
    // Retrieve the information from Plug and Play.
    //
    if (! SetupDiGetInterfaceDeviceDetail (
               HardwareDeviceInfo,
               DeviceInfoData,
               functionClassDeviceData,
               predictedLength,
               &requiredLength,
               NULL))
    {
        return INVALID_HANDLE_VALUE;
    }

	strcpy( devName,functionClassDeviceData->DevicePath) ;

	String sDevName = devName;
	if(sDevName.Pos("hid#vid_04d8&pid_003c") > 0)
	{
		hOut = CreateFile (
					  functionClassDeviceData->DevicePath,
					  GENERIC_READ | GENERIC_WRITE,
					  FILE_SHARE_READ | FILE_SHARE_WRITE,
					  NULL, // no SECURITY_ATTRIBUTES structure
					  OPEN_EXISTING, // No special create flags
					  0, // No special attributes
					  NULL); // No template file

		if (INVALID_HANDLE_VALUE == hOut) {}
	}
    else
	{
	  hOut =  INVALID_HANDLE_VALUE;
	}
	
	free(functionClassDeviceData);

	return hOut;
}


//-------------------------------------------------------------------------------
//① 설       명  :
//                  Do the require
//                  the next available proper device in the system at this time.
//② 인       수  :
//                  pGuid:      ptr to GUID registered by the driver itself
//                  outNameBuf: the generated name for this device
//③ 리       턴  :
//                  return HANDLE if the open and initialization was successful,
//	                else INVLAID_HANDLE_VALUE.
//-------------------------------------------------------------------------------
HANDLE OpenUsbDevice( LPGUID  pGuid, char *outNameBuf)
{
   ULONG NumberDevices;
   HANDLE hOut = INVALID_HANDLE_VALUE;
   HDEVINFO                 hardwareDeviceInfo;
   SP_INTERFACE_DEVICE_DATA deviceInfoData;
   ULONG                    i;
   BOOLEAN                  done;
   PUSB_DEVICE_DESCRIPTOR   usbDeviceInst;
   PUSB_DEVICE_DESCRIPTOR	*UsbDevices = &usbDeviceInst;

   *UsbDevices = NULL;
   NumberDevices = 0;

   //
   // Open a handle to the plug and play dev node.
   // SetupDiGetClassDevs() returns a device information set that contains info on all 
   // installed devices of a specified class.
   //
   hardwareDeviceInfo = SetupDiGetClassDevs (
                           pGuid,
                           NULL, // Define no enumerator (global)
                           NULL, // Define no
                           (DIGCF_PRESENT | // Only Devices present
                            DIGCF_INTERFACEDEVICE)); // Function class devices.

   //
   // Take a wild guess at the number of devices we have;
   // Be prepared to realloc and retry if there are more than we guessed
   //
   NumberDevices = 100;
   done = FALSE;
   deviceInfoData.cbSize = sizeof (SP_INTERFACE_DEVICE_DATA);

   i=0;
   while (!done)
   {
      NumberDevices *= 2;

      if (*UsbDevices)
      {
         *UsbDevices =
               (PUSB_DEVICE_DESCRIPTOR)realloc (*UsbDevices, (NumberDevices * sizeof (USB_DEVICE_DESCRIPTOR)));
      }
      else
      {
         *UsbDevices = (PUSB_DEVICE_DESCRIPTOR)calloc (NumberDevices, sizeof (USB_DEVICE_DESCRIPTOR));
      }

      if (NULL == *UsbDevices)
      {
         // SetupDiDestroyDeviceInfoList destroys a device information set 
         // and frees all associated memory.

         SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
         return INVALID_HANDLE_VALUE;
      }

      usbDeviceInst = *UsbDevices + i;

      for (; i < NumberDevices; i++)
      {
         // SetupDiEnumDeviceInterfaces() returns information about device interfaces 
         // exposed by one or more devices. Each call returns information about one interface;
         // the routine can be called repeatedly to get information about several interfaces
         // exposed by one or more devices.

         if (SetupDiEnumDeviceInterfaces (hardwareDeviceInfo,
                                         0, // We don't care about specific PDOs
										 pGuid,
                                         i,
                                         &deviceInfoData))
         {

            hOut = OpenOneDevice (hardwareDeviceInfo, &deviceInfoData, outNameBuf);
			if ( hOut != INVALID_HANDLE_VALUE )
            {
               done = TRUE;
               break;
			}
         }
         else
         {
            if (ERROR_NO_MORE_ITEMS == GetLastError())
            {
               done = TRUE;
               break;
            }
         }
      }
   }

   NumberDevices = i;

   // SetupDiDestroyDeviceInfoList() destroys a device information set 
   // and frees all associated memory.

   SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);

   if (*UsbDevices) 
	   free(*UsbDevices);

   return hOut;
}


//-------------------------------------------------------------------------------
//① 설       명  : Given a ptr to a driver-registered GUID, give us a string with the device name
//                  that can be used in a CreateFile() call.
//                  Actually briefly opens and closes the device and sets outBuf if successfull;
//                  returns FALSE if not
//② 인       수  :
//                  pGuid:      ptr to GUID registered by the driver itself
//                  outNameBuf: the generated zero-terminated name for this device
//③ 리       턴  : TRUE on success else FALSE
//-------------------------------------------------------------------------------
BOOL GetUsbDeviceFileName( LPGUID  pGuid, char *outNameBuf)
{
	HANDLE hDev = OpenUsbDevice( pGuid, outNameBuf );

	if ( hDev != INVALID_HANDLE_VALUE )
	{
		CloseHandle( hDev );
		return TRUE;
	}

	return FALSE;
}


//-------------------------------------------------------------------------------
//① 설       명  : Called by dumpUsbConfig() to open an instance of our device
//② 인       수  : None
//③ 리       턴  : Device handle on success else NULL
//-------------------------------------------------------------------------------
HANDLE open_dev()
{
	HANDLE hDEV = OpenUsbDevice( (LPGUID)&InterfaceClassGuid, completeDeviceName);
	return hDEV;
}


//-------------------------------------------------------------------------------
//① 설       명  : Called by main() to open an instance of our device after obtaining its name
//② 인       수  : None
//③ 리       턴  : Device handle on success else NULL
//-------------------------------------------------------------------------------
HANDLE open_file( char *filename)
{
	HANDLE h;

	if ( !GetUsbDeviceFileName( 
		(LPGUID) &InterfaceClassGuid,
		completeDeviceName) )
	{
		return  INVALID_HANDLE_VALUE; 
	}

    strcat (completeDeviceName,
			"\\"
			);			

    strcat (completeDeviceName,
			filename
			);					

	h = CreateFile(completeDeviceName,
		GENERIC_WRITE | GENERIC_READ,
		FILE_SHARE_WRITE | FILE_SHARE_READ,
		NULL,
		OPEN_EXISTING,
//        FILE_FLAG_OVERLAPPED,
		0,
		NULL);

	return h;
}



HANDLE open_fileRead( char *filename)
/*++
Routine Description:
    Called by main() to open an instance of our device after obtaining its name
Arguments:
    None
Return Value:
    Device handle on success else NULL
--*/
{
	HANDLE h;
	if ( !GetUsbDeviceFileName((LPGUID) &InterfaceClassGuid, completeDeviceName) )
	{
		return  INVALID_HANDLE_VALUE;
	}
	strcat (completeDeviceName,"\\");
	strcat (completeDeviceName,filename);

	h = CreateFile(completeDeviceName,
		GENERIC_READ,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
//		FILE_ATTRIBUTE_NORMAL |
//		FILE_FLAG_OVERLAPPED, // overlapped I/O,
        0,
		NULL);

	if (h != INVALID_HANDLE_VALUE)
	{
		COMMTIMEOUTS  CommTimeOuts ;
		CommTimeOuts.ReadIntervalTimeout = MAXDWORD;
		CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
		CommTimeOuts.ReadTotalTimeoutConstant = 0 ;
		CommTimeOuts.WriteTotalTimeoutMultiplier = 0 ;
		CommTimeOuts.WriteTotalTimeoutConstant = 0 ;
		SetCommTimeouts( h, &CommTimeOuts ) ;
	}

	return h;
}

HANDLE open_fileWrite( char *filename)
/*++
Routine Description:
    Called by main() to open an instance of our device after obtaining its name
Arguments:
    None
Return Value:
    Device handle on success else NULL
--*/
{
	HANDLE h;
	if ( !GetUsbDeviceFileName((LPGUID) &InterfaceClassGuid, completeDeviceName) )
	{
		return  INVALID_HANDLE_VALUE; 
	}
	strcat (completeDeviceName,"\\");
    strcat (completeDeviceName,filename);					

	h = CreateFile(completeDeviceName,
		GENERIC_WRITE | GENERIC_READ,
		FILE_SHARE_WRITE | FILE_SHARE_READ,
		NULL,
		OPEN_EXISTING,
		0,
		NULL);

	return h;
}