C#进阶——记一次USB HID的各种坑（x86，x64，win10，win7）

一、简叙

写工控上位机的搬砖人，难免会遇到USB通讯，在一个项目中，我写的上位机使用USB HID协议和STM32通讯传输数据，从零大概花了几天找例程，找资料，最后是各种搬砖修补，终于出来了一个出版DOME，能和下位机实时通讯了。

HID通讯方式其实很常见，像鼠标、键盘等待外设都是这种方式，我也不知道为啥要用这种方式，我当初用它是因为其传输速率比串口快（忆当初下位机还没开发出网口的苦日子），再则其是免驱（win内置驱动，直接调API即可）。

HID识别设备主要通过设备的PID（厂商ID）和VID（产品ID），进而区分。

二、主体程序

网上找了很多版本，主体程序都是大同小异，最后我便借鉴了一篇博文，来砌我的主体程序。

很不出意外，砌出来的东西不行。记得以前听前辈说过一句话，你的薪资多高取决于你填坑的能力有多强。

现在想想确实如此，在这个互联网的时代，搬砖并不是一件难事，但是不能确保搬来的砖不是每一块都适合你，你必须要修修补补再用，所以修补的能力便成了你赚钱的能力。

还有我奉献各位年轻气旺年轻人，不要急于求成，网上找到源码不是难事，必须一步一个脚印，把源码啃了，不要以为会搬砖就老子天下第一，那有多难的事呀。（没错，我以前包括现在都是这么一个烂人，正努力扭正态度）。

我们不重复造车轮，但我们必须有造车轮的能力，出来混，迟早要跪的。

下面我贴上我的主要源码部分，基本和其他博文的一样：

