HID设备通讯类欢迎各位 大大 拍砖

[DK_qkfinmmx]

直接上代码 ~

#pragma once
#include <vector>
#include <Windows.h>

extern "C" {				// Declare the C libraries used
#include "setupapi.h"		// Must link in setupapi.lib
#include "hidsdi.h"			// Must link in hid.lib
}

using namespace std;

enum CreateErrMsg{
	NOErr,
	GetHIDDevInfoError
};

class BUSBHID 
{
public:
	BUSBHID(void)	{ Init(); }

	~BUSBHID(void){
		Close();
		Destory();
	}

private:
	//禁止构造拷贝
	BUSBHID(const BUSBHID&);
	//禁止赋值函数
	BUSBHID &operator = (const BUSBHID&);

private:
	//Handle
	HANDLE _hUsbDev;

	//Option
	bool BOOL_EN_OVERLAPPED;

	//Overlapped
	OVERLAPPED RO_;				
	OVERLAPPED WO_;				
	OVERLAPPED EO_;	

	//ReportSize
	int Int_InputReportLen,Int_OutpotReportLen;

	//Count
	DWORD dwInCount;
	DWORD dwOutCount;

	//Dev INF
	GUID HidGuid;
	HDEVINFO DevInfo;
	UINT UInt_CreateErrMsg;

