C++中的串口通信

最近在做一个利用身份证阅读器,阅读身份证信息后,并根据信息控制逻辑控制器,打开对应的端口.需要使用到串口通讯。
在windows系统，串行口和其它通信设备都是作为文件进行处理的。串行口的打开、关闭、发送和接收所用的函数都与操作文件的函数相同。总体来说，利用Visual C＋＋进行异步串行通信程序设计通常可以分为4个大阶段，它们是串行口打开阶段、串行口状态值读取和属性设置阶段、串行数据的发送与接收阶段，以及串行口关闭阶段。

1） 打开串行口
在对串行口进行所有的操作之前，首先要将其打开。串行口的打开可以使用CreateFile函数，CreateFile函数将返回一个句柄，在随后与该串行口相关的各种操作中使用。与文件操作相同，在利用CreateFile打开串行口时，也可以将串行口指定为“读访问权限”、“写访问权限”或“读写访问权限”。

HANDLE CreateFile（
LPCTSTR  lpFileName
DWORD   dwDesiredAccess
DWORD   dwSharedMode
LPSECURITY_ATTRIBUTES  lpSecurityAttributes
DWORD   dwCreationDisposition
DWORD   dwFlagsAndAttributes
HANDLE   hTemplateFile
)；

在调用成功时，CreateFile返回打开文件的句柄，该句柄将在以后与该串口相关的各个调用函数中使用。如果调用失败，则CreateFile返回INVALID_HANDLE_VALUE。

（2） 串行口的状态读取和属性设置
一旦将串口打开，就可以对该串口的属性进行设置。由于串口的属性非常复杂，因此通常采用读取该串口当前状态值，然后在此基础上进行修改的方法。
n 获取串行口当前状态
windows系统使用GetCommState函数获取串行口的当前配置，GetCommState的声明如下：

BOOL  GetCommState（
      HANDLE hFile
      LPDCB  lpDCB
）；

GetCommState函数的第一个参数hFile是由CreateFile函数返回指向已打开串行口的句柄。第二个参数指向设备控制块DCB。DCB是一个非常重要的数据结构，几乎所有的串行口属性和状态都存储在该结构的成员变量中。
n 对串口进行设置
windows系统利用SetCommState函数修改串行口的当前参数配置。SetCommState函数声明如下：

BOOL  SetCommState（
      HANDLE hFile
      LPDCB  lpDCB
）；

GetCommState函数的第一个参数hFile是由CreateFile函数返回指向已打开串行口的句柄。第二个参数指向设备控制块DCB。如果函数调用成功，则返回值为非0；若函数调用失败，则返回值为0。当应用程序仅仅需要修改一部分串行口的配置值时，可以通过GetCommState函数获得当前的DCB结构，然后更改参数，再调用SetCommState函数设置修改过的DCB来配置串行口。

n 为串口分配接收和发送缓冲区

当一个串行口打开时，可以为该串口分配一个发送缓冲区和一个接收缓冲区。串行口发送缓冲区和接收缓冲区的配置可以由函数SetupComm实现。如果不调用SetupComm，系统会为该串口分配默认的发送缓冲区和接收缓冲区。但是为了保证缓冲区的大小与实际需要的一致，最好调用该函数进行设置。SetupComm函数原型如下：

BOOL  SetupComm（
     HANDLE hFile
     DWORD dwInQueue
     DWORD dwOutQueue
）；

其中hFile是由CreateFile函数返回指向已打开串行口的句柄。参数dwInQueue和dwOutQueue分别指定应用程序推荐使用的接收缓冲区和发送缓冲区的大小。
n 清空接收和发送缓冲区
在进行串口所有的发送和接收数据操作之前，最好使用PurgeComm函数将串行口发送缓冲区和接收缓冲区中的数据清楚干净。PurgeComm函数原型如下：

BOOL  PurgeComm（
     HANDLE  hFile
     DWORD   dwFlages
）；

参数hFile是由CreateFile函数返回指向已打开串行口的句柄，参数dwFlags指明执行的动作。如果dwFlags为PURGE_TXCLEAR，则通知系统清空发送缓冲区；如果dwFlags为PURGE_RXCLEAR，则通知系统清空接收缓冲区；如果需要将发送缓冲区和接收缓冲区全部清空，可以把dwFlags设置为PURGE_TXCLEAR|PURGE_RXCLEAR。如果PurgeComm函数调用成功，则返回值为非0；若函数调用失败，则返回值为0。

