糟糕的串口/ USB代码(C++) -修复建议？

Question

我对串行I/O没有太多的经验，但是最近我承担了修复一些缺陷很大的串行代码的任务，因为原来的程序员已经离开了公司。

该应用程序是一个Windows程序，通过运行在USB上的虚拟通信端口与科学仪器进行串行通信。虚拟通讯端口USB驱动程序是由FTDI提供的，因为它们制造了我们在仪器上使用的USB芯片。

串行代码位于非托管C++动态链接库中，由我们的旧C++软件和新的C# / .Net (WinForms)软件共享。

有两个主要问题：

在许多XP系统上失败

当第一个命令被发送到仪器时，没有响应。当您发出下一个命令时，您将从第一个命令获得响应。

下面是一个典型的使用场景(调用的方法的完整源代码包括在下面)：

char szBuf [256];   

CloseConnection ();

if (OpenConnection ())
{   
    ClearBuffer ();

    // try to get a firmware version number
    WriteChar ((char) 'V');
    BOOL versionReadStatus1 = ReadString (szBuf, 100);
        ...
    }

在失败的系统上，ReadString调用将永远不会接收任何串行数据，并且超时。但是，如果我们发出另一个不同的命令，并再次调用ReadString，它将返回来自第一个命令的响应，而不是新的响应！

但这种情况只发生在Windows XP系统的很大一部分上--而在Windows 7上却从未发生过。幸运的是，我们的XP dev机器正常工作，所以直到我们开始测试时才发现问题所在。但是我也可以通过在我的XP机器上运行一个XP VM (VirtualBox)来重现这个问题。此外，这个问题只有在使用新的C#版本的DLL时才会出现--对旧的C++应用程序来说很好。

在调用BytesInQue之前，我在低级别的ClearCommError方法中添加了一个睡眠(21)，这似乎解决了这个问题，但这又加剧了另一个问题-- CPU的使用。睡眠不足21 ms将使故障模式再次出现。

高CPU使用率

在做串行I/O CPU时，CPU的使用率过高--通常超过90%。新的C#应用程序和旧的C++应用程序都会出现这种情况，但在新应用程序中则要糟糕得多。通常情况下，UI非常没有响应性，但并不总是如此。

这是我们Port.cpp类的代码，这是可怕的荣耀。很抱歉这么长，但这是我的工作。最重要的方法可能是OpenConnection、ReadString、ReadChar和BytesInQue.。

// 
// Port.cpp: Implements the CPort class, which is 
//               the class that controls the serial port. 
// 
// Copyright (C) 1997-1998 Microsoft Corporation 
// All rights reserved. 
// 
// This source code is only intended as a supplement to the 
// Broadcast Architecture Programmer's Reference. 
// For detailed information regarding Broadcast 
// Architecture, see the reference. 
// 
#include <windows.h> 
#include <stdio.h> 
#include <assert.h> 
#include "port.h" 

// Construction code to initialize the port handle to null. 
CPort::CPort() 
{ 
    m_hDevice = (HANDLE)0;

    // default parameters
    m_uPort = 1;
    m_uBaud = 9600;
    m_uDataBits = 8;
    m_uParity = 0;
    m_uStopBits = 0; // = 1 stop bit 
    m_chTerminator = '\n';
    m_bCommportOpen = FALSE;
    m_nTimeOut = 50;
    m_nBlockSizeMax = 2048;

} 

// Destruction code to close the connection if the port  
// handle was valid. 
CPort::~CPort() 
{ 
    if (m_hDevice) 
     CloseConnection(); 
} 

// Open a serial communication port for writing short  
// one-byte commands, that is, overlapped data transfer  
// is not necessary. 
BOOL CPort::OpenConnection() 
{ 
    char szPort[64]; 

    m_bCommportOpen = FALSE;

    // Build the COM port string as "COMx" where x is the port. 
    if (m_uPort > 9)
        wsprintf(szPort, "\\\\.\\COM%d", m_uPort); 
    else
        wsprintf(szPort, "COM%d", m_uPort); 

    // Open the serial port device. 
    m_hDevice = CreateFile(szPort, 
                            GENERIC_WRITE | GENERIC_READ, 
                            0, 
                            NULL,          // No security attributes 
                            OPEN_EXISTING, 
                            FILE_ATTRIBUTE_NORMAL,
                            NULL); 

    if (m_hDevice == INVALID_HANDLE_VALUE)
    { 
         SaveLastError ();
         m_hDevice = (HANDLE)0; 
         return FALSE; 
    } 

    return SetupConnection(); // After the port is open, set it up. 
} // end of OpenConnection() 


