C# USB设备接口

最新推荐文章于 2024-08-13 10:59:25 发布
最新推荐文章于 2024-08-13 10:59:25 发布
阅读量1.6k 收藏 10
点赞数 2
分类专栏： C/C++学习 文章标签： c# usb设备 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Management;                          /* System.Management referenced */
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;

namespace TestBoardDriver
{
    public class DevManager
    {
        private static List<int> portNums = new List<int>();
        private static List<string> portIds = new List<string>();

        private static string GetPortId(int portNum)
        {
            for (int i = 0; i < portNums.Count; i++)
            {
                if (portNums[i] == portNum)
                {
                    return portIds[i];
                }
            }

            return "NA";
        }
        /*
            自动查找VID/PID匹配的USB设备当作Virutal COM Port口 
            输入值：   字符串，如VID_0483&PID_5740
            返回值：   0 - 没有找到对应设备
        */
        public static List<int> GetPortNum(String vid_pid)
        {
            ManagementObjectCollection USBControllerDeviceCollection
                = new ManagementObjectSearcher("SELECT * FROM Win32_USBControllerDevice").Get();
            if (USBControllerDeviceCollection != null)
            {
                foreach (ManagementObject USBControllerDevice in USBControllerDeviceCollection)
                {
                    String Dependent = (USBControllerDevice["Dependent"] as String).Split(new Char[] { '=' })[1];     

                    if (Dependent.Contains(vid_pid))
                    {
                        ManagementObjectCollection PnPEntityCollection
                            = new ManagementObjectSearcher("SELECT * FROM Win32_PnPEntity WHERE DeviceID=" + Dependent).Get();
                        if (PnPEntityCollection != null)
                        {
                            foreach (ManagementObject Entity in PnPEntityCollection)
                            {
                                
                                String PortId = Dependent.Split('\\')[4];           //Dependent = ""USB\\VID_0483&PID_5740\\6D8D108F5750""
                                PortId = PortId.Substring(0, PortId.Length - 1);

                                String DevName = Entity["Name"] as String;          // 设备名称 = "STMicroelectronics Virtual COM Port (COM9)"
                                String PortNum = Regex.Replace(DevName, @"[^\d.\d]", "");

                                try
                                {/*安装驱动程序过慢会导致DevName中不含COM号（出现概率小）*/
                                    portNums.Add( Convert.ToInt32(PortNum) );
                                    portIds.Add(PortId);
                                }
                                catch(Exception)
                                {
                                    return GetPortNum(vid_pid);
                                }
                            }
                        }
                    }
                }
            }

            return portNums;
        }

        /*
            删除指定设备 
            输入值：   设备管理器下的设备名称，不包括后面的(COMXX)
            返回值：   成功/失败
        */
        public static bool DeletePort(String vidpid, int comNum)
        {
            bool ret = false;

            Guid classGuid = Guid.Empty;
            IntPtr hDevInfo = Win32.SetupDiGetClassDevs(ref classGuid, null, IntPtr.Zero, Win32.DIGCF_ALLCLASSES | Win32.DIGCF_PRESENT);
            if (hDevInfo.ToInt32() == Win32.INVALID_HANDLE_VALUE)
            {
                Console.WriteLine("访问硬件设备失败");
            }
            else
            {
                string portId = GetPortId(comNum);

                int i = 0;
                int selected = 0;

                StringBuilder deviceName = new StringBuilder();
                deviceName.Capacity = Win32.MAX_DEV_LEN;
                do
                {
                    Win32.SP_DEVINFO_DATA devInfoData = new Win32.SP_DEVINFO_DATA();
                    StringBuilder _DeviceName = new StringBuilder("");
                    _DeviceName.Capacity = 1000;

                    devInfoData.cbSize = Marshal.SizeOf(typeof(Win32.SP_DEVINFO_DATA));
                    devInfoData.classGuid = Guid.Empty;
                    devInfoData.devInst = 0;
                    devInfoData.reserved = IntPtr.Zero;
                    bool result = Win32.SetupDiEnumDeviceInfo(hDevInfo, i, devInfoData);
                    if (false == result)
                    {
                        break;
                    }

                    Win32.SetupDiGetDeviceRegistryProperty(hDevInfo, devInfoData, 0, 0, _DeviceName, (uint)_DeviceName.Capacity, IntPtr.Zero);

                    string devId = GetDeviceInstanceId(hDevInfo, devInfoData);
                    if (devId.Contains(vidpid))
                    {
                        if (devId.Contains(portId))
                        {
                            Log.Show(Log.Level.Operation, "Deleting " + _DeviceName.ToString() + " " + comNum + " :" + devId);
                            selected = i;
                        }
                    }
                    ++i;
                } while (true);

                ret = Remove(selected, hDevInfo);

            }
            Win32.SetupDiDestroyDeviceInfoList(hDevInfo);

            return ret;
        }

