C# 实现自定义的USB设备与上位机进行通信（上位机部分）

　　因为以前没用过USB，对USB也不了解，于是上网查了很多资料，不过网上的资料都是零零散散，不清不楚的，于是我自己总结了一下，下面几个链接是网上这么多零散资料里，我觉得比较有参考意义的。

　　USB设备连接思路参考：https://www.cnblogs.com/xyzyx/articles/2959610.html#undefined

　　代码参考：http://www.cnblogs.com/xidongs/archive/2011/11/28/2266100.html#

　　收发数据参考：https://blog.csdn.net/zouwen198317/article/details/5814212

　　整个思路概况为3步：1、识别设备；2、连接设备；3、数据传输。

　　而我这里所有的步骤都是基于直接调用Windos的DLL实现的，调用了hid.dll、setupapi.dll、kernel32.dll，建立好工程后，可以从你自己的电脑里复制出这几个文件到工程目录下使用，调用DLL思路如下：

            /*          使用USB传输数据思路
             * 0.连接DALL的库函数做好准备工作
             * 1.调用HidD_GetHidGuid获取到GUID
             * 2.调用SetupDiGetClassDevs获取全部的HID值
             * 3.调用SetupDiEnumDeviceInterfaces,填写PSP_DEVICE_INTERFACE_DATA结构数据项，
             *   该结构用于识别一个HID设备接口，结构具体作用参考函数说明
             * 4.调用SetupDiGetDeviceInterfaceDetail获取特定的HID路径名
             * 5.调用CreateFile获得设备HID句柄
             * 6.调用HidD_GetAttributes，填写HID_ATTRIBUTES结构的数据项，
             *   该结构包含设备的厂商ID、产品ID和产品序列号，程序可比照这些获取到的参数值确定该设备是否是查找的设备
             * 7.查找成功完成，未成功重复3 4 5 6 步
             * 8.与自己需要的USB设备连接成功后，调用WriteFile和ReadFile进行数据传输
             * 9.关闭时调用SetupDiDestroyDeviceInfoList(hDevInfo)和CloseHandle(HidHandle)断开连接并关闭USB设备
             */

　　接下来开始按上面的步骤来操作。

0、连接DALL的库函数做好准备工作