// Configure the serial port with the given settings. 
// The given settings enable the port to communicate 
// with the remote control. 
BOOL CPort::SetupConnection(void) 
{ 
    DCB dcb;  // The DCB structure differs betwwen Win16 and Win32. 

    dcb.DCBlength = sizeof(DCB); 

    // Retrieve the DCB of the serial port. 
    BOOL bStatus = GetCommState(m_hDevice, (LPDCB)&dcb); 

    if (bStatus == 0)
    {   
         SaveLastError ();

         return FALSE;
    }


    // Assign the values that enable the port to communicate. 
    dcb.BaudRate          = m_uBaud;       // Baud rate 
    dcb.ByteSize          = m_uDataBits;   // Data bits per byte, 4-8 
    dcb.Parity            = m_uParity;     // Parity: 0-4 = no, odd, even, mark, space 
    dcb.StopBits          = m_uStopBits;   // 0,1,2 = 1, 1.5, 2 


    dcb.fBinary           = TRUE;        // Binary mode, no EOF check : Must use binary mode in NT 
    dcb.fParity           = dcb.Parity == 0 ? FALSE : TRUE;       // Enable parity checking 
    dcb.fOutX             = FALSE;       // XON/XOFF flow control used 
    dcb.fInX              = FALSE;       // XON/XOFF flow control used 
    dcb.fNull             = FALSE;       // Disable null stripping - want nulls 
    dcb.fOutxCtsFlow      = FALSE; 
    dcb.fOutxDsrFlow      = FALSE; 
    dcb.fDsrSensitivity = FALSE; 
    dcb.fDtrControl = DTR_CONTROL_ENABLE; 
    dcb.fRtsControl =  RTS_CONTROL_DISABLE ; 

    // Configure the serial port with the assigned settings. 
    // Return TRUE if the SetCommState call was not equal to zero.
    bStatus = SetCommState(m_hDevice, &dcb);

    if (bStatus == 0)
    {       
         SaveLastError ();
         return FALSE;   
    }

    DWORD dwSize;
    COMMPROP *commprop;
    DWORD dwError;

    dwSize = sizeof(COMMPROP) + sizeof(MODEMDEVCAPS) ;
    commprop = (COMMPROP *)malloc(dwSize);
    memset(commprop, 0, dwSize);

    if (!GetCommProperties(m_hDevice, commprop))
    {
        dwError = GetLastError();
    } 

    m_bCommportOpen = TRUE;

    return TRUE; 
} 


void CPort::SaveLastError ()
{
    DWORD dwLastError = GetLastError ();

    LPVOID lpMsgBuf;

    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                  FORMAT_MESSAGE_FROM_SYSTEM | 
                  FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL,
                  dwLastError,
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                  (LPTSTR) &lpMsgBuf,
                  0,
                  NULL);

    strcpy (m_szLastError,(LPTSTR)lpMsgBuf);
    // Free the buffer.
    LocalFree( lpMsgBuf );

}

void CPort::SetTimeOut (int nTimeOut)
{
    m_nTimeOut = nTimeOut;

}


// Close the opened serial communication port. 

void CPort::CloseConnection(void)
{ 
   if (m_hDevice != NULL &&
       m_hDevice != INVALID_HANDLE_VALUE)
   {
        FlushFileBuffers(m_hDevice);
        CloseHandle(m_hDevice);  ///that the port has been closed. 
   }
   m_hDevice = (HANDLE)0; 

   // Set the device handle to NULL to confirm
   m_bCommportOpen = FALSE;
} 

int CPort::WriteChars(char * psz)
{ 
    int nCharWritten = 0;

    while (*psz)
    {
     nCharWritten +=WriteChar(*psz);
     psz++;
    }

    return nCharWritten;
}

// Write a one-byte value (char) to the serial port. 
int CPort::WriteChar(char c) 
{ 
    DWORD dwBytesInOutQue = BytesInOutQue ();

    if (dwBytesInOutQue > m_dwLargestBytesInOutQue)
        m_dwLargestBytesInOutQue = dwBytesInOutQue;

    static char szBuf[2]; 

    szBuf[0] = c; 
    szBuf[1] = '\0'; 


    DWORD dwBytesWritten; 

    DWORD dwTimeOut = m_nTimeOut; // 500 milli seconds

    DWORD start, now;

    start = GetTickCount();

    do
    {
         now = GetTickCount();
         if ((now - start) > dwTimeOut )
         {
              strcpy (m_szLastError, "Timed Out");

              return 0;
         }

         WriteFile(m_hDevice, szBuf, 1, &dwBytesWritten, NULL); 
    }
    while (dwBytesWritten == 0);

    OutputDebugString(TEXT(strcat(szBuf, "\r\n")));

    return dwBytesWritten; 
}

