windows下的串口编程，串口操作类封装

杨永贞

发布于 2022-06-09 17:58:03

2.7K00

代码可运行

文章被收录于专栏：独行猫a的沉淀积累总结独行猫a的沉淀积累总结

运行总次数：0

代码可运行

以往都是在嵌入式设备中经常操作串口，或者使用QT的串口类。在Win32中处理串口也是有办法的，操作文件的打开和读写进行串口的操作。使用ReadFile、WriteFile函数。

基本步骤

使用Win32文件方式操作：打开串口（创建文件）->配置参数->发送（写文件）-->接收（读文件）

打开串口

打开串口的第一步是初始化或设置串口配置，目的是创建串口代理，整篇文章我们都将用文件句柄作为串口代理。

创建端口句柄
获取配置（DCB)
修改配置
保存配置
设置通讯超时

创建端口句柄 串口句柄是可以被用来存取的串口对象句柄，创建串口句柄的函数是CreateFile，如下代码所示：

handlePort_ = CreateFile(portName, // 端口设备: 默认 "COM1" 
GENERIC_READ | GENERIC_WRITE, // 设备打开模式: 允许读写 
0, // 不共享 
NULL, // 默认安全设置 
OPEN_EXISTING, // 打开方式：打开已经存在的端口 
0, // 默认 NULL
); // 默认

这其中需要注意的是：portName是个LPCSTR类型，需要注意字符编码。直接用c++的m_portName.c_str()即可。若是UNICODE的字符串，则需要转换下wchar to char。

std::wstring ansi2Wchar(LPCSTR pszSrc, int nLen)
{
  int nSize = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pszSrc, nLen, 0, 0);
  if (nSize <= 0)
    return NULL;

  WCHAR* pwszDst = new WCHAR[nSize + 1];
  if (NULL == pwszDst)
    return NULL;

  MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pszSrc, nLen, pwszDst, nSize);
  pwszDst[nSize] = 0;

  if (pwszDst[0] == 0xFEFF)  // skip 0xFEFF
    for (int i = 0; i < nSize; i++)
      pwszDst[i] = pwszDst[i + 1];

  std::wstring wcharString(pwszDst);
  delete[] pwszDst;
  pwszDst = nullptr;

  return wcharString;
}

以下为打开串口的封装：

bool WindowsSerialPort::openCom()
{
  bool open = false;

#ifdef _WIN32

  DCB dcb;
  SecureZeroMemory(&dcb, sizeof(DCB));

  auto comName = ansi2Wchar(m_portName.c_str(), m_portName.size());
#ifdef UNICODE
  wchar_t* buffer = new wchar_t[m_portName.size()];
  MultiByteToWideChar(CP_ACP, 0, m_portName.c_str(), m_portName.size(), buffer, m_portName.size() * sizeof(wchar_t));
  buffer[m_portName.size()] = 0;
  m_port = ::CreateFile(buffer, GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING, NULL);
  delete[] buffer;
  buffer = NULL;
#else
  m_port = ::CreateFile(m_portName.c_str(), GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
                        NULL);
#endif

  if (m_port == INVALID_HANDLE_VALUE)
  {
    open = false;
    LOGGING_ERROR("%s is invalid", m_portName.c_str());
    m_port = INVALID_HANDLE_VALUE;

    return open;
  }

  if (!GetCommState(m_port, &dcb))
  {
    open = false;
    LOGGING_ERROR("%s cannot get status", m_portName.c_str());
    m_port = INVALID_HANDLE_VALUE;

    return open;
  }

  dcb.BaudRate = m_baud;
  dcb.ByteSize = 8;
  dcb.fParity = NOPARITY;
  dcb.Parity = NOPARITY;
  dcb.StopBits = 0;
  dcb.fInX = 0;
  dcb.fOutX = 0;
  dcb.fOutxCtsFlow = 0;
  dcb.fRtsControl = 0;
  auto err = SetCommState(m_port, &dcb);
  if (!err)
  {
    open = false;

    LOGGING_ERROR("%s cannot set comm status", m_portName.c_str());
    m_port = INVALID_HANDLE_VALUE;

    return open;
  }

  COMMTIMEOUTS timeout;
  memset(&timeout, 0, sizeof(timeout));
  GetCommTimeouts(m_port, &timeout);
  // TODO: 可能需要根据实际情况调整该参数
  timeout.ReadTotalTimeoutConstant = 50;
  timeout.ReadIntervalTimeout = 10;
  SetCommTimeouts(m_port, &timeout);

  open = true;

#endif

  return open;
}