        /*
            重新扫描硬件 
            输入值：   无
            返回值：   成功/失败
        */
        public static bool Rescan()
        {
            UInt32 devRoot = 0;

            if (Win32.CM_Locate_DevNode_Ex(ref devRoot, null, 0, IntPtr.Zero) != Win32.CR_SUCCESS)
            {
                return false;
            }
            if (Win32.CM_Reenumerate_DevNode_Ex(devRoot, 0, IntPtr.Zero) != Win32.CR_SUCCESS)
            {
                return false;
            }

            return true;
        }
        /*
            禁用指定设备 
            输入值：   设备管理器下的设备名称，不包括后面的(COMXX)
            返回值：   成功/失败
        */
        public static bool DisablePort(String portName = null)
        {
            bool ret = false;

            Guid classGuid = Guid.Empty;
            IntPtr hDevInfo = Win32.SetupDiGetClassDevs(ref classGuid, null, IntPtr.Zero, Win32.DIGCF_ALLCLASSES | Win32.DIGCF_PRESENT);
            if (hDevInfo.ToInt32() == Win32.INVALID_HANDLE_VALUE)
            {
                Console.WriteLine("访问硬件设备失败");
            }
            else
            {
                int i = 0;
                int selected = 0;

                StringBuilder deviceName = new StringBuilder();
                deviceName.Capacity = Win32.MAX_DEV_LEN;
                do
                {
                    Win32.SP_DEVINFO_DATA devInfoData = new Win32.SP_DEVINFO_DATA();
                    StringBuilder _DeviceName = new StringBuilder("");
                    _DeviceName.Capacity = 1000;

                    devInfoData.cbSize = Marshal.SizeOf(typeof(Win32.SP_DEVINFO_DATA));
                    devInfoData.classGuid = Guid.Empty;
                    devInfoData.devInst = 0;
                    devInfoData.reserved = IntPtr.Zero;
                    bool result = Win32.SetupDiEnumDeviceInfo(hDevInfo, i, devInfoData);
                    if (false == result)
                    {
                        break;
                    }

                    Win32.SetupDiGetDeviceRegistryProperty(hDevInfo, devInfoData, 0, 0, _DeviceName, (uint)_DeviceName.Capacity, IntPtr.Zero);
                    
                    if (_DeviceName.ToString().Equals(portName))
                    {
                        Log.Show(Log.Level.Operation, _DeviceName.ToString());
                        selected = i;
                    }
                    ++i;
                } while (true);

                ret = StateChange(false, selected, hDevInfo);

            }
            Win32.SetupDiDestroyDeviceInfoList(hDevInfo);

            return ret;
        }