int CPort::WriteChars(char * psz, int n)
{ 

    DWORD dwBytesWritten; 

    WriteFile(m_hDevice, psz, n, &dwBytesWritten, NULL); 

    return dwBytesWritten; 
}

// Return number of bytes in RX queue
DWORD CPort::BytesInQue ()
{
    COMSTAT    ComStat ; 
    DWORD      dwErrorFlags; 
    DWORD      dwLength; 

    // check number of bytes in queue 
    ClearCommError(m_hDevice, &dwErrorFlags, &ComStat ) ; 

    dwLength = ComStat.cbInQue; 


    return dwLength;

}

DWORD CPort::BytesInOutQue ()
{
    COMSTAT    ComStat ; 
    DWORD      dwErrorFlags; 
    DWORD      dwLength; 

    // check number of bytes in queue 
    ClearCommError(m_hDevice, &dwErrorFlags, &ComStat ); 

    dwLength = ComStat.cbOutQue ; 

    return dwLength;

}


int CPort::ReadChars (char* szBuf, int nMaxChars)
{
    if (BytesInQue () == 0)
        return 0;

    DWORD dwBytesRead; 

    ReadFile(m_hDevice, szBuf, nMaxChars, &dwBytesRead, NULL); 

    return (dwBytesRead); 
}


// Read a one-byte value (char) from the serial port. 
int CPort::ReadChar (char& c)
{
    static char szBuf[2]; 

    szBuf[0] = '\0'; 
    szBuf[1] = '\0'; 

    if (BytesInQue () == 0)
        return 0;

    DWORD dwBytesRead; 

    ReadFile(m_hDevice, szBuf, 1, &dwBytesRead, NULL); 

    c = *szBuf; 

    if (dwBytesRead == 0)
        return 0;

    return dwBytesRead; 
}


BOOL CPort::ReadString (char *szStrBuf , int nMaxLength)
{
    char str [256];
    char str2 [256];

    DWORD dwTimeOut = m_nTimeOut; 

    DWORD start, now;

    int nBytesRead;
    int nTotalBytesRead = 0;

    char c = ' ';

    static char szCharBuf [2];

    szCharBuf [0]= '\0';
    szCharBuf [1]= '\0';

    szStrBuf [0] = '\0';

    start = GetTickCount();

    while (c != m_chTerminator)
    {        
         nBytesRead = ReadChar (c);
         nTotalBytesRead += nBytesRead;

         if (nBytesRead == 1 && c != '\r' && c != '\n')
         {             
              *szCharBuf = c;

              strncat (szStrBuf,szCharBuf,1);

              if (strlen (szStrBuf) == nMaxLength)
                    return TRUE;

              // restart timer for next char
              start = GetTickCount();
         }

         // check for time out
         now = GetTickCount();
         if ((now - start) > dwTimeOut )
         {
              strcpy (m_szLastError, "Timed Out");

              return FALSE;
         }
    } 

    return TRUE;
}         


int CPort::WaitForQueToFill (int nBytesToWaitFor)
{
    DWORD start = GetTickCount();

    do 
    {
         if (BytesInQue () >= nBytesToWaitFor)
            break;

         if (GetTickCount() - start > m_nTimeOut)
            return 0;

    } while (1);

    return BytesInQue ();
}

int CPort::BlockRead (char * pcInputBuffer, int nBytesToRead)
{
    int nBytesRead = 0;
    int charactersRead;

    while (nBytesToRead >= m_nBlockSizeMax)
    {
        if (WaitForQueToFill (m_nBlockSizeMax) < m_nBlockSizeMax)
            return nBytesRead;

        charactersRead = ReadChars (pcInputBuffer, m_nBlockSizeMax);
        pcInputBuffer += charactersRead;
        nBytesRead += charactersRead;
        nBytesToRead -= charactersRead;
    }

    if (nBytesToRead > 0)
    {
        if (WaitForQueToFill (nBytesToRead) < nBytesToRead)
            return nBytesRead;

        charactersRead = ReadChars (pcInputBuffer, nBytesToRead);
        nBytesRead += charactersRead;
        nBytesToRead -= charactersRead;

    }

    return nBytesRead;
}

