开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > GPS编程 > 查看源码
_com.h
资源名称：GPS_test.rar　[点击查看]
上传用户：fudaml
上传日期：2013-05-28
资源大小：211k
文件大小：15k
源码类别：

GPS编程

开发平台：

Visual C++

_com.h：源码内容
  1. /*
  2. 串口基础类库（WIN32） ver 0.1
  4. 编译器 ： BC++ 5; C++ BUILDER 4, 5, 6, X; VC++ 5, 6; VC.NET;  GCC;
  6. class   _base_com : 虚基类 基本串口接口;
  7. class   _sync_com : 同步I/O 串口类;
  8. class   _asyn_com : 异步I/O 串口类;
  9. class _thread_com : 异步I/O 辅助读监视线程 可转发窗口消息 串口类(可继承虚函数on_receive用于读操作)；
  10. class        _com : _thread_com 同名
  12. copyright(c) 2004.8 llbird wushaojian@21cn.com
  13. */
  14. /*
  15. Example :
  16. */
  17. #ifndef _COM_H_
  18. #define _COM_H_
  20. #pragma warning(disable: 4530)
  21. #pragma warning(disable: 4786)
  22. #pragma warning(disable: 4800)
  24. #include <cassert>
  25. #include <strstream>
  26. #include <algorithm>
  27. #include <exception>
  28. #include <iomanip>
  29. #include <fstream>
  30. using namespace std;
  32. #include "GPSParam.h"
  33. #include <windows.h>
  35. class _base_com   //虚基类 基本串口接口
  36. {
  37. protected:
  39.  volatile int _port;  //串口号
  40.  volatile HANDLE _com_handle;//串口句柄
  41.  char _com_str[20];
  42.  DCB _dcb;     //波特率，停止位，等
  43.  COMMTIMEOUTS _co;  // 超时时间
  45.  virtual bool open_port() = 0;
  46.  void init() //初始化
  47.  {
  48.   memset(_com_str, 0, 20);
  49.   memset(&_co, 0, sizeof(_co));
  50.   memset(&_dcb, 0, sizeof(_dcb));
  51.   _dcb.DCBlength = sizeof(_dcb);
  52.   _com_handle = INVALID_HANDLE_VALUE;
  53.  }                  
  54.  virtual bool setup_port()
  55.  {
  56.   if(!is_open())
  57.    return false;
  59.   if(!SetupComm(_com_handle, 8192, 8192))
  60.    return false; //设置推荐缓冲区
  62.   if(!GetCommTimeouts(_com_handle, &_co))
  63.    return false;
  64.   _co.ReadIntervalTimeout = 0xFFFFFFFF;
  65.   _co.ReadTotalTimeoutMultiplier = 0;
  66.   _co.ReadTotalTimeoutConstant = 0;
  67.   _co.WriteTotalTimeoutMultiplier = 0;
  68.   _co.WriteTotalTimeoutConstant = 2000;
  69.   if(!SetCommTimeouts(_com_handle, &_co))
  70.   return false; //设置超时时间
  72.   if(!PurgeComm(_com_handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR ))
  73.   return false; //清空串口缓冲区
  75.   return true;
  76.  }       
  77.  inline void set_com_port(int port)
  78.  {
  79.   char p[12];
  80.   _port = port;
  81.   strcpy(_com_str, "\\.\COM"); 
  82.   ltoa(_port, p, 10);
  83.   strcat(_com_str, p);
  84.  }
  85. public:
  86.  _base_com()
  87.  {
  88.   init(); 
  89.  }
  90.  virtual ~_base_com()
  91.  {
  92.   close();      
  93.  }
  94.  //设置串口参数：波特率，停止位，等 支持设置字符串 "9600, 8, n, 1"
  95.  bool set_state(char *set_str) 
  96.  {
  97.   if(is_open())
  98.   {
  99.    if(!GetCommState(_com_handle, &_dcb))
  100.     return false;
  101.    if(!BuildCommDCB(set_str, &_dcb))
  102.     return false;
  103.    return SetCommState(_com_handle, &_dcb) == TRUE;
  104.   }
  105.   return false;
  106.  }
  107.  //设置内置结构串口参数：波特率，停止位
  108.  bool set_state(int BaudRate = 9600, int ByteSize = 8, int Parity = NOPARITY, int StopBits = ONESTOPBIT, char EvtChar='n' )
  109.  {
  110.  if(is_open())
  111.  {
  112.  if(!GetCommState(_com_handle, &_dcb))
  113.  return false;
  114.  _dcb.BaudRate = BaudRate;
  115.  _dcb.ByteSize = ByteSize;
  116.  _dcb.Parity   = Parity;
  117.  _dcb.StopBits = StopBits;
  118.  _dcb.EvtChar  = EvtChar;
  119.  return SetCommState(_com_handle, &_dcb) == TRUE;
  120.  }
  121.  return false;
  122.  }
  123.  //打开串口 缺省 9600, 8, n, 1
  124.  inline bool open(int port)
  125.  {
  126.  return open(port, 9600);
  127.  }
  128.  //打开串口 缺省 baud_rate, 8, n, 1
  129.  inline bool open(int port, int baud_rate)
  130.  {
  131.   if(port < 1 || port > 1024)
  132.    return false;
  134.   set_com_port(port);
  136.   if(!open_port())
  137.    return false;
  139.   if(!setup_port())
  140.    return false;
  142.   return set_state(baud_rate);
  143.  }
  144.  //打开串口
  145.  inline bool open(int port, char *set_str)
  146.  {
  147.   if(port < 1 || port > 1024)
  148.    return false;
  150.   set_com_port(port);
  152.   if(!open_port())
  153.    return false;
  155.   if(!setup_port())
  156.    return false;
  158.   return set_state(set_str);
  159.   
  160.  }
  161.  inline bool set_buf(int in, int out)
  162.  {
  163.   return is_open() ? SetupComm(_com_handle, in, out) : false;
  164.  }
  165.  //关闭串口
  166.  inline virtual void close()
  167.  {
  168.   if(is_open())  
  169.   {
  170.    CloseHandle(_com_handle);
  171.    _com_handle = INVALID_HANDLE_VALUE;
  172.   }
  173.  }
  174.  //判断串口是或打开
  175.  inline bool is_open()
  176.  {
  177.   return _com_handle != INVALID_HANDLE_VALUE;
  178.  }
  179.  //获得串口句炳
  180.  HANDLE get_handle()
  181.  {
  182.   return _com_handle;
  183.  }
  184.  operator HANDLE()
  185.  {
  186.   return _com_handle;
  187.  }
  188. };
  190. class _sync_com : public _base_com
  191. {
  192. protected:
  193.  //打开串口
  194.  virtual bool open_port()
  195.  {
  196.   if(is_open())
  197.    close();
  199.   _com_handle = CreateFile(
  200.    _com_str,
  201.    GENERIC_READ | GENERIC_WRITE,
  202.    0,
  203.    NULL,
  204.    OPEN_EXISTING,
  205.    FILE_ATTRIBUTE_NORMAL , 
  206.    NULL
  207.    );
  208.   assert(is_open());
  209.   return is_open();//检测串口是否成功打开
  210.  }
  212. public:
  214.  _sync_com()
  215.  {
  216.  }
  217.  //同步读
  218.  int read(char *buf, int buf_len)
  219.  {
  220.   if(!is_open())
  221.    return 0;
  223.   buf[0] = '';
  224.   
  225.   COMSTAT  stat;
  226.   DWORD error;
  228.   if(ClearCommError(_com_handle, &error, &stat) && error > 0) //清除错误
  229.   {
  230.    PurgeComm(_com_handle, PURGE_RXABORT | PURGE_RXCLEAR); /*清除输入缓冲区*/
  231.    return 0;
  232.   }
  233.    
  234.   unsigned long r_len = 0;
  236.   buf_len = min(buf_len - 1, (int)stat.cbInQue);
  237.   if(!ReadFile(_com_handle, buf, buf_len, &r_len, NULL))
  238.     r_len = 0;
  239.   buf[r_len] = '';
  241.   return r_len;
  242.  }
  243.  //同步写
  244.  int write(char *buf, int buf_len)
  245.  {
  246.   if(!is_open() || !buf)
  247.    return 0;
  248.   
  249.   DWORD    error;
  250.   if(ClearCommError(_com_handle, &error, NULL) && error > 0) //清除错误
  251.    PurgeComm(_com_handle, PURGE_TXABORT | PURGE_TXCLEAR);
  253.   unsigned long w_len = 0;
  254.   if(!WriteFile(_com_handle, buf, buf_len, &w_len, NULL))
  255.    w_len = 0;
  257.   return w_len;
  258.  }
  259.  //同步写
  260.  inline int write(char *buf)
  261.  {
  262.   assert(buf);
  263.   return write(buf, strlen(buf));
  264.  }
  265.  //同步写, 支持部分类型的流输出
  266.  template<typename T>
  267.  _sync_com& operator << (T x)
  268.  {
  269.   strstream s;
  271.   s << x;
  272.   write(s.str(), s.pcount());
  274.   return *this;
  275.  }
  276. };
  278. class _asyn_com : public _base_com
  279. {
  280. protected:
  282.  OVERLAPPED _ro, _wo; // 重叠I/O
  284.  virtual bool open_port()
  285.  {
  286.   if(is_open())
  287.    close();
  289.   _com_handle = CreateFile(
  290.    _com_str,
  291.    GENERIC_READ | GENERIC_WRITE,
  292.    0,
  293.    NULL,
  294.    OPEN_EXISTING,
  295.    FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, //重叠I/O
  296.    NULL
  297.    );
  298.   //assert(is_open());
  299.   return is_open();//检测串口是否成功打开
  300.  }
  302. public:
  304.  _asyn_com()
  305.  {
  306.   memset(&_ro, 0, sizeof(_ro));
  307.   memset(&_wo, 0, sizeof(_wo));
  309.   _ro.hEvent = CreateEvent(NULL, true, false, NULL);
  310.   assert(_ro.hEvent != INVALID_HANDLE_VALUE); 
  311.   
  312.   _wo.hEvent = CreateEvent(NULL, true, false, NULL);
  313.   assert(_wo.hEvent != INVALID_HANDLE_VALUE); 
  314.  }
  315.  virtual ~_asyn_com()
  316.  {
  317.   close();
  319.   if(_ro.hEvent != INVALID_HANDLE_VALUE)
  320.    CloseHandle(_ro.hEvent);
  322.   if(_wo.hEvent != INVALID_HANDLE_VALUE)
  323.    CloseHandle(_wo.hEvent);
  324.  }
  325.  //异步读
  326.  int read(char *buf, int buf_len, int time_wait = 20)
  327.  {
  328.   if(!is_open())
  329.    return 0;
  331.   buf[0] = '';
  333.   COMSTAT  stat;
  334.   DWORD error;
  336.   if(ClearCommError(_com_handle, &error, &stat) && error > 0) //清除错误
  337.   {
  338.    PurgeComm(_com_handle, PURGE_RXABORT | PURGE_RXCLEAR); /*清除输入缓冲区*/
  339.    return 0;
  340.   }
  342.   if(!stat.cbInQue)// 缓冲区无数据
  343.    return 0;
  345.   unsigned long r_len = 0;
  347.   buf_len = min((int)(buf_len ), (int)stat.cbInQue);
  349.   if(!ReadFile(_com_handle, buf, buf_len, &r_len, &_ro)) //2000 下 ReadFile 始终返回 True
  350.   {
  351.    if(GetLastError() == ERROR_IO_PENDING) // 结束异步I/O
  352.    {
  353.     //WaitForSingleObject(_ro.hEvent, time_wait); //等待20ms
  354.     if(!GetOverlappedResult(_com_handle, &_ro, &r_len, false))
  355.     {
  356.      if(GetLastError() != ERROR_IO_INCOMPLETE)//其他错误
  357.        r_len = 0;
  358.     }
  359.    }
  360.    else
  361.     r_len = 0;
  362.   }
  363.    
  364.   buf[r_len] = '';
  365.   return r_len;
  366.  }
  367.  //异步写
  368.  int write(char *buf, int buf_len)
  369.  {
  370.   if(!is_open())
  371.    return 0;
  372.   
  373.   DWORD    error;
  374.   if(ClearCommError(_com_handle, &error, NULL) && error > 0) //清除错误
  375.    PurgeComm(_com_handle, PURGE_TXABORT | PURGE_TXCLEAR); 
  377.   unsigned long w_len = 0, o_len = 0;
  378.   if(!WriteFile(_com_handle, buf, buf_len, &w_len, &_wo))
  379.    if(GetLastError() != ERROR_IO_PENDING)
  380.     w_len = 0;
  382.   return w_len;
  383.  }
  384.  //异步写
  385.  inline int write(char *buf)
  386.  {
  387.   assert(buf);
  388.   return write(buf, strlen(buf));
  389.  }
  390.  //异步写, 支持部分类型的流输出
  391.  template<typename T>
  392.  _asyn_com& operator << (T x)
  393.  {
  394.   strstream s;
  396.   s << x ;
  397.   write(s.str(), s.pcount());
  399.   return *this;
  400.  }
  401. };
  403. //当接受到数据送到窗口的消息
  404. #define ON_COM_RECEIVE WM_USER + 618  //  WPARAM 端口号
  406. class _thread_com : public _asyn_com
  407. {
  408. protected:
  409.  volatile HANDLE _thread_handle; //辅助线程
  410.  volatile HANDLE _file_thread_handle; //文件辅助线程
  411.  CString m_filename; //文件名
  412.  volatile HWND _notify_hwnd; // 通知窗口
  413.  volatile long _notify_num;//接受多少字节(>_notify_num)发送通知消息
  414.  volatile bool _run_flag; //线程运行循环标志
  415.  void (*_func)(WPARAM wp, LPARAM lp);
  417. // GPSParam gps; //存储临时gps返回参数
  418.  OVERLAPPED _wait_o; //WaitCommEvent use
  420.  //线程收到消息自动调用, 如窗口句柄有效, 送出消息, 包含窗口编号
  421.  virtual void on_receive()
  422.  {
  423.  char str[270];
  424.  memset(str,10,270);
  425.  this->read(str,270);
  427.  int j=0;
  428.  bool start=false;
  429.  char order[90];
  430.  for( int i=0; i<270; i++)
  431.  {
  432.  switch(str[i])
  433.  {
  434.  case '$':
  435.  start=true;
  436.  order[0]='$';
  437.  j=1;
  438.  break;
  439.  case 10:
  440.  if( start ) //得到一个完整指令
  441.  {
  443. ////////////////////////////////////
  444. ///如果，消息响应不及时，gps内存有可能泄露
  445.  GPSParam *gps=new GPSParam;
  446.  gps->SetParam(order,90);
  447.  if(gps->DataTransform())
  448.  {
  449.  if(_notify_hwnd)
  450.  {
  451.  PostMessage( _notify_hwnd, ON_COM_RECEIVE, WPARAM(gps), 0 );
  452.  }
  453.  else
  454.  ; ///////////////////
  455.  }
  456. //////////////////////////////////////////////////////
  457. /*
  458.  //GPSParam gps(order,90);
  459.  gps.SetParam(order,j);
  460.  if(gps.DataTransform())
  461.  {
  462.  if(_notify_hwnd)
  463.  PostMessage( _notify_hwnd, ON_COM_RECEIVE, WPARAM(gps.X), LPARAM(gps.Y) );
  464.  else
  465.  ; ///////////////////
  467.  }
  468. */
  469.  }
  470.  start=false;
  471.  j=0;
  472.  memset(order,0,90);
  473.  break;
  474.  default:
  475.  {
  476.  if( start )
  477.  {
  478.  order[j]=str[i];
  479.  j++;
  480.  }
  481.  }
  482.  }
  483.  
  484.  }
  487. /*
  488.   if(_notify_hwnd)
  489.    PostMessage(_notify_hwnd, ON_COM_RECEIVE, WPARAM(_port), LPARAM(0));
  490.   else
  491.   {
  492.    if(_func)
  493.     _func(_port);
  495.   }
  496. */
  498.  }
  499.  //打开串口,同时打开监视线程
  500.  virtual bool open_port()
  501.  {
  502.   if(_asyn_com::open_port())
  503.   {
  504.    _run_flag = true; 
  505.    DWORD id;
  506.    _thread_handle = CreateThread(NULL, 0, com_thread, this, 0, &id); //辅助线程
  507.    assert(_thread_handle);
  508.    if(!_thread_handle)
  509.    {
  510.     CloseHandle(_com_handle);
  511.     _com_handle = INVALID_HANDLE_VALUE;
  512.    }
  513.    else
  514.     return true;
  515.   }
  516.   return false;
  517.  }
  519. public:
  520.  _thread_com()
  521.  {
  522.   _notify_num = 250;
  523.   _notify_hwnd = NULL;
  524.   _thread_handle = NULL;
  525.   _file_thread_handle = NULL;
  526.   _func = NULL;
  528.   memset(&_wait_o, 0, sizeof(_wait_o));
  529.   _wait_o.hEvent = CreateEvent(NULL, true, false, NULL);
  530.   assert(_wait_o.hEvent != INVALID_HANDLE_VALUE); 
  531.  }
  532.  ~_thread_com()
  533.  {
  534.   close();
  536.   if(_wait_o.hEvent != INVALID_HANDLE_VALUE)
  537.    CloseHandle(_wait_o.hEvent);
  538.  }
  539.  //设定发送通知, 接受字符最小值
  540.  void set_notify_num(int num)
  541.  {
  542.   _notify_num = num;
  543.  }
  544.  int get_notify_num()
  545.  {
  546.   return _notify_num;
  547.  }
  548.  //送消息的窗口句柄
  549.  inline void set_hwnd(HWND hWnd)
  550.  {
  551.   _notify_hwnd = hWnd;
  552.  }
  553.  inline HWND get_hwnd()
  554.  {
  555.   return _notify_hwnd;
  556.  }
  557.  inline void set_func(void (*f)(WPARAM wp, LPARAM lp))
  558.  {
  559.   _func = f;
  560.  }
  561.  //关闭线程及串口
  562.  virtual void close()
  563.  {
  564.   if(is_open())  
  565.   {
  566.    _run_flag = false;
  567.    SetCommMask(_com_handle, 0);
  568.    SetEvent(_wait_o.hEvent);
  570.    if(WaitForSingleObject(_thread_handle, 100) != WAIT_OBJECT_0)
  571.     TerminateThread(_thread_handle, 0);
  573.    CloseHandle(_com_handle);
  574.    CloseHandle(_thread_handle);
  576.    _thread_handle = NULL;
  577.    _com_handle = INVALID_HANDLE_VALUE;
  578.    ResetEvent(_wait_o.hEvent);
  579.   }
  580.  }
  581.  /*辅助线程控制*/
  582.  //获得线程句柄
  583.  HANDLE get_thread()
  584.  {
  585.   return _thread_handle;
  586.  }
  587.  //暂停监视线程
  588.  bool suspend()
  589.  {
  590.   return _thread_handle != NULL ? SuspendThread(_thread_handle) != 0xFFFFFFFF : false;
  591.  }
  592.  //恢复监视线程
  593.  bool resume()
  594.  {
  595.   return _thread_handle != NULL ? ResumeThread(_thread_handle) != 0xFFFFFFFF : false;
  596.  }
  597.  //重建监视线程
  598.  bool restart() 
  599.  {
  600.   if(_thread_handle) /*只有已有存在线程时*/
  601.   {
  602.    _run_flag = false;
  603.    SetCommMask(_com_handle, 0);
  604.    SetEvent(_wait_o.hEvent);
  606.    if(WaitForSingleObject(_thread_handle, 100) != WAIT_OBJECT_0)
  607.     TerminateThread(_thread_handle, 0);
  609.    CloseHandle(_thread_handle);
  611.    _run_flag = true;
  612.    _thread_handle = NULL;
  614.    DWORD id;
  615.    _thread_handle = CreateThread(NULL, 0, com_thread, this, 0, &id);
  616.    return (_thread_handle != NULL); //辅助线程
  617.   }
  618.   return false;
  619.  }
  620. bool Open_file(CString str)
  621. {
  622. if (_file_thread_handle ==NULL) 
  623. {
  624. m_filename=str;
  625. DWORD id;
  626. _file_thread_handle=CreateThread(NULL,0,file_thread,this,0,&id);
  627. return (_file_thread_handle != NULL);
  628. }
  629. return false;
  630. }
  631. private:
  632.  //监视线程
  633.  static DWORD WINAPI com_thread(LPVOID para)
  634.  {
  635.  _thread_com *pcom = (_thread_com *)para; 
  636.  
  637.  //制定串口的监视事件 接收到一个字符 或者出现错误
  638.  if(!SetCommMask(pcom->_com_handle, EV_RXCHAR | EV_ERR | EV_RXFLAG ) )
  639.  return 0;
  640.  
  641.  COMSTAT  stat;
  642.  DWORD error;
  643.  
  644.  for(DWORD length, mask = 0; pcom->_run_flag && pcom->is_open(); mask = 0)
  645.  {
  646.  if(!WaitCommEvent(pcom->_com_handle, &mask, &pcom->_wait_o))
  647.  {
  648.  if(GetLastError() == ERROR_IO_PENDING)
  649.  {
  650.  GetOverlappedResult(pcom->_com_handle, &pcom->_wait_o, &length, true);
  651.  }
  652.  }
  654.  //错误处理
  655.  if ( mask & EV_ERR ) //线上错误
  656.  ClearCommError(pcom->_com_handle, &error, &stat);
  657.  
  658.  //接收到事件字符
  659.  if( mask & EV_RXFLAG ) //  EV_RXFLAG事件产生
  660.  {
  661.  ClearCommError(pcom->_com_handle, &error, &stat);
  662.  pcom->on_receive();
  663.  }
  665.  //接收到一个字符处理
  666.  if(mask & EV_RXCHAR) // == EV_RXCHAR
  667.  {
  668.  ClearCommError(pcom->_com_handle, &error, &stat);
  669.  if(stat.cbInQue > pcom->_notify_num)
  670.  pcom->on_receive();
  671.  }
  672.  }
  674.  return 0;
  675.  }
  676.  static DWORD WINAPI file_thread(LPVOID para)
  677.  {  
  678.  _thread_com *pcom = (_thread_com *)para; 
  679.  
  680.  ifstream in;
  681.  in.open(pcom->m_filename);
  683.  while (true)
  684.  {
  685. // Sleep(5);
  686.  char str[270];
  687.  memset(str,10,270);
  688.  if( !in.getline(str,270)  )
  689.  break;
  690.  
  691.  int j=0;
  692.  bool start=false;
  693.  char order[90]; //存储一条指令
  694.  for( int i=0; i<270; i++)
  695.  {
  696.  switch(str[i])
  697.  {
  698.  case '$':
  699.  start=true;
  700.  order[0]='$';
  701.  j=1;
  702.  break;
  703.  case 10:
  704.  if( start ) //得到一个完整指令
  705.  {
  706.  GPSParam *gps=new GPSParam;
  707.  gps->SetParam(order,90);
  708.  if(gps->DataTransform())
  709.  {
  710.  if(pcom->_notify_hwnd)
  711.  {
  712.  PostMessage( pcom->_notify_hwnd, ON_COM_RECEIVE, WPARAM(gps), 0 );
  713.  }
  714.  else
  715.  delete gps; ///////////////////
  716.  /*
  717.  if( pcom->_func )
  718.  {
  719. //  pcom->_func( (WPARAM)gps,(LPARAM)pcom->_notify_hwnd );
  720.  }
  721.  else
  722.  delete gps;
  723.  */
  724.  }
  725.  else
  726.  delete gps;
  727. // delete gps;
  728.  }
  729.  start=false;
  730.  j=0;
  731.  memset(order,0,90);
  732.  break;
  733.  default:
  734.  {
  735.  if( start )
  736.  {
  737.  order[j]=str[i];
  738.  j++;
  739.  }
  740.  }
  741.  }
  742.  
  743.  }
  744.  
  745.  }
  746.  return 0;
  747.  }
  748. };
  750. typedef _thread_com _com; //名称简化
  752. #endif //_COM_H_