        private static bool Remove(int SelectedItem, IntPtr DevInfo)
        {
            bool result = false;
            Win32.SP_DEVINFO_DATA devInfoData = new Win32.SP_DEVINFO_DATA(); ;
            devInfoData.cbSize = Marshal.SizeOf(typeof(Win32.SP_DEVINFO_DATA));
            if (true == Win32.SetupDiEnumDeviceInfo(DevInfo, SelectedItem, devInfoData))
            {
                if (true == Win32.SetupDiCallClassInstaller(Win32.DIF_REMOVE, DevInfo, devInfoData))
                {
                    result = true;
                }
                else
                {
                    uint ret = (uint)Win32.GetLastError();
                    Log.Show(Log.Level.Operation, "删除硬件设备失败(" + ret.ToString() + ")");
                }
            }
            return result;
        }
        private static bool StateChange(bool Enable, int SelectedItem, IntPtr DevInfo)
        {
            bool result = false;
            Win32.SP_DEVINFO_DATA devInfoData = new Win32.SP_DEVINFO_DATA(); ;
            devInfoData.cbSize = Marshal.SizeOf(typeof(Win32.SP_DEVINFO_DATA));
            if (true == Win32.SetupDiEnumDeviceInfo(DevInfo, SelectedItem, devInfoData))
            {
                Win32.SP_PROPCHANGE_PARAMS pcp = new Win32.SP_PROPCHANGE_PARAMS(); ;
                pcp.ClassInstallHeader.cbSize = Marshal.SizeOf(typeof(Win32.SP_CLASSINSTALL_HEADER));
                pcp.ClassInstallHeader.InstallFunction = Win32.DIF_PROPERTYCHANGE;
                pcp.Scope = Win32.DICS_FLAG_CONFIGSPECIFIC;
                pcp.StateChange = (Enable ? Win32.DICS_ENABLE : Win32.DICS_DISABLE);
                if (true == Win32.SetupDiSetClassInstallParams(DevInfo, devInfoData, pcp, Marshal.SizeOf(pcp)))
                {
                    if (true == Win32.SetupDiCallClassInstaller(Win32.DIF_PROPERTYCHANGE, DevInfo, devInfoData))
                    {
                        result = true;
                    }
                    else
                    {
                        uint ret = (uint)Win32.GetLastError();
                        Log.Show(Log.Level.Operation, "禁用硬件设备失败(" + ret.ToString() + ")");
                    }
                }
            }
            return result;
        }

        protected static String GetClassNameFromGuid(Guid guid)
        {
            String result = String.Empty;
            StringBuilder className = new StringBuilder();
            Int32 iRequiredSize = 0;
            Int32 iSize = 0;
            bool b = Win32.SetupDiClassNameFromGuid(ref guid, className, iSize, ref iRequiredSize);

            className = new StringBuilder(iRequiredSize);
            iSize = iRequiredSize;

            b = Win32.SetupDiClassNameFromGuid(ref guid, className, iSize, ref iRequiredSize);
            if (true == b)
            {
                result = className.ToString();
            }
            return result;
        }
        protected static String GetClassDescriptionFromGuid(Guid guid)
        {
            String result = String.Empty;
            StringBuilder classDesc = new StringBuilder(0);
            Int32 iRequiredSize = 0;
            Int32 iSize = 0;
            bool b = Win32.SetupDiGetClassDescription(ref guid, classDesc, iSize, ref iRequiredSize);

            classDesc = new StringBuilder(iRequiredSize);
            iSize = iRequiredSize;

            b = Win32.SetupDiGetClassDescription(ref guid, classDesc, iSize, ref iRequiredSize);
            if (true == b)
            {
                result = classDesc.ToString();
            }
            return result;
        }
        protected static String GetDeviceInstanceId(IntPtr DeviceInfoSet, Win32.SP_DEVINFO_DATA DeviceInfoData)
        {
            String result = String.Empty;
            StringBuilder id = new StringBuilder(0);
            Int32 iRequiredSize = 0;
            Int32 iSize = 0;
            bool b = Win32.SetupDiGetDeviceInstanceId(DeviceInfoSet, DeviceInfoData, id, iSize, ref iRequiredSize);

            id = new StringBuilder(iRequiredSize);
            iSize = iRequiredSize;

            b = Win32.SetupDiGetDeviceInstanceId(DeviceInfoSet, DeviceInfoData, id, iSize, ref iRequiredSize);
            if (true == b)
            {
                result = id.ToString();
            }
            return result;
        }