COMMTIMEOUTS 含义

COMMTIMEOUTS主要用于串口超时参数设置。

COMMTIMEOUTS结构如下：

typedef struct _COMMTIMEOUTS { 
DWORD ReadIntervalTimeout;  //间隔超时
DWORD ReadTotalTimeoutMultiplier; 
DWORD ReadTotalTimeoutConstant; 
DWORD WriteTotalTimeoutMultiplier; 
DWORD WriteTotalTimeoutConstant; 
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

间隔超时 = ReadIntervalTimeout 总超时 = ReadTotalTimeoutMultiplier * 字节数 + ReadTotalTimeoutConstant

// COMMTIMEOUTS对象 COMMTIMEOUTS comTimeOut; 
// 接收时，两字符间最大的时延 
comTimeOut.ReadIntervalTimeout = 3; 
// 读取每字节的超时 
comTimeOut.ReadTotalTimeoutMultiplier = 3; 
// 读串口数据的固定超时 // 总超时 = ReadTotalTimeoutMultiplier * 字节数 ReadTotalTimeoutConstant 
comTimeOut.ReadTotalTimeoutConstant = 2; 
// 写每字节的超时 
comTimeOut.WriteTotalTimeoutMultiplier = 3; 
// 写串口数据的固定超时 
comTimeOut.WriteTotalTimeoutConstant = 2; 
// 将超时参数写入设备控制 
SetCommTimeouts(handlePort_,&comTimeOut);

ReadIntervalTimeout 指定通讯线上两个字符到达的最大时延，以毫秒为单位。在ReadFile操作期间，时间周期从第一个字符接收到算起。如果收到的两个字符之间的间隔超过该值，ReadFile操作完毕并返回所有缓冲数据。如果ReadIntervalTimeout为0，则该值不起作用。如果值为MAXDWORD, 并且ReadTotalTimeoutConstant和ReadTotalTimeoutMultiplier两个值都为0, 则指定读操作携带已经收到的字符立即返回，即使没有收到任何字符。 ReadTotalTimeoutMultiplier 指定以毫秒为单位的累积值。用于计算读操作时的超时总数。对于每次读操作，该值与所要读的字节数相乘。 ReadTotalTimeoutConstant 指定以毫秒为单位的常数。用于计算读操作时的超时总数。对于每次读操作，ReadTotalTimeoutMultiplier与所要读的字节数相乘后与该值相加。如果ReadTotalTimeoutMultiplier和ReadTotalTimeoutConstant都为0，则在读操作时忽略总超时数。 WriteTotalTimeoutMultiplier 指定以毫秒为单位的累积值。用于计算写操作时的超时总数。对于每次写操作，该值与所要写的字节数相乘。 WriteTotalTimeoutConstant 指定以毫秒为单位的常数。用于计算写操作时的超时总数。对于每次写操作， WriteTotalTimeoutMultiplier与所要写的字节数相乘后与该值相加。如果 WriteTotalTimeoutMultiplier 和 WriteTotalTimeoutConstant都为0，则在写操作时忽略总超时数。提示：用户设置通讯超时后，如没有出错，串口已经被打开。

串口数据读取过程

串口读取事件分为两个阶段：第一个阶段：串口执行到ReadFile（）函数时，串口还没有开始传输数据，所以串口缓冲区的第一个字节是没有装数据的，这时候总超时起作用，如果在总超时时间内没有进行串口数据的传输，ReadFile（）函数就返回，当然没有读取到任何数据。而且，间隔超时并没有起作用。

第二阶段：假设总超时为20秒，程序运行到ReadFile()，总超时开始从0 计时，如果在计时到达10秒时，串口开始了数据的传输。那么从接收的第一个字节开始，间隔超时就开始计时，假如间隔超时为1ms，那么在读取完第一个字节后，串口开始等待1ms，如果1ms之内接收到了第二个字节，就读取第二个字节，间隔超时重置为0并计时，等待第三个字节的到来。如果第三个字节到来的时间超过了1ms，那么ReadFile()函数立即返回，这时候总超时计时是没到20秒的。

如果在20秒总计时时间结束之前，所有的数据都遵守数据间隔为1ms的约定并陆陆续续的到达串口缓冲区，那么就成功进行了一次串口传输和读取；如果20秒总计时时间到，串口还陆陆续续的有数据到达，即使遵守字节间隔为1ms的约定，ReadFile()函数也会立即返回，这时候总超时就起作用了。

总结，总超时在两种情况下起作用: 第一：串口没进行数据传输，等待总超时时间那么长ReadFile()才返回。非正常数据传输第二：数据太长，总超时设置太短，数据还没读取完就返回了。读取的数据是不全的。

间隔超时触发是有条件的：第一：在总超时时间内。第二：串口进行了数据的传输。成功的进行一次串口数据的传输和读取，只有总超时和间隔超时相互参与配合才能完成。

发送数据

串口数据发送多作为写文件处理的，程序员可以应用文件操作函数发送数据到串口。采用WriteFile函数发送数据到串口。

BOOL
WINAPI
WriteFile(
    _In_ HANDLE hFile,
    _In_reads_bytes_opt_(nNumberOfBytesToWrite) LPCVOID lpBuffer,
    _In_ DWORD nNumberOfBytesToWrite,
    _Out_opt_ LPDWORD lpNumberOfBytesWritten,
    _Inout_opt_ LPOVERLAPPED lpOverlapped
    );

if (WriteFile(handlePort_, // 文件句柄 
outputData, // 数据缓冲区指针 
sizeBuffer, // 字节数 
&length,
NULL) == 0) // 接收成功发送数据长度的指针 
{ 
	AfxMessageBox("writing of serial communication has problem."); return FALSE;
}

inline std::string stringToHex(const std::string& data)
{
    const std::string hex = "0123456789ABCDEF";
    std::stringstream ss;

    for (std::string::size_type i = 0; i < data.size(); ++i)
        ss << "0x" << hex[(unsigned char)data[i] >> 4] << hex[(unsigned char)data[i] & 0xf] << " ";
    return ss.str();
}

  ......
  LOGGING_DEBUG("send:%s", stringToHex(send).data());
  std::cout << "->send:" << stringToHex(send) << std::endl;

  std::this_thread::sleep_for(std::chrono::milliseconds(5));
  PurgeComm(m_port, PURGE_RXCLEAR | PURGE_TXCLEAR);
  DWORD dwWrite = 0;
  DWORD dwRet = WriteFile(m_port, send.c_str(), send.size(), &dwWrite, NULL);
  PurgeComm(m_port, PURGE_RXCLEAR | PURGE_TXCLEAR);
  if (!dwRet)
  {
    errorCode = base_module_error::make_error_code(base_module_error::BaseModuleErrorCode::serial_port_write_error);
    return;
  }

接收数据

串口数据接收多作为读文件处理。程序员可以应用文件操作函数从串口接收数据。用ReadFile函数接收串口的数据。

if (ReadFile(handlePort_, // 句柄 
inputData, // 数据缓冲区指针 
sizeBuffer, // 字节数 
&length, // 指向已经读入的字节数 
NULL) == 0) // 重叠I/O结构体 
{ 
	AfxMessageBox("Reading of serial communication has problem."); return FALSE; 
}

  char _buf;
  DWORD dwRead;
  //clock_t begin,end;
  auto begin = std::chrono::system_clock::now();
  BOOL bReadOK = ReadFile(m_port, &_buf, 1, &dwRead, NULL);
  auto spend = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - begin).count();
  if(spend != 0){
      //计算花费时间
      LOGGING_DEBUG("spend:%d ms",spend);
  }
  if (bReadOK && (dwRead > 0))
    return static_cast<uint8_t>(_buf);
  else
  {
      if(GetLastError()!=0){
          LOGGING_ERROR("ReadFile error,GetLastError:%u", GetLastError());
          std::cout << "ReadFile error,GetLastError:" << GetLastError() << std::endl;
      }
      errorCode = base_module_error::make_error_code(base_module_error::BaseModuleErrorCode::serial_port_read_error);
      return 0;
  }


