comm.cpp

一个串口通信的实例(含源码)ComToCom,我自己写的

// comm.cpp : implementation of the CComm class
//

#include "stdafx.h"
#include "comm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CCommm construction/destruction

CComm::CComm()
{
m_bConnected=FALSE;
m_pThread=NULL;

m_nBaud = 19200;
m_nDataBits = 8;
m_bEcho = FALSE;
m_nFlowCtrl = 0;
m_bNewLine = FALSE;
m_nParity = 0;
m_sPort = "COM1";
m_nStopBits = 0;
// 为WM_COMMNOTIFY消息创建事件对象，手工重置，初始化为有信号的
if((m_hPostMsgEvent=CreateEvent(NULL, TRUE, TRUE, NULL))==NULL)
return;
memset(&m_osRead, 0, sizeof(OVERLAPPED));
memset(&m_osWrite, 0, sizeof(OVERLAPPED));
// 为重叠读创建事件对象，手工重置，初始化为无信号的
if((m_osRead.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL))==NULL)
return;
// 为重叠写创建事件对象，手工重置，初始化为无信号的
if((m_osWrite.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL))==NULL)
return;
}

CComm::~CComm()
{
if(m_bConnected)
CloseConnection();
// 删除事件句柄
if(m_hPostMsgEvent)
CloseHandle(m_hPostMsgEvent);
if(m_osRead.hEvent)
CloseHandle(m_osRead.hEvent);
if(m_osWrite.hEvent)
CloseHandle(m_osWrite.hEvent);
}

/////////////////////////////////////////////////////////////////////////////
// CComm commands

// 打开并配置串行口，建立工作者线程
BOOL CComm::OpenConnection()
{
COMMTIMEOUTS TimeOuts;

if(m_bConnected)
return FALSE;
m_hCom=CreateFile(m_sPort, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 
NULL); // 重叠方式
if(m_hCom==INVALID_HANDLE_VALUE)
return FALSE;
SetupComm(m_hCom,MAXBLOCK,MAXBLOCK);
SetCommMask(m_hCom, EV_RXCHAR);

// 把间隔超时设为最大，把总超时设为0将导致ReadFile立即返回并完成操作
TimeOuts.ReadIntervalTimeout=MAXDWORD; 
TimeOuts.ReadTotalTimeoutMultiplier=0; 
TimeOuts.ReadTotalTimeoutConstant=0; 
/* 设置写超时以指定WriteComm成员函数中的
GetOverlappedResult函数的等待时间*/
TimeOuts.WriteTotalTimeoutMultiplier=50; 
TimeOuts.WriteTotalTimeoutConstant=2000;
SetCommTimeouts(m_hCom, &TimeOuts);

if(ConfigConnection())
{
m_pThread=AfxBeginThread(CommProc, this, THREAD_PRIORITY_NORMAL, 
0, CREATE_SUSPENDED, NULL); // 创建并挂起线程
if(m_pThread==NULL){
CloseHandle(m_hCom);
return FALSE;
}
else{
m_bConnected=TRUE;
m_pThread->ResumeThread(); // 恢复线程运行
}
}
else{
CloseHandle(m_hCom);
return FALSE;
}
return TRUE;
}

// 结束工作者线程，关闭串行口
void CComm::CloseConnection()
{
if(!m_bConnected) return;
m_bConnected=FALSE;
//结束CommProc线程中WaitSingleObject函数的等待
SetEvent(m_hPostMsgEvent); 
//结束CommProc线程中WaitCommEvent的等待
SetCommMask(m_hCom, 0); 
//等待辅助线程终止
WaitForSingleObject(m_pThread->m_hThread, INFINITE);
m_pThread=NULL;
CloseHandle(m_hCom);
}

