Windows上位机C++串口通信 原理+库代码编写+库运用（机甲大师逐曦战队算法组主线教程1）_c++串口库

C++中的串口通信没有Python方便的sarial库，须自己定义完成库调用。

本文主要教学简单的串口库编写及调用，并附全部代码及库文件。

建议自行编写库体会串口通信，并完成作业。

一、串口通信理论

（一）基本概念

1、数电基础

省流版：通信中串口发送的数据内容与格式编写需一定数电基础，稍作了解即可

（1）数制

指多位数码中每一位的构成方法以及从低位到高位的进位规则。

常用数制：十进制、二进制、八进制、十六进制等

 

 

 （2）码制

用数字技术来处理和传输的以二进制形式表示数字、字母或特殊符号的系统。

用文字、符号或数码表示特定对象的过程称为编码。数字电路中常用的是二进制编码。N位二进制代码有2的N次方个状态，可表示2的N次方个对象。

2、通信基础

（1）并行串行

（2）异步同步

异步串行通信：异步串行通信是指通信双方以一个字符（包括特定附加位）作为数据传输单位且发送方传送字符的间隔时间不一定，具有不规则数据段传送特性的串行数据传输。

同步串行通信：同步串行通信是指在约定的通信速率下，发送端和接收端的时钟信号频率和相位始终保持一致（同步），这就保证了通信双方在发送和接收数据时具有完全一致的定时关系。

（3）单工双工

（二）串口概述

1、UART协议

（1）UART    

Universal Asynchronous Receiver Transmitter 即     通用异步收发器，是一种通用的串行、异步通信总线     该总线有两条数据线，可以实现全双工的发送和接收     在嵌入式系统中常用于主机与辅助设备之间的通信

（2）UART帧格式

（3）硬件连接

 

TXD为发送端，RXD为接收端 

（4）参数 波特率

用于描述UART通信时的通信速度，其单位为     bps(bit per second)即每秒钟传送的bit的数量

2、个人计算机中的串口

（1）USB串口

Universal Serial Bus（通用串行总线) 简称USB，是目前电脑上应用较广泛的接口规范，由Intel、Microsoft、Compaq、IBM、NEC、Northern Telcom等几家大厂商发起的新型外设接口标准。USB接口是电脑主板上的一种四针接口，其中中间两个针传输数据，两边两个针给外设供电。USB接口速度快、连接简单、不需要外接电源，传输速度12Mbps，最新USB2.0可达480Mbps；电缆最大长度5米，USB电缆有4条线，2条信号线，2条电源线，可提供5伏特电源，USB通过串联方式最多可串接127个设备；支持热插拔。

（2）虚拟串口

虚拟串口一般用来调试PC上位机软件和串口的通讯。在没有电控队友在身边时，我们需要知道我们发送过去了什么数据，即数据是否完整，数据传输的状态等，这时候我们就需要虚拟串口 即在mcu中直接虚拟一个串口，这样我们就可以使用串口助手直接查看该串口数据的收发情况。

虚拟串口及串口助手的下载使用可参考以下文章

http://t.csdnimg.cn/fq1ax

二、代码_串口库

先编写串口库文件，

（一）windows主要函数

完成代码须引入windows库，部分常用代码如下。

1.CreateFile - 打开串口；
2.SetupComm-初始化一个指定的通信设备的通信参数
3.ReadFile - 读数据；
4.WriteFile - 写数据；
5.CloseHandle - 关闭串口；
6.GetCommState - 取得串口当前状态；
7.SetCommState - 设置串口状态；
8.PurgeComm - 清除串口缓冲区 ；
9.ClearCommError - 清除串口错误或者读取串口现在的状态；
10.SetCommMask - 设置串口通信事件；
11.WaitCommEvent - 用来判断用SetCommMask()函数设置的串口通

（二）类的完成（结尾有各个文件的完整代码）

1、创建类

在头文件中创建一个串口通信类（先创建.h头文件）

整体结构如图，public处函数声明待补充 。

创建这个头文件对应的cpp文件，编写函数。

2、函数编写

（1）头文件及线程退出

 （2）构造函数与析构函数

类的建立及清除

 （3）初始化串口函数

• 初始化串口并配置其参数，以便与设备进行通信。
• 在打开和关闭串口时处理临界区，以确保串口操作的线程安全性。
• 清空串口缓冲区，以防止旧数据干扰新的通信。