	//Dev Data
	vector<SP_DEVICE_INTERFACE_DATA> vecDevData;
	vector<PSP_INTERFACE_DEVICE_DETAIL_DATA> vecDetail;

public:
	virtual bool Open(LPCWSTR DevPath ,bool EN_OVERLAPPED = true ){
		//设备句柄打开异常处理
		if (IsOpen())	{ Close(); }

		//模式选项
		BOOL_EN_OVERLAPPED = EN_OVERLAPPED;

		//创建句柄
		_hUsbDev = ::CreateFile( DevPath ,GENERIC_READ | GENERIC_WRITE,
			FILE_SHARE_READ | FILE_SHARE_WRITE,(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING,
			FILE_ATTRIBUTE_NORMAL | (IsOverlappedMode() ? FILE_FLAG_OVERLAPPED : 0), NULL );
		
		//获取设备能力
		PHIDP_PREPARSED_DATA PreparsedData;
		::HidD_GetPreparsedData(_hUsbDev,&PreparsedData);
		HIDP_CAPS* Caps = new HIDP_CAPS;
		::HidP_GetCaps(PreparsedData,Caps);
		Int_InputReportLen = Caps->InputReportByteLength;
		Int_OutpotReportLen = Caps->OutputReportByteLength;

		return IsOpen();
	}

	virtual void Close(void){
		if (IsOpen()){
			::SetEvent(RO_.hEvent);
			::SetEvent(WO_.hEvent);
			::CloseHandle(_hUsbDev);
			_hUsbDev = INVALID_HANDLE_VALUE;
		}
	}

	bool AbortRx(void){
		if (IsOpen())
			return ::SetEvent(RO_.hEvent);
		else
			return false;
	}

	DWORD GetHidDevList(vector<int>& PID,vector<int>& VID,vector<int>& Ver){
		
		GUID tHidGuid;
		::HidD_GetHidGuid(&tHidGuid);

		HDEVINFO tDevInfo = ::SetupDiGetClassDevs(&tHidGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE );

		SP_DEVICE_INTERFACE_DATA tDevData;
		tDevData.cbSize = sizeof(tDevData);

		for (DWORD devIndex = 0; ::SetupDiEnumDeviceInterfaces(tDevInfo, NULL, &tHidGuid,devIndex, &tDevData); ++devIndex){
			DWORD needLen = 0;
			::SetupDiGetDeviceInterfaceDetail(tDevInfo, &tDevData, NULL, 0,&needLen, NULL);
			PSP_INTERFACE_DEVICE_DETAIL_DATA detail = (PSP_INTERFACE_DEVICE_DETAIL_DATA) malloc(needLen);
			detail->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
			SP_DEVINFO_DATA did = {sizeof(SP_DEVINFO_DATA)};
			::SetupDiGetDeviceInterfaceDetail(tDevInfo, &tDevData, detail, needLen, NULL, &did);

			//打开句柄
			HANDLE DevHandle = ::CreateFile(detail->DevicePath,GENERIC_READ|GENERIC_WRITE,
				FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
				OPEN_EXISTING, NULL, NULL);
			if (DevHandle == INVALID_HANDLE_VALUE)	{ continue; }
			HIDD_ATTRIBUTES attr =  {sizeof(HIDD_ATTRIBUTES)};

			//获取HID设备属性
			::HidD_GetAttributes(DevHandle,&attr);

			//判断设备是否正确
			PID.push_back(attr.ProductID);
			VID.push_back(attr.VendorID);
			Ver.push_back(attr.VersionNumber);

			//关闭句柄
			::CloseHandle(DevHandle);
		}

		return PID.size();
	}

	vector<PSP_INTERFACE_DEVICE_DETAIL_DATA> GetDevDetailData(int PID,int VID,int Ver){

		vecDetail.clear(); 

		//获取GUID
		::HidD_GetHidGuid(&HidGuid);

		//返回设备信息结构的句柄
		DevInfo = ::SetupDiGetClassDevs(&HidGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE );

		//查询HID信息失败
		if (DevInfo == INVALID_HANDLE_VALUE){ 
			UInt_CreateErrMsg = CreateErrMsg::GetHIDDevInfoError; 
			vecDetail.clear(); 
			return vecDetail;
		}

		SP_DEVICE_INTERFACE_DATA DevData;
		DevData.cbSize = sizeof(DevData);

		//遍历HID设备
		for (DWORD devIndex = 0; ::SetupDiEnumDeviceInterfaces(DevInfo, NULL, &HidGuid,devIndex, &DevData); ++devIndex){
			DWORD needLen = 0;
			::SetupDiGetDeviceInterfaceDetail(DevInfo, &DevData, NULL, 0,&needLen, NULL);
			PSP_INTERFACE_DEVICE_DETAIL_DATA detail = (PSP_INTERFACE_DEVICE_DETAIL_DATA) malloc(needLen);
			detail->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
			SP_DEVINFO_DATA did = {sizeof(SP_DEVINFO_DATA)};
			::SetupDiGetDeviceInterfaceDetail(DevInfo, &DevData, detail, needLen, NULL, &did);

			//打开句柄
			HANDLE DevHandle = ::CreateFile(detail->DevicePath,GENERIC_READ|GENERIC_WRITE,
				FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
				OPEN_EXISTING, NULL, NULL);
			if (DevHandle == INVALID_HANDLE_VALUE)	{ continue; }
			HIDD_ATTRIBUTES attr =  {sizeof(HIDD_ATTRIBUTES)};

			//获取HID设备属性
			::HidD_GetAttributes(DevHandle,&attr);

			//判断设备是否正确
			if (attr.ProductID == PID && attr.VendorID == VID && attr.VersionNumber == Ver){
				vecDevData.push_back(DevData);
				vecDetail.push_back(detail);
			}

			//关闭句柄
			::CloseHandle(DevHandle);
		}

		return vecDetail;
	}

	DWORD WritePort(PUCHAR pBuffer ,DWORD dwLen,UCHAR ReportID){

		unsigned long uWriteLength = 0;

		if (!IsOpen())	{ return 0; }

		int tInt_OutputReportLen = GetOutputReportLen();

		if (dwLen > tInt_OutputReportLen - 1)	{ dwLen = tInt_OutputReportLen - 1; }

		PUCHAR tBuffer = new unsigned char [tInt_OutputReportLen];
		memset(tBuffer,0,sizeof(unsigned char)*tInt_OutputReportLen);
		tBuffer[0] = ReportID;
		CopyMemory(tBuffer+1,pBuffer,dwLen);

		if (IsOverlappedMode()){
			//重叠IO模式
			if (!::WriteFile(_hUsbDev,tBuffer,tInt_OutputReportLen,&uWriteLength,&WO_)
				&& ::GetLastError() != ERROR_IO_PENDING ){
				DWORD ErrorNum = GetLastError();
				uWriteLength = 0;
			}
			else{
				bool rtv = ::GetOverlappedResult(_hUsbDev, &WO_, &uWriteLength, TRUE);
				dwOutCount += uWriteLength;
			}	
		}
		else{
			if (!::WriteFile(_hUsbDev,tBuffer,tInt_OutputReportLen,&uWriteLength,NULL)){
				DWORD ErrorNum = GetLastError();
				dwOutCount += uWriteLength;
			}
			else
				dwOutCount += uWriteLength;
		}

		delete tBuffer;

		return uWriteLength;
	}

	DWORD ReadPort(PUCHAR pBuffer, DWORD dwLength ){

		DWORD dwReadResult = 0;

		if (!IsOpen())	{ return 0; }

		int tInputReportLen = GetInputReportLen();

		if (dwLength != tInputReportLen - 1)	{ return 0; }

		UCHAR* tBuffer = new UCHAR [tInputReportLen];
		memset(tBuffer,0,sizeof(UCHAR)*tInputReportLen);

		if (IsOverlappedMode()){
			//异步模式读取
			if (!::ReadFile(_hUsbDev,tBuffer,tInputReportLen,&dwReadResult,&RO_)){
				if (::GetLastError() == ERROR_IO_PENDING){
					bool rtv = ::GetOverlappedResult(_hUsbDev, &RO_, &dwReadResult, TRUE);
					dwInCount += dwReadResult;
					CopyMemory(pBuffer,tBuffer + 1,dwLength);
				}
				else	{ dwReadResult = 0; dwInCount += dwReadResult; }
			}	
		}
		else{
			//同步模式读取
			if (!::ReadFile(_hUsbDev,tBuffer,tInputReportLen,&dwReadResult,NULL)){
				dwReadResult = 0;
			}
			else{
				dwInCount += dwReadResult;
				CopyMemory(pBuffer,tBuffer + 1,dwLength);
			}
		}

		delete tBuffer;

		return dwReadResult;
	}

	unsigned long GetHidDInputBuffer(void){
		unsigned long size;
		HidD_GetNumInputBuffers(_hUsbDev,&size);
		return size;
	}

	bool SetHidDInputBuffer(ULONG size)	{ return HidD_SetNumInputBuffers(_hUsbDev,size); }

	bool IsOpen(void)	{ return _hUsbDev != INVALID_HANDLE_VALUE; }

	bool IsOverlappedMode(void)	{ return BOOL_EN_OVERLAPPED; }

	operator bool()	{ return _hUsbDev != INVALID_HANDLE_VALUE; }

	int GetInputReportLen(void)	{ return Int_InputReportLen; }

	int GetOutputReportLen(void){ return Int_OutpotReportLen; }

	int GetInputCount(void)	{ return dwInCount; }

	int GetOutputCount(void){ return dwOutCount; }

	void ResetInputCount(void)	{ dwInCount = 0; }

	void ResetOutputCount(void)	{ dwOutCount = 0; }

protected:

	virtual void Init(void){
		//句柄初始化
		_hUsbDev = INVALID_HANDLE_VALUE;

		//计数器清零
		dwInCount = 0;
		dwOutCount = 0;

		//属性值初始化
		Int_InputReportLen = 0;
		Int_OutpotReportLen = 0;

		//重叠IO结构初始化
		memset(&WO_,0,sizeof(WO_));
		memset(&RO_,0,sizeof(RO_));
		memset(&EO_,0,sizeof(EO_));

		WO_.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		RO_.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		EO_.hEvent= ::CreateEvent(NULL, TRUE, FALSE, NULL);
	}

	virtual void Destory(void){
		//重叠IO结构关闭
		if(RO_.hEvent != NULL)
			::CloseHandle(RO_.hEvent);

		if(WO_.hEvent != NULL)
			::CloseHandle(WO_.hEvent);

		if(EO_.hEvent != NULL)
			::CloseHandle(EO_.hEvent);
	}

	HANDLE GetHandle(void)	{ return _hUsbDev; }
};

WritePort函数调用在小于100ms时间间隔下,只能向设备写数据无法读取到数据 . 求解 求救啊 ~!!!!