码迷，mamicode.com
首页 > 其他好文 > 详细

串口封装

时间：2014-11-10 15:50:14      阅读：138      评论：0      收藏：0      [点我收藏+]

标签：串口

/*
串口基础类库（WIN32） ver 0.1

编译器 ： BC++ 5; C++ BUILDER 4, 5, 6, X; VC++ 5, 6; VC.NET;  GCC;

class   _base_com : 虚基类 基本串口接口;
class   _aync_com : 同步I/O 串口类;
class   _sync_com : 异步I/O 串口类;
class _thread_com : 异步I/O 辅助读监视线程 可转发窗口消息 串口类(可继承虚函数on_receive用于读操作)；

copyright(c) 2004.8 llbird wushaojian@21cn.com
*/

#ifndef _COM_CLASS_H_
#define _COM_CLASS_H_

#include "Global.h"

#pragma warning(disable: 4530)
#pragma warning(disable: 4786)
#pragma warning(disable: 4800)

#include <cassert>
#include <strstream>
#include <algorithm>
#include <exception>
#include <iomanip>
using namespace std;

#include <windows.h>

class _base_com   //虚基类 基本串口接口
{
protected:

 volatile int _port;  //串口号
 volatile HANDLE _com_handle;//串口句柄
 DCB _dcb;     //波特率，停止位，等
 int _in_buf, _out_buf; // 缓冲区
 COMMTIMEOUTS _co;  // 超时时间
 //虚函数,用于不同方式的串口打开
 virtual bool open_port() = 0;

 void init() //初始化
 {
  memset(&_dcb, 0, sizeof(_dcb));
  _dcb.DCBlength = sizeof(_dcb);

  _com_handle = INVALID_HANDLE_VALUE;

  _in_buf = _out_buf = 8192;

  memset(&_co, 0, sizeof(_co));
  _co.ReadIntervalTimeout = 0xFFFFFFFF;
  _co.ReadTotalTimeoutMultiplier = 0;
  _co.ReadTotalTimeoutConstant = 0;
  _co.WriteTotalTimeoutMultiplier = 0;
  _co.WriteTotalTimeoutConstant = 5000;
 }

public:
 _base_com()
 {
  init(); 
 }
 virtual ~_base_com()
 {
  close();     
 }
 /*基本参数设置*/
 //设置串口参数：波特率，停止位，等
 inline bool set_para()
 {
  return is_open() ? SetCommState(_com_handle, &_dcb) : false;
 }
 //打开设置对话框
 bool config_dialog() 
 {
  if(is_open())
  {
   COMMCONFIG cf;
   memset(&cf, 0, sizeof(cf));
   cf.dwSize = sizeof(cf);
   cf.wVersion = 1;

   char com_str[10];
   strcpy(com_str, "COM");
   ltoa(_port, com_str + 3, 10);

   if(CommConfigDialog(com_str, NULL, &cf))
   {
     memcpy(&_dcb, &cf.dcb, sizeof(DCB));
     return SetCommState(_com_handle, &_dcb);
   }
  }
  return false;
 }
 //支持设置字符串 "9600, 8, n, 1"
 bool set_dcb(char *set_str) 
 {
  return bool(BuildCommDCB(set_str, &_dcb));
 }
 //设置内置结构串口参数：波特率，停止位
 bool set_dcb(int BaudRate, int ByteSize = 8, int Parity = NOPARITY, int StopBits = ONESTOPBIT)
 {
  _dcb.BaudRate = BaudRate;
     _dcb.ByteSize = ByteSize;
     _dcb.Parity   = Parity;
     _dcb.StopBits = StopBits;
  return true;
 }
 //设置缓冲区大小
 inline bool set_buf(int in_buf, int out_buf)
 {
  return is_open() ? SetupComm(_com_handle, in_buf, out_buf) : false;
 }
 //打开串口 缺省 9600, 8, n, 1
 inline bool open(int port)
 {
  if(port < 1 || port > 1024)
   return false;

  set_dcb(9600);
  _port = port;

  return open_port();
 }
 //打开串口 缺省 baud_rate, 8, n, 1
 inline bool open(int port, int baud_rate)
 {
  if(port < 1 || port > 1024)
   return false;

  set_dcb(baud_rate);
  _port = port;

  return open_port();
 }
 //打开串口
 inline bool open(int port, char *set_str)
 {
  if(port < 1 || port > 1024)
   return false;

  if(!BuildCommDCB(set_str, &_dcb))
   return false;

  _port = port;

  return open_port();
 }
 //关闭串口
 inline virtual void close()
 {
  if(is_open())  
  {
   CloseHandle(_com_handle);
   _com_handle = INVALID_HANDLE_VALUE;
  }
 }
 //判断串口是或打开
 inline bool is_open()
 {
  return _com_handle != INVALID_HANDLE_VALUE;
 }
 //获得串口句炳
 HANDLE get_handle()
 {
  return _com_handle;
 }
};