（3） 串行数据的发送和接收
与普通的文件操作相同，在对串行口进行操作时，通常利用ReadFile函数读取串行口收到的数据，利用WriteFile将需要发送的数据写如串行口。
n 串行数据的接收
利用ReadFile函数可以读取将串行口接收到的数据。ReadFile函数原型如下：

BOOL  ReadFile（
HANDLE  hFile
LPVIOD   lpBuffer
DWORD   nNumberOfBytesToRead
LPDWORD   lpNumberOfBytesRead
LPOVERLAPPED  lpOverlapped
）；

其中参数hFile指向已经打开的串行口句柄；lpBuffer指向一个读取数据缓冲区；nNumberOfBytesToRead指定要从串行设备中读取的字节数；lpNumberOfBytesRead指明实际从串行口中读出的字节数；lpOverlapped指向一个OVERLAPPED结构变量，该结构变量中包含一个同步事件。

通常如果调用成功，ReadFile返回非0值；否则返回值为0。但是对于接收操作在后台进行的串口来说，返回值为0不一定说明函数调用失败。此时可以调用GetLastError函数获取进一步的信息。如果GetLastError返回值为ERROR_IO_PENDING，则说明该读取串口的操作仍然处于后台等待状态，而非一个真正意义上的错误。

n 串行数据的发送
利用WriteFile函数可以向串行口写入数据。WriteFile函数原型如下：

BOOL  WriteFile（
HANDLE  hFile
LPVIOD   lpBuffer
DWORD   nNumberOfBytesToWrite
LPDWORD   lpNumberOfBytesWritten
LPOVERLAPPED  lpOverlapped
）；

其中参数hFile指向已经打开的串行口句柄；lpBuffer指向一个发送数据缓冲区；nNumberOfBytesToRead指定要从串行设备中发送的字节数；lpNumberOfBytesRead指明实际从串行口中发送的字节数；lpOverlapped指向一个OVERLAPPED结构变量，该结构变量中包含一个同步事件。

通常如果调用成功，WriteFile返回非0值；否则返回值为0。但是对于发送操作在后台进行的串口来说，返回值为0不一定说明函数调用失败。此时可以调用GetLastError函数获取进一步的信息。如果GetLastError返回值为ERROR_IO_PENDING，则说明该写入串口的操作仍然处于后台等待状态，而非一个真正意义上的错误。

（4） 关闭串行口
在用完串行口后通常要将其关闭。如果忘记关闭，该串口会始终处于打开状态，其它的应用程序就不能打开或使用它。
关闭串口可以使用函数CloseHandle，其函数原型如下：

BOOL  CloseHandle（
    HANDLE  hObject
）；

CloseHandle函数非常简单，其中hObject为该打开串口的句柄。如果该函数调用成功，则返回值为非0；否则返回值为0。

下面我将自己用C++编写的串口通信的例子贴出来，其特点如下：
1. 本例子使用了比较规范的软件设计方法，类的设计具有比较好的可扩展性和移植性、代码的注释采用doxgen支持的javaDoc风格。
2. 为了能方便初学者更快地了解和入门，几乎每一行代码都加上了详细的注释，对于注释中如果依然有不清楚的概念，相信你通过百度和google一定能找到答案。
3. 本例子设计的串口操作类可以直接移植到其他的工程中去，大家也可以根据自己的需要添加其他的接口。
4. 本例子只实现了串口数据的基本收发功能，其实为了保证串口数据传输的正确性，往往需要设计一些串口通信协议，协议的设计有待你自己完成，如果以后有时间，我也会尝试提供一种比较基本的串口通信协议设计案例给大家学习。

//
/// 
/// @file    SerialPort.h  
/// @brief   串口通信类头文件
///
/// 本文件完成串口通信类的声明
///
///
///  修订说明：
//

#ifndef SERIALPORT_H_
#define SERIALPORT_H_

#include <Windows.h>

/** 串口通信类
 *   
 *  本类实现了对串口的基本操作
 *  例如监听发到指定串口的数据、发送指定数据到串口
 */
class CSerialPort
{
public:
	CSerialPort(void);
	~CSerialPort(void);

public:

