windows c++ 串口通讯

已于 2022-06-24 19:37:25 修改
阅读量4.1k 收藏 61
点赞数 10
分类专栏： c++ 文章标签： windows c++ 单片机
于 2022-06-24 19:15:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43917589/article/details/125450968
版权

串行通讯是指仅用一根接收线和一根发送线就能将数据以位进行传输的一种通讯方式。工业上常用的串行通讯方式是RS232、RS485。
不管是何种通讯方式，接收端和发送端要实现通讯，要注意串口名、波特率、校验位、数据位、停止位一致才行。
USB转RS485长这样：
在这里插入图片描述

USB转RS232长这样：
在这里插入图片描述

windows上查看串口的方式如下图所示。

在这里插入图片描述

c++实现的串口通讯程序如下所示：
需要注意的是通过串口发送的信号，是ASCII还是十六位的信号。w.send(string dat)发送的是ASCII信号，w.sendHex(string datHex)是十六位的信号，string格式的datHex会自动转为十六位信号。
Serial.h

#ifndef _WZSERIALPORT_H
#define _WZSERIALPORT_H
#include <iostream>
using namespace std;

public:
       WZSerialPort();
       ~WZSerialPort();


//打开串口,成功返回true，失败返回false
//portname(串口名): 在Windows下是"COM1""COM2"等，在Linux下是"/dev/ttyS1"等
//baudrate(波特率): 9600、19200、38400、43000、56000、57600、115200 
//parity(校验位): 0为无校验，1为奇校验，2为偶校验，3为标记校验
//databit(数据位): 4-8，通常为8位
//stopbit(停止位): 1为1位停止位，2为2位停止位,3为1.5位停止位
//synchronizable(同步、异步): 0为异步，1为同步

bool open(const char* portname, int baudrate = 115200, char parity = 0, char databit = 8, char stopbit = 1, char synchronizeflag = 1);

 
//关闭串口，参数待定
void close();

//发送ASCII数据或写数据，成功返回发送数据长度，失败返回0
int send(string dat);


//发送hex数据或写数据，成功返回发送数据长度，失败返回0
int sendHex(string dat);

//接受数据或读数据，成功返回读取实际数据的长度，失败返回0
string receive();

private:
	int pHandle[16];
        char synchronizeflag;
};
#endif

Serial.cpp

#include "Serial.h"
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <WinSock2.h>
#include <windows.h>
#include<iostream>
using namespace std;

char* HexStrFilter(char* charStr, char* fiterStr)
{
   if (charStr == NULL || fiterStr == NULL)
   {
      return NULL;
   }

   int len = strlen(charStr);

   char* pTemp = fiterStr;

   for (int i = 0; i < len; i++)
   {
      if (((charStr[i] >= '0') && (charStr[i] <= '9')) ||
         ((charStr[i] >= 'A') && (charStr[i] <= 'F')) ||
         ((charStr[i] >= 'a') && (charStr[i] <= 'f')))
      {
         *fiterStr++ = charStr[i];
      }
   }

   return pTemp;
}

char CombineHexChar(char charH, char charL) /// CombineHexChar(A,B) result=1011;
{
   char result;

   if (charH >= '0' && charH <= '9')
   {
      result = (charH - '0');
   }
   else if (charH >= 'a' && charH <= 'f')
   {
      result = (charH - 'a' + 10);
   }
   else if (charH >= 'A' && charH <= 'F')
   {
      result = (charH - 'A' + 10);
   }
   else
   {
      result = 0;/// need to fiter non-hex character
   }

   result <<= 4;

   if (charL >= '0' && charL <= '9')
   {
      result += (charL - '0');
   }
   else if (charL >= 'a' && charL <= 'f')
   {
      result += (charL - 'a' + 10);
   }
   else if (charL >= 'A' && charL <= 'F')
   {
      result += (charL - 'A' + 10);
   }
   else
   {
      result += 0;
   }

   return result;
}

