使用C#使用Windows的HID通信 - 杨月昌的硬件开发技术博客

Windows使用HID通信相对比较简单，HID都是通过PID、VID信息来查找连接的，相比于串口，几乎无变化，连接无需人工选择，十分方便，也不需要驱动。

下面上实例，PID为0x003f，VID为0x04D8，支持发送接收数据显示到UI，使用C#来编写，调用的是windows api（create file、read file、write file）。

本实例将HID接口分成3层，支持自动连接、断开状态通知，异步收发数据，单个数据包大小为64bytes（因为从设备的数据包设定为64bytes，保持一致）。

接口分为两层，第一层将create file、read file、write file封装，第二层再封装自动连接、异步收发。

HID.cs -> HIDInterface.cs -> 应用

注意，这里所有数据都是64bytes，但是有用数据并非这么多，所以设定为第一个数据为后面数据实际长度，若需要修改定义，请在HIDInterface.cs的Send与HidDataReceived函数中修改处理方法即可。

HID.cs

1
using System;
2
using System.Collections.Generic;
3
using System.Runtime.InteropServices;
4
using System.IO;
5
using Microsoft.Win32.SafeHandles;
6
using System.Windows;
7

8
namespace HID_SIMPLE.HID
9
{
10
    public class ReportEventArgs : EventArgs
11
    {
12
        public byte ReportID { get; }
13
        public byte[] ReportData { get; }
14

15
        public ReportEventArgs(byte reportID, byte[] reportData)
16
        {
17
            ReportID = reportID;
18
            ReportData = reportData;
19
        }
20
    }
21

22
    public class HidDevice : IDisposable
23
    {
24
        private const int MAX_USB_DEVICES = 64;
25
        private readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
26
        private bool _deviceOpened = false;
27
        private FileStream _hidDevice = null;
28
        private IntPtr _hubDevice;
29

30
        private int _outputReportLength;
31
        public int OutputReportLength => _outputReportLength;
32

33
        private int _inputReportLength;
34
        public int InputReportLength => _inputReportLength;
35

36
        public event EventHandler<ReportEventArgs> DataReceived;
37
        public event EventHandler DeviceRemoved;
38

39
        public HidDevice()
40
        {
41
            _deviceOpened = false;
42
        }
43

44
        public HID_RETURN OpenDevice(ushort vendorId, ushort productId, string serial)
45
        {
46
            if (_deviceOpened)
47
                return HID_RETURN.DEVICE_OPENED;
48

49
            var deviceList = GetHidDeviceList();
50
            if (deviceList.Count == 0)
51
                return HID_RETURN.NO_DEVICE_CONECTED;
52

53
            foreach (var devicePath in deviceList)
54
            {
55
                var deviceHandle = CreateFile(devicePath, DESIREDACCESS.GENERIC_READ | DESIREDACCESS.GENERIC_WRITE, 0, IntPtr.Zero, CREATIONDISPOSITION.OPEN_EXISTING, FLAGSANDATTRIBUTES.FILE_FLAG_OVERLAPPED, 0);
56
                if (deviceHandle != INVALID_HANDLE_VALUE)
57
                {
58
                    var attributes = new HIDD_ATTRIBUTES();
59
                    IntPtr serialBuffer = Marshal.AllocHGlobal(512);
60
                    HidD_GetAttributes(deviceHandle, out attributes);
61
                    HidD_GetSerialNumberString(deviceHandle, serialBuffer, 512);
62
                    string deviceSerial = Marshal.PtrToStringAuto(serialBuffer);
63
                    Marshal.FreeHGlobal(serialBuffer);
64

65
                    if (attributes.VendorID == vendorId && attributes.ProductID == productId && deviceSerial.Contains(serial))
66
                    {
67
                        IntPtr preparseData;
68
                        HIDP_CAPS caps;
69
                        HidD_GetPreparsedData(deviceHandle, out preparseData);
70
                        HidP_GetCaps(preparseData, out caps);
71
                        HidD_FreePreparsedData(preparseData);
72

73
                        _outputReportLength = caps.OutputReportByteLength;
74
                        _inputReportLength = caps.InputReportByteLength;
75

76
                        _hidDevice = new FileStream(new SafeFileHandle(deviceHandle, false), FileAccess.ReadWrite, _inputReportLength, true);
77
                        _deviceOpened = true;
78

79
                        BeginAsyncRead();
80
                        _hubDevice = deviceHandle;
81
                        return HID_RETURN.SUCCESS;
82
                    }
83
                }
84
            }
85
            return HID_RETURN.DEVICE_NOT_FIND;
86
        }
87

88
        public void CloseDevice()
89
        {
90
            if (_deviceOpened)
91
            {
92
                _deviceOpened = false;
93
                _hidDevice.Close();
94
            }
95
        }
96

97
        private void BeginAsyncRead()
98
        {
99
            var inputBuff = new byte[InputReportLength];
100
            _hidDevice.BeginRead(inputBuff, 0, InputReportLength, ReadCompleted, inputBuff);
101
        }
102

103
        private void ReadCompleted(IAsyncResult asyncResult)
104
        {
105
            var readBuff = (byte[])asyncResult.AsyncState;
106
            try
107
            {
108
                _hidDevice.EndRead(asyncResult);
109
                var reportData = new byte[readBuff.Length - 1];
110
                Array.Copy(readBuff, 1, reportData, 0, readBuff.Length - 1);
111
                var report = new ReportEventArgs(readBuff[0], reportData);
112

113
                OnDataReceived(report);
114

115
                if (_deviceOpened)
116
                    BeginAsyncRead();
117
            }
118
            catch
119
            {
120
                OnDeviceRemoved(EventArgs.Empty);
121
                CloseDevice();
122
            }
123
        }
124

125
        protected virtual void OnDataReceived(ReportEventArgs e)
126
        {
127
            DataReceived?.Invoke(this, e);
128
        }
129

130
        protected virtual void OnDeviceRemoved(EventArgs e)
131
        {
132
            DeviceRemoved?.Invoke(this, e);
133
        }
134

135
        public HID_RETURN Write(ReportEventArgs report)
136
        {
137
            if (!_deviceOpened)
138
                return HID_RETURN.WRITE_FAILD;
139

140
            try
141
            {
142
                var buffer = new byte[_outputReportLength];
143
                buffer[0] = report.ReportID;
144

145
                int maxBufferLength = Math.Min(report.ReportData.Length, _outputReportLength - 1);
146
                Array.Copy(report.ReportData, 0, buffer, 1, maxBufferLength);
147

148
                _hidDevice.Write(buffer, 0, OutputReportLength);
149
                return HID_RETURN.SUCCESS;
150
            }
151
            catch
152
            {
153
                OnDeviceRemoved(EventArgs.Empty);
154
                CloseDevice();
155
                return HID_RETURN.NO_DEVICE_CONECTED;
156
            }
157
        }
158

159
        public static List<string> GetHidDeviceList()
160
        {
161
            var deviceList = new List<string>();
162
            Guid hidGuid = Guid.Empty;
163
            HidD_GetHidGuid(ref hidGuid);
164

165
            IntPtr deviceInfoSet = SetupDiGetClassDevs(ref hidGuid, 0, IntPtr.Zero, DIGCF.DIGCF_PRESENT | DIGCF.DIGCF_DEVICEINTERFACE);
166
            if (deviceInfoSet != IntPtr.Zero)
167
            {
168
                var interfaceInfo = new SP_DEVICE_INTERFACE_DATA { cbSize = Marshal.SizeOf(typeof(SP_DEVICE_INTERFACE_DATA)) };
169

170
                for (uint index = 0; index < MAX_USB_DEVICES; index++)
171
                {
172
                    if (SetupDiEnumDeviceInterfaces(deviceInfoSet, IntPtr.Zero, ref hidGuid, index, ref interfaceInfo))
173
                    {
174
                        int bufferSize = 0;
175
                        SetupDiGetDeviceInterfaceDetail(deviceInfoSet, ref interfaceInfo, IntPtr.Zero, bufferSize, ref bufferSize, null);
176

177
                        IntPtr detailBuffer = Marshal.AllocHGlobal(bufferSize);
178
                        var detail = new SP_DEVICE_INTERFACE_DETAIL_DATA { cbSize = Marshal.SizeOf(typeof(SP_DEVICE_INTERFACE_DETAIL_DATA)) };
179
                        Marshal.StructureToPtr(detail, detailBuffer, false);
180

181
                        if (SetupDiGetDeviceInterfaceDetail(deviceInfoSet, ref interfaceInfo, detailBuffer, bufferSize, ref bufferSize, null))
182
                        {
183
                            deviceList.Add(Marshal.PtrToStringAuto((IntPtr)((int)detailBuffer + 4)));
184
                        }
185

186
                        Marshal.FreeHGlobal(detailBuffer);
187
                    }
188
                }
189
            }
190

191
            SetupDiDestroyDeviceInfoList(deviceInfoSet);
192
            return deviceList;
193
        }
194

195
        public void Dispose()
196
        {
197
            CloseDevice();
198
        }
199
    }
200

201
    public enum HID_RETURN
202
    {
203
        SUCCESS = 0,
204
        NO_DEVICE_CONECTED,
205
        DEVICE_NOT_FIND,
206
        DEVICE_OPENED,
207
        WRITE_FAILD,
208
        READ_FAILD
209
    }
210

211
    #region Windows API Imports
212

213
    // Add Windows API imports and structures here
214
    // Include all your PInvoke methods from original code
215
    #endregion
216
}