	/** 初始化串口函数
	 *
	 *  @param:  UINT portNo 串口编号,默认值为1,即COM1,注意,尽量不要大于9
	 *  @param:  UINT baud   波特率,默认为9600
	 *  @param:  char parity 是否进行奇偶校验,'Y'表示需要奇偶校验,'N'表示不需要奇偶校验
	 *  @param:  UINT databits 数据位的个数,默认值为8个数据位
	 *  @param:  UINT stopsbits 停止位使用格式,默认值为1
	 *  @param:  DWORD dwCommEvents 默认为EV_RXCHAR,即只要收发任意一个字符,则产生一个事件
	 *  @return: bool  初始化是否成功
	 *  @note:   在使用其他本类提供的函数前,请先调用本函数进行串口的初始化
	 *　　　　　 \n本函数提供了一些常用的串口参数设置,若需要自行设置详细的DCB参数,可使用重载函数
	 *           \n本串口类析构时会自动关闭串口,无需额外执行关闭串口
	 *  @see:    
	 */
	bool InitPort( UINT  portNo = 1,UINT  baud = CBR_9600,char  parity = 'N',UINT  databits = 8, 
		           UINT  stopsbits = 1,DWORD dwCommEvents = EV_RXCHAR);

	/** 串口初始化函数
	 *
	 *  本函数提供直接根据DCB参数设置串口参数
	 *  @param:  UINT portNo
	 *  @param:  const LPDCB & plDCB
	 *  @return: bool  初始化是否成功
	 *  @note:   本函数提供用户自定义地串口初始化参数
	 *  @see:    
	 */
	bool InitPort( UINT  portNo ,const LPDCB& plDCB );

	/** 开启监听线程
	 *
	 *  本监听线程完成对串口数据的监听,并将接收到的数据打印到屏幕输出
	 *  @return: bool  操作是否成功
	 *  @note:   当线程已经处于开启状态时,返回flase
	 *  @see:    
	 */
	bool OpenListenThread();

	/** 关闭监听线程
	 *
	 *  
	 *  @return: bool  操作是否成功
	 *  @note:   调用本函数后,监听串口的线程将会被关闭
	 *  @see:    
	 */
	bool CloseListenTread();

    /** 向串口写数据
	 *
	 *  将缓冲区中的数据写入到串口
	 *  @param:  unsigned char * pData 指向需要写入串口的数据缓冲区
	 *  @param:  unsigned int length 需要写入的数据长度
	 *  @return: bool  操作是否成功
	 *  @note:   length不要大于pData所指向缓冲区的大小
	 *  @see:    
	 */
	bool WriteData(unsigned char* pData, unsigned int length);

	/** 获取串口缓冲区中的字节数
	 *
	 *  
	 *  @return: UINT  操作是否成功
	 *  @note:   当串口缓冲区中无数据时,返回0
	 *  @see:    
	 */
	UINT GetBytesInCOM();

	/** 读取串口接收缓冲区中一个字节的数据
	 *
	 *  
	 *  @param:  char & cRecved 存放读取数据的字符变量
	 *  @return: bool  读取是否成功
	 *  @note:   
	 *  @see:    
	 */
	bool ReadChar(char &cRecved);

private:

	/** 打开串口
	 *
	 *  
	 *  @param:  UINT portNo 串口设备号
	 *  @return: bool  打开是否成功
	 *  @note:   
	 *  @see:    
	 */
	bool openPort( UINT  portNo );

	/** 关闭串口
	 *
	 *  
	 *  @return: void  操作是否成功
	 *  @note:   
	 *  @see:    
	 */
	void ClosePort();

	/** 串口监听线程
	 *
	 *  监听来自串口的数据和信息
	 *  @param:  void * pParam 线程参数
	 *  @return: UINT WINAPI 线程返回值
	 *  @note:   
	 *  @see:    
	 */
	static UINT WINAPI ListenThread(void* pParam);

private:

	/** 串口句柄 */ 
	HANDLE  m_hComm;

	/** 线程退出标志变量 */ 
	static bool s_bExit;

	/** 线程句柄 */ 
	volatile HANDLE    m_hListenThread;

	/** 同步互斥,临界区保护 */ 
	CRITICAL_SECTION   m_csCommunicationSync;       //!< 互斥操作串口

	UINT m_portNo;					//端口号

};

#endif //SERIALPORT_H_

[size=medium][color=orange]SerialPort.cpp 类[/color][/size]

//
/// 
/// @file    SerialPort.cpp  
/// @brief   串口通信类的实现文件
///
/// 本文件为串口通信类的实现代码
///
/// 
///
///  修订说明：
//

#include "StdAfx.h"
#include "SerialPort.h"
#include <process.h>
#include <iostream>


