C++串口通信

一、串口通信的基本原理
        串口的本质功能是作为 CPU 和串行设备间的编码转换器。当数据从 CPU 经过串行端口发送出去时，字节数据转换为串行的位（bit）；在接收数据时，串行的位被转换为字节数据。应用程序要使用串口进行通信，必须在使用之前向操作系统提出资源申请要求（打开串口），通信完成后必须释放资源（关闭串口）。典型地，串口用于 ASCII 码字符的传输。通信使用3根线完成：地线，发送数据线，接收数据线。

        串口通信最重要的参数是波特率、数据位、停止位和奇偶校验。对于两个进行通行的端口，这些参数必须匹配：

（1）波特率是一个衡量通信速度的参数，它表示每秒钟传送的 bit 的个数；

（2）数据位是衡量通信中实际数据位的参数，当计算机发送一个信息包，标准的值是 5，7 和 8 位。如何设置取决于你的需求；

（3）停止位用于表示单个包的最后一位，典型的值为 1，1.5和 2 位，停止位不仅仅是表示传输的结束，并且提供计算机校正时钟同步的机会；

（4）奇偶校验位是串口通信中一种简单的检错方式，有四种检错方式——偶、奇、高和低，也可以没有校验位。

二、C++代码实现

1、头文件“SerialPort.h”

1. #ifndef _CSerialPort_H
2. #define _CSerialPort_H
3. using namespace std;
5. class CSerialPort
6. {
7. public:
8. CSerialPort();
9. ~CSerialPort();
11. // 打开串口,成功返回true，失败返回false
12. // portname(串口名): 在Windows下是"COM1""COM2"等，在Linux下是"/dev/ttyS1"等
13. // baudrate(波特率): 9600、19200、38400、43000、56000、57600、115200
14. // parity(校验位): 0为无校验，1为奇校验，2为偶校验，3为标记校验
15. // databit(数据位): 4-8，通常为8位
16. // stopbit(停止位): 1为1位停止位，2为2位停止位,3为1.5位停止位
17. // synchronizable(同步、异步): 0为异步，1为同步
18. bool open(const char* portname, int baudrate = 115200, char parity = 0, char databit = 8, char stopbit = 1, char synchronizeflag = 0);
20. //关闭串口，参数待定
21. void close();
23. //发送数据或写数据，成功返回发送数据长度，失败返回0
24. int send(string dat);
26. //接受数据或读数据，成功返回读取实际数据的长度，失败返回0
27. string receive();
29. private:
30. int pHandle[16];
31. char synchronizeflag;
32. };
34. #endif

复制代码

2、cpp文件“SerialPort.cpp”