HIDInterface.cs

1
using System;
2
using System.Collections.Generic;
3
using System.IO;
4
using System.Text;
5
using System.Threading;
6
using System.ComponentModel;
7

8
namespace HID_SIMPLE.HID
9
{
10
    public class HIDInterface : IDisposable
11
    {
12
        // 消息类型
13
        public enum MessagesType
14
        {
15
            Message,
16
            Error
17
        }
18

19
        // 结果结构
20
        public struct ResultString
21
        {
22
            public bool Result;
23
            public string Message;
24
        }
25

26
        // 设备结构
27
        public struct HidDevice
28
        {
29
            public UInt16 vID;
30
            public UInt16 pID;
31
            public string Serial;
32
        }
33

34
        private HidDevice lowHidDevice = new HidDevice();
35
        private Hid oSp = new Hid();
36
        private static HIDInterface m_oInstance;
37

38
        private bool bConnected = false;
39

40
        public delegate void DelegateDataReceived(object sender, byte[] data);
41
        public delegate void DelegateStatusConnected(object sender, bool isConnect);
42

43
        public event DelegateDataReceived DataReceived;
44
        public event DelegateStatusConnected StatusConnected;
45

46
        private BackgroundWorker ReadWriteThread = new BackgroundWorker();
47
        private bool ContinueConnectFlag = true;
48

49
        // 构造函数
50
        public HIDInterface()
51
        {
52
            m_oInstance = this;
53
            oSp.DataReceived = HidDataReceived;
54
            oSp.DeviceRemoved = HidDeviceRemoved;
55
        }
56

57
        // 自动连接
58
        public void AutoConnect(HidDevice hidDevice)
59
        {
60
            lowHidDevice = hidDevice;
61
            ContinueConnectFlag = true;
62
            ReadWriteThread.DoWork += ReadWriteThread_DoWork;
63
            ReadWriteThread.WorkerSupportsCancellation = true;
64
            ReadWriteThread.RunWorkerAsync();
65
        }
66

67
        // 停止自动连接
68
        public void StopAutoConnect()
69
        {
70
            try
71
            {
72
                ContinueConnectFlag = false;
73
                Dispose();
74
            }
75
            catch (Exception ex)
76
            {
77
                // 日志记录或进一步处理
78
                Console.WriteLine(ex.Message);
79
            }
80
        }
81

82
        // 连接设备
83
        public bool Connect(HidDevice hidDevice)
84
        {
85
            ResultString result = new ResultString();
86
            Hid.HID_RETURN hdrtn = oSp.OpenDevice(hidDevice.vID, hidDevice.pID, hidDevice.Serial);
87

88
            if (hdrtn == Hid.HID_RETURN.SUCCESS)
89
            {
90
                bConnected = true;
91
                result.Result = true;
92
                result.Message = "Connect Success!";
93
                RaiseEventConnectedState(result.Result);
94
                return true;
95
            }
96

97
            bConnected = false;
98
            result.Result = false;
99
            result.Message = "Device Connect Error";
100
            RaiseEventConnectedState(result.Result);
101
            return false;
102
        }
103

104
        // 发送数据
105
        public bool Send(byte[] byData)
106
        {
107
            byte[] sendtemp = new byte[byData.Length + 1];
108
            sendtemp[0] = (byte)byData.Length;
109
            Array.Copy(byData, 0, sendtemp, 1, byData.Length);
110

111
            Hid.HID_RETURN hdrtn = oSp.Write(new report(0, sendtemp));
112
            return hdrtn == Hid.HID_RETURN.SUCCESS;
113
        }
114

115
        // 发送字符串
116
        public bool Send(string strData)
117
        {
118
            byte[] data = Encoding.Unicode.GetBytes(strData);
119
            return Send(data);
120
        }
121

122
        // 断开连接
123
        public void DisConnect()
124
        {
125
            bConnected = false;
126
            Thread.Sleep(200);
127
            oSp?.CloseDevice();
128
        }
129

130
        // 设备移除事件
131
        private void HidDeviceRemoved(object sender, EventArgs e)
132
        {
133
            bConnected = false;
134
            ResultString result = new ResultString { Result = false, Message = "Device Removed" };
135
            RaiseEventConnectedState(result.Result);
136
            oSp?.CloseDevice();
137
        }
138

139
        // 接收数据事件
140
        private void HidDataReceived(object sender, report e)
141
        {
142
            try
143
            {
144
                byte[] buf = new byte[e.reportBuff[0]];
145
                Array.Copy(e.reportBuff, 1, buf, 0, e.reportBuff[0]);
146
                RaiseEventDataReceived(buf);
147
            }
148
            catch (Exception ex)
149
            {
150
                ResultString result = new ResultString { Result = false, Message = "Receive Error: " + ex.Message };
151
                RaiseEventConnectedState(result.Result);
152
            }
153
        }
154

155
        // 事件通知：连接状态
156
        private void RaiseEventConnectedState(bool isConnect)
157
        {
158
            StatusConnected?.Invoke(this, isConnect);
159
        }
160

161
        // 事件通知：接收到数据
162
        private void RaiseEventDataReceived(byte[] buf)
163
        {
164
            DataReceived?.Invoke(this, buf);
165
        }
166

167
        // 释放资源
168
        public void Dispose()
169
        {
170
            try
171
            {
172
                DisConnect();
173
                oSp.DataReceived -= HidDataReceived;
174
                oSp.DeviceRemoved -= HidDeviceRemoved;
175
                ReadWriteThread.DoWork -= ReadWriteThread_DoWork;
176
                ReadWriteThread.CancelAsync();
177
                ReadWriteThread.Dispose();
178
            }
179
            catch (Exception ex)
180
            {
181
                // 错误处理或日志记录
182
                Console.WriteLine(ex.Message);
183
            }
184
        }
185

186
        // 自动连接线程
187
        private void ReadWriteThread_DoWork(object sender, DoWorkEventArgs e)
188
        {
189
            while (ContinueConnectFlag)
190
            {
191
                try
192
                {
193
                    if (!bConnected)
194
                    {
195
                        Connect(lowHidDevice);
196
                    }
197
                    Thread.Sleep(500);
198
                }
199
                catch (Exception ex)
200
                {
201
                    // 错误处理
202
                    Console.WriteLine(ex.Message);
203
                }
204
            }
205
        }
206
    }
207
}

