🚀 go-pugleaf

I have a clearer picture of the problem now. Access to the HANDLE is
protected by a semiphore, so if one function (like WaitCommEvent) blocks
while using it, other functions that are passed the HANDLE will also block,
just as you have experienced. You have several options, however.

1. Open two handles to the same port. Open one handle with GENERIC_WRITE and
FILE_SHARE_READ. Open the second with GENERIC_READ. Use the GENERIC_READ
handle for reading and the GENERIC_WRITE handle for writing. If one blocks,
the other is still accessable.

2. Forget using WaitCommEvent. Instead, use ReadFile with the timeout
interval set low or zero. Example:

std::string GetStringFromPort()
{
    COMMTIMEOUTS cOld, cNew;
    GetCommTimeouts(hPort, &cOld);
    cNew = cOld;
    cNew.ReadIntervalTimeout = MAXDWORD;
    cNew.ReadTotalTimeoutConstant = 0;
    cNew.ReadTotalTimeoutMultiplier = 0;
    SetCommTimeouts(hPort, &cNew);
    std::string chars;
    DWORD read;
    do {
        char ch;
        ReadFile(hPort, &ch, 1, &read, NULL);
        if(ch == '\0')
            read = 0;
        else
            chars.push_back(ch);
    } while(read > 0);
    SetCommTimeouts(hPort, &cOld);
    return chars;
}

This function reads characters from the buffer and stores them in a
std::string. It is done when it encounters a Nul or there are no more chars
in the buffer. Because the timeouts are set to zero, ReadFile will never
block. However, you should probably use a short timeout interval so that
characters that have not reached the input buffer yet will be read.