C++ 实现USB - HID读写数据

源代码--如下：

1.MCDInterface.h
/*
*MCDInterface.h
*author:
*data:
*/

#ifndef MCDBOX_H_INCLUDED
#define MCDBOX_H_INCLUDED
#pragma once
#define MCD_IOCTRL_OPEN_SIG 0x1001
#define MCD_IOCTRL_CLOSE_SIG 0x1002
#define MCD_IOCTRL_FIND_SIG 0x1003
#define MCD_IOCTRL_READY 0x1003
#define MCD_IOCTRL_UNREADY 0x1004
#define KEY_0 0x3A
#define KEY_1 0x3B
#define KEY_2 0x3C
#define KEY_3 0x3D
#define KEY_4 0x3E
#define KEY_5 0x3F
#define KEY_6 0x40
#define KEY_7 0x41
#define KEY_8 0x42
#define KEY_9 0x43
#define KEY_STAR 0x44
#define KEY_POUND 0x45
#define MSG_HOOKOFF 0x16
#define MSG_HOOKON 0x12
#define MSG_RINGING 0x15
#define HID_DEVICE_REMOVE 0x76 //硬件被移走
#define CLIENT_READY_WRITE_SIG 0x92 //通知设备软件正在运行，每隔一段时间向缓冲区写该数据
#define DLL_EXPORT __declspec(dllexport)
#define DLL_IMPORT __declspec(dllimport)
//定义用于回调的枚举消息
enum{
MCD_CALLBACK_MSG_VERSION,//not used
MCD_CALLBACK_MSG_SERIALNO,//not used
MCD_CALLBACK_DEVICE_FOUND,
MCD_CALLBACK_DEVICE_NOT_FOUND,
MCD_CALLBACK_DEVICE_REMOVE,

MCD_CALLBACK_KEYDOWN,
MCD_CALLBACK_KEYBUFFER_CHANGED,
MCD_CALLBACK_HOOKOFF,
MCD_CALLBACK_HOOKON,
MCD_CALLBACK_RINGING,
MCD_CALLBACK_MSG_WARNING = -2,
MCD_CALLBACK_MSG_ERROR = -1,
};
DLL_EXPORT unsigned long MCD_DeviceIoControl(unsigned long dwIoControlCode,
void* lpInBuffer = 0, unsigned long nInBufferSize = 0,
void* lpOutBuffer = 0, unsigned long nOutBufferSize = 0);
//定义设备状态返回信息
enum{
MCD_RETURN_SUCCESS = 0,
MCD_RETURN_FOUND_HID,
MCD_RETURN_NO_FOUND_HID,
MCD_RETURN_HID_IS_OPENED,//?
MCD_RETURN_HID_NO_OPEN,//?
};
#endif // MCDBOX_H_INCLUDED
2.mcdHid.h
#ifndef MCDHID_H_INCLUDED
#define MCDHID_H_INCLUDED
extern "C"
{
#include "setupapi.h"
#include "hidsdi.h"
#include "dbt.h"
}
typedef struct _HID_DEVICE {
PCHAR DevicePath;
HANDLE HidDevice; // A file handle to the hid device.
HIDP_CAPS Caps; // The Capabilities of this hid device.
HIDD_ATTRIBUTES Attributes;
} HID_DEVICE, *PHID_DEVICE;

class MCDHid
{
public:
static MCDHid & getInstance(){
static MCDHid mcdHid;
return mcdHid;
}
MCDHid(MCDHid & mcdHid);
MCDHid & operator=(MCDHid &mcdHid);
~MCDHid();
unsigned long openMCDHid();
void closeMCDHid();
void startComm(void * pParam);

int writeToHid();

int readFromHid();
char * getHidDeviceName()
{
return _hidDeviceName;
}
bool findMCDHid();
HID_DEVICE* getHidDevice(){
return & _hidDevice;
}
bool getUsbCommRunning(){
return _fUsbCommRunning;
}
bool getOffHookSignal(){
return _offHookSignal;
}
unsigned long getDataWaitProcess(){
return _dataWaitProcess;
}
void setUsbCommRunning(bool usbCommRunning)
{
_fUsbCommRunning = usbCommRunning;
}
unsigned char _inputReportBuffer[9];
unsigned char _outputReportBuffer[2];

private:
MCDHid();
void copy(MCDHid & mcdHid);
char *_hidDeviceName;
HANDLE _hEventObject;
OVERLAPPED _hIDOverlapped;
HID_DEVICE _hidDevice;

bool _fUsbCommRunning;
bool _offHookSignal;
unsigned long _dataWaitProcess;
unsigned long _inputReportByteLength;
unsigned long _outputReportByteLength;
};