        /* setupapi.dll elements */
        public class Win32
        {
            [StructLayout(LayoutKind.Sequential)]
            public struct SP_BROADCAST_HANDLE
            {
                public int dbch_size;
                public int dbch_devicetype;
                public int dbch_reserved;
                public IntPtr dbch_handle;
                public IntPtr dbch_hdevnotify;
                public Guid dbch_eventguid;
                public long dbch_nameoffset;
                public byte dbch_data;
                public byte dbch_data1;
            }

            [StructLayout(LayoutKind.Sequential)]
            public class DEV_BROADCAST_DEVICEINTERFACE
            {
                public int dbcc_size;
                public int dbcc_devicetype;
                public int dbcc_reserved;
            }

            [StructLayout(LayoutKind.Sequential)]
            public class SP_DEVINFO_DATA
            {
                public int cbSize;
                public Guid classGuid;
                public int devInst;
                public IntPtr reserved;
            };

            [StructLayout(LayoutKind.Sequential)]
            public class SP_DEVINSTALL_PARAMS
            {
                public int cbSize;
                public int Flags;
                public int FlagsEx;
                public IntPtr hwndParent;
                public IntPtr InstallMsgHandler;
                public IntPtr InstallMsgHandlerContext;
                public IntPtr FileQueue;
                public IntPtr ClassInstallReserved;
                public int Reserved;
                [MarshalAs(UnmanagedType.LPTStr)]
                public string DriverPath;
            };

            [StructLayout(LayoutKind.Sequential)]
            public class SP_PROPCHANGE_PARAMS
            {
                public SP_CLASSINSTALL_HEADER ClassInstallHeader = new SP_CLASSINSTALL_HEADER();
                public int StateChange;
                public int Scope;
                public int HwProfile;
            };

            [StructLayout(LayoutKind.Sequential)]
            public class SP_CLASSINSTALL_HEADER
            {
                public int cbSize;
                public int InstallFunction;
            };

            [DllImport("kernel32.dll")]
            public static extern uint GetLastError();
            [DllImport("user32.dll", CharSet = CharSet.Auto)]
            public static extern IntPtr RegisterDeviceNotification(IntPtr hRecipient, DEV_BROADCAST_DEVICEINTERFACE NotificationFilter, UInt32 Flags);

            [DllImport("user32.dll", CharSet = CharSet.Auto)]
            public static extern UInt32 UnregisterDeviceNotification(IntPtr hHandle);

            [DllImport("setupapi.dll", SetLastError = true)]
            public static extern IntPtr SetupDiGetClassDevs(ref Guid ClassGuid,
            [MarshalAs(UnmanagedType.LPStr)]String Enumerator, IntPtr hwndParent, Int32 Flags);

            [DllImport("setupapi.dll")]
            public static extern IntPtr SetupDiGetClassDevsEx(ref Guid ClassGuid,
            [MarshalAs(UnmanagedType.LPStr)]String Enumerator,
            IntPtr hwndParent, Int32 Flags, IntPtr DeviceInfoSet,
            [MarshalAs(UnmanagedType.LPStr)]String MachineName,
            IntPtr Reserved);

            [DllImport("setupapi.dll", SetLastError = true)]
            public static extern Int32 SetupDiDestroyDeviceInfoList(IntPtr lpInfoSet);

            [DllImport("setupapi.dll", SetLastError = true)]
            public static extern Boolean SetupDiEnumDeviceInfo(IntPtr lpInfoSet, Int32 dwIndex, SP_DEVINFO_DATA devInfoData);

            [DllImport("setupapi.dll", SetLastError = true)]
            public static extern Boolean SetupDiGetDeviceRegistryProperty(IntPtr lpInfoSet, SP_DEVINFO_DATA DeviceInfoData, UInt32 Property,
            UInt32 PropertyRegDataType, StringBuilder PropertyBuffer, UInt32 PropertyBufferSize, IntPtr RequiredSize);