（4）打开关闭串口

 （5）打开、关闭和运行串口监听线程

监听线程从串口接收传入的数据字节，并将其存储在缓冲区中。

（6）从串口接收缓冲区中读取数据、将数据从缓冲区写入串口

（7）完善.h头文件

3、完整代码 

ZhuXiSerial.h

#ifndef __ZhuXiSerial_H_
#define __ZhuXiSerial_H_
#include <Windows.h>
#include <string>
#include <process.h>
using namespace std;
 
typedef enum AxisType      //枚举类型表达坐标  方便视觉传输信息
{
	AXIS_XX = 2,
	AXIS_YY = 3,
	AXIS_OO = 4,
}AXIS_TYPE;
 
class ZhuXiSerial 
{
public:
    ZhuXiSerial(void);               
    ~ZhuXiSerial(void);
 
public:
    bool InitPort(UINT  portNo, UINT  baud, char  parity, UINT  databits, UINT  stopsbits, DWORD dwCommEvents); //初始化
    bool InitPort(UINT  portNo, const LPDCB& plDCB);                                                            //初始化
    bool OpenListenThread();                                                                                    //打开监听
    bool CloseListenTread();                                                                                    //关闭监听
 
    bool WriteData(unsigned char* pData, int length);                                                           //向串口写数据
    UINT GetBytesInCOM();                                                                                       //获取串口缓冲区中的字节数
    bool ReadChar(unsigned char& cRecved);                                                                      //读取串口接收缓冲区中一个字节的数据
 
	unsigned char* MotorMoveXY(unsigned char x, unsigned char y);//xy相对移动
	unsigned char* StopMotor(unsigned char sm1);
	unsigned char* SetSpeed(AXIS_TYPE enAxisType, int speed);
	unsigned char* SetRunSpeed(int TY, int speed);
 
public:
    bool openPort(UINT  portNo);                              //打开串口
    void ClosePort();                                         //关闭串口
    static UINT WINAPI ListenThread(void* pParam);            //串口监听
 
private:
//一些退出
	HANDLE  m_hComm;
	static bool s_bExit;
	volatile HANDLE    m_hListenThread;
	CRITICAL_SECTION   m_csCommunicationSync; 
 
};
 
#endif
 

 ZhuXiSerial.cpp

#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include "ZhuXiSerial.h"
using namespace std;
 
/** 线程退出标志 */
bool ZhuXiSerial::s_bExit = false;
/** 当串口无数据时,sleep至下次查询间隔的时间,单位:秒 */
const UINT SLEEP_TIME_INTERVAL = 5;
 
//构造函数 析构函数
ZhuXiSerial::ZhuXiSerial(void)
	: m_hListenThread(INVALID_HANDLE_VALUE)
{
	m_hComm = INVALID_HANDLE_VALUE;                                  //存储串口句柄
	m_hListenThread = INVALID_HANDLE_VALUE;                          //存储监听句柄
	InitializeCriticalSection(&m_csCommunicationSync);               //初始化临界区对象。临界区用于同步对串口通信操作的访问。
}
 
ZhuXiSerial::~ZhuXiSerial(void)
{
	CloseListenTread();
	ClosePort();
	DeleteCriticalSection(&m_csCommunicationSync);
}
 