class _sync_com : public _base_com
{
protected:
 //打开串口
 virtual bool open_port()
 {
  if(is_open())
   close();

  char com_str[10];
  
  strcpy(com_str, "COM");
  ltoa(_port, com_str + 3, 10);
  _com_handle = CreateFile(
   com_str,
   GENERIC_READ | GENERIC_WRITE,
   0,
   NULL,
   OPEN_EXISTING,
   FILE_ATTRIBUTE_NORMAL , 
   NULL
   );
//  assert(is_open());
  if(!is_open())//检测串口是否成功打开
   return false;
  
  BOOL ret;
  ret = SetupComm(_com_handle, _in_buf, _out_buf); //设置推荐缓冲区
  assert(ret);
  ret &= SetCommState(_com_handle, &_dcb); //设置串口参数：波特率，停止位，等
  assert(ret);
  ret &= SetCommTimeouts(_com_handle, &_co); //设置超时时间
  assert(ret);
  ret &= PurgeComm(_com_handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR ); //清空串口缓冲区
  assert(ret);
  if(!ret)
  {
   close();
   return false;
  }

  return true;
 }

public:

 _sync_com()
 {
  _co.ReadTotalTimeoutConstant = 5000;
 }
 //同步读
 int read(char *buf, int buf_len)
 {
  if(!is_open())
   return 0;

  buf[0] = ‘\0‘;
  
  COMSTAT  stat;
  DWORD error;

  if(ClearCommError(_com_handle, &error, &stat) && error > 0) //清除错误
  {
   PurgeComm(_com_handle, PURGE_RXABORT | PURGE_RXCLEAR); /*清除输入缓冲区*/
   return 0;
  }
  
  unsigned long r_len = 0;

  buf_len = min(buf_len - 1, (int)stat.cbInQue);
  if(!ReadFile(_com_handle, buf, buf_len, &r_len, NULL))
    r_len = 0;
  buf[r_len] = ‘\0‘;

  return r_len;
 }
 //同步写
 int write(char *buf, int buf_len)
 {
  if(!is_open() || !buf)
   return 0;
  
  DWORD    error;
  if(ClearCommError(_com_handle, &error, NULL) && error > 0) //清除错误
   PurgeComm(_com_handle, PURGE_TXABORT | PURGE_TXCLEAR);

  unsigned long w_len = 0;
  if(!WriteFile(_com_handle, buf, buf_len, &w_len, NULL))
   w_len = 0;

  return w_len;
 }
 //同步写
 inline int write(char *buf)
 {
  assert(buf);
  return write(buf, strlen(buf));
 }
 //同步写, 支持部分类型的流输出
 template<typename T>
 _sync_com& operator << (T x)
 {
  strstream s;

  s << x;
  write(s.str(), s.pcount());

  return *this;
 }
};

class _asyn_com : public _base_com
{
protected:

 OVERLAPPED _ro, _wo; // 重叠I/O

