SerialPorts 和 WaitForMultipleObjects

Question

我在跨平台应用程序（具有 Linux 嵌入式和实际嵌入式目标）中的串行端口方面遇到了一些问题，该应用程序也适用于 Windows 以使开发更容易。这是关于 Windows 实现的。

因此，串行协议的实现是针对操作系统和非操作系统系统的混合体，我不会触及实现本身。我想让它与现有的实现兼容。如果在合理的时间内失败了，我将创建一个单独的线程进行串行读取。

好的，基本上实现是打开串口，在我们的 IO 系统中注册文件描述符（在 Linux 上使用 epoll，在 Windows 上使用 WaitForMultipleObjects）然后，基本上，只是等待所有句柄并执行任何需要的操作.因此，当句柄发出读取信号时，我们希望从串行端口读取。不幸的是，在 Windows 上，您无法指定是等待读取还是写入，所以我想我会使用以下解决方案：

• CreateFile 和 FILE_FLAG_OVERLAPPED
• SetCommMask 和 EV_RXCHAR
• 使用手动重置事件创建 OVERLAPPED 结构
• 使用上述OVERLAPPED结构调用WaitCommEvent，通常返回ERROR_IO_PENDING

这是基本设置。我注册了事件句柄而不是文件句柄来等待。当手柄发出信号时，我执行以下操作：

• ReadFile
• 如果成功，ResetEvent 并再次调用WaitCommEvent

然而，如果你指定FILE_FLAG_OVERLAPPED，你必须使用重叠的IO来读写。所以我想只要ReadFile或WriteFile返回ERROR_IO_PENDING，我就等着WaitForSingleObject和GetOverlappedResult的IO。不过，我似乎并没有参与其中。它似乎基本上可以工作，但有时它会在 ResetEvent 调用之一时崩溃，好像重叠仍然处于活动状态（尽管我猜它仍然不应该崩溃）。

所以，实际的问题。这可以按我的意愿完成吗？总的来说，这种方法是否存在问题，或者它应该有效吗？还是使用另一个线程是唯一好的解决方案？通信已经在一个单独的线程中，因此至少需要三个线程。

---

我会尽量发布所需的代码，尽管它与实际代码相比有所减少，其中包含许多与串行读取没有直接关系的内容。

SerialPort::SerialPort(const std::string &filename)
{
    fd = INVALID_HANDLE_VALUE;
    m_ov = new OVERLAPPED(); // Pointer because header shouldn't include Windows.h.
    memset(m_ov, 0, sizeof(OVERLAPPED));
    m_waitHandle = m_ov->hEvent = CreateEvent(0, true, 0, 0);
}

SerialPort::~SerialPort(void)
{
    Close();
    CloseHandle(m_ov->hEvent);
    delete m_ov;
}

构造函数在单独的线程中调用，稍后调用Open：