#endif // MCDHID_H_INCLUDED

3.mcdHid.cpp
/*
mcdhid.cpp
function: open HID device ,close HID device ,read data from HID device , write data to HID device
author:
date:
version:
*/
#include <stdlib.h>
#include <windows.h>
#include <stdio.h>
#include "mcdhid.h"
#include "MCDInterface.h"
#include "mcdbox.h"
#include "pthread.h"

void *getDataThread(void *pParam);
#define VENDOR_ID 0x1241//test device vendorId
#define PRODUCT_ID 0xe001//test device productId
#define CLIENT_RUNNING_MSG

MCDHid::MCDHid()
{
_hidDeviceName = "MCD Human Interface Device";

_fUsbCommRunning = false;
_offHookSignal = false;
_dataWaitProcess = 1;
memset(_inputReportBuffer,0,sizeof(_inputReportBuffer));
memset(_outputReportBuffer,0,sizeof(_outputReportBuffer));
}
MCDHid::MCDHid(MCDHid & mcdHid)
{
copy(mcdHid);
}
MCDHid & MCDHid::operator=(MCDHid & mcdHid)
{
copy(mcdHid);
return *this;
}
void MCDHid::copy(MCDHid & mcdHid)
{
_hidDeviceName = mcdHid._hidDeviceName;
_hEventObject = mcdHid._hEventObject;
_hIDOverlapped = mcdHid._hIDOverlapped;
_hidDevice = mcdHid._hidDevice;
_fUsbCommRunning = mcdHid._fUsbCommRunning;
_offHookSignal = mcdHid._offHookSignal;
_dataWaitProcess = mcdHid._dataWaitProcess;
_inputReportByteLeng
4000
th = mcdHid._inputReportByteLength;
_outputReportByteLength = mcdHid._outputReportByteLength;
for(int i = 0; i<sizeof(_inputReportBuffer); i++)
{
_inputReportBuffer[i] = mcdHid._inputReportBuffer[i];
}
for(int i = 0; i<sizeof(_outputReportBuffer); i++)
{
_inputReportBuffer[i] = mcdHid._outputReportBuffer[i];
}
}
MCDHid::~MCDHid()
{
}
unsigned long MCDHid::openMCDHid()
{
if(findMCDHid())
{
//采用重叠传输方式
//if( _hEventObject == 0)
// {

_hEventObject = CreateEvent(
NULL,
true,
true,
"");
_hIDOverlapped.hEvent = _hEventObject;
_hIDOverlapped.Offset = 0;
_hIDOverlapped.OffsetHigh =0;
// }

return MCD_RETURN_SUCCESS;
}
else
return MCD_RETURN_NO_FOUND_HID;
}
void MCDHid::closeMCDHid()
{
CloseHandle(_hidDevice.HidDevice);
_hidDevice.HidDevice = INVALID_HANDLE_VALUE;
}
void MCDHid::startComm(void *pParam)
{
int thr_id;
pthread_t m_processT;

if((thr_id=pthread_create(&m_processT, NULL, getDataThread, pParam) != 0))
{
//printf("pthread_create error:%s\n", strerror(thr_id));
return;
}
}
bool MCDHid::findMCDHid()
{
int vendorID = VENDOR_ID;
int productID = PRODUCT_ID;
DWORD required;
GUID hidGuid;
HDEVINFO hDevInfo;
SP_DEVICE_INTERFACE_DATA devInfoData;
int memberIndex = 0;
LONG result;
bool lastDevice = false;
DWORD length;
PSP_DEVICE_INTERFACE_DETAIL_DATA detailData = NULL;
bool deviceDetected = false;

HidD_GetHidGuid(&hidGuid);
hDevInfo = SetupDiGetClassDevs
(&hidGuid,
NULL,
NULL,
DIGCF_PRESENT|DIGCF_INTERFACEDEVICE);
//当应用程序不再需要使用SetupDiGetClassDevs函数的传回值hDevInfo所指的数组时，应该调用SetupDiDeStroyDeviceInfoList函数来释放资源
if(hDevInfo == INVALID_HANDLE_VALUE)
{
//printf("Failed to open device handle!");
return false;
}

devInfoData.cbSize = sizeof(devInfoData);
do
{
result = SetupDiEnumDeviceInterfaces(
hDevInfo,
0,
&hidGuid,
memberIndex,
&devInfoData);
if (result != 0)
{
result = SetupDiGetDeviceInterfaceDetail(
hDevInfo,
&devInfoData,
NULL,
0,
&length,
NULL);
detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(length);
if(!detailData)
{
//printf("Device information allacation failed!");
return false;
}
detailData -> cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
result = SetupDiGetDeviceInterfaceDetail(
hDevInfo,
&devInfoData,
detailData,
length,
&required,
NULL);
if(!result)
{
//printf("Device information reallocation failed!");
return false;
}
_hidDevice.HidDevice = CreateFile(
detailData->DevicePath,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
(LPSECURITY_ATTRIBUTES)NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);

_hidDevice.Attributes.Size = sizeof(HIDD_ATTRIBUTES);
result = HidD_GetAttributes(
_hidDevice.HidDevice,
&_hidDevice.Attributes);
if ((_hidDevice.Attributes.VendorID == vendorID) && (_hidDevice.Attributes.ProductID == productID))
{
int status;
PHIDP_PREPARSED_DATA PreparsedData ;
deviceDetected = true;

//获取USB设备的预解析数据
result = HidD_GetPreparsedData(_hidDevice.HidDevice,&PreparsedData);
if(!result)
{
//printf("无法获取USB设备的预解析数据!");
return false;
}
status= HidP_GetCaps(PreparsedData, &_hidDevice.Caps);
_fUsbCommRunning = true;
HidD_FreePreparsedData(PreparsedData);
PreparsedData = NULL;

}
else
{
//printf("没有找到设备!");
closeMCDHid();
}
free(detailData);
detailData = NULL;
}
else
{
lastDevice = true;
}
memberIndex = memberIndex + 1;
}while((lastDevice == false)&&(deviceDetected == false));

SetupDiDestroyDeviceInfoList(hDevInfo);
return deviceDetected;
}
/*
*写入数据为MCD设备状态通知,把标识位放在第1位
*/
int MCDHid::writeToHid()
{
return 0;
}
int MCDHid::readFromHid()
//int readFromHid()
{
if(_hidDevice.HidDevice != INVALID_HANDLE_VALUE)
{
int result = 0;
DWORD numberOfBytesRead;

result = ReadFile(_hidDevice.HidDevice,
&_inputReportBuffer,
_hidDevice.Caps.InputReportByteLength,
&numberOfBytesRead,
(LPOVERLAPPED)&_hIDOverlapped);
_inputReportByteLength = _hidDevice.Caps.InputReportByteLength;
}
int waitResult = 0;
waitResult = WaitForSingleObject(
_hEventObject,
10);
switch(waitResult)
{
case WAIT_OBJECT_0: break;
case WAIT_TIMEOUT:
{
CancelIo(_hidDevice.HidDevice);
break;
}
default:
{
break;
}
}
ResetEvent(_hEventObject);
return 0;
}
/**************************************************************************
*启动一个读取数据线程，读取数据为拨打电话号码
*启动一个写入数据线程, 写入数据为MCD设备状态通知，现在还没有写数据
***************************************************************************/