            [DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
            public static extern Boolean SetupDiSetClassInstallParams(IntPtr DeviceInfoSet, SP_DEVINFO_DATA DeviceInfoData, SP_PROPCHANGE_PARAMS ClassInstallParams, int ClassInstallParamsSize);

            [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
            public static extern Boolean SetupDiCallClassInstaller(UInt32 InstallFunction, IntPtr DeviceInfoSet, SP_DEVINFO_DATA DeviceInfoData);
            [DllImport("newdev.dll", CharSet = CharSet.Auto)]
            public static extern Boolean DiUninstallDevice(IntPtr parent, IntPtr DeviceInfoSet, SP_DEVINFO_DATA DeviceInfoData, IntPtr flag, bool reboot);
            [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
            public static extern Boolean SetupDiRemoveDevice(IntPtr DeviceInfoSet, SP_DEVINFO_DATA DeviceInfoData);
            [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
            public static extern Boolean SetupDiUnremoveDevice(IntPtr DeviceInfoSet, SP_DEVINFO_DATA DeviceInfoData);

            [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
            public static extern Boolean SetupDiClassNameFromGuid(ref Guid ClassGuid, StringBuilder className, Int32 ClassNameSize, ref Int32 RequiredSize);

            [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
            public static extern Boolean SetupDiGetClassDescription(ref Guid ClassGuid, StringBuilder classDescription, Int32 ClassDescriptionSize, ref Int32 RequiredSize);

            [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
            public static extern Boolean SetupDiGetDeviceInstanceId(IntPtr DeviceInfoSet, SP_DEVINFO_DATA DeviceInfoData, StringBuilder DeviceInstanceId, Int32 DeviceInstanceIdSize, ref Int32 RequiredSize);

            [DllImport("setupapi.dll", SetLastError = true)]
            public static extern bool SetupDiGetDeviceRegistryProperty(IntPtr DeviceInfoSet, SP_DEVINFO_DATA DeviceInfoData, int Property, uint PropertyRegDataType, StringBuilder PropertyBuffer, uint PropertyBufferSize, IntPtr RequiredSize);

            public const int DIGCF_ALLCLASSES = (0x00000004);
            public const int DIGCF_PRESENT = (0x00000002);
            public const int INVALID_HANDLE_VALUE = -1;
            public const int SPDRP_DEVICEDESC = (0x00000000);
            public const int MAX_DEV_LEN = 200;
            public const int DEVICE_NOTIFY_WINDOW_HANDLE = (0x00000000);
            public const int DEVICE_NOTIFY_SERVICE_HANDLE = (0x00000001);
            public const int DEVICE_NOTIFY_ALL_INTERFACE_CLASSES = (0x00000004);
            public const int DBT_DEVTYP_DEVICEINTERFACE = (0x00000005);
            public const int DBT_DEVNODES_CHANGED = (0x0007);
            public const int WM_DEVICECHANGE = (0x0219);
            public const int DIF_REMOVE = (0x00000005);
            public const int DIF_PROPERTYCHANGE = (0x00000012);
            public const int DICS_FLAG_GLOBAL = (0x00000001);
            public const int DICS_FLAG_CONFIGSPECIFIC = (0x00000002);
            public const int DICS_ENABLE = (0x00000001);
            public const int DICS_DISABLE = (0x00000002);

            [DllImport("setupapi.dll", SetLastError = true)]
            static public extern int CM_Locate_DevNode_Ex(ref UInt32 pdnDevInst, string pDeviceID, int ulFlags, IntPtr hMachine);
            [DllImport("setupapi.dll")]
            static public extern UInt32 CM_Reenumerate_DevNode_Ex(UInt32 dnDevInst, UInt32 ulFlags, IntPtr hMachine);
            public const uint CR_SUCCESS = 0x00000000;
        }
    }
}
push0529
关注
专栏目录
C#实现USB接口的程序代码
07-30 1120
实现USB接口的程序代码.namespace ConsoleApplication1{    class Program    {        static void Main(string[] args)        {            USB usb;            usb = new UDisk();//插入U盘            usb.Out
C# USB接口与设备通信
taiguisheng的博客
01-14 2万+
目录USB通信打开指定设备配置设备读取数据关闭设备示例 USB通信 这是我第一次直接使用USB接口与设备进行通信，第一反应就是打开指定设备，配置设备，读取数据，关闭设备备。事后发现确实如此。在网上查看一番之后，花了金币下载了一些代码，但是似乎都有点不太对路。当然，底层的东西还是能用的，我就是通过调用前辈（自己去看代码中的注释）的一些接口（免去了安装Libusbdot, CyUSB等）实现了与USB...
C# USB通讯
热门推荐
shizhibuyi1234的博客
09-12 3万+
项目工程文件下载：工程文件下载地址看了很多网上的博客，讲述如何用C#进行USB设备操作，很多都是不对的。以至于南辕北辙。我们可以使用usb库。在c下有usblib库，在C#下该如何使用libusb呢，下面介绍C#下的强大的开源USB类库就登场了：LibUSBDotNet，没错就是.NET下的libusb，这也是个开源项目，已经把libusb封装成了一个完整的类库它是sourceforge上的一个开......
使用C#禁止Windows系统插入U盘（除鼠标键盘以外的USB设备）
最新发布
贰半的博客
08-13 824
禁止系统插入非法的USB设备
C#版USB通信编程(接收和发送数据)
03-14
里面有两个例子<br>1.怎么捕捉USB的拔插<br>2.列出USB设备<br>希望对大家有用
在Windows中用C#开发USB的接口库
09-09
完全的通用USB开发库，不需要要任何的驱动（Windows自带），本人开发USB上位机软件包时，发现都是非托管的C++调用库，C#调用库非常少。所以收集了这个，供用.NET方式开发USB的朋友使用。(也包含VC++调用案例）
C#实现USB设备通信
08-23
导入hid.dll、setupapi.dll、Kernel32.dll 获取全部的USB设备列表 通过比对VID、PID、Version来识别待连接的USB设备 使用CreateFile、WriteFile等接口进行读写 返回消息读取为异步方式 VS2017、VS2019
C# USB设备通信
02-12
本文将详细讨论如何使用C#语言实现与USB设备的通信，包括设备的插拔检测和设备列表的获取，以及如何进行数据的发送和接收。 首先，让我们了解USB设备通信的基础。通用串行总线（USB）是一种标准接口，允许不同类型...
C#USB大全 （串口和USB通信，U盘）
06-18
这些库通常封装了Windows的Win32 API，如DeviceIoControl函数，使得开发者可以通过设备接口描述符、设备配置、端点等USB协议概念与USB设备进行交互。 关于**U盘读写**，在C#中，可以使用`System.IO`命名空间的`...
C# 安全移除USB设备
03-03
在本实例中，我们将探讨如何使用C#来安全地检测和移除USB设备。这个主题涉及到Windows API调用、设备管理以及用户界面的交互。 首先，了解USB设备的基本概念是必要的。USB（Universal Serial Bus）是一种通用串行...
C# 操作USB接口
11-27
C#操作USB的一个例子，内附CHM说明书[不过是E文的]
C# 读写USB设备通讯类
11-28
主要是和USB接口类的对接，条屏、读卡器等，其中增加的类型。
c# 如何操作usb设备
zhangzhechun的专栏
08-01 7679
需要注意的是，USB 设备的读写操作可能会阻塞当前线程，因此建议在单独的线程中进行 USB 设备的读写操作，以避免阻塞主线程。在 C# 中，可以使用 System.IO.Ports 命名空间中的 SerialPort 类来操作串口设备，也可以使用 Windows.Devices.Usb 命名空间中的 UsbDevice 类来操作 USB 设备。需要注意的是，USB 设备的读写操作可能会阻塞当前线程，因此建议在单独的线程中进行 USB 设备的读写操作，以避免阻塞主线程。读取到的数据存储在 data 数组中。
C#通过HID访问USB设备
C#代码访问USB(HID)是指使用C#语言编程来访问和控制USB设备，特别是HID（Human Interface Device）设备。HID设备是一种特殊类型的USB设备，例如游戏控制器、键盘、鼠标等。 在C#中访问USB(HID)设备需要使用P/Invoke...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值