bool SerialPort::Open(void)
{
    if (fd != INVALID_HANDLE_VALUE)
        return true;
    fd = CreateFile(filename.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
    if (fd != INVALID_HANDLE_VALUE) {
        DCB dcb;
        ZeroMemory(&dcb, sizeof(DCB));

        COMMTIMEOUTS timeouts = {0};
        timeouts.ReadIntervalTimeout = TimeOut();
        timeouts.ReadTotalTimeoutConstant = TimeOut();
        timeouts.ReadTotalTimeoutMultiplier = TimeOut() / 5;
        if (timeouts.ReadTotalTimeoutMultiplier == 0) {
            timeouts.ReadTotalTimeoutMultiplier = 1;
        }

        if (!SetCommTimeouts(fd, &timeouts)) {
            DebugBreak();
        }
        SetCommMask(fd, EV_RXCHAR);
        InitWait();

        return true;
    }
    return false;
}

void SerialPort::InitWait()
{
    if (WaitForSingleObject(m_ov->hEvent, 0) == WAIT_OBJECT_0) {
        return; // Still signaled
    }         
    DWORD dwEventMask;
    if (!WaitCommEvent(fd, &dwEventMask, m_ov)) {
        // For testing, I have some prints here for the different cases.
    }
}

通过一个相当长的链，线程然后在 m_waitHandle 上调用WaitForMultipleObjects，这与OVERLAPPED 结构的hEvent 成员相同。这是在一个循环中完成的，并且列表中还有其他几个句柄，这就是为什么这与您有一个线程专门从串行端口读取的典型解决方案不同的原因。我基本上无法控制循环，这就是为什么我尝试在正确的时间执行WaitCommEvent（在InitWait 内）。

当句柄发出信号时，线程调用ReadData方法：

int SerialPort::ReadData(void *buffer, int size)
{
    if (fd != INVALID_HANDLE_VALUE) {
        // Timeouts are reset here to MAXDWORD/0/0, not sure if necessary.
        DWORD dwBytesRead;
        OVERLAPPED ovRead = {0};
        ovRead.hEvent = CreateEvent(0, true, 0, 0);
        if (ReadFile(fd, buffer, size, &dwBytesRead, &ovRead)) {
            if (WaitForSingleObject(m_ov->hEvent, 0) == WAIT_OBJECT_0) {
                // Only reset if signaled, because we might get here because of a timer.
                ResetEvent(m_waitHandle);
                InitWait();
            }
            CloseHandle(ovRead.hEvent);
            return dwBytesRead;
        } else {
            if (GetLastError() == ERROR_IO_PENDING) {
                WaitForSingleObject(ovRead.hEvent, INFINITE);
                GetOverlappedResult(fd, &ovRead, &dwBytesRead, true);
                InitWait();
                CloseHandle(ovRead.hEvent);
                return dwBytesRead;
            }
        }
        InitWait();
        CloseHandle(ovRead.hEvent);
        return -1;
    } else {
        return 0;
    }
}

写入如下，不同步：

int SerialPort::WriteData(const void *buffer, int size)
{
    if (fd != INVALID_HANDLE_VALUE) {
        DWORD dwBytesWritten;
        OVERLAPPED ovWrite = {0};
        ovWrite.hEvent = CreateEvent(0, true, 0, 0);
        if (!WriteFile(fd, buffer, size, &dwBytesWritten, &ovWrite)) {
            if (GetLastError() == ERROR_IO_PENDING) {
                WaitForSingleObject(ovWrite.hEvent, INFINITE);
                GetOverlappedResult(fd, &ovWrite, &dwBytesWritten, true);
                CloseHandle(ovWrite.hEvent);
                return dwBytesWritten;
            } else {
                CloseHandle(ovWrite.hEvent);
                return -1;
            }
        }
        CloseHandle(ovWrite.hEvent);
    }
    return 0;
}

现在好像可以了。再也没有崩溃了，至少我无法重现它们。所以它现在有效，我只是在问我做的事情是否理智，或者我是否应该做不同的事情。

Answer 1

顺便说一句，我在您显示的代码中没有看到任何错误，但我想建议替代代码来清理您在 ReadData() 和 WriteData() 中的错误处理：

int SerialPort::ReadData(void *buffer, int size)
{
    if (fd == INVALID_HANDLE_VALUE)
        return 0;

    OVERLAPPED ovRead = {0};
    ovRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (!ovRead.hEvent)
        return -1;

    DWORD dwBytesRead;
    if (!ReadFile(fd, buffer, size, &dwBytesRead, &ovRead))
    {
        if (GetLastError() != ERROR_IO_PENDING)
        {
            CloseHandle(ovRead.hEvent);
            return -1;
        }

        if (!GetOverlappedResult(fd, &ovRead, &dwBytesRead, TRUE))
        {
            CloseHandle(ovRead.hEvent);
            return -1;
        }
    }

    if (WaitForSingleObject(m_waitHandle, 0) == WAIT_OBJECT_0)
    {
        ResetEvent(m_waitHandle);
        InitWait();
    }

    CloseHandle(ovRead.hEvent);
    return dwBytesRead;
}

int SerialPort::WriteData(const void *buffer, int size)
{
    if (fd == INVALID_HANDLE_VALUE)
        return 0;

    OVERLAPPED ovWrite = {0};
    ovWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (!ovWrite.hEvent)
        return -1;

    DWORD dwBytesWritten;
    if (!WriteFile(fd, buffer, size, &dwBytesWritten, &ovWrite))
    {
        if (GetLastError() != ERROR_IO_PENDING)
        {
            CloseHandle(ovWrite.hEvent);
            return -1;
        }

        if (!GetOverlappedResult(fd, &ovWrite, &dwBytesWritten, TRUE))
        {
            CloseHandle(ovWrite.hEvent);
            return -1;
        }
    }

    CloseHandle(ovWrite.hEvent);
    return dwBytesWritten;
}