混合DotNet与Win32API来实现的Hidlibrary，c/c++可直接使用，c#可直接使用
异步IO，拔插事件订阅，数据读取事件订阅
工程目录结构
HidEvent.h
#pragma once typedef void (*HidEvent)();
typedef void (__cdecl *HidReadDataEvent)(unsigned char *data, int len);
Hidimpl.h
#pragma once
#include "HidEvent.h" class Hidimpl
{
public:
Hidimpl(int vid, int pid);
~Hidimpl(void); bool FindMyDevice();
void NotifyEvents(HidEvent arrival, HidEvent removed, HidReadDataEvent rdata); int getInputLen()
{
return mInputLen;
} int getOutputLen()
{
return mOutputLen;
} bool IsConnected()
{
return mIsConnected;
} public:
// IO Functions
//int Read(unsigned char *data, int len);
void Write(unsigned char *data, int len); public:
static Hidimpl *mTarget;
static DWORD ThreadMessageRoutine(LPVOID lparam);
static LRESULT CALLBACK ZSHidWndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam); public:
HidEvent mArrivalEvent;
HidEvent mRemovedEvent;
HidReadDataEvent mReadDataEvent; private:
void MyDeviceRemoved(); private:
int mInputLen;
int mOutputLen;
bool mIsConnected; int mVid;
int mPid;
HANDLE mhHidRx;
HANDLE mhHidTx; DWORD mThreadId;
HANDLE mThreadHandle; // Managed objects FileStream
void *mFsRx;
void *mFsTx;
};
Hidimpl.cpp
#include "StdAfx.h"
#include "Hidimpl.h"
#include "HidState.h"
#include <vcclr.h> #pragma comment(lib, "hid.lib")
#pragma comment(lib, "setupapi.lib") using namespace System;
using namespace System::IO;
using namespace Microsoft::Win32::SafeHandles; Hidimpl *Hidimpl::mTarget = nullptr; Hidimpl::Hidimpl(int vid, int pid)
:mFsRx(nullptr), mFsTx(nullptr),
mArrivalEvent(nullptr), mRemovedEvent(nullptr),
mThreadId(), mThreadHandle(INVALID_HANDLE_VALUE)
{
mVid = vid;
mPid = pid; FindMyDevice();
} Hidimpl::~Hidimpl(void)
{
MyDeviceRemoved();
if (mThreadHandle != INVALID_HANDLE_VALUE)
{
PostThreadMessage(mThreadId, WM_CLOSE, , );
mThreadHandle = INVALID_HANDLE_VALUE;
}
} void Hidimpl::MyDeviceRemoved()
{
if (mFsRx)
{
gcroot<FileStream ^> *_pfs = static_cast<gcroot<FileStream ^> *>(mFsRx);
// not need only delete ok
//((FileStream ^)*_pfs)->Close();
delete _pfs;
mFsRx = nullptr;
} if (mFsTx)
{
gcroot<FileStream ^> *_pfs = static_cast<gcroot<FileStream ^> *>(mFsTx);
// not need only delete ok
//((FileStream ^)*_pfs)->Close();
delete _pfs;
mFsTx = nullptr;
} // 不需要手动关闭GC自动处理
// this is also a crazy fucking shit
// 关闭的句柄被重复关闭会引发[0xC0000008: An invalid handle was specified]
//CloseHandle(mhHidRx);
//mhHidRx = INVALID_HANDLE_VALUE;
//CloseHandle(mhHidTx);
//mhHidTx = INVALID_HANDLE_VALUE;
} bool Hidimpl::FindMyDevice()
{
bool isFind = false;
GUID guid;
HidD_GetHidGuid(&guid);
HDEVINFO hdevinfo = SetupDiGetClassDevs(&guid, , , DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
SP_DEVICE_INTERFACE_DATA device_interface_data;
ZeroMemory(&device_interface_data, sizeof(device_interface_data));
device_interface_data.cbSize = sizeof(device_interface_data); int device_interface_index = ;
while (SetupDiEnumDeviceInterfaces(hdevinfo, NULL, &guid, device_interface_index, &device_interface_data))
{
DWORD requireSize;
SetupDiGetDeviceInterfaceDetail(hdevinfo, &device_interface_data, NULL, , &requireSize, NULL);
PSP_DEVICE_INTERFACE_DETAIL_DATA psp_device_interface_detail_data = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(requireSize);
psp_device_interface_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
if (SetupDiGetDeviceInterfaceDetail(hdevinfo, &device_interface_data, psp_device_interface_detail_data, requireSize, &requireSize, NULL))
{
TCHAR *device_path = psp_device_interface_detail_data->DevicePath; // 打印设备路径[将TCHAR *转换为System::String^]
//String ^str_path = gcnew String(device_path);
//Console::ForegroundColor = ConsoleColor::Blue;
//Console::WriteLine(str_path);
//Console::ResetColor(); HANDLE handle = CreateFile(device_path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, NULL);
if (handle != INVALID_HANDLE_VALUE)
{
HIDD_ATTRIBUTES hidd_attributes;
HidD_GetAttributes(handle, &hidd_attributes);
if (hidd_attributes.VendorID == mVid && hidd_attributes.ProductID == mPid)
{
PHIDP_PREPARSED_DATA phidp_preparsed_data;
HidD_GetPreparsedData(handle, &phidp_preparsed_data);
HIDP_CAPS hidp_caps;
HidP_GetCaps(phidp_preparsed_data, &hidp_caps);
mInputLen = hidp_caps.InputReportByteLength;
mOutputLen = hidp_caps.OutputReportByteLength;
HidD_FreePreparsedData(phidp_preparsed_data); // 打印设备路径[将TCHAR *转换为System::String^]
String ^str_path = gcnew String(device_path);
Console::ForegroundColor = ConsoleColor::Green;
Console::WriteLine(str_path);
Console::ResetColor(); mhHidRx = CreateFile(device_path, GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
mhHidTx = CreateFile(device_path, GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL); SafeFileHandle ^_hRx = gcnew SafeFileHandle((IntPtr)mhHidRx, true);
FileStream ^_fsRx = gcnew FileStream(_hRx, FileAccess::Read, mInputLen, true);
// managed type conversion into unmanaged pointer is not allowed.
// we can use gcroot<> wrapper
gcroot<FileStream^> *_pfs = new gcroot<FileStream ^>(_fsRx);
mFsRx = static_cast<void *>(_pfs); SafeFileHandle ^_hTx = gcnew SafeFileHandle((IntPtr)mhHidTx, true);
FileStream ^_fsTx = gcnew FileStream(_hTx, FileAccess::Write, mOutputLen, true);
// managed type conversion into unmanaged pointer is not allowed.
// we can use gcroot<> wrapper
_pfs = new gcroot<FileStream^>(_fsTx);
mFsTx = static_cast<void *>(_pfs); HidState ^state = gcnew HidState(this, _fsRx, mInputLen);
_fsRx->BeginRead(state->mBuffer, , state->mBuffer->Length, gcnew AsyncCallback(state, &HidState::EndRead), state); isFind = true;
CloseHandle(handle);
free(psp_device_interface_detail_data);
break;
} CloseHandle(handle);
}
}
else
{
int error = GetLastError();
Console::ForegroundColor = ConsoleColor::Blue;
Console::WriteLine("[SetupDiGetDeviceInterfaceDetail Error]GetLastError = " + error);
Console::ResetColor();
} device_interface_index++;
free(psp_device_interface_detail_data);
} SetupDiDestroyDeviceInfoList(hdevinfo);
mIsConnected = isFind; return isFind;
} void Hidimpl::NotifyEvents(HidEvent arrival, HidEvent removed, HidReadDataEvent rdata)
{
// Cannt reset event to device
if (mThreadHandle != INVALID_HANDLE_VALUE) return; mArrivalEvent = arrival;
mRemovedEvent = removed;
mReadDataEvent = rdata; mThreadHandle = CreateThread(NULL, ,
(LPTHREAD_START_ROUTINE)ThreadMessageRoutine, this, THREAD_PRIORITY_NORMAL, &mThreadId);
} DWORD Hidimpl::ThreadMessageRoutine(LPVOID lparam)
{
mTarget = static_cast<Hidimpl *>(lparam);
HINSTANCE hInstance = reinterpret_cast<HINSTANCE>(GetModuleHandle(NULL)); WNDCLASS wndClass = {};
wndClass.lpfnWndProc = ZSHidWndProc;
wndClass.lpszClassName = L"ZSHidlib";
wndClass.hInstance = hInstance;
if (RegisterClass(&wndClass))
{
// 为线程消息循环(HWND_MESSAGE)
HWND hwnd = CreateWindowEx(, wndClass.lpszClassName, NULL,
, , , , , HWND_MESSAGE, NULL, hInstance, NULL);
if (hwnd != INVALID_HANDLE_VALUE)
{
GUID guid;
HidD_GetHidGuid(&guid);
DEV_BROADCAST_DEVICEINTERFACE notifycationFilter = {};
notifycationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
notifycationFilter.dbcc_classguid = guid;
notifycationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
HDEVNOTIFY hdevnotify = RegisterDeviceNotification(hwnd, ¬ifycationFilter, DEVICE_NOTIFY_WINDOW_HANDLE); if (hdevnotify != INVALID_HANDLE_VALUE)
{
Console::ForegroundColor = ConsoleColor::Blue;
Console::WriteLine("Notify注册成功，即将进入消息循环.");
Console::ResetColor(); MSG msg;
if (GetMessage(&msg, NULL, , ) > )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
} Console::ForegroundColor = ConsoleColor::Blue;
Console::WriteLine("退出消息循环........................");
Console::ResetColor(); UnregisterDeviceNotification(hdevnotify);
DestroyWindow(hwnd);
UnregisterClass(wndClass.lpszClassName, hInstance);
}
} return ;
} LRESULT CALLBACK Hidimpl::ZSHidWndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
if (msg == WM_DEVICECHANGE)
{
switch (wparam)
{
case DBT_DEVICEARRIVAL:
{
if (!mTarget->mIsConnected)
{
if (mTarget->FindMyDevice())
{
Console::ForegroundColor = ConsoleColor::Blue;
Console::WriteLine("MY HID DEVICE IS FOUND AND OPEN.");
Console::ResetColor(); // My device arrival event
if (mTarget->mArrivalEvent != nullptr)
mTarget->mArrivalEvent();
}
}
}
break;
case DBT_DEVICEREMOVECOMPLETE:
{
if (mTarget->mIsConnected)
{
if (!mTarget->FindMyDevice())
{
Console::ForegroundColor = ConsoleColor::Blue;
Console::WriteLine("MY HID DEVICE REMOVED.");
Console::ResetColor(); // My device remove event
mTarget->MyDeviceRemoved();
if (mTarget->mRemovedEvent != nullptr)
mTarget->mRemovedEvent();
}
}
}
break;
default:
break;
}
} return DefWindowProc(hwnd, msg, wparam, lparam);
} void Hidimpl::Write(unsigned char *data, int len)
{
if (!mIsConnected) return;
array<unsigned char> ^_data = gcnew array<unsigned char>(mOutputLen);
try
{
int length = len>mOutputLen?mOutputLen:len;
for (int i = ; i < length; i++) _data[i] = data[i]; if (mFsTx != nullptr)
{
gcroot<FileStream^> *_pfs = static_cast<gcroot<FileStream^> *>(mFsTx);
//((FileStream^)*_pfs)->Write(_data, 0, _data->Length);
((FileStream^)*_pfs)->BeginWrite(_data, , _data->Length, nullptr, nullptr);
((FileStream^)*_pfs)->Flush();
}
}
catch(IOException ^e)
{
Console::WriteLine(e->Message);
}
catch(Exception ^e)
{
Console::WriteLine(e->Message);
}
}
HidState.h
#pragma once
#include "Hidimpl.h" using namespace System;
using namespace System::IO; public ref class HidState
{
public:
HidState(Hidimpl *hid, FileStream ^fs, int bufferLen);
~HidState();
void EndRead(IAsyncResult ^ar); public:
Hidimpl *mHidimpl;
FileStream ^mFileStream;
array<unsigned char> ^mBuffer;
};
HidState.cpp
#include "stdafx.h"
#include "HidState.h" HidState::HidState(Hidimpl *hid, FileStream ^fs, int bufferLen)
{
mHidimpl = hid;
mFileStream = fs;
mBuffer = gcnew array<unsigned char>(bufferLen);
} HidState::~HidState()
{
mHidimpl = nullptr;
} void HidState::EndRead(IAsyncResult ^ar)
{
HidState ^state = dynamic_cast<HidState ^>(ar->AsyncState);
try
{
int count = state->mFileStream->EndRead(ar);
// [有数据读入的情况下]调用ReadData事件
if (mHidimpl->mReadDataEvent != nullptr && count > )
{
unsigned char *ptrdt = new unsigned char[count];
for (int i = ; i < count; i++) ptrdt[i] = mBuffer[i];
// 此处封送到C#的IntPtr指针(this a crazy fucking)
mHidimpl->mReadDataEvent(ptrdt, count);
delete []ptrdt;
}
if (mHidimpl->IsConnected())
state->mFileStream->BeginRead(state->mBuffer, , mBuffer->Length, gcnew AsyncCallback(this, &HidState::EndRead), state);
}
catch(IOException ^e)
{
Console::WriteLine(e->Message);
}
catch(Exception ^e)
{
Console::WriteLine(e->Message);
}
}
_______export，wrap managed clr class for csharp
Hidlib.h
#pragma once
#include "Hidimpl.h" using namespace System; public ref class Hidlib
{
public:
delegate void HidDelegate();
delegate void HidReadDataDelegate(IntPtr data, int len); public:
Hidlib(int vid, int pid);
void NotifyEvents(HidDelegate ^arrival, HidDelegate ^removed, HidReadDataDelegate ^rdata);
void Write(array<unsigned char> ^data); private:
Hidimpl *impl;
};
Hidlib.cpp
#include "stdafx.h"
#include "Hidlib.h"
#include <vcclr.h> using namespace System::IO;
using namespace System::Runtime::InteropServices; Hidlib::Hidlib(int vid, int pid)
{
impl = new Hidimpl(vid, pid);
} void Hidlib::NotifyEvents(HidDelegate ^arrival, HidDelegate ^removed, HidReadDataDelegate ^rdata)
{
IntPtr _arrival = Marshal::GetFunctionPointerForDelegate(arrival);
IntPtr _removed = Marshal::GetFunctionPointerForDelegate(removed);
IntPtr _rdata = Marshal::GetFunctionPointerForDelegate(rdata);
impl->NotifyEvents((HidEvent)_arrival.ToPointer(), (HidEvent)_removed.ToPointer(), (HidReadDataEvent)_rdata.ToPointer());
} void Hidlib::Write(array<unsigned char> ^data)
{
try
{
int length = data->Length>impl->getOutputLen()?impl->getOutputLen():data->Length;
if (impl->mFsTx != nullptr)
{
gcroot<FileStream^> *_pfs = static_cast<gcroot<FileStream^> *>(impl->mFsTx);
//((FileStream^)*_pfs)->Write(_data, 0, _data->Length);
((FileStream^)*_pfs)->BeginWrite(data, , length, nullptr, nullptr);
((FileStream^)*_pfs)->Flush();
}
}
catch(IOException ^e)
{
Console::WriteLine(e->Message);
}
catch(Exception ^e)
{
Console::WriteLine(e->Message);
}
}
- 提供PInvoke接口
PInvoke(平台调用)
#pragma once
#include <Hidimpl.h>
#include "HidEvent.h" #ifdef ZSHIDLIB_EXPORTS
#define ZSHIDLIB_API __declspec(dllexport)
#else
#define ZSHIDLIB_API __declspec(dllimport)
#endif #ifdef __cplusplus
extern "C" {
#endif
ZSHIDLIB_API void Open(int vid, int pid);
ZSHIDLIB_API bool IsOpen();
ZSHIDLIB_API bool IsConnected();
ZSHIDLIB_API int getInputLen();
ZSHIDLIB_API int getOutputLen();
ZSHIDLIB_API void Notify(HidEvent arrival, HidEvent removed, HidReadDataEvent rdata);
ZSHIDLIB_API void Write(unsigned char *data, int len);
ZSHIDLIB_API void Close();
#ifdef __cplusplus
};
#endif
#include "stdafx.h"
#include "Hidlib.h"
#include "Hidimpl.h" Hidimpl *pHidimpl = nullptr; ZSHIDLIB_API void Open(int vid, int pid)
{
if (pHidimpl == nullptr)
pHidimpl = new Hidimpl(vid, pid);
} ZSHIDLIB_API bool IsOpen()
{
return (pHidimpl != nullptr);
} ZSHIDLIB_API bool IsConnected()
{
if (pHidimpl != nullptr)
return pHidimpl->IsConnected(); return ;
} ZSHIDLIB_API int getInputLen()
{
if (pHidimpl != nullptr)
return pHidimpl->getInputLen(); return ;
} ZSHIDLIB_API int getOutputLen()
{
if (pHidimpl != nullptr)
return pHidimpl->getOutputLen(); return ;
} ZSHIDLIB_API void Notify(HidEvent arrival, HidEvent removed, HidReadDataEvent rdata)
{
if (pHidimpl != nullptr)
{
pHidimpl->NotifyEvents(arrival, removed, rdata);
}
} ZSHIDLIB_API void Write(unsigned char *data, int len)
{
if (pHidimpl != nullptr)
pHidimpl->Write(data, len);
} ZSHIDLIB_API void Close()
{
if (pHidimpl != nullptr)
{
delete pHidimpl;
pHidimpl = nullptr;
}
}
- C#中的使用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices; namespace ZSHidApp
{
delegate void HidEvent();
delegate void HidReadDataEvent(IntPtr data, int len); class Program
{
//[DllImport("ZSHidlib.dll")]
//public static extern void Open(int vid, int pid); //[DllImport("ZSHidlib.dll")]
//public static extern void Notify(HidEvent arrival, HidEvent removed, HidReadDataEvent rdata); //[DllImport("ZSHidlib.dll")]
//public static extern void Write(Byte[] data, int len); //[DllImport("ZSHidlib.dll")]
//public static extern void GetData(ref Byte[] data, int len); static void ReadData(IntPtr data, int len)
{
Byte[] _data = new Byte[len];
Marshal.Copy(data, _data, , len); // Log
Console.WriteLine("// usr subscription //_____________________________________");
for (int i = ; i < _data.Length; i++) Console.Write(string.Format("{0:x2} ", _data[i]));
Console.WriteLine();
} static void Main(string[] args)
{
//Open(0x0b6a, 0x5346);
//Notify(() => Console.WriteLine("______________device arrival."),
// () => Console.WriteLine("__________________device removed."),
// ReadData);
Hidlib hidlib = new Hidlib(0x0b6a, 0x5346);
hidlib.NotifyEvents(() => Console.WriteLine("______________device arrival."),
() => Console.WriteLine("__________________device removed."),
ReadData); while (true)
{
ConsoleKeyInfo keyInfo = Console.ReadKey();
if (keyInfo.Key == ConsoleKey.Q)
{
break;
}
else if (keyInfo.Key == ConsoleKey.W)
{
Byte[] buffer = new Byte[];
// ab 69 42 01 fe aa 00 00 aa cd
int i = ;
buffer[i++] = ;
buffer[i++] = 0xab;
buffer[i++] = 0x69;
buffer[i++] = 0x42;
buffer[i++] = 0x01;
buffer[i++] = 0xfe;
buffer[i++] = 0xaa;
buffer[i++] = 0x00;
buffer[i++] = 0x00;
buffer[i++] = 0xaa;
buffer[i++] = 0xcd;
hidlib.Write(buffer);
}
}
}
}
}
- Standard C++中的使用
// ZSHidWin32App.cpp : 定义控制台应用程序的入口点。
// #include "stdafx.h"
#include "../ZSHidlib/Hidlib.h"
#include "../ZSHidlib/Hidimpl.h" #pragma comment(lib, "../Debug/ZSHidlib.lib") void Arrival()
{
printf("______________________device arrival.\n");
} void Removed()
{
printf("______________________device removed.\n");
} void ReadData(unsigned char *data, int len)
{
for (int i = ; i < len; i++)
{
printf("%.2x ", data[i]);
}
printf("___________________call in ReadData callback function.");
} int _tmain(int argc, _TCHAR* argv[])
{
Hidimpl *hidImpl = new Hidimpl(0x0b6a, 0x5346);
hidImpl->NotifyEvents(Arrival, Removed, ReadData); while(true)
{
unsigned char buffer[] = {0x00, 0xab, 0x69, 0x42, 0x01, 0xfe, 0xaa, 0x00, 0x00, 0xaa, 0xcd};
hidImpl->Write(buffer, ); Sleep();
} system("pause"); return ;
}
- 参考书籍/资料
《Visual C++/CLI从入门到精通》
《NET互操作 P_Invoke，C++Interop和COM Interop》