一个简单得异步串口类

/*
一个简单异步串口类（WIN32），这个是我自己一直使用得串口类

这个异步类只实现了一些简单功能。在使用时候需要注意下面几点：
1。串口得相关参数需要在open之前设置好，打开之后，就不能设置了
2。读取串口数据采取查询方式
3。向串口发送数据函数得执行需要一定得时间，知道成功它才返回。
4。默认是没有硬件握手得，如果要握手，需要调用函数setflowctrl
5。串口波特率直接传递数值就可以，比如9600。
如果有问题，请与我联系。Email:stevecrise@163.com
优快云上帐号：stevecrisewu(月亮骑士)

说明：
1。发送数据用write函数，直到成功才返回（如果没有其他错误的话）
2。读取数据用read函数，能够立刻返回，需要你定时去调用。当然，你也可以用消息通知的办法，你可以创建一个线程来给你的应用程序发送消息。
3。获取线控状态函数用getlstatus函数，如下示就可以返回DSR,CTS，RI和CD的线的状态。
      value=getlstatus();
     DSR=value&S_DSR;
     CTS=value&S_CTS;
     RI=value&S_RI;
     CD=value&S_CD;
*/
#include <windows.h>

/* MODEM CONTROL setting */
#define C_DTR  0x01
#define C_RTS  0x02

/* MODEM LINE STATUS */
#define S_CTS  0x01
#define S_DSR  0x02
#define S_RI  0x04
#define S_CD  0x08

#define SIO_OK  0
#define SIO_ERROR -1 

class CAsynComm 
{
public:
 //构造函数
 CAsynComm();
 //析构函数
 virtual ~CAsynComm();
protected:
 //串口号
 volatile int nPort; 
 //串口句柄
 volatile HANDLE ComHandle;
 //DCB结构
 DCB MyDcb;  
 //输入输出缓冲区大小
 int InbufSize, OutbufSize;
 //超时参数
 COMMTIMEOUTS coTimeOut;
 //OVERLAPPED结构
 OVERLAPPED ro,wo;
 //初始化函数
 void Init();
 //判断串口是否打开函数
 bool IsOpen(); 
public:
 //从串口读取一个字符，返回SIO_ERROR表示失败，否则为0-255之间的一个数
 int getch();
 //向串口写一个字符，返回SIO_ERROR表示失败，SIO_OK表示成功写入
 int putch(char ch);
 //从串口读取len个字符并放到缓冲区buf中，返回SIO_ERROR表示失败，否则返回实际读取的字符数
 int read(char *buf, int len);
 //向串口写入len个字符，返回SIO_ERROR表示失败，否则返回实际写入串口的字符数
 int write(char *buf, int len);    
 //关闭串口
 int close();
 //打开串口，port为串口号，默认打开9600,n,8,1，无硬件握手
 virtual int open(int port);
 //设置串口通信参数
 int setsetting(int BaudRate, int ByteSize = 8, int Parity = NOPARITY, int StopBits = ONESTOPBIT);
 //设置硬件握手
 int setflowctrl();
 //读取控制线状态
 int getlstatus();
 //设置DTR状态
 int setdtr(bool enable);
 //设置RTS状态
 int setrts(bool enable);
 //设置超时时间
 int settimeout(unsigned long ulTimeOut);
 //设置输入输出缓冲区大小函数
 int setiosize(int isize,int osize);
};

cpp文件如下：

#include "AsynComm.h"
//初始化串口
CAsynComm::CAsynComm()
{
 Init(); 
}

//关闭串口并释放资源
CAsynComm::~CAsynComm()
{
 close();
 if(ro.hEvent != INVALID_HANDLE_VALUE)
  CloseHandle(ro.hEvent);

 if(wo.hEvent != INVALID_HANDLE_VALUE)
  CloseHandle(wo.hEvent); 
}

//初始化函数
void CAsynComm::Init()
{
 memset(&MyDcb, 0, sizeof(MyDcb));
 MyDcb.DCBlength = sizeof(MyDcb);
 
 MyDcb.BaudRate = 9600;  //通信速率
 MyDcb.ByteSize = 8;  //比特位 
 MyDcb.Parity   = NOPARITY; //奇偶校验位
 MyDcb.StopBits = ONESTOPBIT; //停止位
 
 ComHandle = INVALID_HANDLE_VALUE; //初始化为无效句柄
 
 InbufSize = 8192;  //默认输入缓冲为8k
 OutbufSize = 8192;  //默认输出缓冲为8k
 memset(&coTimeOut, 0, sizeof(coTimeOut)); //定义超时，默认为5秒
 coTimeOut.ReadIntervalTimeout = 0xFFFFFFFF;
 coTimeOut.ReadTotalTimeoutMultiplier = 0;
 coTimeOut.ReadTotalTimeoutConstant = 0;
 coTimeOut.WriteTotalTimeoutMultiplier = 0;
 coTimeOut.WriteTotalTimeoutConstant = 5000;
 
 memset(&ro, 0, sizeof(ro));  //读入时候得重叠结构
 memset(&wo, 0, sizeof(wo));  //写入时候得重叠结构
 ro.hEvent = CreateEvent(NULL, true, false, NULL); 
 wo.hEvent = CreateEvent(NULL, true, false, NULL);  
}