/** 线程退出标志 */ 
bool CSerialPort::s_bExit = false;
/** 当串口无数据时,sleep至下次查询间隔的时间,单位:秒 */ 
const UINT SLEEP_TIME_INTERVAL = 5;

CSerialPort::CSerialPort(void)
: m_hListenThread(INVALID_HANDLE_VALUE)
{
	m_hComm = INVALID_HANDLE_VALUE;
	m_hListenThread = INVALID_HANDLE_VALUE;

	InitializeCriticalSection(&m_csCommunicationSync);

}

CSerialPort::~CSerialPort(void)
{
	CloseListenTread();
	ClosePort();
	DeleteCriticalSection(&m_csCommunicationSync);
}

bool CSerialPort::InitPort( UINT portNo /*= 1*/,UINT baud /*= CBR_9600*/,char parity /*= 'N'*/,
						    UINT databits /*= 8*/, UINT stopsbits /*= 1*/,DWORD dwCommEvents /*= EV_RXCHAR*/ )
{
	m_portNo = portNo;

	/** 临时变量,将制定参数转化为字符串形式,以构造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 )
	{
		// 将ANSI字符串转换为UNICODE字符串
		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(pwText, &dcb) ;

		//2014-1-15日周改
		bIsSuccess = GetCommState(m_hComm, &dcb) && BuildCommDCB(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 CSerialPort::InitPort( UINT portNo ,const LPDCB& plDCB )
{
	m_portNo = portNo;

	/** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */ 
	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 CSerialPort::ClosePort()
{
	/** 如果有串口被打开，关闭它 */
	if( m_hComm != INVALID_HANDLE_VALUE )
	{
		CloseHandle( m_hComm );
		m_hComm = INVALID_HANDLE_VALUE;
	}
}

bool CSerialPort::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)
	{
		LeaveCriticalSection(&m_csCommunicationSync);
		return false;
	}

	/** 退出临界区 */ 
	LeaveCriticalSection(&m_csCommunicationSync);

	return true;
}

bool CSerialPort::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 CSerialPort::CloseListenTread()
{	
	if (m_hListenThread != INVALID_HANDLE_VALUE)
	{
		/** 通知线程退出 */ 
		s_bExit = true;

		/** 等待线程退出 */ 
		Sleep(10);

		/** 置线程句柄无效 */ 
		CloseHandle( m_hListenThread );
		m_hListenThread = INVALID_HANDLE_VALUE;
	}
	return true;
}

UINT CSerialPort::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 CSerialPort::ListenThread( void* pParam )
{
	/** 得到本类的指针 */ 
	CSerialPort *pSerialPort = reinterpret_cast<CSerialPort*>(pParam);

	char icdata[BUFFER_SIZE];
	int iCount = 0;

	int DLE = 16;

	bool flag = false;

	int STA = 2;
	bool lenFlag = false;
	int iLen;

	memset(&icdata[0],0,BUFFER_SIZE);

	// 线程循环,轮询方式读取串口数据
	while (!pSerialPort->s_bExit) 
	{
		UINT BytesInQue = pSerialPort->GetBytesInCOM();
		/** 如果串口输入缓冲区中无数据,则休息一会再查询 */ 
		if ( BytesInQue == 0 )
		{
			Sleep(SLEEP_TIME_INTERVAL);
			continue;
		}

		/** 读取输入缓冲区中的数据并输出显示 */
		char cRecved = 0x00;
		do
		{
			cRecved = 0x00;
			if(pSerialPort->ReadChar(cRecved) == true)
			{


				if (cRecved == STA){
					lenFlag = true;
					flag = false;
					goto data;
				}

				if (cRecved == DLE){
					flag = true;
					continue;
				}


				if (flag){
					cRecved = cRecved - 64;
					flag = false;
				}

				if (lenFlag)
				{
					iLen = cRecved;
					lenFlag = false;
				}

			data:
				icdata[iCount] = cRecved;
				iCount ++ ;
				continue;
			}
		}while(--BytesInQue);

		if (iCount>=iLen)
		{

			//AfxGetApp()->m_pMainWnd->PostMessageA(WM_DataRefen,0,(LPARAM)cardData);
		}
	}

	return 0;
}

bool CSerialPort::ReadChar( 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 == 1);

}

bool CSerialPort::WriteData( unsigned char* pData, unsigned int length )
{
	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;
}

[size=large][color=darkred]以上代码就是C++中串口通信的基本方法了,记录下来方便以后使用的时候可以方便查找.[/color][/size]