void *getDataThread(void *pParam)
{
MCDBox *ht = (MCDBox *)pParam;
MCDHid *hr = &(MCDHid::getInstance());

while(hr->getUsbCommRunning())//USB设备running，并且有摘机信号
{
hr->readFromHid();
//readFromHid();
//printf("获取缓冲区的数据\n");

if(hr->getDataWaitProcess() > 0)//可以定义_dataWaitProcess为一次拨号数据的长度
{
unsigned long i = 0;

for(i = 0; i < 9; i++)
{
ht->_inputReportBuffer[i] = hr->_inputReportBuffer[i];
//printf("read data from device is:%d\n",ht->_inputReportBuffer[1]);
}
ht->processData();
memset(hr->_inputReportBuffer,0,sizeof(hr->_inputReportBuffer));
//printf("数据处理!\n");
}
int status = 0;
//PHIDP_PREPARSED_DATA PreparsedData ;
//status = HidD_GetPreparsedData(_hidDevice.HidDevice,&PreparsedData);
status = HidD_GetAttributes(
hr->getHidDevice()->HidDevice,
&hr->getHidDevice()->Attributes);
if(!status)
{
hr->setUsbCommRunning(false);
memset(ht->_inputReportBuffer,0,sizeof(ht->_inputReportBuffer));
ht->_inputReportBuffer[2] = HID_DEVICE_REMOVE;
ht->processData();
printf("设备移走!");
//return false;
break;
}
//HidD_FreePreparsedData (PreparsedData);
// PreparsedData = NULL;
Sleep(100);
}
return 0;
}