int Char2Hex(char* charStr, char* hexStr)/// character to hex, return value is hexStr length
{
   if (charStr == NULL || hexStr == NULL)
   {
      return 0;
   }

   int hexStrCount = 0;

   char* fiterStr = NULL;
   fiterStr = new char[strlen(charStr) + 1];
   memset(fiterStr, 0, strlen(charStr) + 1);

   HexStrFilter(charStr, fiterStr);///filter non-hex character

   int len = strlen(fiterStr);

   // warn: if charStr length not even, the last charactor will lost
   for (int i = 0; i < len / 2; i++)
   {
      *hexStr++ = CombineHexChar(fiterStr[i * 2], fiterStr[i * 2 + 1]);
      hexStrCount++;
   }

   if (fiterStr)
   {
      delete[] fiterStr;
      fiterStr = NULL;
   }

   return hexStrCount;
}



WZSerialPort::WZSerialPort()
{

}

WZSerialPort::~WZSerialPort()
{

}

bool WZSerialPort::open(const char* portname,
   int baudrate,
   char parity,
   char databit,
   char stopbit,
   char synchronizeflag)
{
   this->synchronizeflag = synchronizeflag;
   HANDLE hCom = NULL;
   if (this->synchronizeflag)
   {
      //同步方式
      hCom = CreateFileA(portname, //串口名
         GENERIC_READ | GENERIC_WRITE, //支持读写
         0, //独占方式，串口不支持共享
         NULL,//安全属性指针，默认值为NULL
         OPEN_EXISTING, //打开现有的串口文件
         0, //0：同步方式，FILE_FLAG_OVERLAPPED：异步方式
         NULL);//用于复制文件句柄，默认值为NULL，对串口而言该参数必须置为NULL
   }
   else
   {
      //异步方式
      hCom = CreateFileA(portname, //串口名
         GENERIC_READ | GENERIC_WRITE, //支持读写
         0,       //独占方式，串口不支持共享
         NULL,  //安全属性指针，默认值为NULL
         OPEN_EXISTING, //打开现有的串口文件
         FILE_FLAG_OVERLAPPED, //0：同步方式，FILE_FLAG_OVERLAPPED：异步方式
         NULL);//用于复制文件句柄，默认值为NULL，对串口而言该参数必须置为NULL
   }

   if (hCom == (HANDLE)-1)
   {
      return false;
   }

   //配置缓冲区大小 
   if (!SetupComm(hCom, 1024, 1024))
   {
      return false;
   }

   // 配置参数 
   DCB p;
   memset(&p, 0, sizeof(p));
   p.DCBlength = sizeof(p);
   p.BaudRate = baudrate; // 波特率
   p.ByteSize = databit; // 数据位

   switch (parity) //校验位
   {
   case 0:
      p.Parity = NOPARITY; //无校验
      break;
   case 1:
      p.Parity = ODDPARITY; //奇校验
      break;
   case 2:
      p.Parity = EVENPARITY; //偶校验
      break;
   case 3:
      p.Parity = MARKPARITY; //标记校验
      break;
   }

   switch (stopbit) //停止位
   {
   case 1:
      p.StopBits = ONESTOPBIT; //1位停止位
      break;
   case 2:
      p.StopBits = TWOSTOPBITS; //2位停止位
      break;
   case 3:
      p.StopBits = ONE5STOPBITS; //1.5位停止位
      break;
   }

   if (!SetCommState(hCom, &p))
   {
      // 设置参数失败
      return false;
   }

   //超时处理,单位：毫秒
   //总超时＝时间系数×读或写的字符数＋时间常量
   COMMTIMEOUTS TimeOuts;
   TimeOuts.ReadIntervalTimeout = 1000; //读间隔超时
   TimeOuts.ReadTotalTimeoutMultiplier = 500; //读时间系数
   TimeOuts.ReadTotalTimeoutConstant = 5000; //读时间常量
   TimeOuts.WriteTotalTimeoutMultiplier = 500; // 写时间系数
   TimeOuts.WriteTotalTimeoutConstant = 2000; //写时间常量
   SetCommTimeouts(hCom, &TimeOuts);

   PurgeComm(hCom, PURGE_TXCLEAR | PURGE_RXCLEAR);//清空串口缓冲区

   memcpy(pHandle, &hCom, sizeof(hCom));//保存句柄

   return true;
}