//返回TRUE表示串口处于open状态
bool CAsynComm::IsOpen()
{
 return (ComHandle!=INVALID_HANDLE_VALUE); 
}

//关闭串口
int CAsynComm::close()
{
 if(IsOpen()) CloseHandle(ComHandle);   
 ComHandle = INVALID_HANDLE_VALUE;
 return SIO_OK; 
}

//异步读函数
//buf为用户提供得暂存缓冲区，len为缓冲区大小
//函数返回SIO_ERROR表示读取失败，原因可能是串口没有打开等
//函数返回非负数表示成功读取得字节数
int CAsynComm::read(char *buf, int len)
{
 if(!IsOpen()) return SIO_ERROR; //串口没有打开
 memset(buf,0,len);

 COMSTAT  stat;
 DWORD error;

 if(ClearCommError(ComHandle, &error, &stat) && error > 0)  //清除错误
 {
  PurgeComm(ComHandle, PURGE_RXABORT | PURGE_RXCLEAR);
  return SIO_ERROR;
 }
 if(!stat.cbInQue) return SIO_ERROR;  //如果缓冲区没有数据，直接返回

 unsigned long count = 0;
 len = min((int)(len - 1), (int)stat.cbInQue);  //取缓存中得实际数据和len得最小值

 if(!ReadFile(ComHandle, buf, len, &count, &ro))  //如果调用失败，则看错误类型,count包含了读取得实际字节
 {
  if(GetLastError() == ERROR_IO_PENDING)   
  {
   if(!GetOverlappedResult(ComHandle, &ro, &count, false))
   {
    if(GetLastError() != ERROR_IO_INCOMPLETE) count = 0;
   }
  }
  else
   count = 0;
 }   
 
 if(count>0) 
 {
  buf[count] = '/0'; 
  return count; 
 }
 return SIO_ERROR;
}

//从缓冲区中读取一个字节函数
int CAsynComm::getch()
{
 if(!IsOpen()) return SIO_ERROR; //串口没有打开
 COMSTAT  stat;
 DWORD error;
 char buf[2];

 if(ClearCommError(ComHandle, &error, &stat) && error > 0)  //清除错误
 {
  PurgeComm(ComHandle, PURGE_RXABORT | PURGE_RXCLEAR);
  return SIO_ERROR;
 }
 if(!stat.cbInQue) return SIO_ERROR;  //如果缓冲区没有数据，直接返回
 unsigned long count = 0; 

 if(!ReadFile(ComHandle, buf, 1, &count, &ro))  //如果调用失败，则看错误类型,count包含了读取得实际字节
 {
  if(GetLastError() == ERROR_IO_PENDING)
  {
   if(!GetOverlappedResult(ComHandle, &ro, &count, false))
   {
    if(GetLastError() != ERROR_IO_INCOMPLETE) count = 0;
   }
  }
  else
   count = 0;
 }   
 
 if(count>0) 
 {  
  return ((int)(buf[0])); 
 }
 
 return SIO_ERROR;
}

//异步写函数
//buf为需要写入得数据缓冲区，len为其长度
//返回SIO_ERROR表示写入失败，否则返回实际写入得字节数
//在这里，我们采取了超时机制，知道数据成功写入才返回，超时时间可以用函数settimeout设置
int CAsynComm::write(char *buf, int len)
{
 if(!IsOpen()) return SIO_ERROR;  //串口没有打开

 if(buf==NULL) return SIO_ERROR;
 DWORD    error;
 
 if(ClearCommError(ComHandle, &error, NULL) && error > 0) //清除错误
 {
  PurgeComm(ComHandle, PURGE_TXABORT | PURGE_TXCLEAR); 
 }
 
 unsigned long count = 0;
 unsigned long value=0;
 if(!WriteFile(ComHandle, buf, len, &count, &wo))  //如果调用失败，则看错误类型
 {
  value=GetLastError();
  if(value != ERROR_IO_PENDING) count = 0;  //如果非ERROR_IP_PENDING，则返回错误
  else
  {
   if(!GetOverlappedResult(ComHandle, &wo, &count, TRUE))
   {
    if(GetLastError() != ERROR_IO_INCOMPLETE) count = 0;
   }
  }
 }
 if(count>0) return count;
 return SIO_ERROR;
}