 virtual bool open_port()
 {
  if(is_open())
   close();

  char com_str[10];

  strcpy(com_str, "COM");
  ltoa(_port, com_str + 3, 10);
  _com_handle = CreateFile(
   com_str,
   GENERIC_READ | GENERIC_WRITE,
   0,
   NULL,
   OPEN_EXISTING,
   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, //重叠I/O
   NULL
   );
  //assert(is_open());
  if(!is_open())//检测串口是否成功打开
   return false;
  
  BOOL ret;
  ret = SetupComm(_com_handle, _in_buf, _out_buf); //设置推荐缓冲区
  assert(ret);
  ret = SetCommState(_com_handle, &_dcb); //设置串口参数：波特率，停止位，等
  assert(ret);
  ret = SetCommTimeouts(_com_handle, &_co); //设置超时时间
  assert(ret);
  ret = PurgeComm(_com_handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR ); //清空串口缓冲区
  assert(ret);

  return true;
 }

public:

 _asyn_com()
 {
  memset(&_ro, 0, sizeof(_ro));
  memset(&_wo, 0, sizeof(_wo));

  _ro.hEvent = CreateEvent(NULL, true, false, NULL);
  assert(_ro.hEvent != INVALID_HANDLE_VALUE);
  
  _wo.hEvent = CreateEvent(NULL, true, false, NULL);
  assert(_wo.hEvent != INVALID_HANDLE_VALUE); 
 }
 virtual ~_asyn_com()
 {
  close();

  if(_ro.hEvent != INVALID_HANDLE_VALUE)
   CloseHandle(_ro.hEvent);

  if(_wo.hEvent != INVALID_HANDLE_VALUE)
   CloseHandle(_wo.hEvent);
 }
 //异步读
 int read(char *buf, int buf_len)
 {
  if(!is_open())
   return 0;

  buf[0] = ‘\0‘;

  COMSTAT  stat;
  DWORD error;

  if(ClearCommError(_com_handle, &error, &stat) && error > 0) //清除错误
  {
   PurgeComm(_com_handle, PURGE_RXABORT | PURGE_RXCLEAR); /*清除输入缓冲区*/
   return 0;
  }

  if(!stat.cbInQue)// 缓冲区无数据
   return 0;

  unsigned long r_len = 0;

  buf_len = min((int)(buf_len - 1), (int)stat.cbInQue);

  if(!ReadFile(_com_handle, buf, buf_len, &r_len, &_ro)) //2000 下 ReadFile 始终返回 True
  {
   if(GetLastError() == ERROR_IO_PENDING) // 结束异步I/O
   {
    if(!GetOverlappedResult(_com_handle, &_ro, &r_len, false))
    {
     if(GetLastError() != ERROR_IO_INCOMPLETE)//其他错误
       r_len = 0;
    }
   }
   else
    r_len = 0;
  }
   
  buf[r_len] = ‘\0‘;
  return r_len;
 }
 //异步写
 int write(char *buf, int buf_len)
 {
  if(!is_open())
   return 0;

  assert(buf);

  DWORD    error;
  if(ClearCommError(_com_handle, &error, NULL) && error > 0) //清除错误
   PurgeComm(_com_handle, PURGE_TXABORT | PURGE_TXCLEAR); 

  unsigned long w_len = 0, o_len = 0;
  if(!WriteFile(_com_handle, buf, buf_len, &w_len, &_wo))
   if(GetLastError() != ERROR_IO_PENDING)
    w_len = 0;

  return w_len;
 }
 //异步写
 inline int write(char *buf)
 {
  assert(buf);
  return write(buf, strlen(buf));
 }
 //异步写, 支持部分类型的流输出
 template<typename T>
 _asyn_com& operator << (T x)
 {
  strstream s;

  s << x ;
  write(s.str(), s.pcount());

  return *this;
 }
};

//当接受到数据送到窗口的消息
#define ON_COM_RECEIVE WM_USER + 618  //  WPARAM 端口号

class _thread_com : public _asyn_com
{
protected:
 volatile HANDLE _thread_handle; //辅助线程
 volatile HWND _notify_hwnd; // 通知窗口
 volatile long _notify_num;//接受多少字节(>_notify_num)发送通知消息
 volatile bool _run_flag; //线程运行循环标志