void WZSerialPort::close()
{
   HANDLE hCom = *(HANDLE*)pHandle;
   CloseHandle(hCom);
}

int WZSerialPort::send(string dat)
{
   HANDLE hCom = *(HANDLE*)pHandle;

   if (this->synchronizeflag)
   {
      // 同步方式
      DWORD dwBytesWrite = dat.length(); //成功写入的数据字节数
      BOOL bWriteStat = WriteFile(hCom, //串口句柄
         (char*)dat.c_str(), //数据首地址
         dwBytesWrite, //要发送的数据字节数
         &dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
         NULL); //NULL为同步发送，OVERLAPPED*为异步发送
      if (!bWriteStat)
      {
         return 0;
      }
      return dwBytesWrite;
   }
   else
   {
      //异步方式
      DWORD dwBytesWrite = dat.length(); //成功写入的数据字节数
      DWORD dwErrorFlags; //错误标志
      COMSTAT comStat; //通讯状态
      OVERLAPPED m_osWrite; //异步输入输出结构体

      //创建一个用于OVERLAPPED的事件处理，不会真正用到，但系统要求这么做
      memset(&m_osWrite, 0, sizeof(m_osWrite));
      m_osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, "WriteEvent");

      ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误，获得设备当前状态
      BOOL bWriteStat = WriteFile(hCom, //串口句柄
         (char*)dat.c_str(), //数据首地址
         dwBytesWrite, //要发送的数据字节数
         &dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
         &m_osWrite); //NULL为同步发送，OVERLAPPED*为异步发送
      if (!bWriteStat)
      {
         if (GetLastError() == ERROR_IO_PENDING) //如果串口正在写入
         {
            WaitForSingleObject(m_osWrite.hEvent, 1000); //等待写入事件1秒钟
         }
         else
         {
            ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
            CloseHandle(m_osWrite.hEvent); //关闭并释放hEvent内存
            return 0;
         }
      }
      return dwBytesWrite;
   }
}

int WZSerialPort::sendHex(string dat)
{
   // 先将string格式的dat转为十六进制的hexStr
   char* hexStr = NULL;
   int len = dat.length();
   hexStr = new char[len + 1];
   memset(hexStr, 0, len + 1);

   int hexStrLen = 0;
   char* dat1 = (char*)dat.data();
   hexStrLen = Char2Hex(dat1, hexStr);

   HANDLE hCom = *(HANDLE*)pHandle;

   if (this->synchronizeflag)
   {
      // 同步方式
      DWORD dwBytesWrite = hexStrLen; //成功写入的数据字节数
      BOOL bWriteStat = WriteFile(hCom, //串口句柄
         hexStr, //数据首地址
         dwBytesWrite, //要发送的数据字节数
         &dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
         NULL); //NULL为同步发送，OVERLAPPED*为异步发送
      if (!bWriteStat)
      {
         return 0;
      }
      return dwBytesWrite;
   }
   else
   {
      //异步方式
      DWORD dwBytesWrite = hexStrLen; //成功写入的数据字节数
      DWORD dwErrorFlags; //错误标志
      COMSTAT comStat; //通讯状态
      OVERLAPPED m_osWrite; //异步输入输出结构体

      //创建一个用于OVERLAPPED的事件处理，不会真正用到，但系统要求这么做
      memset(&m_osWrite, 0, sizeof(m_osWrite));
      m_osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, "WriteEvent");

      ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误，获得设备当前状态
      BOOL bWriteStat = WriteFile(hCom, //串口句柄
         hexStr, //数据首地址
         dwBytesWrite, //要发送的数据字节数
         &dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
         &m_osWrite); //NULL为同步发送，OVERLAPPED*为异步发送
      if (!bWriteStat)
      {
         if (GetLastError() == ERROR_IO_PENDING) //如果串口正在写入
         {
            WaitForSingleObject(m_osWrite.hEvent, 1000); //等待写入事件1秒钟
         }
         else
         {
            ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
            CloseHandle(m_osWrite.hEvent); //关闭并释放hEvent内存
            return 0;
         }
      }
      return dwBytesWrite;
   }
}