//初始化串口函数
bool ZhuXiSerial::InitPort(UINT portNo /*= 1*/, UINT baud /*= CBR_9600*/, char parity /*= 'N'*/,
	UINT databits /*= 8*/, UINT stopsbits /*= 1*/, DWORD dwCommEvents /*= EV_RXCHAR*/)
{
	/** 临时变量,将制定参数转化为字符串形式,以构造DCB结构 */
	char szDCBparam[50];
	sprintf_s(szDCBparam, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopsbits);
 
	/** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
	if (!openPort(portNo))
	{
		return false;
	}
 
	/** 进入临界段 */
	EnterCriticalSection(&m_csCommunicationSync);
 
	/** 是否有错误发生 */
	BOOL bIsSuccess = TRUE;
 
	/** 在此可以设置输入输出的缓冲区大小,如果不设置,则系统会设置默认值.
	 自己设置缓冲区大小时,要注意设置稍大一些,避免缓冲区溢出	*/
	/*if (bIsSuccess )
	{
	bIsSuccess = SetupComm(m_hComm,10,10);
	}*/
	/** 设置串口的超时时间,均设为0,表示不使用超时限制 */
	COMMTIMEOUTS  CommTimeouts;
	CommTimeouts.ReadIntervalTimeout = 0;
	CommTimeouts.ReadTotalTimeoutMultiplier = 0;
	CommTimeouts.ReadTotalTimeoutConstant = 0;
	CommTimeouts.WriteTotalTimeoutMultiplier = 0;
	CommTimeouts.WriteTotalTimeoutConstant = 0;
	if (bIsSuccess)
	{
		bIsSuccess = SetCommTimeouts(m_hComm, &CommTimeouts);
	}
 
	DCB  dcb;
	if (bIsSuccess)
	{
		//DWORD dwNum = MultiByteToWideChar(CP_ACP, 0, szDCBparam, -1, NULL, 0);
		//wchar_t *pwText = new wchar_t[dwNum];
		//if (!MultiByteToWideChar(CP_ACP, 0, szDCBparam, -1, pwText, dwNum))
		//{
		//	bIsSuccess = TRUE;
		//}
		/** 获取当前串口配置参数,并且构造串口DCB参数 */
		/*	bIsSuccess = GetCommState(m_hComm, &dcb) && BuildCommDCB(szDCBparam, &dcb);*/
		bIsSuccess = GetCommState(m_hComm, &dcb); //&& BuildCommDCB((LPCWSTR)szDCBparam, &dcb)
 
	/** 开启RTS flow控制 */
		dcb.fRtsControl = RTS_CONTROL_ENABLE;
 
		/** 释放内存空间 */
		/*delete[] pwText;*/
	}
 
	if (bIsSuccess)
	{
		/** 使用DCB参数配置串口状态 */
		bIsSuccess = SetCommState(m_hComm, &dcb);
	}
 
	/**  清空串口缓冲区 */
	PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
 
	/** 离开临界段 */
	LeaveCriticalSection(&m_csCommunicationSync);
	return bIsSuccess == TRUE;
}
 
//初始化串口函数
bool ZhuXiSerial::InitPort(UINT portNo, const LPDCB& plDCB)
{
	/** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
	if (!openPort(portNo))
	{
		return false;
	}
 
	/** 进入临界段 */
	EnterCriticalSection(&m_csCommunicationSync);
 
	/** 配置串口参数 */
	if (!SetCommState(m_hComm, plDCB))
	{
		return false;
	}
 
	/**  清空串口缓冲区 */
	PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
 
	/** 离开临界段 */
	LeaveCriticalSection(&m_csCommunicationSync);
 
	return true;
}
 
 
void ZhuXiSerial::ClosePort()    //关闭串口
{
	/** 如果有串口被打开，关闭它 */
	if (m_hComm != INVALID_HANDLE_VALUE)
	{
		CloseHandle(m_hComm);
		m_hComm = INVALID_HANDLE_VALUE;
	}
}
 
bool ZhuXiSerial::openPort(UINT portNo)    //打开串口
{
	EnterCriticalSection(&m_csCommunicationSync);    	/** 进入临界段 */
	/** 把串口的编号转换为设备名 */
	char szPort[50];
	sprintf_s(szPort, "COM%d", portNo);
	/** 打开指定的串口 */
	m_hComm = CreateFileA(szPort,     /** 设备名,COM1,COM2等 */
		GENERIC_READ | GENERIC_WRITE, /** 访问模式,可同时读写 */
		0,                            /** 共享模式,0表示不共享 */
		NULL,                         /** 安全性设置,一般使用NULL */
		OPEN_EXISTING,                /** 该参数表示设备必须存在,否则创建失败 */
		0,
		0);
	/** 如果打开失败，释放资源并返回 */
	if (m_hComm == INVALID_HANDLE_VALUE)
	{
		cout << "打开失败!" << endl;
		LeaveCriticalSection(&m_csCommunicationSync);
		return false;
	}
	/** 退出临界区 */
	LeaveCriticalSection(&m_csCommunicationSync);
 
	return true;
}
 