// 配置串行口
BOOL CComm::ConfigConnection()
{
DCB dcb;

if(!GetCommState(m_hCom, &dcb))
return FALSE;
dcb.fBinary=TRUE;
dcb.BaudRate=m_nBaud; // 波特率
dcb.ByteSize=m_nDataBits; // 每字节位数
dcb.fParity=TRUE;
switch(m_nParity){ // 校验设置
case 0: dcb.Parity=NOPARITY;
break;
case 1: dcb.Parity=EVENPARITY;
break;
case 2: dcb.Parity=ODDPARITY;
break;
default:;
}
switch(m_nStopBits){ // 停止位
case 0: dcb.StopBits=ONESTOPBIT;
break;
case 1: dcb.StopBits=ONE5STOPBITS;
break;
case 2: dcb.StopBits=TWOSTOPBITS;
break;
default:;
}
// 硬件流控制设置
dcb.fOutxCtsFlow=m_nFlowCtrl==1;
dcb.fRtsControl=m_nFlowCtrl==1?RTS_CONTROL_HANDSHAKE:RTS_CONTROL_ENABLE;
// XON/XOFF流控制设置
dcb.fInX=dcb.fOutX=m_nFlowCtrl==2;
dcb.XonChar=XON;
dcb.XoffChar=XOFF;
dcb.XonLim=50;
dcb.XoffLim=50;
return SetCommState(m_hCom, &dcb);
}

// 从串行口输入缓冲区中读入指定数量的字符
DWORD CComm::ReadComm(char *buf,DWORD dwLength)
{
DWORD length=0;
COMSTAT ComStat;
DWORD dwErrorFlags;
CString str,txt;
ClearCommError(m_hCom,&dwErrorFlags,&ComStat);
length=min(dwLength, ComStat.cbInQue);
ReadFile(m_hCom,buf,length,&length,&m_osRead);
buf[length]=0;
return length;
}

// 将指定数量的字符从串行口输出
DWORD CComm::WriteComm(char *buf,DWORD dwLength)
{
BOOL fState;
DWORD length=dwLength;
COMSTAT ComStat;
DWORD dwErrorFlags;

ClearCommError(m_hCom,&dwErrorFlags,&ComStat);
fState=WriteFile(m_hCom,buf,length,&length,&m_osWrite);
if(!fState){
if(GetLastError()==ERROR_IO_PENDING){
GetOverlappedResult(m_hCom,&m_osWrite,&length,TRUE);// 等待
}
else
length=0;
}

return length;
}

LRESULT CComm::OnCommNotify(WPARAM wParam, LPARAM lParam)
{
char buf[MAXBLOCK];
int nLength;

if(!m_bConnected || (wParam & EV_RXCHAR)!=EV_RXCHAR){ // 是否是EV_RXCHAR事件?
SetEvent(m_hPostMsgEvent); // 允许发送下一个WM_COMMNOTIFY消息
return 0L;
									}
nLength=ReadComm(buf,MAXBLOCK);
if(nLength>0)
{
for(int i=0;i<nLength;i++)
{
switch(buf[i]){
	case ' ':
	m_bRinging=false;
	m_strTel=m_strTel.Mid(3);
	if(m_strTel.Left(3)=="532")
	m_strTel=m_strTel.Mid(3);
	TRACE(m_strTel);
	break;
default : 
	if(m_bRinging) m_strTel+=buf[i];
			}
}
}
if(buf[2]=='R'){
m_bRinging=true;
m_strTel.Empty();

}
SetEvent(m_hPostMsgEvent); // 允许发送下一个WM_COMMNOTIFY消息
return 0L;
}

// 工作者线程，负责监视串行口
UINT CommProc(LPVOID pParam)
{
OVERLAPPED os;
DWORD dwMask, dwTrans;
COMSTAT ComStat;
DWORD dwErrorFlags;
CComm *pComm=(CComm*)pParam;

memset(&os, 0, sizeof(OVERLAPPED));
os.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);
if(os.hEvent==NULL){
AfxMessageBox("Can't create event object!");
return (UINT)-1;
}
while(pComm->m_bConnected){
ClearCommError(pComm->m_hCom,&dwErrorFlags,&ComStat);
if(ComStat.cbInQue){
// 无限等待WM_COMMNOTIFY消息被处理完
WaitForSingleObject(pComm->m_hPostMsgEvent, INFINITE);
ResetEvent(pComm->m_hPostMsgEvent);
pComm->OnCommNotify(EV_RXCHAR,0);
continue;
}
dwMask=0;
if(!WaitCommEvent(pComm->m_hCom, &dwMask, &os)){ // 重叠操作
if(GetLastError()==ERROR_IO_PENDING)
// 无限等待重叠操作结果
GetOverlappedResult(pComm->m_hCom, &os, &dwTrans, TRUE);
else{
CloseHandle(os.hEvent);
return (UINT)-1;
}
}
}
CloseHandle(os.hEvent);
return 0;
}