Win32串口ReadFile延迟致吞吐量不足及板卡缓冲区溢出问题

你遇到的15ms延迟是Windows同步串口读取的典型问题，根源在于同步ReadFile会等待系统串口驱动的缓冲区积累到一定数据量，或触发超时才返回。这个15ms通常是系统默认的串口超时阈值，和波特率无关，直接把吞吐量限制在约33KB/s，最终导致板卡的16KB内部缓冲区溢出。

以下是针对性的优化措施，按优先级排序：

1. 切换为重叠（异步）IO模式 #

同步IO下ReadFile会阻塞直到满足超时条件或读取到指定字节数，而异步IO能在数据到达时立即触发读取，彻底规避固定等待延迟。

修改步骤： #

• 打开串口时添加FILE_FLAG_OVERLAPPED标志：

  // 先定义常量
  int FILE_FLAG_OVERLAPPED = 0x40000000;
  
  // 在Open()方法中替换CreateFileA调用
  hSerial = CreateFileA(winPortName, GENERIC_RW, 0, (IntPtr)0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, (IntPtr)0);
  

• 定义重叠IO结构并补充相关API导入：

  [StructLayout(LayoutKind.Sequential)]
  public struct OVERLAPPED
  {
      public IntPtr Internal;
      public IntPtr InternalHigh;
      public int Offset;
      public int OffsetHigh;
      public IntPtr hEvent;
  }
  
  [DllImport("kernel32.dll", SetLastError = true)]
  private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, IntPtr lpName);
  
  [DllImport("kernel32.dll", SetLastError = true)]
  private static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);
  
  [DllImport("kernel32.dll", SetLastError = true)]
  private static extern bool GetOverlappedResult(IntPtr hFile, ref OVERLAPPED lpOverlapped, ref int lpNumberOfBytesTransferred, bool bWait);
  
  [DllImport("kernel32.dll", SetLastError = true)]
  private static extern bool CloseHandle(IntPtr hObject);
  

• 实现异步读取逻辑：

  public int ReadAsync(byte[] buf, int offset, int lenToRead, ref int readLen)
  {
      if (hSerial == INVALID_HANDLE) return -1;
  
      OVERLAPPED overlapped = new OVERLAPPED();
      overlapped.hEvent = CreateEvent(IntPtr.Zero, true, false, IntPtr.Zero);
      if (overlapped.hEvent == IntPtr.Zero) return -2;
  
      byte[] readBuf = new byte[lenToRead];
      readLen = 0;
  
      bool result = ReadFile(hSerial, readBuf, lenToRead, ref readLen, ref overlapped);
      if (!result)
      {
          int error = Marshal.GetLastWin32Error();
          if (error == ERROR_IO_PENDING)
          {
              // 等待数据到达，超时设为1ms（可按需调小）
              WaitForSingleObject(overlapped.hEvent, 1);
              GetOverlappedResult(hSerial, ref overlapped, ref readLen, false);
          }
          else
          {
              CloseHandle(overlapped.hEvent);
              return -3;
          }
      }
  
      if (readLen > 0 && readLen <= lenToRead)
      {
          Array.Copy(readBuf, 0, buf, offset, readLen);
      }
  
      CloseHandle(overlapped.hEvent);
      return readLen;
  }
  

2. 优化COMMTIMEOUTS参数 #

当前超时设置可能强制系统等待固定时长才返回，调整为激进的超时策略让ReadFile有数据就返回：

private void SetTimeouts()
{
    if (hSerial == INVALID_HANDLE) return;

    COMMTIMEOUTS comPortTimeouts = new COMMTIMEOUTS();
    GetCommTimeouts(hSerial, ref comPortTimeouts);

    // 关键调整：字节间隔超时1ms，无固定总超时
    comPortTimeouts.ReadIntervalTimeout = 1;    // 两个字节间隔超过1ms就返回
    comPortTimeouts.ReadTotalTimeoutMultiplier = 0;
    comPortTimeouts.ReadTotalTimeoutConstant = 0; // 不等待固定时长
    comPortTimeouts.WriteTotalTimeoutMultiplier = 0;
    comPortTimeouts.WriteTotalTimeoutConstant = WriteTimeout;

    SetCommTimeouts(hSerial, ref comPortTimeouts);
}

3. 增大系统串口接收缓冲区 #

默认系统缓冲区较小，会导致频繁触发读取，用SetupComm扩容减少系统唤醒次数：

[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool SetupComm(IntPtr hFile, int dwInQueue, int dwOutQueue);

// 在Open()方法中打开串口后立即调用
if (hSerial != INVALID_HANDLE)
{
    // 设置输入缓冲区为32KB（大于板卡的16KB缓冲区）
    SetupComm(hSerial, 32768, 1024);
    // 后续SetTimeouts、SetCommState等逻辑...
}

4. 用COMM事件通知替代轮询 #

通过SetCommMask监听数据到达事件，有数据时立即读取，比主动轮询更高效：

[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool SetCommMask(IntPtr hFile, int dwEvtMask);

[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool WaitCommEvent(IntPtr hFile, ref int dwEvtMask, IntPtr lpOverlapped);

[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool ClearCommError(IntPtr hFile, ref int lpErrors, ref COMSTAT lpStat);

// 定义事件常量
int EV_RXCHAR = 0x0001;

// 在Open()中设置事件掩码
SetCommMask(hSerial, EV_RXCHAR);

// 读取线程循环监听
private void ReadLoop()
{
    int evtMask = 0;
    int errorCode = 0;
    while (true)
    {
        if (WaitCommEvent(hSerial, ref evtMask, IntPtr.Zero))
        {
            if ((evtMask & EV_RXCHAR) != 0)
            {
                COMSTAT stat = new COMSTAT();
                ClearCommError(hSerial, ref errorCode, ref stat);
                if (stat.cbInQue > 0)
                {
                    byte[] buf = new byte[stat.cbInQue];
                    int readLen = 0;
                    ReadFile(hSerial, buf, stat.cbInQue, ref readLen, IntPtr.Zero);
                    // 处理读取到的数据
                }
            }
        }
    }
}

5. 提升读取线程优先级 #

把负责串口读取的线程设为最高优先级，避免被系统其他线程抢占导致延迟：

Thread readThread = new Thread(ReadLoop);
readThread.Priority = ThreadPriority.Highest;
readThread.IsBackground = true;
readThread.Start();

6. 修正DCB配置 #

当前dcbParams.flags = 1可能配置错误，建议根据板卡需求正确设置：

// 示例：启用RTS硬件流控，启用二进制模式
dcbParams.flags = 0x0001 | 0x0002; // fBinary=1 + fRtsControl=RTS_CONTROL_ENABLE

• 修改后用示波器重新测试ping响应的ReadFile返回时间，确认延迟降到微秒级。
• 持续读取时监控板卡缓冲区占用，确保不再溢出。

内容的提问来源于stack exchange，提问作者Max