1. #include "stdafx.h"
2. #include "SerialPort.h"
3. #include <WinSock2.h>
5. using namespace std;
7. CSerialPort::CSerialPort()
8. {
10. }
12. CSerialPort::~CSerialPort()
13. {
15. }
17. bool CSerialPort::open(const char* portname, int baudrate, char parity, char databit, char stopbit, char synchronizeflag)
18. {
19. this->synchronizeflag = synchronizeflag;
20. HANDLE hCom = NULL;
21. if (this->synchronizeflag)
22. {
23. //同步方式
24. hCom = CreateFileA(portname, //串口名
25. GENERIC_READ | GENERIC_WRITE, //支持读写
26. 0, //独占方式，串口不支持共享
27. NULL,//安全属性指针，默认值为NULL
28. OPEN_EXISTING, //打开现有的串口文件
29. 0, //0：同步方式，FILE_FLAG_OVERLAPPED：异步方式
30. NULL);//用于复制文件句柄，默认值为NULL，对串口而言该参数必须置为NULL
31. }
32. else
33. {
34. //异步方式
35. hCom = CreateFileA(portname, //串口名
36. GENERIC_READ | GENERIC_WRITE, //支持读写
37. 0, //独占方式，串口不支持共享
38. NULL,//安全属性指针，默认值为NULL
39. OPEN_EXISTING, //打开现有的串口文件
40. FILE_FLAG_OVERLAPPED, //0：同步方式，FILE_FLAG_OVERLAPPED：异步方式
41. NULL);//用于复制文件句柄，默认值为NULL，对串口而言该参数必须置为NULL
42. }
44. if (hCom == (HANDLE)-1)
45. {
46. return false;
47. }
49. //配置缓冲区大小
50. if (!SetupComm(hCom, 1024, 1024))
51. {
52. return false;
53. }
55. // 配置参数
56. DCB p;
57. memset(&p, 0, sizeof(p));
58. p.DCBlength = sizeof(p);
59. p.BaudRate = baudrate; // 波特率
60. p.ByteSize = databit; // 数据位
62. switch (parity) //校验位
63. {
64. case 0:
65. p.Parity = NOPARITY; //无校验
66. break;
67. case 1:
68. p.Parity = ODDPARITY; //奇校验
69. break;
70. case 2:
71. p.Parity = EVENPARITY; //偶校验
72. break;
73. case 3:
74. p.Parity = MARKPARITY; //标记校验
75. break;
76. }
78. switch (stopbit) //停止位
79. {
80. case 1:
81. p.StopBits = ONESTOPBIT; //1位停止位
82. break;
83. case 2:
84. p.StopBits = TWOSTOPBITS; //2位停止位
85. break;
86. case 3:
87. p.StopBits = ONE5STOPBITS; //1.5位停止位
88. break;
89. }
91. if (!SetCommState(hCom, &p))
92. {
93. // 设置参数失败
94. return false;
95. }
97. //超时处理,单位：毫秒
98. //总超时＝时间系数×读或写的字符数＋时间常量
99. COMMTIMEOUTS TimeOuts;
100. TimeOuts.ReadIntervalTimeout = 1000; //读间隔超时
101. TimeOuts.ReadTotalTimeoutMultiplier = 500; //读时间系数
102. TimeOuts.ReadTotalTimeoutConstant = 5000; //读时间常量
103. TimeOuts.WriteTotalTimeoutMultiplier = 500; // 写时间系数
104. TimeOuts.WriteTotalTimeoutConstant = 2000; //写时间常量
105. SetCommTimeouts(hCom, &TimeOuts);
107. PurgeComm(hCom, PURGE_TXCLEAR | PURGE_RXCLEAR);//清空串口缓冲区
109. memcpy(pHandle, &hCom, sizeof(hCom));// 保存句柄
111. return true;
112. }
114. void CSerialPort::close()
115. {
116. HANDLE hCom = *(HANDLE*)pHandle;
117. CloseHandle(hCom);
118. }
120. int CSerialPort::send(string dat)
121. {
122. HANDLE hCom = *(HANDLE*)pHandle;
124. if (this->synchronizeflag)
125. {
126. // 同步方式
127. DWORD dwBytesWrite = dat.length(); //成功写入的数据字节数
128. BOOL bWriteStat = WriteFile(hCom, //串口句柄
129. (char*)dat.c_str(), //数据首地址
130. dwBytesWrite, //要发送的数据字节数
131. &dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
132. NULL); //NULL为同步发送，OVERLAPPED*为异步发送
133. if (!bWriteStat)
134. {
135. return 0;
136. }
137. return dwBytesWrite;
138. }
139. else
140. {
141. //异步方式
142. DWORD dwBytesWrite = dat.length(); //成功写入的数据字节数
143. DWORD dwErrorFlags; //错误标志
144. COMSTAT comStat; //通讯状态
145. OVERLAPPED m_osWrite; //异步输入输出结构体
147. //创建一个用于OVERLAPPED的事件处理，不会真正用到，但系统要求这么做
148. memset(&m_osWrite, 0, sizeof(m_osWrite));
149. m_osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, L"WriteEvent");
151. ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误，获得设备当前状态
152. BOOL bWriteStat = WriteFile(hCom, //串口句柄
153. (char*)dat.c_str(), //数据首地址
154. dwBytesWrite, //要发送的数据字节数
155. &dwBytesWrite, //DWORD*，用来接收返回成功发送的数据字节数
156. &m_osWrite); //NULL为同步发送，OVERLAPPED*为异步发送
157. if (!bWriteStat)
158. {
159. if (GetLastError() == ERROR_IO_PENDING) //如果串口正在写入
160. {
161. WaitForSingleObject(m_osWrite.hEvent, 1000); //等待写入事件1秒钟
162. }
163. else
164. {
165. ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
166. CloseHandle(m_osWrite.hEvent); //关闭并释放hEvent内存
167. return 0;
168. }
169. }
170. return dwBytesWrite;
171. }
172. }
174. string CSerialPort::receive()
175. {
176. HANDLE hCom = *(HANDLE*)pHandle;
177. string rec_str = "";
178. char buf[1024];
179. if (this->synchronizeflag)
180. {
181. //同步方式
182. DWORD wCount = 1024; //成功读取的数据字节数
183. BOOL bReadStat = ReadFile(hCom, //串口句柄
184. buf, //数据首地址
185. wCount, //要读取的数据最大字节数
186. &wCount, //DWORD*,用来接收返回成功读取的数据字节数
187. NULL); //NULL为同步发送，OVERLAPPED*为异步发送
188. for (int i = 0; i < 1024; i++)
189. {
190. if (buf[i] != -52)
191. rec_str += buf[i];
192. else
193. break;
194. }
195. return rec_str;
196. }
197. else
198. {
199. //异步方式
200. DWORD wCount = 1024; //成功读取的数据字节数
201. DWORD dwErrorFlags; //错误标志
202. COMSTAT comStat; //通讯状态
203. OVERLAPPED m_osRead; //异步输入输出结构体
205. //创建一个用于OVERLAPPED的事件处理，不会真正用到，但系统要求这么做
206. memset(&m_osRead, 0, sizeof(m_osRead));
207. m_osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, L"ReadEvent");
209. ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误，获得设备当前状态
210. if (!comStat.cbInQue)return 0; //如果输入缓冲区字节数为0，则返回false
211. //std::cout << comStat.cbInQue << std::endl;
212. BOOL bReadStat = ReadFile(hCom, //串口句柄
213. buf, //数据首地址
214. wCount, //要读取的数据最大字节数
215. &wCount, //DWORD*,用来接收返回成功读取的数据字节数
216. &m_osRead); //NULL为同步发送，OVERLAPPED*为异步发送
217. if (!bReadStat)
218. {
219. if (GetLastError() == ERROR_IO_PENDING) //如果串口正在读取中
220. {
221. //GetOverlappedResult函数的最后一个参数设为TRUE
222. //函数会一直等待，直到读操作完成或由于错误而返回
223. GetOverlappedResult(hCom, &m_osRead, &wCount, TRUE);
224. }
225. else
226. {
227. ClearCommError(hCom, &dwErrorFlags, &comStat); //清除通讯错误
228. CloseHandle(m_osRead.hEvent); //关闭并释放hEvent的内存
229. return 0;
230. }
231. }
232. for (int i = 0; i<1024; i++)
233. {
234. if (buf[i] != -52)
235. rec_str += buf[i];
236. else
237. break;
238. }
239. return rec_str;
240. }
241. }

复制代码