C++ Builder 访问 USB 口的方法[转]

cpubbs

Victor Chen, (C++ 爱好者)编译环境: Borland C++ Builder 6.0, Windows Server 2003 DDK
运行环境: Win98/2000/XP/2003

下面是访问 USB 口必备的函数:
<>#include &lt;vcl.h&gt;
#include &lt;dir.h&gt;
#include &lt;setupapi.h&gt;
#include "C:/WINDDK/3790/inc/ddk/w2k/usbdi.h"
#include "C:/WINDDK/3790/inc/ddk/w2k/devioctl.h"
#include &lt;initguid.h&gt;
//---------------------------------------------------------------------------
// 下面必须为驱动程序的 GUID 值, 这里我乱写的数
DEFINE_GUID(USB_DRIVER_GUID, 0x12345678,0xabcd,0x1122,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00);
//---------------------------------------------------------------------------
HANDLE OpenOneDevice(HDEVINFO hDvcInfo, PSP_INTERFACE_DEVICE_DATA DvcInfoData, char *sDevNameBuf)
{
  HANDLE hOut = INVALID_HANDLE_VALUE;

  ULONG  iReqLen = 0;
  SetupDiGetInterfaceDeviceDetail(hDvcInfo, DvcInfoData, NULL, 0, &amp;iReqLen, NULL);

  ULONG iDevDataLen = iReqLen; //sizeof(SP_FNCLASS_DEVICE_DATA) + 512;
  PSP_INTERFACE_DEVICE_DETAIL_DATA pDevData = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc(iDevDataLen);

  pDevData-&gt;cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
  if(SetupDiGetInterfaceDeviceDetail(hDvcInfo, DvcInfoData, pDevData, iDevDataLen, &amp;iReqLen, NULL))
   {
     strcpy(sDevNameBuf, pDevData-&gt;DevicePath);
     hOut = CreateFile(pDevData-&gt;DevicePath, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
   }

  free(pDevData);
  return hOut;
}
//---------------------------------------------------------------------------
HANDLE OpenUsbDevice(const GUID *pGuid, char *sDevNameBuf)
{
  HANDLE hOut = INVALID_HANDLE_VALUE;

  HDEVINFO hDevInfo = SetupDiGetClassDevs(pGuid, NULL, NULL, DIGCF_PRESENT|DIGCF_INTERFACEDEVICE);

  SP_INTERFACE_DEVICE_DATA deviceInfoData;
  deviceInfoData.cbSize = sizeof (SP_INTERFACE_DEVICE_DATA);

  ULONG nGuessCount = MAXLONG;
  for(ULONG iDevIndex=0; iDevIndex&lt;nGuessCount; iDevIndex++)
   {
     if(SetupDiEnumDeviceInterfaces(hDevInfo, 0, pGuid, iDevIndex, &amp;deviceInfoData))
      {
        if((hOut=OpenOneDevice(hDevInfo, &amp;deviceInfoData, sDevNameBuf)) != INVALID_HANDLE_VALUE)
          break;
      }
     else if(GetLastError() == ERROR_NO_MORE_ITEMS) //No more items
      {
        break;
      }
   }
  SetupDiDestroyDeviceInfoList(hDevInfo);
  return hOut;
}
//---------------------------------------------------------------------------
bool GetUsbDeviceFileName(const GUID *pGuid, char *sDevNameBuf)
{
  HANDLE hDev = OpenUsbDevice(pGuid, sDevNameBuf);
  if(hDev != INVALID_HANDLE_VALUE)
   {
     CloseHandle(hDev);
     return true;
   }
  return false;
}
//---------------------------------------------------------------------------
HANDLE OpenMyDevice()
{
  char DeviceName[MAXPATH] = "";
  return OpenUsbDevice(&amp;USB_DRIVER_GUID, DeviceName);
}
//---------------------------------------------------------------------------
HANDLE OpenMyDevPipe(const char *PipeName)
{
  char DeviceName[MAXPATH] = "";
  if(GetUsbDeviceFileName(&amp;USB_DRIVER_GUID, DeviceName))
   {
     strcat(DeviceName,"\\");
     strcat(DeviceName,PipeName);
     return CreateFile(DeviceName, GENERIC_WRITE|GENERIC_READ, FILE_SHARE_WRITE|FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
   }
  return INVALID_HANDLE_VALUE;
}
//---------------------------------------------------------------------------</P>
<>有了上面的函数就可以访问 USB 口了:</P>
<>//打开 USB 口读写, 由驱动程序的 Pipe 名确定

HANDLE hPipe = OpenMyDevPipe("MyPipe1"); //驱动程序里面的 Pipe 名, 对应访问某个端点的 I/O, 这里我乱写的, 需要与驱动一致
if(hPipe != INVALID_HANDLE_VALUE) //打开 Pipe 成功
{
   ReadFile(hPipe, Buffer, BufSize, &amp;nBytesRead, NULL); //从 hPipe 里读取数据到 Buffer 里
   //WriteFile(hPipe, Buffer, BytesToWrite, &amp;nBytesWritten, NULL); //把 Buffer 里面的 BytesToWrite 字节写入 hPipe
   CloseHandle(hPipe);
}

//使用 DeviceIoControl 访问 USB 设备

HANDLE hDevice = OpenMyDevice();
if(hDevice != INVALID_HANDLE_VALUE) //打开设备成功
{
   //这些 DeviceIoControl 功能都是由设备定义的, 具体看设备和驱动的资料
   if(DeviceIoControl(hDevice, IOCTL_READ_xxxx, &amp;IOBlock, sizeof(IOBLOCK), &amp;c, 1, &amp;nBytes, NULL))
    {
      //成功
    }
   CloseHandle(hDevice);
}</P>
<P>USB 设备、USB 驱动、USB 应用程序

1.USB 设备硬件部分
  a.这个硬件的标识是用的 Vender ID 和 Product ID, 即“厂家标识”和“产品标识”
  b.这个硬件规定了各个 End Point (端点) 的性质, 读/写 及 类型 (Control/Interrupt/Bulk/Isochronous)
  c.这个硬件的固件里面有 DeviceIoControl 的实现部分, 规定了这个函数的具体参数和动作 </P>
<P>2.USB 设备驱动
①硬件接口
  a.需要识别 Vender ID 和 Product ID
  b.对每个 EndPoint 的每个 I/O 分配一个 Pipe, 并且起一个名字作为软件接口
  c.做 DeviceIoControl 的接口
②软件接口
  a.GUID, 驱动程序的标识, 每个驱动程序使用不同的 GUID, GUID 是识别驱动的, 与硬件无关 (驱动程序升级版本 GUID 不能修改)
  b.硬件接口里面的 b: Pipe 名字是软件接口, 这个 Pipe 名字纯粹由驱动定义的, 和硬件无关, 升级驱动不能改 Pipe 的名字
  c.硬件接口里面的 c 的各个参数也是软件的接口, 这些参数是由硬件带来的, 不是驱动规定的, 当然也可以在驱动里面转义, 隐藏设备的真实情况
③这个驱动程序是用 WinDDK 编译的, 可以用文本编辑器或其他开发工具的编辑器编程序代码, 然后调用 WinDDK 编译</P>
<P>3.读写 USB 口的程序
①与驱动的接口
  a.利用驱动程序里面的 GUID 找出设备的文件名, 用 CreateFile 函数打开设备。我前面的程序里面的 OpenUsbDevice 就是这个作用
  b.通过 a.得到的设备文件名和驱动程序里面的 Pipe 名打开 Pipe, 访问这个 Pipe 对应的 USB 端点 (读写数据)
  c.使用 a.的 CreateFile 得到的句柄, 通过 DeviceIoControl 实现设备规定的动作
②有关需要的资料
  a.Vender ID, Product ID 和 GUID 一般在驱动程序的 .inf 文件里面能看到, 如果找不到就需要和厂家联系
  b.Pipe 的名字是驱动程序规定的, 需要有驱动程序的资料才能知道
  c.DeviceIoControl 的参数需要有驱动程序的资料或者硬件资料才能知道
③这个程序一般用 C/C++ 直接编写, 如果使用其他语言(VB/PB等)需要调用 C/C++ 编的 DLL


其他相关内容:

USB 驱动程序可以到注册表里面找到：
"HKEY_LOCAL_MACHINE\\SYSTEM\\ControlSet001\\Enum\\USB\\Vid_厂家标识&amp;Pid_产品标识\\驱动程序"

里面的 ClassGUID 就是驱动程序的 GUID 标识, 例如 {36FC9E60-C465-11CF-8056-444553540000}
相当于程序的: DEFINE_GUID(USB_DRIVER_GUID, 0x36FC9E60,0xC465,0x11CF,0x80,0x56,0x44,0x45,0x53,0x54,0x00,0x00);
另外在这个注册表键里面还可找到有关设备的其他描述, 例如 DeviceDesc = "USB Mass Storage Device" 等
</P>

cpubbs

<>下面是個台灣人寫的代碼,貼出來,研究以下吧</P><>//如果你想打開一個USB管道，你首先要知道這種USB設備的GUID和管理道名稱，
//獲取句柄以后就可以使用ReadFile/WriteFile進行讀寫了﹗
//以下是代碼，請參考﹗﹗

// filename是管道名稱，如pipe01等
int TForm1:pen_file( char *filename)
{

int successOpened = 0,i;
int NumOpened;
HANDLE h;
NumOpened=OpenAllUsbDevices((LPGUID) &amp;GUID_CLASS_I82930_BULK);
    if(NumOpened&lt;=0)
  return 0;
    for(i=0;i&lt;NumOpened;i++){
        strcat (outnamebuf<i>,"\\");

        strcat (outnamebuf<i>,filename);


     h= CreateFile(outnamebuf<i>,
                  GENERIC_WRITE | GENERIC_READ,
                  FILE_SHARE_WRITE | FILE_SHARE_READ,
                  NULL,
                  OPEN_EXISTING,
                  0,
                  NULL);
     if (h == INVALID_HANDLE_VALUE) {
   handUsbArray<i>=NULL;
  } else {
    handUsbArray<i>=h;
    successOpened++;
  }
}
return successOpened;
}


int TForm1::OpenAllUsbDevices(LPGUID pGuid)     //打開所有的GUID為pGuid的USB器件
{                //輸出名存在outnamebuf中
ULONG NumberDevices;
HANDLE hOut = INVALID_HANDLE_VALUE;       //HANDLE Phout[8];
HDEVINFO                 hardwareDeviceInfo;
SP_INTERFACE_DEVICE_DATA deviceInfoData;
ULONG                    i,flag=1,j;
ULONG       NumDevicesOpened=0;
BOOLEAN                  done;
PUSB_DEVICE_DESCRIPTOR   usbDeviceInst;
PUSB_DEVICE_DESCRIPTOR *UsbDevices = &amp;usbDeviceInst;
char DeviceName[256]="";         //器件名

*UsbDevices = NULL;
    UsbDevicesOpened = 0;          //打開器件數置零

hardwareDeviceInfo = SetupDiGetClassDevs (
  pGuid,
  NULL,             // Define no enumerator (global)
  NULL,             // Define no
  (DIGCF_PRESENT |          // Only Devices present
  DIGCF_INTERFACEDEVICE));        // Function class devices.

NumberDevices = 4;
done = FALSE;
deviceInfoData.cbSize = sizeof (SP_INTERFACE_DEVICE_DATA);
i=0  ;
while (!done) {
  NumberDevices *= 2;

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

  if (NULL == *UsbDevices) {
   SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
   return 0 ;
  }

  usbDeviceInst = *UsbDevices + i;

  for (; i &lt; NumberDevices; i++) {
   if (SetupDiEnumDeviceInterfaces (hardwareDeviceInfo,
    0,
    pGuid,
    i,
    &amp;deviceInfoData))
   {
    hOut = OpenOneDevice (hardwareDeviceInfo, &amp;deviceInfoData, DeviceName);
    if ( hOut != INVALID_HANDLE_VALUE )
    {
     handUsbArray[UsbDevicesOpened]=hOut;

     if(!outnamebuf[UsbDevicesOpened])
     {
      return 0;
     }
     for(j=0;j&lt;256;j++)
     {
      *(outnamebuf[UsbDevicesOpened]+j)=*(DeviceName+j);
      *(DeviceName+j)=0;
     }
     UsbDevicesOpened++;
    }
   }
   else
   {
    if(ERROR_NO_MORE_ITEMS == GetLastError())
    {
     done = TRUE;
     break;
    }
   }

  }    //end for
}       //end while
SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
free ( *UsbDevices );
return UsbDevicesOpened ;

}

//--------------------------------------------------------------------
//
//
//
//--------------------------------------------------------------------
HANDLE TForm1::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;
    SetupDiGetInterfaceDeviceDetail (
            HardwareDeviceInfo,
            DeviceInfoData,
            NULL,            // probing so no output buffer yet
            0,             // probing so output buffer length of zero
            &amp;requiredLength,
            NULL);        
predictedLength = requiredLength;

    functionClassDeviceData =(struct _SP_DEVICE_INTERFACE_DETAIL_DATA_A *)
malloc (predictedLength);
    functionClassDeviceData-&gt;cbSize = sizeof
(SP_INTERFACE_DEVICE_DETAIL_DATA);

    if (! SetupDiGetInterfaceDeviceDetail (
               HardwareDeviceInfo,
               DeviceInfoData,
               functionClassDeviceData,
               predictedLength,
               &amp;requiredLength,
               NULL)) {
  free( functionClassDeviceData );
        return INVALID_HANDLE_VALUE;
    }

strcpy( devName,functionClassDeviceData-&gt;DevicePath) ;

    hOut = CreateFile (
                  functionClassDeviceData-&gt;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) {

    }
free( functionClassDeviceData );
return hOut;
}
</P>

cpubbs

标题   如何根据驱动程序及其安装文件来访问该设备呢（Visual C++ or C++ Builder均可以）     kingcaiyao [原作]  


First of all,我要讲一下Windows对每检测到一个新设备的处理过程：
1.首先Windows将各种设备分成不同的设备类，比如说USB Storage存储类设备，而这些类设备都有一个GUID,它们位于注册表中HKEY_LOCAL_MACHINE\ControlSet001\Control\Class下，在这个键下你看到的以128位长度结点名称为结点都是设备类。
2.当检测到一个新设备时，Windows OS就会到KEY_LOCAL_MACHINE\ControlSet001下去搜索，如果此类设备已经注册，那么就此子键下增加一个子键，这个子键的名称是顺序递增的，如果当前该类设备中最大子键名称为0005,那么新设备的就是0006，0000,0001等就是设备的序列号。如果发现这个设备没有注册，那么OS就会以该设备对应的驱动程序安装文件.inf中的ClassGuid为名称来创建一个键，并将此被检测到的设备的序列号为0，在该键下创建一个子键，并且命名为0000来存储该设备的相关信息，之所以命名为0000，因为该设备是该类设备的第一个。
3.有些设备，如我们常用的COM1,COM2,当我们要访问它时可以用CreateFile("COM1"。。。)就可以打开串口，这里的COM1,COM2是符号名，有些设备也用到了符号名，比如说有些USB设备虚拟成一个COM口，如COM3,COM4,COM5等，在程序中我们只需要对COM3,COM4,COM5进行访问，就相当对该设备进行访问。
在没有符号名的情况下，我们如何根据设备驱动程序以及设备安装文件.inf来对设备进行访问呢？我们可以这样：
1.首先，我们在这个设备的符号名中找到设备类的ClassGuid，这是一定可以找到的。
2.然后我们到HKEY_LOCAL_MACHINE\ControlSet001\Control\Class下去找这个设备类，在找到后，我们再找它的子键，找到该设备对应的序列号，如它到底是0000还是0001，在得到这两个数据即ClassGuid和设备序列号后，就好办了。
下面我写一段代码，用来访问我机器上的一USB设备，并在listbox中列出当前机器上此设备类下的所有设备。

extern "C"
{
#include "setupapi.h"
}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
   //First of all,I will enumurate all the devices under the specified deviceclass
   HKEY m_hKey,m_hSubKey;
   long m_lResult=0;//using for return value
   int m_nKeyIndex=0,m_nValueIndex=0;
   char cKeyName[255],cValue[255];
   unsigned char pbData[255];
   BOOL bOutter=TRUE,bInter=TRUE;
   char *cRoot="SYSTEM\\ControlSet001\\Control\\Class\\{4D36E96D-E325-11CE-BFC1-08002BE10318}";
   AnsiString m_sAttached("");
   m_lResult=::RegOpenKeyEx(HKEY_LOCAL_MACHINE,cRoot,0,KEY_ALL_ACCESS,&amp;m_hKey);
   if(m_lResult!=ERROR_SUCCESS) return FALSE;
   //Enum Keys
   while(bOutter){
   m_lResult=::RegEnumKey(m_hKey,m_nKeyIndex,cKeyName,255);
   bInter=TRUE;
   if(m_lResult!=ERROR_SUCCESS) bOutter=FALSE;
   else{
   m_lResult=::RegOpenKeyEx(m_hKey,cKeyName,0,KEY_ALL_ACCESS,&amp;m_hSubKey);
   if(m_lResult!=ERROR_SUCCESS){
   ::RegCloseKey(m_hKey);
   return FALSE;}
   while(bInter){
   unsigned long m_nDataSize=255;
   unsigned long m_nValueNameSize=255;
   unsigned long m_nType;
   m_lResult=::RegEnumValue(m_hSubKey,m_nValueIndex,cValue,&amp;m_nValueNameSize,0,&amp;m_nType,pbData,&amp;m_nDataSize);
   if(m_lResult!=ERROR_SUCCESS)  bInter=FALSE;
    else{
     if(!strcmp(cValue,"AttachedTo")){
      m_sAttached=(AnsiString)(char*)pbData;
     }
     if(!strcmp(cValue,"DriverDesc")){
      m_lstDevice-&gt;Items-&gt;Add((AnsiString)(char*)pbData+"  "+m_sAttached);
     }
     m_nValueIndex++;
    }
   }
   m_nValueIndex=0;
   m_nKeyIndex++;
   
  }
}
::RegCloseKey(m_hKey);
::RegCloseKey(m_hSubKey);
   
  file://Next/ Step,I will access one of the device.I know its device serialn0001
  DWORD ReqLength;
  DWORD Flags=DIGCF_PRESENT|DIGCF_DEVICEINTERFACE;
  GUID CardGuid={4D36E96D-E325-11CE-BFC1-08002BE10318};
  HANDLE hCard=0;
  PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceDetailData;
     SP_DEVICE_INTERFACE_DATA        DeviceInterfaceData;
     DeviceInterfaceData.cbSize=sizeof(SP_DEVICE_INTERFACE_DATA);
     hCard=SetupDiGetClassDevs(&amp;CardGuid,NULL,NULL,Flags);
     if(hCard==INVALID_HANDLE_VALUE){
     ::MessageBox(0,"Invalid Parameters!","Error",MB_OK|MB_ICONERROR);
         return;}
     BOOL status=SetupDiEnumDeviceInterfaces(hCard,NULL,&amp;CardGuid,Index,&amp;DeviceInterfaceData,&amp;ReqLength,
NULL);//Index即设备的序号，这里的Index为1.
if(!status){
  ::MessageBox(0,"Failed to enumurate the specified
device!","Error",MB_OK+MB_ICONERROR);
         ::CloseHandle(hCard);
         return;}
SetupDiGetInterfaceDeviceDetail(hCard,&amp;DeviceInterfaceData,NULL,0,&amp;ReqLength,NULL);
DeviceDetailData=(PSP_INTERFACE_DEVICE_DETAIL_DATA)new char[ReqLength];
if(DeviceDetailData){
  ::MessageBox("ERROR NOT ENOUGH MEMORY!","Error",MB_OK+MB_ICONERROR);
         ::CloseHandle(hCard);
         return;}
         status=SetupDiGetInterfaceDeviceDetail(hCard,&amp;DeviceInterfaceData,DeviceDetailD
status=SetupDiGetInterfaceDeviceDetail(hCard,&amp;DeviceInterfaceData,DeviceDetailData,ReqLength,&amp;ReqLength,NULL);
         if(!status){
  ::MessageBox(0,"Failed to get interface detailed data","Error",MB_OK+MB_ICONERROR);
         delete DeviceDetailData;
         DeviceDetailData=NULL;
         return;}
        ShowMessage(DeviceDetailData-&gt;DevicePath());//在这里得到DevicePath就像得到符号名一样，那么接着下来，你你就可以象对串口操作一样来写程序，即是说：
        HANDLE hUSB=::CreateFile(DeviceDetailData.DevicePath(),..............);
        file://ReadFile,WriteFile/ and so on.....
}
所有以file:为前缀的地方都是注释部分

MAX291

<>好,顶!</P>