调用示例：#

1
HIDInterface hid = new HIDInterface();
2

3
connectStatusStruct connectStatus = new connectStatusStruct();
4

5
// 推送连接状态信息
6
public delegate void isConnectedDelegate(bool isConnected);
7
public isConnectedDelegate isConnectedFunc;
8

9
// 推送接收数据
10
public delegate void PushReceiveDataDele(byte[] datas);
11
public PushReceiveDataDele pushReceiveData;
12

13
// 初始化
14
public void Initial()
15
{
16
    hid.StatusConnected = StatusConnected;
17
    hid.DataReceived = DataReceived;
18

19
    HIDInterface.HidDevice hidDevice = new HIDInterface.HidDevice
20
    {
21
        vID = 0x04D8,
22
        pID = 0x003F,
23
        Serial = ""
24
    };
25
    hid.AutoConnect(hidDevice);
26
}
27

28
// 关闭
29
public void Close()
30
{
31
    hid.StopAutoConnect();
32
}
33

34
// 发送数据
35
public bool SendBytes(byte[] data)
36
{
37
    return hid.Send(data);
38
}
39

40
// 数据接收回调
41
public void DataReceived(object sender, byte[] e)
42
{
43
    pushReceiveData?.Invoke(e);
44
}
45

46
// 状态变化回调
47
public void StatusConnected(object sender, bool isConnect)
48
{
49
    connectStatus.curStatus = isConnect;
50
    if (connectStatus.curStatus == connectStatus.preStatus) // 相同状态不处理
51
        return;
52
    connectStatus.preStatus = connectStatus.curStatus;
53

54
    if (connectStatus.curStatus)
55
    {
56
        isConnectedFunc(true);
57
    }
58
    else
59
    {
60
        isConnectedFunc(false);
61
    }
62
}