/*  ======================声明dll文件中需要调用的函数,以下是调用windows的API的函数======================= */

        //获得USB设备的GUID
        [DllImport("hid.dll")]
        public static extern void HidD_GetHidGuid(ref Guid HidGuid);
        Guid guidHID = Guid.Empty;


        //获得一个包含全部HID信息的结构数组的指针，具体配置看函数说明:https://docs.microsoft.com/zh-cn/windows/desktop/api/setupapi/nf-setupapi-setupdigetclassdevsw
        [DllImport("setupapi.dll", SetLastError = true)]
        public static extern IntPtr SetupDiGetClassDevs(ref Guid ClassGuid, uint Enumerator, IntPtr HwndParent, DIGCF Flags);
        IntPtr hDevInfo;

        public enum DIGCF   
        {
            DIGCF_DEFAULT = 0x1,
            DIGCF_PRESENT = 0x2,
            DIGCF_ALLCLASSES = 0x4,
            DIGCF_PROFILE = 0x8,
            DIGCF_DEVICEINTERFACE = 0x10
        }

        //该结构用于识别一个HID设备接口，获取设备，true获取到
        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern Boolean SetupDiEnumDeviceInterfaces(IntPtr hDevInfo, IntPtr devInfo, ref Guid interfaceClassGuid, UInt32 memberIndex, ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData);
        //SetupDiEnumDeviceInterfaces 识别出来的SP_DEVICE_INTERFACE_DATA结构，该结构标识满足搜索参数的接口
        public struct SP_DEVICE_INTERFACE_DATA
        {
            public int cbSize;                     //SP_DEVICE_INTERFACE_DATA结构的大小
            public Guid interfaceClassGuid;        //设备接口所属的类的GUID
            public int flags;                      //接口转态标记
            public int reserved;                   //保留，不做使用
        }

        // 获得一个指向该设备的路径名，接口的详细信息 必须调用两次 第1次返回长度 第2次获取数据 
        [DllImport("setupapi.dll", SetLastError = true, 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);

        [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;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        internal struct SP_DEVICE_INTERFACE_DETAIL_DATA
        {
            internal int cbSize;
            internal short devicePath;
        }
         
        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern Boolean SetupDiDestroyDeviceInfoList(IntPtr deviceInfoSet);

        //获取设备文件（获取句柄）
        [DllImport("kernel32.dll", SetLastError = true)]
        //根据要求可在下面设定参数，具体参考参数说明：https://docs.microsoft.com/zh-cn/windows/desktop/api/fileapi/nf-fileapi-createfilea
        private static extern int CreateFile
            (
             string lpFileName,                             // file name 文件名
             uint   dwDesiredAccess,                        // access mode 访问模式
             uint   dwShareMode,                            // share mode 共享模式
             uint   lpSecurityAttributes,                   // SD 安全属性
             uint   dwCreationDisposition,                  // how to create 如何创建
             uint   dwFlagsAndAttributes,                   // file attributes 文件属性
             uint   hTemplateFile                           // handle to template file 模板文件的句柄
            );
      
        [DllImport("Kernel32.dll", SetLastError = true)]  //接收函数DLL
        private static extern bool ReadFile
            (
                IntPtr hFile,
                byte[] lpBuffer,
                uint nNumberOfBytesToRead,
                ref uint lpNumberOfBytesRead,
                IntPtr lpOverlapped
            );

        [DllImport("kernel32.dll", SetLastError = true)] //发送数据DLL
        public static extern Boolean WriteFile
            (
                IntPtr hFile,
                byte[] lpBuffer,
                uint nNumberOfBytesToWrite,
                ref uint nNumberOfBytesWrite,
                IntPtr lpOverlapped
            );
        
        [DllImport("hid.dll")]       
        /*HidDeviceObject:指定顶级集合的打开句柄
          Attributes:指向调用者分配的HIDD_ATTRIBUTES结构的指针，该结构返回由HidDeviceObject指定的集合的属性*/        
        private static extern Boolean HidD_GetAttributes(IntPtr hidDeviceObject, out HIDD_ATTRIBUTES HIDD_ATTRIBUTES);       
        //HidD_GetAttributes的调用者使用此结构来对比查找设备
        public unsafe struct HIDD_ATTRIBUTES
        {
            public int    Size;            //指定HIDD_ATTRIBUTES结构的大小（以字节为单位）
            public ushort VendorID;        //指定HID设备的供应商ID( VID )
            public ushort ProductID;       //指定HID设备的产品ID( PID )
            public ushort VersionNumber;   //指定HIDClass设备的制造商版本号
        }

        //自定义的结构体，用来存放自己要操作的设备信息
        public unsafe struct my_usb_id
        {
            public ushort my_vid;
            public ushort my_Pid;
            public ushort my_number;
        }

        /**/
        [DllImport("hid.dll")]
        /*HidP_GetCaps返回一个顶级集合的 HIDP_CAPS结构，获取设备具体信息，这里暂时用不上
        PreparsedData:指向顶级集合的预分析数据的指针; Capabilities:指向调用程序分配的缓冲区的指针，该缓冲区用于返回集合的HIDP_CAPS结构*/
        private static extern uint HidP_GetCaps(IntPtr PreparsedData, out HIDP_CAPS Capabilities);
        [StructLayout(LayoutKind.Sequential)]
        public unsafe struct HIDP_CAPS
        {
            public ushort UsagePage;                                            //指定顶级集合的使用情况
            public uint   Usage;                                                //指定顶级集合的 使用ID
            public ushort InputReportByteLength;                                //指定所有输入报告的最大大小（以字节为单位）
            public ushort OutputReportByteLength;                               //指定所有输出报告的最大大小（以字节为单位）
            public ushort FeatureReportByteLength;                              //指定所有功能报告的最大长度（以字节为单位）
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 17)]               //保留供内部系统使用数组
            public ushort NumberLinkCollectionNodes;                            //指定的数量HIDP_LINK_COLLECTION_NODE了为这个顶级集合返回的结构HidP_GetLinkCollectionNodes
            public ushort NumberInputButtonCaps;                                //指定HidP_GetButtonCaps返回的输入HIDP_BUTTON_CAPS结构的数量
            public ushort NumberInputValueCaps;                                 //指定HidP_GetValueCaps返回的输入HIDP_VALUE_CAPS结构的数量
            public ushort NumberInputDataIndices;                               //指定分配给所有输入报告中的按钮和值的数据索引数
            public ushort NumberOutputButtonCaps;                               //指定HidP_GetButtonCaps返回的输出HIDP_BUTTON_CAPS结构的数量
            public ushort NumberOutputValueCaps;                                //指定HidP_GetValueCaps返回的输出HIDP_VALUE_CAPS结构的数量
            public ushort NumberOutputDataIndices;                              //指定分配给所有输出报告中的按钮和值的数据索引数
            public ushort NumberFeatureButtonCaps;                              //指定HidP_GetButtonCaps返回的功能HIDP_BUTTONS_CAPS结构的总数
            public ushort NumberFeatureValueCaps;                               //指定HidP_GetValueCaps返回的功能HIDP_VALUE_CAPS结构的总数
            public ushort NumberFeatureDataIndices;                             //指定分配给所有要素报告中的按钮和值的数据索引数
        }

        [DllImport("hid.dll")]
        private static extern Boolean HidD_GetPreparsedData(IntPtr hidDeviceObject, out IntPtr PreparsedData);     

        //释放设备
        [DllImport("hid.dll")]
        static public extern bool HidD_FreePreparsedData(ref IntPtr PreparsedData);

        //关闭访问设备句柄，结束进程的时候把这个加上保险点
        [DllImport("kernel32.dll")]
        static public extern int CloseHandle(int hObject);

        //查看数据传输异常函数
        [DllImport("kernel32.dll", EntryPoint = "GetProcAddress", SetLastError = true)]
        public static extern IntPtr GetProcAddress(int hModule, [MarshalAs(UnmanagedType.LPStr)] string lpProcName);