namespace HID{    #region 结构体    /// <summary>    /// SP_DEVICE_INTERFACE_DATA structure defines a device interface in a device information set.    /// </summary>    public struct SP_DEVICE_INTERFACE_DATA    {        public int cbSize;        public Guid interfaceClassGuid;        public int flags;        public int reserved;    }    /// <summary>    /// SP_DEVICE_INTERFACE_DETAIL_DATA structure contains the path for a device interface.    /// </summary>    [StructLayout(LayoutKind.Sequential, Pack = 2)]    internal struct SP_DEVICE_INTERFACE_DETAIL_DATA    {        internal int cbSize;        internal short devicePath;    }    /// <summary>    /// SP_DEVINFO_DATA structure defines a device instance that is a member of a device information set.    /// </summary>    [StructLayout(LayoutKind.Sequential)]    public class SP_DEVINFO_DATA    {        public int cbSize = Marshal.SizeOf(typeof(SP_DEVINFO_DATA));        public Guid classGuid = Guid.Empty; // temp        public int devInst = 0; // dumy        public int reserved = 0;    }    /// <summary>    /// Flags controlling what is included in the device information set built by SetupDiGetClassDevs    /// </summary>    public enum DIGCF    {        DIGCF_DEFAULT = 0x00000001, // only valid with DIGCF_DEVICEINTERFACE                         DIGCF_PRESENT = 0x00000002,        DIGCF_ALLCLASSES = 0x00000004,        DIGCF_PROFILE = 0x00000008,        DIGCF_DEVICEINTERFACE = 0x00000010    }    /// <summary>    /// The HIDD_ATTRIBUTES structure contains vendor information about a HIDClass device    /// </summary>    public struct HIDD_ATTRIBUTES    {        public int Size;        public ushort VendorID;        public ushort ProductID;        public ushort VersionNumber;    }    public struct HIDP_CAPS    {        public ushort Usage;        public ushort UsagePage;        public ushort InputReportByteLength;        public ushort OutputReportByteLength;        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 17)]        public ushort[] Reserved;        public ushort NumberLinkCollectionNodes;        public ushort NumberInputButtonCaps;        public ushort NumberInputValueCaps;        public ushort NumberInputDataIndices;        public ushort NumberOutputButtonCaps;        public ushort NumberOutputValueCaps;        public ushort NumberOutputDataIndices;        public ushort NumberFeatureButtonCaps;        public ushort NumberFeatureValueCaps;        public ushort NumberFeatureDataIndices;    }    /// <summary>    /// Type of access to the object.     ///</summary>    static class DESIREDACCESS    {        public const uint GENERIC_READ = 0x80000000;        public const uint GENERIC_WRITE = 0x40000000;        public const uint GENERIC_EXECUTE = 0x20000000;        public const uint GENERIC_ALL = 0x10000000;    }    /// <summary>    /// Action to take on files that exist, and which action to take when files do not exist.     /// </summary>    static class CREATIONDISPOSITION    {        public const uint CREATE_NEW = 1;        public const uint CREATE_ALWAYS = 2;        public const uint OPEN_EXISTING = 3;        public const uint OPEN_ALWAYS = 4;        public const uint TRUNCATE_EXISTING = 5;    }    /// <summary>    /// File attributes and flags for the file.     /// </summary>    static class FLAGSANDATTRIBUTES    {        public const uint FILE_FLAG_WRITE_THROUGH = 0x80000000;        public const uint FILE_FLAG_OVERLAPPED = 0x40000000;        public const uint FILE_FLAG_NO_BUFFERING = 0x20000000;        public const uint FILE_FLAG_RANDOM_ACCESS = 0x10000000;        public const uint FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000;        public const uint FILE_FLAG_DELETE_ON_CLOSE = 0x04000000;        public const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;        public const uint FILE_FLAG_POSIX_SEMANTICS = 0x01000000;        public const uint FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000;        public const uint FILE_FLAG_OPEN_NO_RECALL = 0x00100000;        public const uint FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000;    }    /// <summary>    /// Serves as a standard header for information related to a device event reported through the WM_DEVICECHANGE message.    /// </summary>    [StructLayout(LayoutKind.Sequential)]    public struct DEV_BROADCAST_HDR    {        public int dbcc_size;        public int dbcc_devicetype;        public int dbcc_reserved;    }    /// <summary>    /// Contains information about a class of devices    /// </summary>    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]    public struct DEV_BROADCAST_DEVICEINTERFACE    {        public int dbcc_size;        public int dbcc_devicetype;        public int dbcc_reserved;        public Guid dbcc_classguid;        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 255)]        public string dbcc_name;    }    static class DEVICE_FLAG    {        /// <summary>Windows message sent when a device is inserted or removed</summary>        public const int WM_DEVICECHANGE = 0x0219;        /// <summary>WParam for above : A device was inserted</summary>        public const int DEVICE_ARRIVAL = 0x8000;        /// <summary>WParam for above : A device was removed</summary>        public const int DEVICE_REMOVECOMPLETE = 0x8004;        /// <summary>Used when registering for device insert/remove messages : specifies the type of device</summary>        public const int DEVTYP_DEVICEINTERFACE = 0x05;        /// <summary>Used when registering for device insert/remove messages : we're giving the API call a window handle</summary>        public const int DEVICE_NOTIFY_WINDOW_HANDLE = 0;    }    /// <summary>    /// Sharing mode of the file or object    ///</summary>    static class SHAREMODE    {        public const uint FILE_SHARE_READ = 0x00000001;        public const uint FILE_SHARE_WRITE = 0x00000002;        public const uint FILE_SHARE_DELETE = 0x00000004;    }    #endregion    /// <summary>    /// 传入ID和arraybuff（只读）    /// </summary>    public class report : EventArgs    {        public readonly byte reportID; //接收发送的数据（第一帧）        public readonly byte[] reportBuff; //接收发送的数据（第二帧及以后）        public report(byte id, byte[] arrayBuff)        {            reportID = id;            reportBuff = arrayBuff;        }    }    public class Hid    {        #region 声明winAPI        // **************************以下是调用windows的API的函数**********************************        /// <summary>        /// The HidD_GetHidGuid routine returns the device interface GUID for HIDClass devices.        /// </summary>        /// <param name="HidGuid">a caller-allocated GUID buffer that the routine uses to return the device interface GUID for HIDClass devices.</param>        [DllImport("hid.dll")]        private static extern void HidD_GetHidGuid(ref Guid HidGuid);        /// <summary>        /// The SetupDiGetClassDevs function returns a handle to a device information set that contains requested device information elements for a local machine.         /// </summary>        /// <param name="ClassGuid">GUID for a device setup class or a device interface class. </param>        /// <param name="Enumerator">A pointer to a NULL-terminated string that supplies the name of a PnP enumerator or a PnP device instance identifier. </param>        /// <param name="HwndParent">A handle of the top-level window to be used for a user interface</param>        /// <param name="Flags">A variable  that specifies control options that filter the device information elements that are added to the device information set. </param>        /// <returns>a handle to a device information set </returns>        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]        private static extern IntPtr SetupDiGetClassDevs(ref Guid ClassGuid, uint Enumerator, IntPtr HwndParent, DIGCF Flags);        /// <summary>        /// The SetupDiDestroyDeviceInfoList function deletes a device information set and frees all associated memory.        /// </summary>        /// <param name="DeviceInfoSet">A handle to the device information set to delete.</param>        /// <returns>returns TRUE if it is successful. Otherwise, it returns FALSE </returns>        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]        private static extern Boolean SetupDiDestroyDeviceInfoList(IntPtr deviceInfoSet);        /// <summary>        /// The SetupDiEnumDeviceInterfaces function enumerates the device interfaces that are contained in a device information set.         /// </summary>        /// <param name="deviceInfoSet">A pointer to a device information set that contains the device interfaces for which to return information</param>        /// <param name="deviceInfoData">A pointer to an SP_DEVINFO_DATA structure that specifies a device information element in DeviceInfoSet</param>        /// <param name="interfaceClassGuid">a GUID that specifies the device interface class for the requested interface</param>        /// <param name="memberIndex">A zero-based index into the list of interfaces in the device information set</param>        /// <param name="deviceInterfaceData">a caller-allocated buffer that contains a completed SP_DEVICE_INTERFACE_DATA structure that identifies an interface that meets the search parameters</param>        /// <returns></returns>        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = false)]        private static extern Boolean SetupDiEnumDeviceInterfaces(IntPtr deviceInfoSet, IntPtr deviceInfoData, ref Guid interfaceClassGuid, uint memberIndex, ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData);        /// <summary>        /// The SetupDiGetDeviceInterfaceDetail function returns details about a device interface.        /// </summary>        /// <param name="deviceInfoSet">A pointer to the device information set that contains the interface for which to retrieve details</param>        /// <param name="deviceInterfaceData">A pointer to an SP_DEVICE_INTERFACE_DATA structure that specifies the interface in DeviceInfoSet for which to retrieve details</param>        /// <param name="deviceInterfaceDetailData">A pointer to an SP_DEVICE_INTERFACE_DETAIL_DATA structure to receive information about the specified interface</param>        /// <param name="deviceInterfaceDetailDataSize">The size of the DeviceInterfaceDetailData buffer</param>        /// <param name="requiredSize">A pointer to a variable that receives the required size of the DeviceInterfaceDetailData buffer</param>        /// <param name="deviceInfoData">A pointer buffer to receive information about the device that supports the requested interface</param>        /// <returns></returns>        [DllImport("setupapi.dll", SetLastError = false, CharSet = CharSet.Auto)]        private static extern bool SetupDiGetDeviceInterfaceDetail(IntPtr deviceInfoSet, ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData, IntPtr deviceInterfaceDetailData, int deviceInterfaceDetailDataSize, ref int requiredSize, SP_DEVINFO_DATA deviceInfoData);        /// <summary>        /// The HidD_GetAttributes routine returns the attributes of a specified top-level collection.        /// </summary>        /// <param name="HidDeviceObject">Specifies an open handle to a top-level collection</param>        /// <param name="Attributes">a caller-allocated HIDD_ATTRIBUTES structure that returns the attributes of the collection specified by HidDeviceObject</param>        /// <returns></returns>        [DllImport("hid.dll")]        private static extern Boolean HidD_GetAttributes(IntPtr hidDeviceObject, out HIDD_ATTRIBUTES attributes);        /// <summary>        /// The HidD_GetSerialNumberString routine returns the embedded string of a top-level collection that identifies the serial number of the collection's physical device.        /// </summary>        /// <param name="HidDeviceObject">Specifies an open handle to a top-level collection</param>        /// <param name="Buffer">a caller-allocated buffer that the routine uses to return the requested serial number string</param>        /// <param name="BufferLength">Specifies the length, in bytes, of a caller-allocated buffer provided at Buffer</param>        /// <returns></returns>        [DllImport("hid.dll")]        private static extern Boolean HidD_GetSerialNumberString(IntPtr hidDeviceObject, IntPtr buffer, int bufferLength);        /// <summary>        /// The HidD_GetPreparsedData routine returns a top-level collection's preparsed data.        /// </summary>        /// <param name="hidDeviceObject">Specifies an open handle to a top-level collection. </param>        /// <param name="PreparsedData">Pointer to the address of a routine-allocated buffer that contains a collection's preparsed data in a _HIDP_PREPARSED_DATA structure.</param>        /// <returns>HidD_GetPreparsedData returns TRUE if it succeeds; otherwise, it returns FALSE.</returns>        [DllImport("hid.dll")]        private static extern Boolean HidD_GetPreparsedData(IntPtr 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);        /// <summary>        /// This function creates, opens, or truncates a file, COM port, device, service, or console.         /// </summary>        /// <param name="fileName">a null-terminated string that specifies the name of the object</param>        /// <param name="desiredAccess">Type of access to the object</param>        /// <param name="shareMode">Share mode for object</param>        /// <param name="securityAttributes">Ignored; set to NULL</param>        /// <param name="creationDisposition">Action to take on files that exist, and which action to take when files do not exist</param>        /// <param name="flagsAndAttributes">File attributes and flags for the file</param>        /// <param name="templateFile">Ignored</param>        /// <returns>An open handle to the specified file indicates success</returns>        [DllImport("kernel32.dll", SetLastError = false)]        private static extern IntPtr CreateFile(string fileName, uint desiredAccess, uint shareMode, uint securityAttributes, uint creationDisposition, uint flagsAndAttributes, uint templateFile);        /// <summary>        /// This function closes an open object handle.        /// </summary>        /// <param name="hObject">Handle to an open object</param>        /// <returns></returns>        [DllImport("kernel32.dll")]        private static extern int CloseHandle(IntPtr hObject);        /// <summary>        /// This function reads data from a file, starting at the position indicated by the file pointer.        /// </summary>        /// <param name="file">Handle to the file to be read</param>        /// <param name="buffer">Pointer to the buffer that receives the data read from the file </param>        /// <param name="numberOfBytesToRead">Number of bytes to be read from the file</param>        /// <param name="numberOfBytesRead">Pointer to the number of bytes read</param>        /// <param name="lpOverlapped">Unsupported; set to NULL</param>        /// <returns></returns>        [DllImport("Kernel32.dll", SetLastError = false)]        private static extern bool ReadFile(IntPtr file, byte[] buffer, uint numberOfBytesToRead, out uint numberOfBytesRead, IntPtr lpOverlapped);        /// <summary>        ///  This function writes data to a file        /// </summary>        /// <param name="file">Handle to the file to be written to</param>        /// <param name="buffer">Pointer to the buffer containing the data to write to the file</param>        /// <param name="numberOfBytesToWrite">Number of bytes to write to the file</param>        /// <param name="numberOfBytesWritten">Pointer to the number of bytes written by this function call</param>        /// <param name="lpOverlapped">Unsupported; set to NULL</param>        /// <returns></returns>        [DllImport("Kernel32.dll", SetLastError = false)]        private static extern bool WriteFile(IntPtr file, byte[] buffer, uint numberOfBytesToWrite, out uint numberOfBytesWritten, IntPtr lpOverlapped);        /// <summary>        /// Registers the device or type of device for which a window will receive notifications        /// </summary>        /// <param name="recipient">A handle to the window or service that will receive device events for the devices specified in the NotificationFilter parameter</param>        /// <param name="notificationFilter">A pointer to a block of data that specifies the type of device for which notifications should be sent</param>        /// <param name="flags">A Flags that specify the handle type</param>        /// <returns>If the function succeeds, the return value is a device notification handle</returns>        [DllImport("User32.dll", SetLastError = false)]        private static extern IntPtr RegisterDeviceNotification(IntPtr recipient, IntPtr notificationFilter, int flags);        /// <summary>        /// Closes the specified device notification handle.        /// </summary>        /// <param name="handle">Device notification handle returned by the RegisterDeviceNotification function</param>        /// <returns></returns>        [DllImport("user32.dll", SetLastError = false)]        private static extern bool UnregisterDeviceNotification(IntPtr handle);        #endregion        #region 定义字段/属性        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; //创建一个usb对象        //public IntPtr[] devices = new IntPtr[10]; //存储已打开可读写的设备        List<string> deviceList = new List<string>(); //存储所有设备        IntPtr device; //打开文件的设备        private bool IsRead = true; //允许读取标志        int outputReportLength;//输出报告长度,包刮一个字节的报告ID        public int OutputReportLength { get { return outputReportLength; } } //数据长度        int inputReportLength;//输入报告长度,包刮一个字节的报告ID           public int InputReportLength { get { return inputReportLength; } }        private Guid device_class;        #endregion        /// <summary>        /// 构造函数        /// </summary>        public Hid()        {            device_class = HIDGuid;        }        #region 封装函数        /// <summary>        /// 遍历所有设备，返回所有可用设备的VID/PID到字符串，以“\r\n”分割        /// </summary>        /// <param name="deviceCount">设备数量</param>        /// <returns></returns>        public String ListHidDevice(ref int deviceCount)        {            //获取连接的HID列表            string str = "";            deviceCount = 0;            deviceList.Clear();            GetHidDeviceList(ref deviceList);//调用函数获取所有连接设备并返回给实参列表deviceList            //遍历所有设备            for (int i = 0; i < deviceList.Count; i++)            {                //打开设备文件（可读写）并返回句柄到device变量                device = CreateFile(deviceList[i], DESIREDACCESS.GENERIC_READ | DESIREDACCESS.GENERIC_WRITE, 0, 0, CREATIONDISPOSITION.OPEN_EXISTING, FLAGSANDATTRIBUTES.FILE_FLAG_OVERLAPPED, 0);                if (device != INVALID_HANDLE_VALUE)                {                    //devices[j] = device;                    //j++;                    HIDD_ATTRIBUTES attributes;                    HidD_GetAttributes(device, out attributes);                    str += "VID:" + attributes.VendorID.ToString("X4") + " PID:" + attributes.ProductID.ToString("X4") + "\r\n";                    deviceCount++;                    CloseHandle(device); //释放打开的句柄                }            }            if (deviceCount == 0)            {                return "Unable to find equipment!";            }            return str;        }        /// <summary>        /// 打开指定信息的设备        /// </summary>        /// <param name="vID">设备的vID</param>        /// <param name="pID">设备的pID</param>        public HID_RETURN OpenDevice(UInt16 vID, UInt16 pID)        {            if (deviceOpened == false)            {                for (int i = 0; i < deviceList.Count; i++)                {                    //打开设备文件（可读写）并返回句柄到device变量                    device = CreateFile(deviceList[i], DESIREDACCESS.GENERIC_READ | DESIREDACCESS.GENERIC_WRITE, 0, 0, CREATIONDISPOSITION.OPEN_EXISTING, FLAGSANDATTRIBUTES.FILE_FLAG_OVERLAPPED, 0);                    HIDD_ATTRIBUTES attributes;                    HidD_GetAttributes(device, out attributes);                    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(new SafeFileHandle(device, false), FileAccess.ReadWrite, inputReportLength, true); //实例化sub对象，对象为字段，所以全局调用同一个，这里已经定了读数据长度                        deviceOpened = true;                        IsRead = true; //允许读取                        BeginAsyncRead(); //打开成功马上自动读取                        //返回打开成功                        return HID_RETURN.SUCCESS;                    }                    else                    {                        CloseHandle(device); //释放打开的句柄                    }                }                //返回打开失败                return HID_RETURN.DEVICE_NOT_FIND;            }            //返回已打开            else                return HID_RETURN.DEVICE_OPENED;        }        /// <summary>        /// 停止读取        /// </summary>        public void StopRead()        {            IsRead = false; //禁止读取        }        /// <summary>        /// 开始读取        /// </summary>        public void StatiRead()        {            IsRead = true; //允许读取        }        /// <summary>        /// 关闭打开的设备        /// </summary>        public void CloseDevice()        {            IsRead = false; //禁止读取            System.Threading.Thread.Sleep(100); //线程等待，等待数据读完在关闭设备            if (deviceOpened == true)            {                hidDevice.Close(); //关闭usb                deviceOpened = false;                CloseHandle(device); //释放打开的句柄            }        }        /// <summary>        /// 开始一次异步读        /// </summary>        private void BeginAsyncRead()        {            byte[] inputBuff = new byte[InputReportLength];            if (IsRead)            {                try                {                    //异步读数据，缓存区、开始读的帧、最大读取长度、读完异步调用的方法、将该特定的异步读取请求与其他请求区别开来                    hidDevice.BeginRead(inputBuff, 0, InputReportLength, new AsyncCallback(ReadCompleted), inputBuff);                }                catch (Exception)                {                    throw;                }            }        }        List<byte[]> buffer = new List<byte[]>();        /// <summary>        /// 异步读取结束,发出有数据到达事件        /// </summary>        /// <param name="iResult">这里是输入报告的数组</param>        private void ReadCompleted(IAsyncResult iResult)        {            byte[] readBuff = (byte[])(iResult.AsyncState); //装载数据            buffer.Add(readBuff);            if (IsRead)            {                try                {                    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); //触发事件                    }                    finally                    {                        BeginAsyncRead();//启动下一次读操作                    }                }                catch (IOException)//读写错误,设备已经被移除                {                    EventArgs ex = new EventArgs();                    OnDeviceRemoved(ex);//发出设备移除消息                    //CloseDevice();                }            }        }        /// <summary>        /// 事件:数据到达,处理此事件以接收输入数据        /// </summary>        public event EventHandler<report> DataReceived;        /// <summary>        /// 调用数据到达事件方法        /// </summary>        /// <param name="e"></param>        protected virtual void OnDataReceived(report e)        {            DataReceived?.Invoke(this, e);        }        /// <summary>        /// 事件：设置连接        /// </summary>        public event EventHandler DeviceArrived;        protected virtual void OnDeviceArrived(EventArgs e)        {            DeviceArrived?.Invoke(this, e);        }        /// <summary>        /// 事件:设备断开        /// </summary>        public event EventHandler DeviceRemoved;        protected virtual void OnDeviceRemoved(EventArgs e)        {            DeviceRemoved?.Invoke(this, e);        }        /// <summary>        /// 发送数据函数        /// </summary>        /// <param name="buffer"></param>        /// <returns></returns>        public HID_RETURN Write(report r)        {            if (deviceOpened)            {                try                {                    byte[] buffer = new byte[outputReportLength]; //存储数据位                    buffer[0] = r.reportID; //数据位第一帧                    int maxBufferLength = 0; //循环赋值                    //判断数据长度-1 与 赋值列表长度-1的大小,循环赋值以最小的长度为准                    if (r.reportBuff.Length < outputReportLength - 1)                        maxBufferLength = r.reportBuff.Length;                    else                        maxBufferLength = outputReportLength;                    //遍历赋值数据位第二帧及以后的数据                    for (int i = 1; i < maxBufferLength; i++)                        buffer[i] = r.reportBuff[i - 1];                    hidDevice.Write(buffer, 0, OutputReportLength); //缓存区、开始读的帧数、最大数据长度                    IsRead = true;//允许读取                    BeginAsyncRead(); //继续读取                }                catch                {                    EventArgs ex = new EventArgs();                    OnDeviceRemoved(ex);//发出设备移除消息                    CloseDevice();                }            }            return HID_RETURN.WRITE_FAILD;        }        /// <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();        }        ///// <summary>        ///// 检测设备连接状态        ///// </summary>        ///// <param name="m"></param>        //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(VID, PID);        //                break;        //            case DEVICE_FLAG.DEVICE_REMOVECOMPLETE:    // removed        //                Console.WriteLine("ParseMessages 设备拔除");        //                if (DeviceRemoved != null)        //                {        //                    DeviceRemoved(this, new EventArgs());        //                }        //                CheckDevicePresent(VID, PID);        //                break;        //        }        //    }        //}        /// <summary>        /// 打开指定设备        /// </summary>        /// <param name="parameterVID">设备的VID</param>        /// <param name="parameterPID">设备的PID</param>        /// <returns>打开成功与否</returns>        public bool CheckDevicePresent(ushort parameterVID, ushort parameterPID)        {            this.VID = parameterVID;            this.PID = parameterPID;            HID_RETURN hid_ret;            try            {                hid_ret = OpenDevice(VID, PID);                if (hid_ret == HID_RETURN.SUCCESS)                {                    return true;                }                else                {                    return false;                }            }            catch (Exception)            {                throw;            }        }        /// <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;            }        }        /// <summary>        /// btye数组转换为字符串        /// </summary>        /// <param name="bytes"></param>        /// <returns></returns>        public static string ByteToHexString(byte[] bytes)        {            string str = string.Empty;            if (bytes != null)            {                for (int i = 0; i < bytes.Length; i++)                {                    str += bytes[i].ToString("X2");                }            }            return str;        }        public enum HID_RETURN        {            SUCCESS = 0,            NO_DEVICE_CONECTED,            DEVICE_NOT_FIND,            DEVICE_OPENED,            WRITE_FAILD,            READ_FAILD        }        #endregion    }}

三、坑之总结

我简单地总结了一下，坑有以下几个：

1.接收数据长度没对齐，导致接收不成功；

2.Win10调试成功，Win7调试失败；

3.32程序运行成功，64位程序运行失败；

4.异步接收数据顺序错乱。

四、谈坑

1.坑之接收不成

实话说，我也忘了为什么接收数据不成功，修改了哪里。因为我是在一年前写的这个程序，而最近同时需要我封的代码，且他的程序是64位的，我之前是32位，故不兼容，好人做到底，我就帮他稍微改了一下，兼容进去了。然后写下这篇随笔记录一下情况，方便追溯。

下面是我凭借零星的回忆，一顿乱说，我实在忘了原版（接收不成功）长啥样了。

接收数据不成功主要有两个原因，一个是接收数据的长度不对，另一个也是接收长度不对。我这里不是学鲁迅大师说话，两种情况是不一样的。

第一个接收长度不对是因为发送长度超过了64byte，HID帧数据不能超过64Byte，我也不知到为什么，亲测确实如此，如果有兴趣可以深究一下。

第二个报文的长度不对，