string WZSerialPort::receive()
{
   HANDLE hCom = *(HANDLE*)pHandle;
   string rec_str = "";
   char buf[1024];
   if (this->synchronizeflag)
   {
      //同步方式
      DWORD wCount = 1024; //成功读取的数据字节数
      BOOL bReadStat = ReadFile(hCom, //串口句柄
         buf, //数据首地址
         wCount, //要读取的数据最大字节数
         &wCount, //DWORD*,用来接收返回成功读取的数据字节数
         NULL); //NULL为同步发送，OVERLAPPED*为异步发送

      for (int i = 0; i < 1024; i++)
      {
         //if (buf[i] != -52) {
         if (buf[i]) {
            rec_str += buf[i];
            std::cout << buf[i] << std::endl;
         }
         else
            break;
      }
      return rec_str;
   }
   else
   {
      //异步方式
      DWORD wCount = 1024; //成功读取的数据字节数
      DWORD dwErrorFlags;  //错误标志
      COMSTAT comStat;     //通讯状态
      OVERLAPPED m_osRead; //异步输入输出结构体

                      //创建一个用于OVERLAPPED的事件处理，不会真正用到，但系统要求这么做
      memset(&m_osRead, 0, sizeof(m_osRead));
      m_osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, "ReadEvent");

      ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误，获得设备当前状态
      //if (!comStat.cbInQue)    
      // return 0;  //如果输入缓冲区字节数为0，则返回false

      //std::cout << comStat.cbInQue << std::endl;
      BOOL bReadStat = ReadFile(hCom,     //串口句柄
         buf, //数据首地址
         wCount, //要读取的数据最大字节数
         &wCount, //DWORD*,用来接收返回成功读取的数据字节数
         &m_osRead); //NULL为同步发送，OVERLAPPED*为异步发送
      if (!bReadStat)
      {
         if (GetLastError() == ERROR_IO_PENDING) //如果串口正在读取中
         {
            //GetOverlappedResult函数的最后一个参数设为TRUE
            //函数会一直等待，直到读操作完成或由于错误而返回
            GetOverlappedResult(hCom, &m_osRead, &wCount, TRUE);
         }
         else
         {
            ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
            CloseHandle(m_osRead.hEvent); //关闭并释放hEvent的内存
            return 0;
         }
      }
      for (int i = 0; i < 1024; i++)
      {
         if (buf[i] != -52)
            rec_str += buf[i];
         else
            break;
      }
      return rec_str;
   }
}

main.cpp

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include "Serial.h"
#include<iostream>
#include <Windows.h>