　　上面的DLL调用在 public partial class Form1 : Form{}函数里直接声明就好了

1~7连接USB设备
　　连接前先定义一些要用到的变量，再调用 UsBMethod 函数连接，这个函数里面包含了1~7的所有步骤：

        //定于句柄序号和一些参数，具体可以去网上找这些API的参数说明
        int HidHandle = -1;
        int sele = 0;
        int usb_flag = 0;
        bool result;
        string devicePathName;

        //CreateFile参数配置
        public const uint GENERIC_READ = 0x80000000;
        public const uint GENERIC_WRITE = 0x40000000;
        public const uint FILE_SHARE_READ = 0x00000001;
        public const uint FILE_SHARE_WRITE = 0x00000002;
        public const int OPEN_EXISTING = 3;

        private void UsBMethod(int index)
        {
            //获取USB设备的GUID
            HidD_GetHidGuid(ref guidHID);

            //Console.WriteLine(" GUID_HID = "+ guidHID);       //输出guid信息调试用

            //获取系统中存在的所有设备的列表，这些设备已从存储卷设备接口类启用了接口
            hDevInfo = SetupDiGetClassDevs(ref guidHID, 0, IntPtr.Zero, DIGCF.DIGCF_PRESENT | DIGCF.DIGCF_DEVICEINTERFACE);

            int bufferSize = 0;
            ArrayList HIDUSBAddress = new ArrayList();

            while (true)
            {

                //获取设备，true获取到
                SP_DEVICE_INTERFACE_DATA DeviceInterfaceData = new SP_DEVICE_INTERFACE_DATA();
                DeviceInterfaceData.cbSize = Marshal.SizeOf(DeviceInterfaceData);

                for (int i = 0; i < 3; i++)
                {
                    //识别HID设备接口，获取设备，返回true成功
                    result = SetupDiEnumDeviceInterfaces(hDevInfo, IntPtr.Zero, ref guidHID, (UInt32)index, ref DeviceInterfaceData);
                }

                //Console.WriteLine(" 识别HID接口	"+result);       //识别接口打印信息查看

                //第一次调用出错，但可以返回正确的Size 
                SP_DEVINFO_DATA strtInterfaceData = new SP_DEVINFO_DATA();
                //获得一个指向该设备的路径名，接口的详细信息 必须调用两次 第1次返回路径长度 
                result = SetupDiGetDeviceInterfaceDetail(hDevInfo, ref DeviceInterfaceData, IntPtr.Zero, 0, ref bufferSize, strtInterfaceData);

                //第二次调用传递返回值，调用即可成功 , 第2次获取路径数据 
                IntPtr detailDataBuffer = Marshal.AllocHGlobal(bufferSize);
                SP_DEVICE_INTERFACE_DETAIL_DATA detailData = new SP_DEVICE_INTERFACE_DETAIL_DATA();
                detailData.cbSize = Marshal.SizeOf(typeof(SP_DEVICE_INTERFACE_DETAIL_DATA));

                Marshal.StructureToPtr(detailData, detailDataBuffer, false);
                result = SetupDiGetDeviceInterfaceDetail(hDevInfo, ref DeviceInterfaceData, detailDataBuffer, bufferSize, ref bufferSize, strtInterfaceData);

                if (result == false)
                {
                    break;
                }

                //获取设备路径访
                IntPtr pdevicePathName = (IntPtr)((int)detailDataBuffer + 4);
                devicePathName = Marshal.PtrToStringAuto(pdevicePathName);
                HIDUSBAddress.Add(devicePathName);

                //Console.WriteLine(" Get_DvicePathName = "+ devicePathName);     //打印路径信息，调试用

                //连接USB设备文件
                int aa = CT_CreateFile(devicePathName);
                usb_flag = aa;
                if (aa == 1)                                    //设备连接成功               
                {
                    //获取设备VID PID 出厂编号信息判断是否跟自定义的USB设备匹配，匹配返回 1
                    usb_flag = HidD_GetAttributes(HidHandle);
                    if (usb_flag == 1) break;
                    else usb_flag = 0;
                }
                else usb_flag = 0;
                index++;
            }

        }

