简单的COM串口通信程序,供大家参考实用:
头文件Serial.h:
class CSerial
{
public:
CSerial();
~CSerial();
BOOL Open(int nPort=1,int nBaud=9600,char * nBauds="n");
BOOL Close(void);
int ReadData(void *,int);
int SendData(const char *,int);
int ReadDataWaiting(void);
BOOL IsOpened(void) {return (m_bOpened);}
protected:
BOOL WriteCommByte(unsigned char);
HANDLE m_hIDComDev;
OVERLAPPED m_OverlappedRead,m_OverlappedWrite;
BOOL m_bOpened;
};
实现文件Serial.cpp:
#include "stdafx.h"
#include "Serial.h"
CSerial::CSerial()
{
memset(&m_OverlappedRead,0,sizeof(OVERLAPPED));
memset(&m_OverlappedWrite,0,sizeof(OVERLAPPED));
m_hIDComDev=NULL;
m_bOpened=FALSE;
}
CSerial::~CSerial()
{
Close();
}
BOOL CSerial::Open(int nPort/* =1 */,
int nBaud/* =9600 */,
char *nBauds/* = */)
{
if(m_bOpened)
return(TRUE);
char szPort[15];
char szComParams[50];
DCB dcb;
wsprintf(szPort,"COM%d",nPort);
m_hIDComDev=CreateFile(szPort,
GENERIC_READ|GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
NULL);
if((m_hIDComDev==NULL)&&(m_hIDComDev==INVALID_HANDLE_VALUE))
return(FALSE);
memset(&m_OverlappedRead,0,sizeof(OVERLAPPED));
memset(&m_OverlappedWrite,0,sizeof(OVERLAPPED));
COMMTIMEOUTS CommTimeOuts;
CommTimeOuts.ReadIntervalTimeout=0xFFFFFFFF;
CommTimeOuts.ReadTotalTimeoutMultiplier=0;
CommTimeOuts.ReadTotalTimeoutConstant=0;
CommTimeOuts.WriteTotalTimeoutMultiplier=0;
CommTimeOuts.WriteTotalTimeoutConstant=5000;
SetCommTimeouts(m_hIDComDev,&CommTimeOuts);
wsprintf(szComParams,"COM%d:%d,%s,8,1",nPort,nBaud,&nBauds);
m_OverlappedRead.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
m_OverlappedWrite.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
dcb.DCBlength=sizeof(DCB);
GetCommState(m_hIDComDev,&dcb);
dcb.BaudRate=nBaud;
dcb.ByteSize=8;
unsigned char ucSet;
ucSet=(unsigned char)((FC_RTSCTS&FC_DTRDSR)!=0);
ucSet=(unsigned char)((FC_RTSCTS&FC_RTSCTS)!=0);
ucSet=(unsigned char)((FC_RTSCTS&FC_XONXOFF)!=0);
if(!SetCommState(m_hIDComDev,&dcb)||!SetupComm(m_hIDComDev,10000,10000)||m_OverlappedRead.hEvent==NULL||m_OverlappedWrite.hEvent==NULL)
{
DWORD dwError=GetLastError();
if(m_OverlappedRead.hEvent!=NULL)
CloseHandle(m_OverlappedRead.hEvent);
if(m_OverlappedWrite.hEvent!=NULL)
CloseHandle(m_OverlappedWrite.hEvent);
CloseHandle(m_hIDComDev);
return(FALSE);
}
PurgeComm(m_hIDComDev,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
m_bOpened=TRUE;
return(m_bOpened);
}
BOOL CSerial::Close(void)
{
if(!m_bOpened||m_hIDComDev==NULL) return(NULL);
if(m_OverlappedRead.hEvent!=NULL) CloseHandle(m_OverlappedRead.hEvent);
if(m_OverlappedWrite.hEvent!=NULL) CloseHandle(m_OverlappedWrite.hEvent);
CloseHandle(m_hIDComDev);
m_bOpened=FALSE;
m_hIDComDev=NULL;
return(TRUE);
}
BOOL CSerial::WriteCommByte(unsigned char ucByte)
{
BOOL bWriteStat;
DWORD dwBytesWritten;
bWriteStat=WriteFile(m_hIDComDev,(LPSTR)&ucByte,1,&dwBytesWritten,&m_OverlappedWrite);
if(!bWriteStat && (GetLastError()==ERROR_IO_PENDING))
{
if(WaitForSingleObject(m_OverlappedWrite.hEvent,1000))
dwBytesWritten=0;
else
{
GetOverlappedResult(m_hIDComDev,&m_OverlappedWrite,&dwBytesWritten,FALSE);
m_OverlappedWrite.Offset+=dwBytesWritten;
}
}
return(TRUE);
}
int CSerial::SendData(const char *buffer,int size)
{
if(!m_bOpened||m_hIDComDev==NULL)
return(0);
DWORD dwBytesWritten=0;
int i;
for(i=0;i<size;i++)
{
WriteCommByte(buffer[i]);
dwBytesWritten++;
}
return((int) dwBytesWritten);
}
int CSerial::ReadDataWaiting(void)
{
if(!m_bOpened||m_hIDComDev==NULL)
return(0);
DWORD dwErrorFlags;
COMSTAT Comstat;
ClearCommError(m_hIDComDev,&dwErrorFlags,&Comstat);
return((int)Comstat.cbInQue);
}
int CSerial::ReadData( void *buffer, int limit )
{
if( !m_bOpened || m_hIDComDev == NULL ) return( 0 );
BOOL bReadStatus;
DWORD dwBytesRead, dwErrorFlags;
COMSTAT ComStat;
ClearCommError( m_hIDComDev, &dwErrorFlags, &ComStat );
if( !ComStat.cbInQue ) return( 0 );
dwBytesRead = (DWORD) ComStat.cbInQue;
if( limit < (int) dwBytesRead ) dwBytesRead = (DWORD) limit;
bReadStatus = ReadFile( m_hIDComDev, buffer, dwBytesRead, &dwBytesRead, &m_OverlappedRead );
//bReadStatus = ReadFile(m_hIDComDev, buffer, dwBytesRead, &dwBytesRead, NULL);
if( !bReadStatus )
{
if( GetLastError() == ERROR_IO_PENDING )
{
WaitForSingleObject( m_OverlappedRead.hEvent, 2000 );
return( (int) dwBytesRead );
}
return( dwBytesRead );
}
return( (int) dwBytesRead );
}