创建C# USB hid通讯类
下面是应用到WIN32 API:
1. 读取Hid设备全局id
[DllImport("hid.dll")]
private static extern void HidD_GetHidGuid(ref Guid HidGuid);
2. 取得一个包含所有HID接口信息集合的句柄
[DllImport("setupapi.dll", SetLastError = true)]
private static extern IntPtr SetupDiGetClassDevs(ref Guid ClassGuid, uint Enumerator, IntPtr HwndParent, DIGCF Flags);
3.遍历信息集合,得到每个设备的接口信息
[DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern Boolean SetupDiEnumDeviceInterfaces(IntPtr deviceInfoSet, IntPtr deviceInfoData, ref Guid interfaceClassGuid, UInt32 memberIndex, ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData);
4. 取得接口详细信息:第一次读取错误,但可以取得信息缓冲区的大小
SetupDiGetDeviceInterfaceDetail(hidInfoSet, ref interfaceInfo, IntPtr.Zero, buffsize, ref buffsize, null);
5. 取得接口详细信息: 第二次可以读取内容(内容包括VID,PID)
SetupDiGetDeviceInterfaceDetail(hidInfoSet, ref interfaceInfo, IntPtr.Zero, buffsize, ref buffsize, null);
6. 利用上一步读取的设备路径信息,使用CreateFile打开设备
[DllImport("kernel32.dll", SetLastError = true)]
protected static extern SafeFileHandle CreateFile(string strName, uint nAccess, uint nShareMode, uint lpSecurity, uint nCreationFlags, uint nAttributes, uint lpTemplate);
7. 根据文件句柄,读取设备属性信息
[DllImport("hid.dll")]
private static extern Boolean HidD_GetAttributes(SafeFileHandle hidDeviceObject, out HIDD_ATTRIBUTES attributes);
8. 根据属性信息, 判断VID和PID和下位机设备相同,得到此设备
根据得到的匹配设备, 得到准备数据
[DllImport("hid.dll")]
private static extern Boolean HidD_GetPreparsedData(SafeFileHandle hidDeviceObject, out IntPtr PreparsedData);
[DllImport("hid.dll")]
private static extern Boolean HidD_FreePreparsedData(IntPtr PreparsedData);
[DllImport("hid.dll")]
private static extern uint HidP_GetCaps(IntPtr PreparsedData, out HIDP_CAPS Capabilities);
9.创建文件流
hidDevice = new FileStream(device, FileAccess.ReadWrite, inputReportLength, true);
10. 根据文件流读写数据
从流中读取字节块并将该数据写入给定缓冲区中。
public override int Read(byte[] array, int offset, int count);
使用从缓冲区读取的数据将字节块写入该流。
public override void Write(byte[] array, int offset, int count);
注意内容:
发送内容的时候需要发送outputReportLength长度的内容,其中第一个字节是reportid=0x00,发送内容从第二个字节开始，这里的获取到下位机设置的outputReportLength为65
接收下位机内容时,下位机需要发inputReportLength长度的内容, 这里的长度为64
核心源码:
public class Hid : object { protected const Int32 WAIT_TIMEOUT = 0X102; protected const Int32 WAIT_OBJECT_0 = 0; protected static string strDevicePath = ""; public UInt16 VID = 0x0483; public UInt16 PID = 0x5750; private IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1); private const int MAX_USB_DEVICES = 64; private bool deviceOpened = false; private FileStream hidDevice = null; int outputReportLength;//输出报告长度,包刮一个字节的报告ID public int OutputReportLength { get { return outputReportLength; } } int inputReportLength;//输入报告长度,包刮一个字节的报告ID public int InputReportLength { get { return inputReportLength; } } private Guid device_class; private IntPtr usb_event_handle; private IntPtr handle; private SafeFileHandle device; private frmMain _main; private Thread _readThread; private int _openDeviceFlag = 0; public int OpenDeviceFlag { get { return _openDeviceFlag; } set { _openDeviceFlag = value; } } public Hid(frmMain main) { device_class = HIDGuid; _main = main; } /// <summary> /// Provides details about a single USB device /// </summary> [StructLayout(LayoutKind.Sequential, Pack = 1)] protected struct DeviceInterfaceData { public int Size; public Guid InterfaceClassGuid; public int Flags; public IntPtr Reserved; // should correspond to ULONG_PTR but was an int } private static string GetDevicePath(IntPtr hInfoSet, ref DeviceInterfaceData oInterface) { DeviceInterfaceDetailData oDetail = new DeviceInterfaceDetailData(); // Size workaround if (IntPtr.Size == 8) oDetail.Size = 8; else oDetail.Size = 5; Console.WriteLine("Size of struct: {0}", Marshal.SizeOf(oDetail)); // 4 + 256 = 260 uint nRequiredSize = 0; // Error 0 if (!SetupDiGetDeviceInterfaceDetail(hInfoSet, ref oInterface, IntPtr.Zero, 0, ref nRequiredSize, IntPtr.Zero)) // Error 122 - ERROR_INSUFFICIENT_BUFFER (not a problem, just used to set nRequiredSize) if (SetupDiGetDeviceInterfaceDetail(hInfoSet, ref oInterface, ref oDetail, nRequiredSize, ref nRequiredSize, IntPtr.Zero)) return oDetail.DevicePath; // Error 1784 - ERROR_INVALID_USER_BUFFER (unless size=5 on 32bit, size=8 on 64bit) return null; } /// <summary> /// 打开指定信息的设备 /// </summary> /// <param name="vID">设备的vID</param> /// <param name="pID">设备的pID</param> /// <param name="serial">设备的serial</param>,string serial /// <returns></returns> public HID_RETURN OpenDevice(UInt16 vID,UInt16 pID) { // IntPtr hInfoSet = SetupDiGetClassDevs(ref gHid, null, IntPtr.Zero, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); if (deviceOpened == false) { //获取连接的HID列表 List<string> deviceList = new List<string>(); GetHidDeviceList(ref deviceList); if (deviceList.Count == 0) return HID_RETURN.NO_DEVICE_CONECTED; for (int i = 0; i < deviceList.Count; i++) { device = CreateFile(deviceList[i], DESIREDACCESS.GENERIC_READ | DESIREDACCESS.GENERIC_WRITE, 0, 0, CREATIONDISPOSITION.OPEN_EXISTING, FLAGSANDATTRIBUTES.FILE_FLAG_OVERLAPPED, 0); if (!device.IsInvalid) { // strDevicePath = GetDevicePath(hInfoSet, ref oInterface); HIDD_ATTRIBUTES attributes; //IntPtr serialBuff = Marshal.AllocHGlobal(512); HidD_GetAttributes(device, out attributes); //HidD_GetSerialNumberString(device, serialBuff, 512); //string deviceStr = Marshal.PtrToStringAuto(serialBuff); //Marshal.FreeHGlobal(serialBuff); if (attributes.VendorID == vID && attributes.ProductID == pID) // && deviceStr == serial { IntPtr preparseData; HIDP_CAPS caps; HidD_GetPreparsedData(device, out preparseData); HidP_GetCaps(preparseData, out caps); HidD_FreePreparsedData(preparseData); outputReportLength = caps.OutputReportByteLength; inputReportLength = caps.InputReportByteLength; hidDevice = new FileStream (device, FileAccess.ReadWrite, inputReportLength, true); deviceOpened = true; //BeginAsyncRead(); Guid gHid = HIDGuid; IntPtr hInfoSet = SetupDiGetClassDevs(ref gHid, null, IntPtr.Zero, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); DeviceInterfaceData oInterface = new DeviceInterfaceData(); strDevicePath = GetDevicePath(hInfoSet, ref oInterface); return HID_RETURN.SUCCESS; } } } return HID_RETURN.DEVICE_NOT_FIND; } else return HID_RETURN.DEVICE_OPENED; } /// <summary> /// 关闭打开的设备 /// </summary> public void CloseDevice() { if (deviceOpened == true) { hidDevice.Close(); deviceOpened = false; } } /// <summary> /// 开始一次异步读 /// </summary> private void BeginAsyncRead() { byte[] inputBuff = new byte[InputReportLength]; hidDevice.BeginRead(inputBuff, 0, InputReportLength, new AsyncCallback(ReadCompleted), inputBuff); } /// <summary> /// 异步读取结束,发出有数据到达事件 /// </summary> /// <param name="iResult">这里是输入报告的数组</param> private void ReadCompleted(IAsyncResult iResult) { byte[] readBuff = (byte[])(iResult.AsyncState); try { hidDevice.EndRead(iResult);//读取结束,如果读取错误就会产生一个异常 byte[] reportData= new byte[readBuff.Length - 1]; for (int i = 1; i < readBuff.Length; i++) reportData[i - 1] = readBuff[i]; Report e = new Report(readBuff[0], reportData); //OnDataReceived(e); //发出数据到达消息 Define.cmdRecv.ProcData(reportData,reportData.Length); BeginAsyncRead();//启动下一次读操作 } catch (IOException e)//读写错误,设备已经被移除 { EventArgs ex = new EventArgs(); OnDeviceRemoved(ex);//发出设备移除消息 CloseDevice(); } } /// <summary> /// 事件:数据到达,处理此事件以接收输入数据 /// </summary> public event EventHandler<Report> DataReceived; protected virtual void OnDataReceived(Report e) { if(DataReceived != null) DataReceived(this, e); } /// <summary> /// 事件：设置连接 /// </summary> public event EventHandler DeviceArrived; protected virtual void OnDeviceArrived( EventArgs e ) { if (DeviceArrived != null) DeviceArrived(this, e); } /// <summary> /// 事件:设备断开 /// </summary> public event EventHandler DeviceRemoved; protected virtual void OnDeviceRemoved(EventArgs e) { if (DeviceRemoved != null) DeviceRemoved(this, e); } /// <summary> /// 发送report命令 /// </summary> /// <param name="buffer"></param> /// <returns></returns> public string Write(Report r) { byte[] buffer = null; if (deviceOpened) { try { buffer = new byte[outputReportLength]; buffer[0] = r.reportID; int maxBufferLength = 0; if (r.reportBuff.Length < outputReportLength - 1) maxBufferLength = r.reportBuff.Length; else maxBufferLength = outputReportLength - 1; for (int i = 1; i < maxBufferLength; i++) buffer[i] = r.reportBuff[i - 1]; hidDevice.Write(buffer, 0, OutputReportLength); //buffer= DataRead(); //Hid.ByteToHexString(buffer); } catch { EventArgs ex = new EventArgs(); OnDeviceRemoved(ex);//发出设备移除消息 CloseDevice(); throw; } } return ByteToHexString(buffer); } /// <summary> /// 发送字节数组命令 /// </summary> /// <param name="buffer"></param> /// <returns></returns> public bool Write(Byte[] buf) { if (deviceOpened) { try { hidDevice.Write(buf, 0, OutputReportLength); if (_readThread == null) { _readThread = new Thread(new ThreadStart(DataRead)); _readThread.IsBackground = true; _readThread.Start(); } //buffer = DataRead(); //Hid.ByteToHexString(buffer); return true; } catch { EventArgs ex = new EventArgs(); OnDeviceRemoved(ex);//发出设备移除消息 CloseDevice(); return false; } } else { return false; } } private void DataRead() { try { InputReportViaInterruptTransfer report = new InputReportViaInterruptTransfer(); bool foundMyDevice = false; bool result = false; byte[] readBuffer = new Byte[OutputReportLength]; report.Read(device, ref foundMyDevice, ref readBuffer, ref result); if (result == false) { _main.ProgressBarEnd(); MessageBox.Show("更新超时!"); } _readThread = null; } catch(Exception ex) { _readThread = null; } } internal class InputReportViaInterruptTransfer : ReportIn { internal Boolean readyForOverlappedTransfer; // initialize to false /// <summary> /// closes open handles to a device. /// </summary> /// /// <param name="hidHandle"> the handle for learning about the device and exchanging Feature reports. </param> /// <param name="readHandle"> the handle for reading Input reports from the device. </param> /// <param name="writeHandle"> the handle for writing Output reports to the device. </param> internal void CancelTransfer(SafeFileHandle hidHandle, SafeFileHandle readHandle, SafeFileHandle writeHandle, IntPtr eventObject) { try { // *** // API function: CancelIo // Purpose: Cancels a call to ReadFile // Accepts: the device handle. // Returns: True on success, False on failure. // *** CancelIo(readHandle); //Console.WriteLine("************ReadFile error*************"); //String functionName = "CancelIo"; //Console.WriteLine(MyDebugging.ResultOfAPICall(functionName)); //Console.WriteLine(""); // The failure may have been because the device was removed, // so close any open handles and // set myDeviceDetected=False to cause the application to // look for the device on the next attempt. if ((!(hidHandle.IsInvalid))) { hidHandle.Close(); } if ((!(readHandle.IsInvalid))) { readHandle.Close(); } if ((!(writeHandle.IsInvalid))) { writeHandle.Close(); } } catch (Exception ex) { //DisplayException(MODULE_NAME, ex); throw; } } /// <summary> /// Creates an event object for the overlapped structure used with /// ReadFile. Called before the first call to ReadFile. /// </summary> /// /// <param name="hidOverlapped"> the overlapped structure </param> /// <param name="eventObject"> the event object </param> internal void PrepareForOverlappedTransfer(ref NativeOverlapped hidOverlapped, ref IntPtr eventObject) { try { // *** // API function: CreateEvent // Purpose: Creates an event object for the overlapped structure used with ReadFile. // Accepts: // A security attributes structure or IntPtr.Zero. // Manual Reset = False (The system automatically resets the state to nonsignaled // after a waiting thread has been released.) // Initial state = False (not signaled) // An event object name (optional) // Returns: a handle to the event object // *** eventObject = CreateEvent(IntPtr.Zero, false, false, ""); // Console.WriteLineLine(MyDebugging.ResultOfAPICall("CreateEvent")) // Set the members of the overlapped structure. hidOverlapped.OffsetLow = 0; hidOverlapped.OffsetHigh = 0; hidOverlapped.EventHandle = eventObject; readyForOverlappedTransfer = true; } catch (Exception ex) { //DisplayException(MODULE_NAME, ex); throw; } } /// <summary> /// reads an Input report from the device using interrupt transfers. /// </summary> /// /// <param name="hidHandle"> the handle for learning about the device and exchanging Feature reports. </param> /// <param name="readHandle"> the handle for reading Input reports from the device. </param> /// <param name="writeHandle"> the handle for writing Output reports to the device. </param> /// <param name="myDeviceDetected"> tells whether the device is currently attached. </param> /// <param name="inputReportBuffer"> contains the requested report. </param> /// <param name="success"> read success </param> internal override void Read(SafeFileHandle readHandle, ref Boolean myDeviceDetected, ref Byte[] inputReportBuffer, ref Boolean success) { IntPtr eventObject = CreateEvent(IntPtr.Zero, false, false, ""); //IntPtr.Zero; NativeOverlapped HidOverlapped = new NativeOverlapped(); Int32 numberOfBytesRead = 0; Int32 result = 0; try { // If it's the first attempt to read, set up the overlapped structure for ReadFile. if (readyForOverlappedTransfer == false) { PrepareForOverlappedTransfer(ref HidOverlapped, ref eventObject); } // *** // API function: ReadFile // Purpose: Attempts to read an Input report from the device. // Accepts: // A device handle returned by CreateFile // (for overlapped I/O, CreateFile must have been called with FILE_FLAG_OVERLAPPED), // A pointer to a buffer for storing the report. // The Input report length in bytes returned by HidP_GetCaps, // A pointer to a variable that will hold the number of bytes read. // An overlapped structure whose hEvent member is set to an event object. // Returns: the report in ReadBuffer. // The overlapped call returns immediately, even if the data hasn't been received yet. // To read multiple reports with one ReadFile, increase the size of ReadBuffer // and use NumberOfBytesRead to determine how many reports were returned. // Use a larger buffer if the application can't keep up with reading each report // individually. // *** success = ReadFile(readHandle, inputReportBuffer, inputReportBuffer.Length, ref numberOfBytesRead, ref HidOverlapped); if (!success) { Console.WriteLine("waiting for ReadFile"); // API function: WaitForSingleObject // Purpose: waits for at least one report or a timeout. // Used with overlapped ReadFile. // Accepts: // An event object created with CreateEvent // A timeout value in milliseconds. // Returns: A result code. result = WaitForSingleObject(eventObject, 3000); //eventObject //result = GetOverlappedResult(readHandle.DangerousGetHandle(), ref HidOverlapped, ref numberOfBytesRead, false); //if (result != 0) // success = true; // Find out if ReadFile completed or timeout. switch (result) { case (System.Int32)WAIT_OBJECT_0: // ReadFile has completed success = true; Console.WriteLine("ReadFile completed successfully."); Define.cmdRecv.ProcData(inputReportBuffer, inputReportBuffer.Length); break; case WAIT_TIMEOUT: // Cancel the operation on timeout // CancelTransfer(hidHandle, readHandle, writeHandle, eventObject); Console.WriteLine("Readfile timeout"); success = false; myDeviceDetected = false; break; default: // Cancel the operation on other error. //CancelTransfer(hidHandle, readHandle, writeHandle, eventObject); Console.WriteLine("Readfile undefined error"); success = false; myDeviceDetected = false; break; } } } catch (Exception ex) { ////DisplayException(MODULE_NAME, ex); throw; } } } internal abstract class ReportIn { /// <summary> /// Each class that handles reading reports defines a Read method for reading /// a type of report. Read is declared as a Sub rather /// than as a Function because asynchronous reads use a callback method /// that can access parameters passed by ByRef but not Function return values. /// </summary> internal abstract void Read(SafeFileHandle readHandle, ref Boolean myDeviceDetected, ref Byte[] readBuffer, ref Boolean success); } /// <summary> /// 获取所有连接的hid的设备路径 /// </summary> /// <returns>包含每个设备路径的字符串数组</returns> public static void GetHidDeviceList(ref List<string> deviceList) { Guid hUSB = Guid.Empty; uint index = 0; deviceList.Clear(); // 取得hid设备全局id HidD_GetHidGuid(ref hUSB); //取得一个包含所有HID接口信息集合的句柄 IntPtr hidInfoSet = SetupDiGetClassDevs(ref hUSB, 0, IntPtr.Zero, DIGCF.DIGCF_PRESENT | DIGCF.DIGCF_DEVICEINTERFACE); if (hidInfoSet != IntPtr.Zero) { SP_DEVICE_INTERFACE_DATA interfaceInfo = new SP_DEVICE_INTERFACE_DATA(); interfaceInfo.cbSize = Marshal.SizeOf(interfaceInfo); //查询集合中每一个接口 for (index = 0; index < MAX_USB_DEVICES; index++) { //得到第index个接口信息 if (SetupDiEnumDeviceInterfaces(hidInfoSet, IntPtr.Zero, ref hUSB, index, ref interfaceInfo)) { int buffsize = 0; // 取得接口详细信息:第一次读取错误,但可以取得信息缓冲区的大小 SetupDiGetDeviceInterfaceDetail(hidInfoSet, ref interfaceInfo, IntPtr.Zero, buffsize, ref buffsize, null); //构建接收缓冲 IntPtr pDetail = Marshal.AllocHGlobal(buffsize); SP_DEVICE_INTERFACE_DETAIL_DATA detail = new SP_DEVICE_INTERFACE_DETAIL_DATA(); detail.cbSize = Marshal.SizeOf(typeof(SP_DEVICE_INTERFACE_DETAIL_DATA)); Marshal.StructureToPtr(detail, pDetail, false); if (SetupDiGetDeviceInterfaceDetail(hidInfoSet, ref interfaceInfo, pDetail, buffsize, ref buffsize, null)) { deviceList.Add(Marshal.PtrToStringAuto((IntPtr)((int)pDetail + 4))); } Marshal.FreeHGlobal(pDetail); } } } SetupDiDestroyDeviceInfoList(hidInfoSet); //return deviceList.ToArray(); } public void ParseMessages( ref Message m ) { if (m.Msg == DEVICE_FLAG.WM_DEVICECHANGE) // we got a device change message! A USB device was inserted or removed { switch (m.WParam.ToInt32()) // Check the W parameter to see if a device was inserted or removed { case DEVICE_FLAG.DEVICE_ARRIVAL: // inserted Console.WriteLine("ParseMessages 设备连接"); if (DeviceArrived != null) { DeviceArrived(this, new EventArgs()); } CheckDevicePresent(); break; case DEVICE_FLAG.DEVICE_REMOVECOMPLETE: // removed Console.WriteLine("ParseMessages 设备拔除"); if (DeviceRemoved != null) { DeviceRemoved(this, new EventArgs()); } CheckDevicePresent(); break; } } } public void RegisterHandle( IntPtr Handle ) { usb_event_handle = RegisterForUsbEvents(Handle, device_class); this.handle = Handle; //Check if the device is already present. CheckDevicePresent(); } public bool CheckDevicePresent() { HID_RETURN hid_ret; string sSerial=""; try { hid_ret = OpenDevice(VID, PID); if (hid_ret == HID_RETURN.SUCCESS) { Console.WriteLine("打开设备成功"); _openDeviceFlag = (int)HID_RETURN.SUCCESS; return true; } else { _openDeviceFlag = (int)hid_ret; return false; } } catch (System.Exception ex) { return false; } } /// <summary> /// Helper to get the HID guid. /// </summary> public static Guid HIDGuid { get { Guid gHid = Guid.Empty; HidD_GetHidGuid(ref gHid); return gHid; //return new Guid("A5DCBF10-6530-11D2-901F-00C04FB951ED"); //gHid; } }