　　上面的函数调用到了一个建立和设备的连接的函数，该函数主要是用来跟设备建立连接，函数如下：

  /*  =================建立和设备的连接==================    */
        public unsafe int CT_CreateFile(string DeviceName)
        {
            HidHandle = CreateFile
            (
                DeviceName,
                //GENERIC_READ |          // | GENERIC_WRITE,//读写，或者一起
                GENERIC_READ | GENERIC_WRITE,
                //FILE_SHARE_READ |       // | FILE_SHARE_WRITE,//共享读写，或者一起
                FILE_SHARE_READ | FILE_SHARE_WRITE,
                0,
                OPEN_EXISTING,
                0,
                0
             );

            //Console.WriteLine(" IN_DeviceName = " + DeviceName);                    //查看参数是否传入           

            if (HidHandle == -1) //INVALID_HANDLE_VALUE实际值等于-1，连接失败
            {

                //Console.WriteLine(" 失败 HidHandle = 0x" + "{0:x}",HidHandle );     //查看状态，打印调试用
                return 0;
            }
            else    //连接成功
            {
                //Console.WriteLine(" 成功 HidHandle = 0x" + "{0:x}",HidHandle);      //查看状态，打印调试用
                return 1;
            }
        }

　　调用函数建立好连接后，就要判断是否是自己需要的USB设备了，这里就调用了一个判断函数：

 /*  ==============获取设备的VID PID 出厂编号等信息，存放到HIDD_ATTRIBUTES==============   */
        public unsafe int HidD_GetAttributes(int handle)
        {
            HIDD_ATTRIBUTES HIDD_ATTRIBUTE = new HIDD_ATTRIBUTES();
            //handle是CreateFile函数返回一个有效的设备操作句柄，HIDD_ATTRIBUTES是函数返回的结构体信息（VID PID 设备号）
            bool sel = HidD_GetAttributes((IntPtr)handle, out HIDD_ATTRIBUTE);

            /*//打印VID、PID信息以16进制显示调试用，打印数据前不能接+号，不然打印不出来，信息为0
            Console.Write("	" + "VID:{0:x}", HIDD_ATTRIBUTE.VendorID );
            Console.Write("	" + "PID:{0:x}", HIDD_ATTRIBUTE.ProductID);
            Console.WriteLine("
");   */

            if (sel == true)  //获取设备信息成功
            {
                //对自己定义的my_usb_id结构体赋值，输入自己要操作的设备参数，用来跟读取出来的设备参数比较
                my_usb_id my_usb_id = new my_usb_id();
                my_usb_id.my_vid = 4292;        //自定义的USB设备VID 0x10c4=4292
                my_usb_id.my_Pid = 33485;       //自定义的USB设备PID 0x82cd=33485

                if (my_usb_id.my_vid == HIDD_ATTRIBUTE.VendorID && my_usb_id.my_Pid == HIDD_ATTRIBUTE.ProductID) //判断识别出来的是不是自定义的USB设备
                {
                    //Console.WriteLine("获取VID PID成功"); //打印信息调试用
                    sele = 1;
                }
                else sele = 0;
                return sele;
            }
            else
            {
                //Console.WriteLine("获取VID PID失败");     //打印信息调试用
                return sele = 0;
            }
        }

