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

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

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;
}

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

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

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;
  }

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;
}

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