using namespace std;
int main()
{
   WZSerialPort w;
   w.close();
   if (w.open("COM4",115200))
   {
     cout << "com is opened!" << endl;
     string str = "A80B000000A3";
     // 发送的是十六位的信号, 若发送ASCII的串口信号，则用w.send(str)
     int a = w.sendHex(str);

      cout << "a:" << a << std::endl;
      w.close();
   }
    return 0;
}
脆皮茄条
关注
  • 10
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
C++实现的串口通信
01-19
上位机和下位机通信的问题，使用的协议rs485协议. 　　题目是用VC++让上位机和下位机进行通信. 　　接在电脑上的rs232口，使用了232和485的转换器，发送相应的数据格式，然后上位机接受相应的格式。 　　原代码如下: 　　// TODO: Add your cONtrol notification handler code here 　　char buff[200]; 　　CSTring str; 　　GetDlgItem(IDC_EDI_BUF) -> GetWindowText(str); 　　sprintf(buff,"%s",(LPCSTR)str); 　　
wins下C++读写串口设备（CreateFile方式）
qq_45343995的博客
01-11 3115
创建文件句柄方式对串口设备进行操作 因工作要求我链接的是虚拟串口做转接数据的功能，我只能指明我当时链接设备读写的时候遇到的一些问题 **主要函数//打开串口的模式 CreateFile 创建(串口名称,打开串口的模式,不公开,默认,打开,默认,默认) ReadFile 读 (文件句柄,接收缓存,接收多少，存放缓存里面具体字节) WriteFile 写(文件句柄,要写入的东西,要写入的字节数,用于存放实际写入的字节数)** 对于传参不做过多解释 自行百度都有 注意创建时候的方式和确定是同
使用C++进行Windows串口通信的详细教程及源码解析
最新发布
m0_57781768的博客
06-22 1096
串口通信是一种点对点的通信方式，通常用于计算机和外部设备（如传感器、控制器、嵌入式系统）之间的数据传输。串口通信基于RS-232、RS-485等标准，具有结构简单、使用方便、成本低等优点。
c++ 之 串口通信windows版
enjoy.day
04-22 3252
Windows 串口编程
C++串口编程
热门推荐
lingtianyulong的专栏
06-03 2万+
本文为本人为满足个人项目需要而进行编写，不足之处还请见谅
C++ 串口编程 打开串口
Hsing Hsu's Blog
05-16 4809
<br />新建windows应用程序commtest。<br /> <br />commtest.cpp：<br /> <br /><br />// commtest.cpp: 主项目文件。<br /> <br />#include "stdafx.h"<br />#inclu
c++串口操作
u011555996的博客
05-18 5139
0. 前言　　做串口方面的程序，使用CreateFile打开串口通信端口。在对串口操作之前，需要首先打开串口。使用C++进行串口编程，如果采用VS开发，则可以直接借助于串口通信控件来操作，其次，直接调用Windows的底层API函数来控制串口通信。　　在Window 32bit 的操作系统上， 将串口（通信设备）作为文件来处理，所以串口的打开、关闭、读写所使用的API函数与文件操作一样。所以打开串...
Windows下C++串口通信
01-23
windows下c++串口通信，包括串口打开、SCB设定、串口事件设定、收发等
C++侦听串口通讯程序
11-03
**C++串口通讯程序详解** 串口通讯是计算机与外部设备之间的一种常见通信方式，尤其在嵌入式系统、工业控制以及数据采集等领域中应用广泛。本项目以C++编程语言为基础，实现了一个串口监听程序，它能够监控并处理...
c/c++ windows hid串口通信
06-20
c/c++ windows 通过hidsdi进行串口通信 GUID InterfaceClassGuid = { 0x4d1e55b2, 0xf16f, 0x11cf, { 0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30 } }; SP_DEVINFO_DATA devinfo_data; SP_DEVICE_INTERFACE_...
c++串口通讯程序
10-11
在IT领域，串口通讯是一种常见且重要的通信方式，...以上就是C++串口通讯程序的基本知识，通过这个简单的程序，你可以实现设备间的基本信息交换。实际应用中，可能需要根据具体需求进行更复杂的协议设计和错误处理。
串口通信（windows C++）全代码
02-21
串行通信口简称串口。美国电子工业协会EIA按电气标准及协议来分，包括RS-232C、RS-422、...最常用的接口就是RS-232串口和并口，RS232是一个全双工的通讯协议，它可以同时进行数据接收和发送的工作。本工具包含全代码。
C++串口通信
qq_40544338的博客
05-05 7146
一、目的： 1、MFC接受串口发送来的信号处理事情 二、参考 1、 三、步骤 1、
C++串口通讯相关函数（Windows）
weixin_50953229的博客
04-22 1181
该函数用于初始化指定通讯设备的通讯参数，可用于设置串口通讯的输入和输出缓冲区。该函数用于设置串口通讯的参数，包括波特率、数据位、停止位和奇偶校验等。该函数用于设置串口通讯的事件掩码，以便应用程序能够监视特定的串口事件。该函数用于清除串行端口的错误并获取当前状态。该函数用于获取指定串口通讯设备的当前设置。该函数用于获取异步I/O操作的结果。该函数用于将数据写入文件或通讯设备。该函数用于关闭一个已打开的对象句柄。该函数用于清除串口缓冲区中的数据。该函数用于设置串口超时时间。该函数用于等待串口事件发生。
串口使用系列学习之Windows上使用C++进行串口打开、读写、流控、关闭操作
学无止尽，谨言慎行！
10-22 3204
在Windows上，要打开COM10以后的串口（包括COM10），串口名称不再是“COM10”，而是“\.\COM10”，因此在open函数中，如果是COM10及以后的串口，串口名（假设当前要打开COM10）应该写“\\.\COM10”，其中“\\.\”为“\.\”的转义。我们解决方案是进行流控设置，因为一般是由于读写未同步，导致缓冲区满后，数据写入异常。2、串口号大于10时，操作串口报异常。上修改，增加流控部分代码。1、获取串口数据异常；
halcon/mfc利用serialport类制作串口通信对话框
MAYBE的博客
04-28 3675
利用serialport制作串口通信对话框，接收和发送数据实时显示在编辑框中
【Qt】Windows下编译构建串口库，并给出示例演示（Serial Port library）
Fanjufei的博客
09-21 236
使用qt打开cmakelists文件：（注释下面的内容）然后运行程序：接收的输入如下。
c++读写串口
FairLikeSnow的博客
05-11 9863
本文来自:https://wangbaiyuan.cn/c-serial-communication-write-reading.html     在工业控制中，工控机（一般都基于Windows平台）经常需要与智能仪表通过串口进行通信。串口通信方便易行，应用广泛。 一般情况下，工控机和各智能仪表通过RS485总线进行通信。RS485的通信方式是半双工的，只能由作为主节点的工控PC机依次轮询网络上的各智能控制单元子节点。每次通信都是由PC机通过串口向智能控制单元发布命令
c++串口通讯面试题
10-16
好的，我会尽力回答你的问题。请问你的问题是什么？ 我的回答： 在C++中，如何使用串口进行通讯？ 要使用串口进行通讯，需要使用串口库。在Windows平台上，可以使用WinAPI提供的串口函数，也可以使用第三方库，如Boost.Asio、Qt Serial Port等。在Linux平台上，可以使用POSIX提供的串口函数。 下面是一个使用WinAPI的例子： ```c++ #include <windows.h> int main() { HANDLE hSerial = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hSerial == INVALID_HANDLE_VALUE) { // 处理错误 return 1; } DCB dcbSerialParams = { 0 }; dcbSerialParams.DCBlength = sizeof(dcbSerialParams); if (!GetCommState(hSerial, &dcbSerialParams)) { // 处理错误 CloseHandle(hSerial); return 1; } dcbSerialParams.BaudRate = CBR_9600; dcbSerialParams.ByteSize = 8; dcbSerialParams.StopBits = ONESTOPBIT; dcbSerialParams.Parity = NOPARITY; if (!SetCommState(hSerial, &dcbSerialParams)) { // 处理错误 CloseHandle(hSerial); return 1; } char buffer[1024]; DWORD bytesRead; while (true) { if (!ReadFile(hSerial, buffer, sizeof(buffer), &bytesRead, NULL)) { // 处理错误 break; } // 处理读取到的数据 } CloseHandle(hSerial); return 0; } ```
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值