　　到这里就已经连接上USB设备了，接下来可以收发数据了。

8、调用WriteFile和ReadFile进行数据传输
　　这里的发送函数使用的是同步发送，至于怎样同步异步各位可以自行到https://docs.microsoft.com/zh-cn/windows/desktop/api/fileapi/nf-fileapi-writefile查看，或者看我前面的收发数据的参考链接

 private void button2_Click(object sender, EventArgs e)
        {
            if (usb_flag == 1)   //USB识别成功后发送数据
            {
                uint read = 0;
                byte[] src = { 1, 3,1 };
                bool isread = WriteFile((IntPtr)HidHandle, src, (uint)9, ref read, IntPtr.Zero);
                if (isread == false)
                {
                    int errCode = Marshal.GetLastWin32Error();
                    // Console.WriteLine("数据发送失败！错误代码：" + errCode);
                }
            }
        }

注意这里缓存区要比你的报文描述符多一个字节，不然会出错，至于接收，使用异步接收，在接收前要做一个调用DLL声明：

        /*构建一个Overlapped结构，异步通信用，
           internal是错误码，internalHigh是传输字节,这个两个是IO操作完成后需要填写的内容*/
        [StructLayout(LayoutKind.Sequential)]
        public struct OVERLAPPED
        {
            public IntPtr Internal;         //I/O请求的状态代码
            public IntPtr InternalHigh;     //传输I/O请求的字节数
            public int Offset;              //文件读写起始位置
            public int OffsetHigh;          //地址偏移量
            public IntPtr hEvent;           //操作完成时系统将设置为信号状态的事件句柄
        }

        /*监听异步通信函数*/
        [DllImport("Kernel32.dll")]
        public static extern unsafe long WaitForSingleObject(IntPtr hHandle, long dwMilliseconds);

　　声明好后就开始写接收函数了，接收函数怎么异步接收各位可以自行百度，或者官网查阅，也可以看穷前面的收发函数参考链接。

        public void redata()//USB异步接收数据
        {
            //初始化Overlapped
            OVERLAPPED overlap = new OVERLAPPED();
            overlap.Offset = 0;
            overlap.OffsetHigh = 0;

            //创建事件对象
            overlap.hEvent = CreateEvent(IntPtr.Zero, false, false, null);

            //接收数据缓存区：接收到的数据如果比这个小，则按实际数据大小，接收到一个ID+64个数据
            byte[] buffer = new byte[70];
            int dwRead = 0;
            Console.WriteLine("read... ");
            //while (true)
            {
                //读设备
                bool re = ReadFile(HidHandle, buffer, 70, out dwRead, out overlap);
                if (re != false)
                {
                    SetupDiDestroyDeviceInfoList(hDevInfo);
                    for (int i = 0; i < 70; i++)
                    {
                        Console.WriteLine("i = " + i + " 	 buffer = " + buffer[i]);
                    }
                    MessageBox.Show(" READ OK ！");
                    //break;
                }
            }
            // long cc=WaitForSingleObject(overlap.hEvent, 5000);
        }

　　这样异步接收可以开一个定时器时不时检测是否有数据接收，来实现，开定时是可以参考我的隐藏窗体功能的那篇文章：https://www.cnblogs.com/xingboy/p/10110443.html 不过用定时器做不定时检测可能会出现丢包情况，最好的方法是多开一个线程一直等待接收，接收到立刻跳转处理接收处理函数。

　　收发完函数后，就可以关闭通道了，以便节约资源嘛。

9、关闭USB设备

  /*  释放关闭USB设备   */
        public void Dispost()
        {
            //释放设备资源(hDevInfo是SetupDiGetClassDevs获取的)
            SetupDiDestroyDeviceInfoList(hDevInfo);
            //关闭连接(HidHandle是Create的时候获取的)
            CloseHandle(HidHandle);
        }
        //===================================================

 以上就是USB通信上位机部分的内容了，这些函数都放在 public partial class Form1 : Form{ } 完成，至于下位机的部分各位可以参考：https://www.cnblogs.com/xingboy/p/9913963.html

补充一点：如果生成的程序在你的电脑可正常使用，在别的电脑不可以用的话，那可能是windows系统的DLL出了问题，解决方法可以参考我另一个文章：https://www.cnblogs.com/xingboy/p/9876812.html