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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 单片机开发 > 查看源码
cnComm.h
资源名称：DELTA_PLC.rar　[点击查看]
上传用户：hailongwei
上传日期：2020-11-29
资源大小：5839k
文件大小：12k
源码类别：

单片机开发

开发平台：

Visual C++

cnComm.h：源码内容
  1. /*
  2. 串口基础类库（WIN32） ver 0.2
  4. 编译器 ： BC++ 5; C++ BUILDER 4, 5, 6, X; VC++ 5, 6; VC.NET;  GCC;
  6. 使用:
  8. 定义
  9. cnComm MyComm1(false, 0);//第1个参数为是否启动监视线程， 第2个参数为阻塞（0）/异步方式（默认）
  10. cnComm MyComm2;//默认启动监视线程， 异步
  11. cnComm MyComm3(true);//监视线程， 阻塞
  13. 打开
  14. MyComm1.Open(1);//1-1024  2k支持1024串口
  15. MyComm1.Open(1, 1200);
  16. MyComm1.Open(1, 9600);
  17. MyComm1.Open(1, "9600,8,n,1");//可使用标准的设置字符串
  18. MyComm1.SetBufferSize(1200, 4800)//设置缓冲区大小,可不用设置
  19. MyComm1.SetState("9600,8,n,1")//修改波特率等
  22. 读写
  24. MyComm1.Read(buf, 1000);
  25. MyComm1.Write(buf, 200);
  28. 窗口句柄
  29. MyComm1.SetWnd(hWnd);
  31. 线程控制下面都有注明就不说了
  33. copyright(c) 2004.8 llbird wushaojian@21cn.com
  34. */
  36. #ifndef _CN_COMM_H_
  37. #define _CN_COMM_H_
  39. #pragma warning(disable: 4530)
  40. #pragma warning(disable: 4786)
  41. #pragma warning(disable: 4800)
  43. #include <assert.h>
  44. #include <stdio.h>
  45. #include <windows.h>
  47. //当接受到数据送到窗口的消息
  48. #define ON_COM_RECEIVE WM_USER + 618  //  WPARAM 端口号
  50. class cnComm   
  51. {
  52. public:
  53. cnComm(bool fAutoBeginThread = true, DWORD dwIOMode = FILE_FLAG_OVERLAPPED)
  54. : _dwIOMode(dwIOMode), _fAutoBeginThread(fAutoBeginThread)
  55. {
  56. Init();
  57. }
  58. virtual ~cnComm()
  59. {
  60. Close();
  61. UnInit();
  62. }
  63. //打开串口 缺省 9600, 8, n, 1
  64. inline bool Open(DWORD dwPort)
  65. {
  66. return Open(dwPort, 9600);
  67. }
  68. //打开串口 缺省 baud_rate, 8, n, 1
  69. inline bool Open(DWORD dwPort, DWORD dwBaudRate)
  70. {
  71. if(dwPort < 1 || dwPort > 1024)
  72. return false;
  74. BindCommPort(dwPort);
  76. if(!OpenCommPort())
  77. return false;
  79. if(!SetupPort())
  80. return false;
  82. return SetState(dwBaudRate);
  83. }
  84. //打开串口, 使用类似"9600, 8, n, 1"的设置字符串设置串口
  85. inline bool Open(DWORD dwPort, char *szSetStr)
  86. {
  87. if(dwPort < 1 || dwPort > 1024)
  88. return false;
  90. BindCommPort(dwPort);
  92. if(!OpenCommPort())
  93. return false;
  95. if(!SetupPort())
  96. return false;
  98. return SetState(szSetStr);
  99. }
  100. //判断串口是或打开
  101. inline bool IsOpen()
  102. {
  103. return _hCommHandle != INVALID_HANDLE_VALUE;
  104. }
  105. //获得串口句炳
  106. inline HANDLE GetHandle()
  107. {
  108. return _hCommHandle;
  109. }
  110. //设置串口参数：波特率，停止位，等 支持设置字符串 "9600, 8, n, 1"
  111. bool SetState(char *szSetStr)
  112. {
  113. if(IsOpen())
  114. {
  115. if(!::GetCommState(_hCommHandle, &_DCB))
  116. return false;
  117. if(!::BuildCommDCB(szSetStr, &_DCB))
  118. return false;
  119. return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
  120. }
  121. return false;
  122. }
  123. //设置串口参数：波特率，停止位
  124. bool SetState(DWORD dwBaudRate, DWORD dwByteSize = 8, DWORD dwParity = NOPARITY, DWORD dwStopBits = ONESTOPBIT)
  125. {
  126. if(IsOpen())
  127. {
  128. if(!::GetCommState(_hCommHandle, &_DCB))
  129. return false;
  130. _DCB.BaudRate = dwBaudRate;
  131.     _DCB.ByteSize = (unsigned char)dwByteSize;
  132.     _DCB.Parity   = (unsigned char)dwParity;
  133. _DCB.StopBits = (unsigned char)dwStopBits;
  134. return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
  135. }
  136. return false;
  137. }
  138. //设置串口的I/O缓冲区大小
  139. bool SetBufferSize(DWORD dwInputSize, DWORD dwOutputSize)
  140. {
  141. if(IsOpen())
  142. return ::SetupComm(_hCommHandle, dwInputSize, dwOutputSize);
  143. return false;
  144. }
  145. //读取串口 dwBufferLength - 1 个字符到 szBuffer 返回实际读到的字符数
  146. DWORD Read(char *szBuffer, DWORD dwBufferLength, DWORD dwWaitTime = 20)
  147. {
  148. if(!IsOpen())
  149. return 0;
  151. szBuffer[0] = '';
  153. COMSTAT  Stat;
  154. DWORD dwError;
  156. if(::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0) //清除错误
  157. {
  158. ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR); /*清除输入缓冲区*/
  159. return 0;
  160. }
  162. if(!Stat.cbInQue)// 缓冲区无数据
  163. return 0;
  165. unsigned long uReadLength = 0;
  167. dwBufferLength = dwBufferLength - 1 > Stat.cbInQue ? Stat.cbInQue : dwBufferLength - 1;
  169. if(!::ReadFile(_hCommHandle, szBuffer, dwBufferLength, &uReadLength, &_ReadOverlapped)) //2000 下 ReadFile 始终返回 True
  170. {
  171. if(::GetLastError() == ERROR_IO_PENDING) // 结束异步I/O
  172. {
  173. WaitForSingleObject(_ReadOverlapped.hEvent, dwWaitTime); //等待20ms
  174. if(!::GetOverlappedResult(_hCommHandle, &_ReadOverlapped, &uReadLength, false))
  175. {
  176. if(::GetLastError() != ERROR_IO_INCOMPLETE)//其他错误
  177. uReadLength = 0;
  178. }
  179. }
  180. else
  181. uReadLength = 0;
  182. }
  184. szBuffer[uReadLength] = '';
  185. return uReadLength;
  186. }
  187. //写串口 szBuffer
  188. DWORD Write(char *szBuffer, DWORD dwBufferLength)
  189. {
  190. if(!IsOpen())
  191. return 0;
  193. DWORD dwError;
  195. if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) //清除错误
  196. ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
  198. unsigned long uWriteLength = 0;
  200. if(!::WriteFile(_hCommHandle, szBuffer, dwBufferLength, &uWriteLength, &_WriteOverlapped))
  201. if(::GetLastError() != ERROR_IO_PENDING)
  202. uWriteLength = 0;
  204. return uWriteLength;
  205. }
  206. //写串口 szBuffer
  207. inline DWORD Write(char *szBuffer)
  208. {
  209. assert(szBuffer);
  211. return Write(szBuffer, (DWORD)strlen(szBuffer));
  212. }
  213. //强制同步写
  214. //  inline DWORD WriteSync(char *szBuffer, DWORD dwBufferLength)
  215. //  {
  216. //  if(!IsOpen())
  217. //  return 0;
  218. // 
  219. //  DWORD dwError;
  220. // 
  221. //  if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) //清除错误
  222. //  ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
  223. // 
  224. //  unsigned long uWriteLength = 0;
  225. // 
  226. //  if(!::WriteFile(_hCommHandle, szBuffer, dwBufferLength, &uWriteLength, NULL))
  227. //  if(::GetLastError() != ERROR_IO_PENDING)
  228. //  uWriteLength = 0;
  229. // 
  230. //  return uWriteLength;
  231. //  }
  232. //写串口 szBuffer 可以输出格式字符串
  233. //  DWORD Write(char *szBuffer, DWORD dwBufferLength, char * szFormat, ...)
  234. //  {
  235. //  if(!IsOpen())
  236. //  return 0;
  237. // 
  238. //  DWORD dwError;
  239. // 
  240. //  if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) //清除错误
  241. //  ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
  242. // 
  243. //  va_list va;
  244. //  va_start(va, szFormat);
  245. //  _vsnprintf(szBuffer, dwBufferLength, szFormat, va);
  246. //  va_end(va);
  247. // 
  248. //  unsigned long uWriteLength = 0;
  249. // 
  250. //  if(!::WriteFile(_hCommHandle, szBuffer, dwBufferLength, &uWriteLength, &_WriteOverlapped))
  251. //  if(::GetLastError() != ERROR_IO_PENDING)
  252. //  uWriteLength = 0;
  253. // 
  254. //  return uWriteLength;
  255. //  }
  256. //关闭串口
  257. inline virtual void Close()
  258. {
  259. if(IsOpen())
  260. {
  261. EndThread();
  262. ::CloseHandle(_hCommHandle);
  264. _hCommHandle = INVALID_HANDLE_VALUE;
  265. }
  266. }
  267. //设定发送通知, 接受字符最小值
  268. inline void SetNotifyNum(int iNum)
  269. {
  270. _dwNotifyNum = iNum;
  271. }
  272. //送消息的窗口句柄
  273. inline void SetWnd(HWND hWnd)
  274. {
  275. _hNotifyWnd = hWnd;
  276. }
  277. //辅助线程控制 建监视线程
  278. bool BeginThread() 
  279. {
  280. if(!IsThreadRunning()) 
  281. {
  282. _fRunFlag = true;
  283. _hThreadHandle = NULL;
  285. DWORD id;
  287. _hThreadHandle = ::CreateThread(NULL, 0, CommThreadProc, this, 0, &id); //兼容98 故使用&ID
  289. return (_hThreadHandle != NULL); //辅助线程
  290. }
  291. return false;
  292. }
  293. //线程是否运行
  294. inline bool IsThreadRunning()
  295. {
  296. return _hThreadHandle != NULL;
  297. }
  298. //获得线程句柄
  299. inline HANDLE GetThread()
  300. {
  301. return _hThreadHandle;
  302. }
  303. //暂停监视线程
  304. inline bool SuspendThread()
  305. {
  306. return IsThreadRunning() ? ::SuspendThread(_hThreadHandle) != 0xFFFFFFFF : false;
  307. }
  308. //恢复监视线程
  309. inline bool ResumeThread()
  310. {
  311. return IsThreadRunning() ? ::ResumeThread(_hThreadHandle) != 0xFFFFFFFF : false;
  312. }
  313. //终止线程
  314. bool EndThread(DWORD dwWaitTime = 100)
  315. {
  316. if(IsThreadRunning()) 
  317. {
  318. _fRunFlag = false;
  319. ::SetCommMask(_hCommHandle, 0);
  320. ::SetEvent(_WaitOverlapped.hEvent);
  321. if(::WaitForSingleObject(_hThreadHandle, dwWaitTime) != WAIT_OBJECT_0)
  322. if(!::TerminateThread(_hThreadHandle, 0))
  323. return false;
  325. ::CloseHandle(_hThreadHandle);
  326. ::ResetEvent(_WaitOverlapped.hEvent);
  328. _hThreadHandle = NULL;
  330. return true;
  331. }
  332. return false;
  333. }
  334. protected:
  336. volatile DWORD _dwPort;  //串口号
  337. volatile HANDLE _hCommHandle;//串口句柄
  338. char _szCommStr[20];
  340. DCB _DCB;   //波特率，停止位，等
  341. COMMTIMEOUTS _CO;     //超时结构
  343. DWORD _dwIOMode; // 0 同步  默认 FILE_FLAG_OVERLAPPED 重叠I/O 异步
  344. OVERLAPPED _ReadOverlapped, _WriteOverlapped; // 重叠I/O
  346. //线程用
  347. volatile HANDLE _hThreadHandle; //辅助线程
  348. volatile HWND _hNotifyWnd; // 通知窗口
  349. volatile DWORD _dwNotifyNum;//接受多少字节(>_dwNotifyNum)发送通知消息
  350. volatile bool _fRunFlag; //线程运行循环标志
  351. bool _fAutoBeginThread;//Open() 自动 BeginThread();
  352. OVERLAPPED _WaitOverlapped; //WaitCommEvent use
  354. //线程收到消息自动调用, 如窗口句柄有效, 送出消息, 包含窗口编号
  355. virtual void OnReceive()
  356. {
  357. if(_hNotifyWnd)
  358. ::PostMessage(_hNotifyWnd, ON_COM_RECEIVE, WPARAM(_dwPort), LPARAM(0));
  359. }
  360. void Init() //初始化
  361. {
  362. memset(_szCommStr, 0, 20);
  363. memset(&_DCB, 0, sizeof(_DCB));
  364. _DCB.DCBlength = sizeof(_DCB);
  365. _hCommHandle = INVALID_HANDLE_VALUE;
  367. memset(&_ReadOverlapped, 0, sizeof(_ReadOverlapped));
  368. memset(&_WriteOverlapped, 0, sizeof(_WriteOverlapped));
  370. _ReadOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
  371. assert(_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE); 
  373. _WriteOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
  374. assert(_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE);
  376. _dwNotifyNum = 0;
  377. _hNotifyWnd = NULL;
  378. _hThreadHandle = NULL;
  380. memset(&_WaitOverlapped, 0, sizeof(_WaitOverlapped));
  381. _WaitOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
  382. assert(_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE);
  383. }
  384. void UnInit()
  385. {
  386. if(_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE)
  387. CloseHandle(_ReadOverlapped.hEvent);
  389. if(_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE)
  390. CloseHandle(_WriteOverlapped.hEvent);
  392. if(_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE)
  393. CloseHandle(_WaitOverlapped.hEvent);
  394. }
  395. //绑定串口
  396. inline void BindCommPort(DWORD dwPort)
  397. {
  398. assert(dwPort >= 1 && dwPort <= 1024);
  400. char p[5];
  402. _dwPort = dwPort;
  403. strcpy(_szCommStr, "\\.\COM");
  404. ltoa(_dwPort, p, 10);
  405. strcat(_szCommStr, p);
  406. }
  407. //打开串口
  408. virtual bool OpenCommPort()
  409. {
  410. if(IsOpen())
  411. Close();
  413. _hCommHandle = ::CreateFile(
  414. _szCommStr,
  415. GENERIC_READ | GENERIC_WRITE,
  416. 0,
  417. NULL,
  418. OPEN_EXISTING,
  419. FILE_ATTRIBUTE_NORMAL | _dwIOMode,
  420. NULL
  421. );
  423. if(_fAutoBeginThread)
  424. {
  425. if(IsOpen() && BeginThread())
  426. return true;
  427. else
  428. {
  429. Close(); //创建线程失败
  430. return false;
  431. }
  432. }
  433. return IsOpen();//检测串口是否成功打开
  434. }
  435. //设置串口
  436. virtual bool SetupPort()
  437. {
  438. if(!IsOpen())
  439. return false;
  441. //设置推荐缓冲区
  442. if(!::SetupComm(_hCommHandle, 4096, 4096))
  443. return false;
  445. //设置超时时间
  446. if(!::GetCommTimeouts(_hCommHandle, &_CO))
  447. return false;
  448. _CO.ReadIntervalTimeout = 0xFFFFFFFF;
  449. _CO.ReadTotalTimeoutMultiplier = 0;
  450. _CO.ReadTotalTimeoutConstant = 0;
  451. _CO.WriteTotalTimeoutMultiplier = 0;
  452. _CO.WriteTotalTimeoutConstant = 2000;
  453. if(!::SetCommTimeouts(_hCommHandle, &_CO))
  454. return false;
  456. //清空串口缓冲区
  457. if(!::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR ))
  458. return false;
  460. return true;
  461. }
  463. private:
  464. //监视线程
  465. static DWORD WINAPI CommThreadProc(LPVOID lpPara)
  466. {
  467. cnComm *pComm = (cnComm *)lpPara;
  470.         if(!::SetCommMask(pComm->_hCommHandle, EV_RXCHAR | EV_ERR))
  471. return 1;
  473. COMSTAT Stat;
  474. DWORD dwError;
  476. for(DWORD dwLength, dwMask = 0; pComm->_fRunFlag && pComm->IsOpen(); dwMask = 0)
  477. {
  478. if(!::WaitCommEvent(pComm->_hCommHandle, &dwMask, &pComm->_WaitOverlapped))
  479. {
  480. if(::GetLastError() == ERROR_IO_PENDING)
  481. {
  482. ::GetOverlappedResult(pComm->_hCommHandle, &pComm->_WaitOverlapped, &dwLength, TRUE);
  483. }
  484. }
  486. if(dwMask & EV_ERR) // == EV_ERR
  487. ::ClearCommError(pComm->_hCommHandle, &dwError, &Stat);
  489. if(dwMask & EV_RXCHAR) // == EV_RXCHAR
  490. {
  491. ::ClearCommError(pComm->_hCommHandle, &dwError, &Stat);
  492. if(Stat.cbInQue > pComm->_dwNotifyNum)
  493. pComm->OnReceive();
  494. }
  495.         }
  496. return 0;
  497. }
  498. };
  500. #endif //_CN_COMM_H_