 //异步读数据，缓存区、开始读的帧、最大读取长度、读完异步调用的方法、将该特定的异步读取请求与其他请求区别开来 hidDevice.BeginRead(inputBuff, 0, InputReportLength, new AsyncCallback(ReadCompleted), inputBuff); 

上面的“InputReportLength”必须和下面的“inputReportLength”相同，其是报文的长度。

outputReportLength = caps.OutputReportByteLength; //赋值输出长度inputReportLength = caps.InputReportByteLength; //赋值输入长度

2.坑之win7发送失败

这个坑确实很坑爹，之前在win10下用得好好的，后面来了一台win7的工控机，然后就发送不了数据了。

后面把第一帧数据改成“0x00”，又可以了，就那么神奇，哎！

3.坑之x64框架枚举设备失败

这个坑，其实也不叫坑，只能说明我的技术不行，被虐得完无体肤！网上查了海量资料，遇到我这个问题的不多，并且大部分回答都是把x64改成x86，显然这并不是我想要的答案。还有少部分人说是winAPI调用错了，改成x64要改成x64的API，然后又给出了一些修改特性的方式，只能说，统统不行！我理解是，同样的声明方式，win系统会更加我们软件框架不一样，自动调用相应winAPI，x86的API在C:\Windows\SysWOW64文件夹里，而x64的API在C:\Windows\System32文件夹里。

x86和x64的数据长度是有差异的，包括指针的长度都是不一样。

我在x86下，调用“SetupDiGetClassDevs”获取设备信息集的句柄时返回的地址大概是9位数左右，而在x64中，返回的地址大概是13位数。

IntPtr hidInfoSet = SetupDiGetClassDevs(ref hUSB, 0, IntPtr.Zero, DIGCF.DIGCF_PRESENT | DIGCF.DIGCF_DEVICEINTERFACE);

当枚举列表中的设备时，返回false！

SetupDiEnumDeviceInterfaces(hidInfoSet, IntPtr.Zero, ref hUSB, index, ref interfaceInfo)

我们会想到一个声明句柄的类型“IntPtr”，平台特定的整数类型。资源的大小取决于使用的硬件和操作系统，即此类型的实例在32位硬件和操作系统中将是32位，在64位硬件和操作系统中将是64位；但其大小总是足以包含系统的指针（因此也可以包含资源的名称），关心的小伙伴可以深入了解一下。

问题又缩小了，肯定是哪个类型声明有问题。细分析了一下，

SetupDiEnumDeviceInterfaces中五个参数中，前面四个都没有问题，问题肯定出在最后一个参数“interfaceInfo”，而最后一个参数是SP_DEVICE_INTERFACE_DATA类型的结构体，那问题肯定在结构体中某个成员，再查了一下这个结构体，最后一个成员是指针类型“reserved”

　　public struct SP_DEVICE_INTERFACE_DATA    {        public int cbSize;        public Guid interfaceClassGuid;        public int flags;        public int reserved;    }

于是把“reserved”的类型改成IntPtr类型即可，果然能通过枚举。后面又用同样的方式修改了其他结构体“reserved”的类型。

这里还有个小问题，上面结构体的其他成员类型不要修改，我之前把int改成uint，报内存溢出的错误。

4.坑之接收数据顺序错乱

如前面所言，我用usb主要是考虑传输速度，所以下位机发上来的频率基本是1ms一次，貌似异步接收还是反应不错的。

但是解析数据就有点和想的不太一样了，我把数据采集上来，用动态波形图显示在上位机，但是显示时明显发现数据是不对的，后面监听发现数据排序的有问题，比如后一帧数据比前一帧数据解析完成早。

后面利用开了三个线程来解决这个问题，一个线程专门接收数据（异步接收），接到立马放到list里，然后开一个线程解析数据，再开一个线程显示。这里必须要做多线程同步，不然还是没有达到我们的要求。我是用线程的信号来处理他们之间同步的，因为这里涉及的东西比较多，后面有空再单独整理。

五、学不完的新知识，调不完的BUG

虽然解决了几个HID的坑，目前来说是没有多大问题，但是并不能保证以后没有新的需求新的bug出现，革命尚未完成，同志仍需努力！

本人并非计算机科班出身，对于编程也不是说很热爱，曾经年少时，觉得黑客很牛逼，很酷，于是就踏上了这一条“不归路”，学不完的新知识，调不完的新bug，应了那句，从入门到入土。

我们必须要放低态度，以无知，无我的状态修身，才能知之，自我！