根据我的测试和阅读，我在代码中看到了一些可疑的东西：

1. COMMTIMEOUTS从来没有设定过。docs女士说，“如果你不能设置超时值，就会出现不可预测的结果”。但是我试着设置它，但它没有帮助。
2. --许多方法(例如ReadString) --将进入一个紧密的循环，如果它们不能立即获得数据，就会反复读取端口。这似乎解释了高CPU使用率的原因。
3. 很多方法都有自己的超时处理，使用GetTickCount()。这不是COMMTIMEOUTS的目的吗?在新的

(WinForms)程序中，所有这些串行例程都是直接从主线程，从MultiMediaTimer事件调用的。也许应该在不同的thread?

1. BytesInQue方法中运行似乎是一个瓶颈。当CPU使用率很高时，如果我中断调试器，程序通常会停止。此外，在调用problem.
2. Code之前向该方法添加一个睡眠(21)似乎解决了XP问题，但加剧了CPU的使用-- complicated.

只是不必要的

我的问题

1. 能解释为什么这只适用于少量XP系统上的C#程序吗？
2. 有关于如何重写这个程序的建议吗？非常欢迎指向好的示例代码的指针。

Answer 1

这个类有一些严重的问题，更糟糕的是它有微软的版权。

这门课没有什么特别之处。这让我想知道为什么它甚至存在，除了作为一个适配器，而不是创建/读/写文件。如果在SerialPort框架中使用.NET类，甚至不需要这个类。

CPU的使用是因为在等待设备有足够的可用数据时，代码会进入无限循环。如果您必须坚持使用while(1);和Win32，可以查看完成端口，并在调用CreateFile时设置重叠标志。这样，您可以在单独的工作线程中等待数据。

在与多个COM端口通信时，您需要小心。我已经很久没有做C++了，但是我相信读和写方法中的静态缓冲区szBuff对于该类的所有实例都是静态的。这意味着，如果您“同时”对两个不同的COM端口调用Read，您将得到意想不到的结果。

至于某些XP机器上的问题，如果您在每次读取/写入并记录结果之后检查GetLastError，您肯定会发现这个问题。无论如何，它应该检查GetLastError，因为它有时并不总是一个“错误”，而是子系统为获得所需结果而请求做其他事情的请求。

如果您正确地设置了COMMTIMEOUTS，就可以去掉整个while循环来阻塞。如果Read操作有特定的超时，请在执行读取之前使用SetCommTimeouts。

我将ReadIntervalTimeout设置为最大超时，以确保读取不会比m_nTimeOut更快地返回。如果任何两个字节之间的时间间隔，此值将导致Read返回。如果它被设置为2毫秒，第一个字节在t，第二个字节在t+1，第三个字节在t+4，那么ReadFile只返回前两个字节，因为字节之间的间隔超过了。ReadTotalTimeoutConstant确保无论发生什么事情，您都不会比m_nTimeOut等得更久。

maxWait = BytesToRead * ReadTotalTimeoutMultiplier + ReadTotalTimeoutConstant。因此，(BytesToRead * 0) + m_nTimeout = m_nTimeout

BOOL CPort::SetupConnection(void) 
{
      // Snip...
      COMMTIMEOUTS comTimeOut;                   
      comTimeOut.ReadIntervalTimeout = m_nTimeOut; // Ensure's we wait the max timeout
      comTimeOut.ReadTotalTimeoutMultiplier = 0;
      comTimeOut.ReadTotalTimeoutConstant = m_nTimeOut;
      comTimeOut.WriteTotalTimeoutMultiplier = 0;
      comTimeOut.WriteTotalTimeoutConstant = m_nTimeOut;
      SetCommTimeouts(m_hDevice,&comTimeOut);
}

// If return value != nBytesToRead check check GetLastError()
// Most likely Read timed out.
int CPort::BlockRead (char * pcInputBuffer, int nBytesToRead)
{
      DWORD dwBytesRead; 
      if (FALSE == ReadFile(
             m_hDevice, 
             pcInputBuffer, 
             nBytesToRead, 
             &dwBytesRead, 
             NULL))
      {
           // Check GetLastError
           return dwBytesRead;
      }
      return dwBytesRead;
}

我不知道这是否完全正确，但它应该给你一个想法。删除ReadChar和ReadString方法，并在程序依赖于同步的情况下使用它。也要小心设置高暂停时间。通信速度很快，以毫秒为单位。

Answer 2

