🚀 go-pugleaf

I have a problem scanning COM ports for a certain device:

Actually, the task seems easy: Open each COM port, send an
identification request, and close the respective connection when either
an invalid response or no response at allis being received.

This works well with serial COM ports and virtual serial COM ports
created by USB<->RS232 adapters. Unfortunately, this is extremely slow
for virtual serial COM ports created by Bluetooth dongles!

The problem resides in the GetOverlappedResult(...) function which waits
almost three seconds, although I have set the Write Timeout to only 60 ms!

Do you know a way to optimize the following write function so that it
doesn't hang up for such a long time?`


int __fastcall ThreadComm::Write(char Buf[], DWORD Count)
{
    BOOL        fWriteStat ;
    DWORD       dwBytesWritten ;
    DWORD       dwErrorFlags;
    DWORD       dwError;
    DWORD       dwBytesSent=0;
    COMSTAT     ComStat;

    const MaxRetries = 9;
    int Tries = 0;

    if (!Enabled()) return -1;
    Lock();
    try
    {
      fWriteStat = WriteFile(FHandle, Buf, Count,
                             &dwBytesWritten, &WRITE_OS ) ;
      if (!fWriteStat)
      {
        if(GetLastError() == ERROR_IO_PENDING)
        {
          Tries = 0;
          while(!GetOverlappedResult(FHandle,&WRITE_OS, &dwBytesWritten,
TRUE ))
          {
             dwError = GetLastError();
             if(dwError == ERROR_IO_INCOMPLETE)
             {
                if (dwBytesWritten == 0) {
                  Tries++;
                  if (Tries == MaxRetries)
                    LogLine(ALog, "Low-level Write to port failed.
Giving up ("+IntToStr(MaxRetries)+")");
                } else {
                  if (Tries > 0)
                    LogLine(ALog, "Low-level Write to port failed
"+IntToStr(Tries)+" times");
                  Tries = 0;
                }
                dwBytesSent += dwBytesWritten;

                if (Tries == MaxRetries) {  // Error - Device in use,
e.g. by ActiveSync ??
                  Unlock();
                  return 0;
                }
                continue;
             }
             else
             {
                ClearCommError(FHandle, &dwErrorFlags, &ComStat ) ;
                break;
             }
          }
          dwBytesSent += dwBytesWritten;
        }
        else
        {
          ClearCommError(FHandle, &dwErrorFlags, &ComStat ) ;
        }
     }
     else dwBytesSent += dwBytesWritten;
   }
   catch(...) { Unlock(); }
   Unlock();
   return dwBytesSent ;
}