以往都是在嵌入式设备中经常操作串口，或者使用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;
}

附CMakeLists.txt文件

cmake_minimum_required(VERSION 3.12)
project(mywincom VERSION 0.0.1)
set(CMAKE_CXX_STANDARD 11)
IF(WIN32)
    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS")
ENDIF(WIN32)
####################  QT dependencies ####################
#set(CMAKE_CXX_STANDARD 11)
#set(CMAKE_AUTOMOC ON)
#set(CMAKE_AUTORCC ON)
#set(CMAKE_AUTOUIC ON)
#set(QT_VERSION 5)
#set(REQUIRED_LIBS Core)
#set(REQUIRED_LIBS_QUALIFIED Qt5::Core)
####################  set output directory ####################
set(BUILD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/build)
set(LIB_DIR ${BUILD_DIR}/Release)
set(LIB_FIX)
if (CMAKE_BUILD_TYPE MATCHES "Debug")
    set(LIB_DIR ${BUILD_DIR}/Debug)
    set(LIB_FIX _d)
endif ()
get_filename_component(ABSOLUTE_PATH ${LIB_DIR} ABSOLUTE)
set(LIB_DIR ${ABSOLUTE_PATH})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIB_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIB_DIR}/lib)
set(CMAKE_PDB_OUTPUT_DIRECTORY ${LIB_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIB_DIR}/lib)
set(LIB_DIR_FIX ${LIB_DIR}/bin)
option(USE_VS_BUILD "use visual studio build." OFF)
if (USE_VS_BUILD)
    set(LIB_DIR_FIX ${LIB_DIR}/bin/Debug)
endif ()
####################  set include path ####################
set(SRC_PATH
        ${CMAKE_CURRENT_SOURCE_DIR}/src
        ${CMAKE_CURRENT_SOURCE_DIR}/src/misc
        ${CMAKE_CURRENT_SOURCE_DIR}/src/protocol
        )
include_directories(
        ${SRC_PATH}
        ${CMAKE_CURRENT_SOURCE_DIR}/src/misc
        ${CMAKE_CURRENT_SOURCE_DIR}/src/protocol
        ${BUILD_DIR}/../include
)
add_definitions(
)
####################  scan source files ####################
foreach (path ${SRC_PATH})
    aux_source_directory(${path} SRC_FILES)
endforeach ()
####################  version config ####################
#configure_file(${BUILD_DIR}/../include/version.h.in ${CMAKE_CURRENT_BINARY_DIR}/plugin_version.h)
#include_directories(${CMAKE_CURRENT_BINARY_DIR})
#if (MSVC)
#    set(MY_VERSIONINFO_RC "${CMAKE_CURRENT_BINARY_DIR}/VersionInfo.rc")
#    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/resource.rc.in"
#            "${MY_VERSIONINFO_RC}")
#endif ()
#add_library(${PROJECT_NAME} SHARED ${SRC_FILES} ${MY_VERSIONINFO_RC})
#add_executable(${PROJECT_NAME} WIN32 ${SRC_FILES})
add_executable(${PROJECT_NAME} ${SRC_FILES})
####################  set target properties ####################
set_target_properties(${PROJECT_NAME} PROPERTIES DEBUG_POSTFIX _d)
####################  set target dependencies ####################
#find_package(g3log CONFIG REQUIRED)
#find_package(GTest CONFIG REQUIRED)
#find_package(Qt${QT_VERSION} COMPONENTS ${REQUIRED_LIBS} REQUIRED)
find_library(LibConfig libconfig++)
message(STATUS ${LibConfig})
find_package(unofficial-breakpad CONFIG REQUIRED)
set(LOGGING_LIB ${LIB_DIR}/lib/Logging${LIB_FIX}.lib)
set(THIRD_LIBS
        ${LOGGING_LIB}
        unofficial::breakpad::libbreakpad
        unofficial::breakpad::libbreakpad_client
        )
#target_link_options(${PROJECT_NAME} PRIVATE -mwindows)
target_link_libraries(${PROJECT_NAME} PRIVATE ${THIRD_LIBS} ${LibConfig})
####################### copy interface file ###############################################
file(COPY
        src/misc/config.hpp
        DESTINATION ${BUILD_DIRECTORY}/include)
file(COPY
        config.conf
        DESTINATION ${BUILD_DIRECTORY}/conf)