如何获取 Win32 中可用串行端口的列表？

Question

我有一些遗留代码，通过调用 EnumPorts() 函数，然后过滤以“COM”开头的端口名称。

出于测试目的，如果我可以将此代码与 com0com 之类的东西一起使用，它会提供虚拟对COM 端口作为零调制解调器循环在一起。

但是，EnumPorts() 函数找不到 com0com 端口（即使没有过滤“COM”）。超级终端和 SysInternals PortMon 都可以看到它们，所以我确信它安装正确。

那么还有其他一些 Win32 函数可以提供可用串行端口的明确列表吗？

Answer 1

Nick D 建议的 EnumSerialPorts v1.20 使用九种不同的方法来列出串行端口！我们当然不缺少选择，尽管结果似乎有所不同。

为了省去其他人的麻烦，我将在这里列出它们，并表明它们在我的 PC (XP Pro SP2) 上成功找到 com0com 端口：

1. CreateFile("COM" + 1 ->255) 根据 Wael Dalloul 的建议
   ✔ 找到 com0com 端口，花费了 234 毫秒。

2. QueryDosDevice()
   ✔ 找到 com0com 端口，花费了 0 毫秒。

3. GetDefaultCommConfig("COM" + 1->255)
   ✔ 找到 com0com 端口，耗时 235 毫秒。

4. “SetupAPI1”使用对 SETUPAPI.DLL 的调用
   ✔ 找到 com0com 端口，还报告“友好名称”，花费了 15 毫秒。

5. “SetupAPI2”使用对 SETUPAPI.DLL 的调用
   ✘ 未找到 com0com 端口，报告“友好名称”，耗时 32 毫秒。

6. EnumPorts()
   ✘ 报告一些非COM端口，没有找到com0com端口，花了15ms。

7. 使用 WMI 调用
   ✔ 找到 com0com 端口，还报告“友好名称”，花费了 47 毫秒。

8. 使用 MSPORTS.DLL 调用的 COM 数据库
   ✔/✘ 报告了一些非 COM 端口，找到了 com0com 端口，花费了 16 毫秒。

9. 迭代注册表项 HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\SERIALCOMM
   ✔ 找到 com0com 端口，花费了 0 毫秒。这显然是 SysInternals PortMon 使用的。

基于这些结果，我认为 WMI 方法可能最适合我的要求，因为它相对较快，而且它还提供了友好的名称（例如“通信端口 (COM1)”、“com0com - 串行端口模拟器”）。

Answer 2

看来这不是一个简单的任务。

看看这个：EnumSerialPorts v1.20

Answer 3

例如，您可以从 1 到 50 进行循环，并尝试打开每个端口。如果端口可用，则打开即可。如果端口正在使用中，您将收到共享错误。如果未安装该端口，您将收到文件未找到错误。

使用CreateFile API 打开端口：

HANDLE Port = CreateFile(
                  "\\\\.\\COM1",
                  GENERIC_READ | GENERIC_WRITE,
                  0,
                  NULL,
                  OPEN_EXISTING,
                  FILE_ATTRIBUTE_NORMAL,
                  NULL);

然后检查结果。

Answer 4

现在可在 Windows 中使用，GetCommPorts 可以直接返回通讯端口列表

获取包含格式正确的 COM 端口的数组。

该函数获取COM端口号
HKLM\Hardware\DeviceMap\SERIALCOMM 注册表项，然后写入它们
到调用者提供的数组。如果数组太小，函数
获得必要的尺寸。

您需要添加此代码才能正确链接该函数

#pragma comment (lib, "OneCore.lib")

Answer 5

就我而言，我需要全名和 COM 端口地址。我有物理串口、USB串口和com0com虚拟串口。

正如已接受的答案所示，我使用 WMI 调用。 SELECT * FROM Win32_PnPEntity 查找所有设备。它返回这样的物理设备，并且可以从 Caption 解析地址：

Serial Port for Barcode Scanner (COM13)

但是，对于 com0com 端口 Caption 如下（无地址）：

com0com - serial port emulator

SELECT * FROM Win32_SerialPort 返回地址 (DeviceID) 以及全名 (Name)。但是，它只找到物理串行端口和com0com端口，而不是USB串行端口。

所以最后，我需要两个 WMI 调用：SELECT * FROM Win32_SerialPort（地址为 DeviceID）和 SELECT * FROM Win32_PnPEntity WHERE Name LIKE '%(COM% ' （地址可以从 Caption 解析）。我已经缩小了 Win32_PnPEntity 调用的范围，因为它只需要查找第一次未找到的设备。 此 C++代码

可用于查找所有串行端口：