这是我几年前写的一个终端程序(可能至少15年前，现在我想到了)。我刚刚做了一个快速检查，在Windows7 x64下，它似乎仍然工作得相当好-连接到我的GPS，读取，并显示来自它的数据。

如果您查看代码，您会发现我没有花费太多时间选择comm值。我将它们全部设置为1，打算用更长的超时时间进行实验，直到CPU的使用可以容忍为止。长话短说，它使用的CPU时间如此之少，我从来没有烦恼过。例如，在任务管理器的CPU使用情况图上，我看不到它运行与不运行之间的任何区别。我让它一次运行几个小时从GPS收集数据，任务管理器仍然说它的CPU总使用量是0:00:00。

一句话:我很肯定它会更有效率--但有时候足够好就足够了。考虑到我不再大量使用它，再加上像文件传输协议这样的东西的机会，让它变得更有效率可能永远不会达到需要做的事情的顶端。

#include <stdio.h>
#include <conio.h>
#include <string.h>

#define STRICT
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

void system_error(char *name) {
// Retrieve, format, and print out a message from the last error.  The 
// `name' that's passed should be in the form of a present tense noun 
// (phrase) such as "opening file".
//
    char *ptr = NULL;
    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER |
        FORMAT_MESSAGE_FROM_SYSTEM,
        0,
        GetLastError(),
        0,
        (char *)&ptr,
        1024,
        NULL);

    fprintf(stderr, "\nError %s: %s\n", name, ptr);
    LocalFree(ptr);
}

int main(int argc, char **argv) {

    int ch;
    char buffer[64];
    HANDLE file;
    COMMTIMEOUTS timeouts;
    DWORD read, written;
    DCB port;
    HANDLE keyboard = GetStdHandle(STD_INPUT_HANDLE);
    HANDLE screen = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD mode;
    char port_name[128] = "\\\\.\\COM3";
    char init[] = "";

    if ( argc > 2 )
        sprintf(port_name, "\\\\.\\COM%s", argv[1]);

    // open the comm port.
    file = CreateFile(port_name,
        GENERIC_READ | GENERIC_WRITE,
        0, 
        NULL, 
        OPEN_EXISTING,
        0,
        NULL);

    if ( INVALID_HANDLE_VALUE == file) {
        system_error("opening file");
        return 1;
    }

    // get the current DCB, and adjust a few bits to our liking.
    memset(&port, 0, sizeof(port));
    port.DCBlength = sizeof(port);
    if (!GetCommState(file, &port))
        system_error("getting comm state");
    if (!BuildCommDCB("baud=19200 parity=n data=8 stop=1", &port))
        system_error("building comm DCB");
    if (!SetCommState(file, &port))
        system_error("adjusting port settings");

    // set short timeouts on the comm port.
    timeouts.ReadIntervalTimeout = 1;
    timeouts.ReadTotalTimeoutMultiplier = 1;
    timeouts.ReadTotalTimeoutConstant = 1;
    timeouts.WriteTotalTimeoutMultiplier = 1;
    timeouts.WriteTotalTimeoutConstant = 1;
    if (!SetCommTimeouts(file, &timeouts))
        system_error("setting port time-outs.");

    // set keyboard to raw reading.
    if (!GetConsoleMode(keyboard, &mode))
        system_error("getting keyboard mode");
    mode &= ~ ENABLE_PROCESSED_INPUT;
    if (!SetConsoleMode(keyboard, mode))
        system_error("setting keyboard mode");

    if (!EscapeCommFunction(file, CLRDTR))
        system_error("clearing DTR");
    Sleep(200);
    if (!EscapeCommFunction(file, SETDTR))
        system_error("setting DTR");

    if (!WriteFile(file, init, sizeof(init), &written, NULL))
        system_error("writing data to port");

    if (written != sizeof(init))
        system_error("not all data written to port");

    // basic terminal loop:
    do {
        // check for data on port and display it on screen.
        ReadFile(file, buffer, sizeof(buffer), &read, NULL);
        if (read)
            WriteFile(screen, buffer, read, &written, NULL);

        // check for keypress, and write any out the port.
        if ( kbhit() ) {
            ch = getch();
            WriteFile(file, &ch, 1, &written, NULL);
        }
    // until user hits ctrl-backspace.
    } while ( ch != 127);

    // close up and go home.
    CloseHandle(keyboard);
    CloseHandle(file);
    return 0;
}

Answer 3

我想补充一下

Sleep(2);

到CPort中的while循环：：WaitForQueToFill()

这将使操作系统有机会在队列中实际放置一些字节。