//打开监听线程
bool ZhuXiSerial::OpenListenThread()
{
	/** 检测线程是否已经开启了 */
	if (m_hListenThread != INVALID_HANDLE_VALUE)
	{		
		return false;      /** 线程已经开启 */
	}
	s_bExit = false;
	/** 线程ID */
	UINT threadId;
	/** 开启串口数据监听线程 */
	m_hListenThread = (HANDLE)_beginthreadex(NULL, 0, ListenThread, this, 0, &threadId);
	if (!m_hListenThread)
	{
		return false;
	}
	/** 设置线程的优先级,高于普通线程 */
	if (!SetThreadPriority(m_hListenThread, THREAD_PRIORITY_ABOVE_NORMAL))
	{
		return false;
	}
 
	return true;
}
 
//关闭监听线程
bool ZhuXiSerial::CloseListenTread()
{
	if (m_hListenThread != INVALID_HANDLE_VALUE)
	{
		s_bExit = true;   /** 通知线程退出 */
		Sleep(10);      /** 等待线程退出 */
		CloseHandle(m_hListenThread);     /** 置线程句柄无效 */
		m_hListenThread = INVALID_HANDLE_VALUE;
	}
	return true;
}
 
//获取串口缓冲区的字节数
UINT ZhuXiSerial::GetBytesInCOM()
{
	DWORD dwError = 0;  /** 错误码 */
	COMSTAT  comstat;   /** COMSTAT结构体,记录通信设备的状态信息 */
	memset(&comstat, 0, sizeof(COMSTAT));
 
	UINT BytesInQue = 0;
	/** 在调用ReadFile和WriteFile之前,通过本函数清除以前遗留的错误标志 */
	if (ClearCommError(m_hComm, &dwError, &comstat))
	{
		BytesInQue = comstat.cbInQue; /** 获取在输入缓冲区中的字节数 */
	}
 
	return BytesInQue;
}
 
//串口监听线程
UINT WINAPI ZhuXiSerial::ListenThread(void* pParam)
{
	/** 得到本类的指针 */
	ZhuXiSerial* pSerialPort = reinterpret_cast<ZhuXiSerial*>(pParam);
 
	string str_input = "";
 
	// 线程循环,轮询方式读取串口数据  
	while (!pSerialPort->s_bExit)
	{
		UINT BytesInQue = pSerialPort->GetBytesInCOM();
		/** 如果串口输入缓冲区中无数据,则休息一会再查询 */
		if (BytesInQue == 0)
		{
			Sleep(SLEEP_TIME_INTERVAL);
			continue;
		}
 
		/** 读取输入缓冲区中的数据并输出显示 */
		unsigned char cRecved = 0x00;
		do
		{
			cRecved = 0x00;
			if (pSerialPort->ReadChar(cRecved) == true)
			{
				std::stringstream  ss;
				int tm = cRecved;
				ss << std::hex << std::setw(2) << std::setfill('0') << tm;//std::hex进复行制十六进制百流输出    std::setw ：需要填充多少个字符,默认填充的字符为' '空格   std::setfill：设置std::setw将填充什么样的字符,如:std::setfill('*')
				ss << " ";
				string a = ss.str();//str(): return string copy of character array复制字符数组并且返回
				string b;
				//transform函数的作用是：将某操作应用于指定范围的每个元素,first是容器的首迭代器，last为容器的末迭代器，result为存放结果的容器，op为要进行操作的一元函数对象或sturct、class。
				//back_inserter用于在末尾插入元素
				transform(a.begin(), a.end(), back_inserter(b), ::toupper);
 
				if (b == "2A ")
				{
					b = "AA ";
				}
				//完成：将获取的输入放到我的字符串中，到时候判断输入的是否是我需要的输入				
				str_input.append(b);
 
				continue;
			}
		} while (--BytesInQue);
 
		//完成：输入串口信号进行解析
		if (BytesInQue == 0)
		{
			//string str_target="55 AA 07 1E 01 01 E6";//制定的信号
			string str_target = "55 aa 07 03 00 01";//制定的信号
			//str_target=toupper(str_target.size());
			transform(str_target.begin(), str_target.end(), str_target.begin(), ::toupper);
			str_input.pop_back();//断点发现，字符串最后会多个字符，所以将其删除
			int a = str_input.compare(str_target);//比较输入串口信号和制定的信号
 
			if (a == 0)
			{
				//TODO：执行动作，因为输入串口信号符合制定信号，所以执行动作
				int b = 0;
			}
 
			str_input.clear();
		}
 
	}
 
	return 0;
}
 