std::string WindowsSerialPort::getFrameData(const std::string& sd)
{
  char sendDataArray[50];
  memset(sendDataArray, 0xFC, sizeof(sendDataArray));
  char* pSendDataArray = sendDataArray;
  memcpy((pSendDataArray + 3), sd.c_str(), sd.size());

  uint8_t crcHi, crcLo;
  auto* pDat = reinterpret_cast<uint8_t*>(const_cast<char*>(sd.data()));
  CRCCal(pDat, sd.size(), &crcHi, &crcLo);

  sendDataArray[sd.size() + 3] = (char)(crcLo & 0x00FFU);
  sendDataArray[sd.size() + 4] = (char)(crcHi & 0x00FFU);

  std::string _send(pSendDataArray, sd.size() + 3 + 2);
  pSendDataArray = nullptr;
  pDat = nullptr;

  return _send;
}

void WindowsSerialPort::CRCCal(uint8_t* pnt, uint8_t len, uint8_t* CrcHi, uint8_t* CrcLo)
{
  uint8_t i;
  uint16_t crc = 0;

  while (len-- != 0)
  {
    for (i = 0x80; i != 0; i /= 2)
    {
      if ((crc & 0x8000U) != 0)
      {
        crc *= 2;
        crc ^= 0x1021U;
      }
      else
      {
        crc *= 2;
      }

      if ((*pnt & i) != 0)
        crc ^= 0x1021U;
    }

    pnt++;
  }

  *CrcHi = crc >> 8U;
  *CrcLo = crc & 0xFFU;
}