 OVERLAPPED _wait_o; //WaitCommEvent use

 //线程收到消息自动调用, 如窗口句柄有效, 送出消息, 包含窗口编号
 virtual void on_receive()
 {
  if(_notify_hwnd)
   PostMessage(_notify_hwnd, ON_COM_RECEIVE, WPARAM(_port), LPARAM(0));
 }
 //打开串口,同时打开监视线程
 virtual bool open_port()
 {
  if(_asyn_com::open_port())
  {
   _run_flag = true;
   DWORD id;
   _thread_handle = CreateThread(NULL, 0, com_thread, this, 0, &id); //辅助线程
   assert(_thread_handle);
   if(!_thread_handle)
   {
    CloseHandle(_com_handle);
    _com_handle = INVALID_HANDLE_VALUE;
   }
   else
    return true;
  }
  return false;
 }

public:
 _thread_com()
 {
  _notify_num = 0;
  _notify_hwnd = NULL;
  _thread_handle = NULL;

  memset(&_wait_o, 0, sizeof(_wait_o));
  _wait_o.hEvent = CreateEvent(NULL, true, false, NULL);
  assert(_wait_o.hEvent != INVALID_HANDLE_VALUE); 
 }
 ~_thread_com()
 {
  close();

  if(_wait_o.hEvent != INVALID_HANDLE_VALUE)
   CloseHandle(_wait_o.hEvent);
 }
 //设定发送通知, 接受字符最小值  默认 0
 void set_notify_num(int num)
 {
  _notify_num = num;
 }
 //送消息的窗口句柄
 inline void set_hwnd(HWND hWnd)
 {
  _notify_hwnd = hWnd;
 }
 //关闭线程及串口
 virtual void close()
 {
  if(is_open())  
  {
   _run_flag = false;
   SetCommMask(_com_handle, 0);
   ResetEvent(_wait_o.hEvent);

   if(WaitForSingleObject(_thread_handle, 100) != WAIT_OBJECT_0)
    TerminateThread(_thread_handle, 0);

   CloseHandle(_com_handle);
   CloseHandle(_thread_handle);

   _thread_handle = NULL;
   _com_handle = INVALID_HANDLE_VALUE;
  }
 }
 /*辅助线程控制*/
 //获得线程句柄
 HANDLE get_thread()
 {
  return _thread_handle;
 }
 //暂停监视线程
 bool suspend()
 {
  return _thread_handle != NULL ? SuspendThread(_thread_handle) != 0xFFFFFFFF : false;
 }
 //恢复监视线程
 bool resume()
 {
  return _thread_handle != NULL ? ResumeThread(_thread_handle) != 0xFFFFFFFF : false;
 }

private:
 //监视线程
 static DWORD WINAPI com_thread(LPVOID para)
 {
  _thread_com *pcom = (_thread_com *)para; 
  

        if(!SetCommMask(pcom->_com_handle, EV_RXCHAR | EV_ERR))
   return 0;

  COMSTAT  stat;
  DWORD error;


  for(DWORD length, mask = 0; pcom->_run_flag && pcom->is_open(); mask = 0)
  {
   if(!WaitCommEvent(pcom->_com_handle, &mask, &pcom->_wait_o))
   {
    if(GetLastError() == ERROR_IO_PENDING)
    {
     GetOverlappedResult(pcom->_com_handle, &pcom->_wait_o, &length, true);
    }
   }

   if(mask & EV_ERR) // == EV_ERR
    ClearCommError(pcom->_com_handle, &error, &stat);

   if(mask & EV_RXCHAR) // == EV_RXCHAR
   {
    ClearCommError(pcom->_com_handle, &error, &stat);
    if(stat.cbInQue > pcom->_notify_num)
     pcom->on_receive();
   }
        }

  return 0;
 } 
};

#endif _COM_CLASS_H_

串口封装

标签：串口

原文地址：http://embeded.blog.51cto.com/3989210/1574920
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！