//读取串口接收缓冲区中一个字节的数据
bool ZhuXiSerial::ReadChar(unsigned char& cRecved)
{
	BOOL  bResult = TRUE;
	DWORD BytesRead = 0;
	if (m_hComm == INVALID_HANDLE_VALUE)
	{
		return false;
	}
 
	/** 临界区保护 */
	EnterCriticalSection(&m_csCommunicationSync);
 
	/** 从缓冲区读取一个字节的数据 */
	bResult = ReadFile(m_hComm, &cRecved, 1, &BytesRead, NULL);
	if ((!bResult))
	{
		/** 获取错误码,可以根据该错误码查出错误原因 */
		DWORD dwError = GetLastError();
 
		/** 清空串口缓冲区 */
		PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
		LeaveCriticalSection(&m_csCommunicationSync);
 
		return false;
	}
 
	/** 离开临界区 */
	LeaveCriticalSection(&m_csCommunicationSync);
 
	return BytesRead;
 
}
 
// 向串口写数据, 将缓冲区中的数据写入到串口
bool ZhuXiSerial::WriteData(unsigned char* pData, int length)
{
	int* pData1 = new int;
	BOOL   bResult = TRUE;
	DWORD  BytesToSend = 0;
	if (m_hComm == INVALID_HANDLE_VALUE)
	{
		return false;
	}
 
	/** 临界区保护 */
	EnterCriticalSection(&m_csCommunicationSync);
 
	/** 向缓冲区写入指定量的数据 */
	bResult = WriteFile(m_hComm,/*文件句柄*/pData,/*用于保存读入数据的一个缓冲区*/ length,/*要读入的字符数*/ &BytesToSend,/*指向实际读取字节数的指针*/ NULL);
	if (!bResult)
	{
		DWORD dwError = GetLastError();
		/** 清空串口缓冲区 */
		PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
		LeaveCriticalSection(&m_csCommunicationSync);
 
		return false;
	}
 
	/** 离开临界区 */
	LeaveCriticalSection(&m_csCommunicationSync);
 
	return true;
}

三、代码_使用库

可自行使用定义声明的代码完成主程序撰写和功能设计。

以下以装甲板识别发送颜色和数字为例。

 main.cpp

#include "ZhuXiSerial.h"
#include <windows.h>
#include <iostream>
 
using namespace std;
 
void sendBtyle(int color,int num)
{
	ZhuXiSerial mySerialPort;//首先将之前定义的类实例化
	if (!mySerialPort.InitPort(1, CBR_19200, 'N', 8, 1, EV_RXCHAR))//是否打开串口，3就是你外设连接电脑的com口，可以在设备管理器查看，然后更改这个参数
	{
		std::cout << "initPort fail !" << std::endl;
	}
	else
	{
		std::cout << "initPort success !" << std::endl;
	}
	if (!mySerialPort.OpenListenThread())//是否打开监听线程，开启线程用来传输返回值
	{
		std::cout << "OpenListenThread fail !" << std::endl;
	}
	else
	{
		std::cout << "OpenListenThread success !" << std::endl;
	}
	if (color == 0)
	{
		unsigned char temp[] = "红色";//动态创建一个数组
		mySerialPort.WriteData(temp, 4);
		unsigned char* temp2 = new unsigned char[4];
		temp2[0] = ' ';
		char str[25];
		itoa(num, str, 10);
		temp2[1] = str[0];
		mySerialPort.WriteData(temp2, 2);
	}
	else
	{
		unsigned char temp[] = "蓝色";//动态创建一个数组
		mySerialPort.WriteData(temp, 4);
		unsigned char* temp2 = new unsigned char[4];
		temp2[0] = ' ';
		char str[25];
		itoa(num, str, 10);
		temp2[1] = str[0];
		mySerialPort.WriteData(temp2, 2);
	}
	Sleep(1000);
 
}
 
int main()
{
    int color,Num;
    color = 1;
    Num = 2;
    sendBtyle(color, Num);
 
}

四、完整使用

开虚拟串口，开串口助手，COM几就把主程序里的下图数字改成几，第二个参数是波特率，串口助手波特率设置一致，串口助手打开串口，主程序发送数据，在串口助手上观察。

串口的更多玩法自己开拓~

五、作业

感谢SCU的作业，搬搬