// Return list of serial ports as (number, name)
std::map<int, std::wstring> enumerateSerialPorts()
{
    std::map<int, std::wstring> result;

    HRESULT hres;

    hres = CoInitializeEx(0, COINIT_APARTMENTTHREADED);
    if (SUCCEEDED(hres) || hres == RPC_E_CHANGED_MODE) {
        hres =  CoInitializeSecurity(
            NULL,
            -1,                          // COM authentication
            NULL,                        // Authentication services
            NULL,                        // Reserved
            RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
            RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation
            NULL,                        // Authentication info
            EOAC_NONE,                   // Additional capabilities
            NULL                         // Reserved
            );

        if (SUCCEEDED(hres) || hres == RPC_E_TOO_LATE) {
            IWbemLocator *pLoc = NULL;

            hres = CoCreateInstance(
                CLSID_WbemLocator,
                0,
                CLSCTX_INPROC_SERVER,
                IID_IWbemLocator, (LPVOID *) &pLoc);

            if (SUCCEEDED(hres)) {
                IWbemServices *pSvc = NULL;

                // Connect to the root\cimv2 namespace with
                // the current user and obtain pointer pSvc
                // to make IWbemServices calls.
                hres = pLoc->ConnectServer(
                     bstr_t(L"ROOT\\CIMV2"),  // Object path of WMI namespace
                     NULL,                    // User name. NULL = current user
                     NULL,                    // User password. NULL = current
                     0,                       // Locale. NULL indicates current
                     NULL,                    // Security flags.
                     0,                       // Authority (for example, Kerberos)
                     0,                       // Context object
                     &pSvc                    // pointer to IWbemServices proxy
                     );
                if (SUCCEEDED(hres)) {
                    hres = CoSetProxyBlanket(
                       pSvc,                        // Indicates the proxy to set
                       RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
                       RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
                       NULL,                        // Server principal name
                       RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
                       RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
                       NULL,                        // client identity
                       EOAC_NONE                    // proxy capabilities
                    );
                    if (SUCCEEDED(hres)) {
                        // Use Win32_PnPEntity to find actual serial ports and USB-SerialPort devices
                        // This is done first, because it also finds some com0com devices, but names are worse
                        IEnumWbemClassObject* pEnumerator = NULL;
                        hres = pSvc->ExecQuery(
                            bstr_t(L"WQL"),
                            bstr_t(L"SELECT Name FROM Win32_PnPEntity WHERE Name LIKE '%(COM%'"),
                            WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
                            NULL,
                            &pEnumerator);

                        if (SUCCEEDED(hres)) {
                            constexpr size_t max_ports = 30;
                            IWbemClassObject *pclsObj[max_ports] = {};
                            ULONG uReturn = 0;

                            do {
                                hres = pEnumerator->Next(WBEM_INFINITE, max_ports, pclsObj, &uReturn);
                                if (SUCCEEDED(hres)) {
                                    for (ULONG jj = 0; jj < uReturn; jj++) {
                                        VARIANT vtProp;
                                        pclsObj[jj]->Get(L"Name", 0, &vtProp, 0, 0);

                                        // Name should be for example "Serial Port for Barcode Scanner (COM13)"
                                        const std::wstring deviceName = vtProp.bstrVal;
                                        const std::wstring prefix = L"(COM";
                                        size_t ind = deviceName.find(prefix);
                                        if (ind != std::wstring::npos) {
                                            std::wstring nbr;
                                            for (size_t i = ind + prefix.length();
                                                i < deviceName.length() && isdigit(deviceName[i]); i++)
                                            {
                                                nbr += deviceName[i];
                                            }
                                            try {
                                                const int portNumber = boost::lexical_cast<int>(nbr);
                                                result[portNumber] = deviceName;
                                            }
                                            catch (...) {}
                                        }
                                        VariantClear(&vtProp);

                                        pclsObj[jj]->Release();
                                    }
                                }
                            } while (hres == WBEM_S_NO_ERROR);
                            pEnumerator->Release();
                        }

                        // Use Win32_SerialPort to find physical ports and com0com virtual ports
                        // This is more reliable, because address doesn't have to be parsed from the name
                        pEnumerator = NULL;
                        hres = pSvc->ExecQuery(
                            bstr_t(L"WQL"),
                            bstr_t(L"SELECT DeviceID, Name FROM Win32_SerialPort"),
                            WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
                            NULL,
                            &pEnumerator);

                        if (SUCCEEDED(hres)) {
                            constexpr size_t max_ports = 30;
                            IWbemClassObject *pclsObj[max_ports] = {};
                            ULONG uReturn = 0;

                            do {
                                hres = pEnumerator->Next(WBEM_INFINITE, max_ports, pclsObj, &uReturn);
                                if (SUCCEEDED(hres)) {
                                    for (ULONG jj = 0; jj < uReturn; jj++) {
                                        VARIANT vtProp1, vtProp2;
                                        pclsObj[jj]->Get(L"DeviceID", 0, &vtProp1, 0, 0);
                                        pclsObj[jj]->Get(L"Name", 0, &vtProp2, 0, 0);

                                        const std::wstring deviceID = vtProp1.bstrVal;
                                        if (deviceID.substr(0, 3) == L"COM") {
                                            const int portNumber = boost::lexical_cast<int>(deviceID.substr(3));
                                            const std::wstring deviceName = vtProp2.bstrVal;
                                            result[portNumber] = deviceName;
                                        }
                                        VariantClear(&vtProp1);
                                        VariantClear(&vtProp2);

                                        pclsObj[jj]->Release();
                                    }
                                }
                            } while (hres == WBEM_S_NO_ERROR);
                            pEnumerator->Release();
                        }
                    }
                    pSvc->Release();
                }
                pLoc->Release();
            }
        }
        CoUninitialize();
    }
    if (FAILED(hres)) {
        std::stringstream ss;
        ss << "Enumerating serial ports failed. Error code: " << int(hres);
        throw std::runtime_error(ss.str());
    }

    return result;
}

Answer 6

我将 PJ Naughter 的 EnumSerialPorts 重新组织为更便携和个性化的形式，这更有用。

为了更好的兼容性，我使用 C，而不是 C++。

如果您需要或感兴趣，请访问我的博客中的帖子。