//向缓冲区写一个字节函数
int CAsynComm::putch(char ch)
{
 if(!IsOpen()) return SIO_ERROR; //串口没有打开
 
 DWORD    error;
 char buf[2];
 
 if(ClearCommError(ComHandle, &error, NULL) && error > 0)  //清除错误
 {
  PurgeComm(ComHandle, PURGE_TXABORT | PURGE_TXCLEAR); 
 }
 
 buf[0]=ch;
 buf[1]=0;
 
 unsigned long count = 0;
 
 if(!WriteFile(ComHandle, buf, 1, &count, &wo))  //如果调用失败，则看错误类型
 {
  if(GetLastError() != ERROR_IO_PENDING) count = 0;
  else
  {
   if(!GetOverlappedResult(ComHandle, &wo, &count, TRUE))
   {
    if(GetLastError() != ERROR_IO_INCOMPLETE) count = 0;
   }
  }
 }
 if(count>0) return SIO_OK;
 return SIO_ERROR;
}

//串口打开函数，只需要指定端口号就可以
//对于串口得基本参数，系统默认采取9600,n,8,1和无硬件握手
//如果希望调整参数，请打开串口之前调用setsetting，settimeout，setflowctrl，setiosize等函数
int CAsynComm::open(int port)
{
 if(port>1024 || port<1) return SIO_ERROR;  //非法端口号
 
 if(IsOpen()) close();    //如果已经打开，则关闭
 nPort = port;
 char str[10];
 
 if(ro.hEvent==INVALID_HANDLE_VALUE || wo.hEvent==INVALID_HANDLE_VALUE) return SIO_ERROR; 
 strcpy(str, "COM");
 ltoa(port, str + 3, 10);
 ComHandle = CreateFile(    //打开串口
   str,
   GENERIC_READ | GENERIC_WRITE,
   0,
   NULL,
   OPEN_EXISTING,
   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,  //重叠标志
   NULL
   );
 if(!IsOpen()) return SIO_ERROR;  //打开失败，直接返回
  
 SetupComm(ComHandle, InbufSize, OutbufSize); //设置缓冲区大小
 SetCommState(ComHandle, &MyDcb);  //设置通信参数 
 SetCommTimeouts(ComHandle, &coTimeOut);  //设置超时
 PurgeComm(ComHandle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR ); //清除错误
 
 return SIO_OK; 
}

//设置通信参数
//不允许在串口打开之后还可设置
//BaudRate为通信速率，如9600，19200，38400等，传递时候可直接传递数值
int CAsynComm::setsetting(int BaudRate, int ByteSize, int Parity, int StopBits)
{
 if(IsOpen()) return SIO_ERROR;
 
 MyDcb.BaudRate = BaudRate;
 MyDcb.ByteSize = ByteSize;
 MyDcb.Parity   = Parity;
 MyDcb.StopBits = StopBits;
 
 return SIO_OK;
}

//设置超时时间
//不允许在串口打开之后还可设置
int CAsynComm::settimeout(unsigned long ulTimeOut)
{
 if(IsOpen()) return SIO_ERROR; 
 coTimeOut.WriteTotalTimeoutConstant = ulTimeOut;
 return SIO_OK;
}

//设置硬件握手，流量控制
//不允许在串口打开之后还可设置
int CAsynComm::setflowctrl()
{
 if(IsOpen()) return SIO_ERROR; 
 MyDcb.fOutxCtsFlow=TRUE;
 MyDcb.fRtsControl=TRUE;
 return SIO_OK;
}

//获取线路状态
int CAsynComm::getlstatus()
{
 DWORD  dwEvtmask; 
 int ret=0;
 if(!IsOpen()) return SIO_ERROR; 

 if(GetCommModemStatus(ComHandle,&dwEvtmask)==0)
 {
  return SIO_ERROR;
 }
 ret=dwEvtmask; 
 return ret;
}

//设置DTR线状态
int CAsynComm::setdtr(bool enable)
{
 if(!IsOpen()) return SIO_ERROR;
 
 DWORD data=CLRDTR; 
 if(enable)data=SETDTR;
 if(EscapeCommFunction(ComHandle,data))return SIO_OK;
 return SIO_ERROR;
}

//设置RTS线状态
int CAsynComm::setrts(bool enable)
{
 if(!IsOpen()) return SIO_ERROR;
 
 DWORD data=CLRRTS; 
 if(enable)data=SETRTS;
 if(EscapeCommFunction(ComHandle,data))return SIO_OK;
 return SIO_ERROR;
}

//设置缓冲区参数函数
//不允许在串口打开之后还可设置
int CAsynComm::setiosize(int isize,int osize)
{
 if(IsOpen()) return SIO_ERROR;
 if(isize<=0) return SIO_ERROR;
 if(osize<=0) return SIO_ERROR;
 InbufSize = isize;
 OutbufSize = osize;
 return SIO_OK;
}