关闭串口

可以调用CloseHandle API函数关闭串口。

if(CloseHandle(handlePort_) == 0) // 调用该函数关闭串口 
{ 
	AfxMessageBox("Port Closeing isn''t successed."); return FALSE;
}

关于内存泄漏

虚拟内存是您的程序处理的内容。它由所有由malloc,new等人返回的地址组成。每个进程都有自己的虚拟地址空间。虚拟地址的使用在理论上受到程序地址大小的限制：32位程序具有4GB的地址空间; 64位程序有更多。实际上，一个进程可以分配的虚拟内存量少于这些限制。

物理内存是芯片焊接到您的主板，或安装在您的内存插槽。在任何给定时间使用的物理内存量都限制在计算机中的物理内存量。

虚拟内存子系统将您的程序使用的虚拟地址映射到CPU发送到RAM芯片的物理地址。在任何特定时刻，大部分分配的虚拟地址都是未映射的;因此物理内存使用低于虚拟内存使用。如果访问已分配但未映射的虚拟地址，操作系统会无形地分配物理内存并将其映射。如果不访问虚拟地址，操作系统可能会取消映射物理内存。应用程序一般使用malloc，calloc，realloc，new等函数从堆中分配到一块内存，使用完后，程序未调用对应的free或delete释放该内存块，从而导致内存泄漏。

所以内存泄漏会导致进程的虚拟内存使用不断增加，而由于申请后未被访问使用，所以并不会映射到物理内存占用电脑内存资源（这样系统可以防止某个恶心进程占着茅坑不拉屎…）。当是如果程序运行的事件够长，每次泄漏不断累积，长期下去虚拟内存空间也会被全部用完，此时系统会使用系统的硬盘存储充当虚拟内存的扩展，如使用C盘空间（操作据编译器不同而不同），所以这样漏下去还是会导致电脑系统卡顿甚至蓝屏。