CSerialPort串口类最新修正版2016-08-02

原博客网址：http://blog.csdn.NET/itas109 

QQ技术交流群：129518033

 

这是一份优秀的串口类文件，好多的地方值得我们学习，具体在多线程，事件，自定义消息，类的封装方面等等。
Remon提供的串口类网址为： http://codeguru.earthweb.com/network/serialport.shtml，
由于已经运行十几年了，原文的问答部分列出来这么多年来的问题，经过网友们的总结，补充和修改原来代码后，整理出一份相对比较完美的代码。

 

CSerialPort类地址：https://github.com/itas109/CSerialPort

 

2016-08-02补充说明

CSDN下载：http://download.csdn.net/detail/itas109/9598347

 更新内容：

1、 改进IsOpen方法，m_hComm增加INVALID_HANDLE_VALUE的情况，因为CreateFile方法失败返回的是INVALID_HANDLE_VALUE，不是NULL
2、改进ClosePort方法：增加串口句柄无效的判断(防止关闭死锁)；m_hWriteEvent不使用CloseHandle关闭
3、 改进CommThread、ReceiveChar、ReceiveStr和WriteChar方法中异常处理的判断，增加三种判断：串口打开失败(error code:ERROR_INVALID_HANDLE)、连接过程中非法断开(error code:ERROR_BAD_COMMAND)和拒绝访问(error code:ERROR_ACCESS_DENIED)
4、  采用安全函数sprintf_s和strcpy_s函数替换掉sprintf和strcpy
5、 改进QueryKey方法，用于查询注册表的可用串口值，可以搜索到任意的可用串口
6、改进InitPort方法，串口打开失败，增加提示信息:串口不存在(error code:ERROR_FILE_NOT_FOUND)和串口拒绝访问(error code:ERROR_ACCESS_DENIED)
7、加入viruscamp 取消对 MFC 的依赖
8、改进InitPort方法，如果上次串口是打开，再次调用InitPort方法，关闭串口需要做一定的延时，否则有几率导致ERROR_ACCESS_DENIED拒绝访问，也就是串口占用问题
9、初始化默认波特率修改为9600
10、修复一些释放的BUG
11、规范了一些错误信息，参考winerror.h --  error code definitions for the Win32 API functions
12、删除SendData和RecvData方法

 

2016-06-29补充说明：

CSDN下载：http://download.csdn.Net/detail/itas109/9563059

 更新内容：               

1、解决RestartMonitoring方法和StopMonitoring方法命令不准确引起的歧义，根据实际作用。 将RestartMonitoring更改为ResumeMonitoring，将StopMonitoring更改为SuspendMonitoring。

2、增加IsThreadSuspend方法，用于判断线程是否挂起。

3、改进ClosePort方法，增加线程挂起判断，解决由于线程挂起导致串口关闭死锁的问题。

4、增加IsReceiveString宏定义，用于接收时采用单字节接收还是多字节接收。

 

2016-06-22补充说明：

 更新内容：

1、增加ReceiveStr方法，用于接收字符串（接收缓冲区有多少字符就接收多少字符）。 解决ReceiveChar只能接收单个字符的问题。

 

2016-05-07补充说明：

CSDN下载：http://download.csdn.net/detail/itas109/9512828

 更新内容：

1、修复每次打开串口发送一次，当串口无应答时，需要关闭再打开或者接收完数据才能发送的问题。 解决办法：在m_hEventArray中调整m_hWriteEvent的优先级高于读的优先级。CommThread(LPVOID pParam)函数中读写的位置也调换。 参考：http://zhidao.baidu.com/link?url=RSrbPcfTZRULFFd2ziHZPBwnoXv1iCSu_Nmycb_yEw1mklT8gkoNZAkWpl3UDhk8L35DtRPo5VV5kEGpOx-Gea

2、修复停止位在头文件中定义成1导致SetCommState报错的问题，应为1对应的停止位是1.5。UINT stopsbits = ONESTOPBIT

3、switch(stopbits)和switch(parity)增加默认情况，增强程序健壮性

 

历史更新：

First Version by Remon Spekreijse on 2000-02-08
http://www.codeguru.com/cpp/i-n/network/serialcommunications/article.php/c2483/A-communication-class-for-serial-port.htm

Second Version by mrlong on 2007-12-25
https://code.google.com/p/mycom/
* 增加 ClosePort
* 增加 WriteToPort 两个方法
* 增加 SendData 与 RecvData 方法

by liquanhai on 2011-11-04
http://blog.csdn.net/liquanhai/article/details/4955253
* 增加 ClosePort 中交出控制权，防止死锁问题

by liquanhai on 2011-11-06
http://blog.csdn.net/liquanhai/article/details/6941574
* 增加 ReceiveChar 中防止线程死锁

by viruscamp on 2013-12-04
https://github.com/viruscamp/CSerialPort
* 增加 IsOpen 判断是否打开
* 修正 InitPort 中 parity Odd Even 参数取值错误
* 修改 InitPort 中 portnr 取值范围，portnr>9 时特殊处理
* 取消对 MFC 的依赖，使用 HWND 替代 CWnd，使用 win32 thread 函数而不是 MFC 的
* 增加用户消息编号自定义，方法来自 CnComm

by itas109 on 2014-01-10
http://blog.csdn.net/itas109/article/details/18358297
* 解决COM10以上端口无法显示的问题 
* 扩展可选择端口，最大值MaxSerialPortNum可以自定义 
* 添加QueryKey()和Hkey2ComboBox两个方法，用于自动查询当前有效的串口号。

by liquanhai on 2014-12-18
* 增加一些处理措施，主要是对减少CPU占用率

 

by itas109 on 2016-05-06
* 修复每次打开串口发送一次，当串口无应答时，需要关闭再打开或者接收完数据才能发送的问题。
   解决办法：在m_hEventArray中调整m_hWriteEvent的优先级高于读的优先级。CommThread(LPVOID pParam)函数中读写的位置也调换。
   参考：http://zhidao.baidu.com/link?url=RSrbPcfTZRULFFd2ziHZPBwnoXv1iCSu_Nmycb_yEw1mklT8gkoNZAkWpl3UDhk8L35DtRPo5VV5kEGpOx-Gea
* 修复停止位在头文件中定义成1导致SetCommState报错的问题，应为1对应的停止位是1.5。UINT stopsbits = ONESTOPBIT
* switch(stopbits)和switch(parity)增加默认情况，增强程序健壮性

by itas109 on 2016-06-22
* 增加ReceiveStr方法，用于接收字符串（接收缓冲区有多少字符就接收多少字符）。
* 解决ReceiveChar只能接收单个字符的问题。

by itas109 on 2016-06-29
* 解决RestartMonitoring方法和StopMonitoring方法命令不准确引起的歧义，根据实际作用。
* 将RestartMonitoring更改为ResumeMonitoring，将StopMonitoring更改为SuspendMonitoring。
* 增加IsThreadSuspend方法，用于判断线程是否挂起。
* 改进ClosePort方法，增加线程挂起判断，解决由于线程挂起导致串口关闭死锁的问题。
* 增加IsReceiveString宏定义，用于接收时采用单字节接收还是多字节接收

 

 /*
 **  FILENAME            CSerialPort.h
 **
 **  PURPOSE             This class can read, write and watch one serial port.
 **                      It sends messages to its owner when something happends on the port
 **                      The class creates a thread for reading and writing so the main
 **                      program is not blocked.
 **
 **  CREATION DATE       15-09-1997
 **  LAST MODIFICATION   12-11-1997
 **
 **  AUTHOR              Remon Spekreijse
 **
 **
 ************************************************************************************
 **  author: mrlong date:2007-12-25
 **
 **  改进
 **  1) 增加 ClosePort
 **  2) 增加 WriteToPort 两个方法
 **  3) 增加 SendData 与 RecvData 方法
 **************************************************************************************
 ***************************************************************************************
 **  author：liquanhai date:2011-11-06
 **
 **  改进
 **  1) 增加 ClosePort 中交出控制权，防止死锁问题
 **  2) 增加 ReceiveChar 中防止线程死锁
 **************************************************************************************
 ***************************************************************************************
 **  author：viruscamp date:2013-12-04
 **
 **  改进
 **  1) 增加 IsOpen 判断是否打开
 **  2) 修正 InitPort 中 parity Odd Even 参数取值错误
 **  3) 修改 InitPort 中 portnr 取值范围，portnr>9 时特殊处理
 **  4) 取消对 MFC 的依赖，使用 HWND 替代 CWnd，使用 win32 thread 函数而不是 MFC 的
 **  5) 增加用户消息编号自定义，方法来自 CnComm
 ***************************************************************************************
 ***************************************************************************************
 **  author: itas109  date:2014-01-10
 **  Blog：blog.csdn.net/itas109
 **  Git：https://github.com/itas109
 **
 **  改进
 **    1) 解决COM10以上端口无法显示的问题
 **    2) 扩展可选择端口，最大值MaxSerialPortNum可以自定义
 **    3) 添加QueryKey()和Hkey2ComboBox两个方法，用于自动查询当前有效的串口号。
 ***************************************************************************************
 **  author: liquanhai  date:2014-12-18
 **
 ** 增加一些处理措施，主要是对减少CPU占用率
 ***************************************************************************************
 **  author: itas109  date:2016-05-06
 **  Blog：blog.csdn.net/itas109
 **  Git：https://github.com/itas109
 **
 **  改进
 **    1) 修复每次打开串口发送一次，当串口无应答时，需要关闭再打开或者接收完数据才能发送的问题。
 **       解决办法：在m_hEventArray中调整m_hWriteEvent的优先级高于读的优先级。CommThread(LPVOID pParam)函数中读写的位置也调换。
 **       参考：http://zhidao.baidu.com/link?url=RSrbPcfTZRULFFd2ziHZPBwnoXv1iCSu_Nmycb_yEw1mklT8gkoNZAkWpl3UDhk8L35DtRPo5VV5kEGpOx-Gea
 **    2) 修复停止位在头文件中定义成1导致SetCommState报错的问题，应为1对应的停止位是1.5。UINT stopsbits = ONESTOPBIT
 **    3) switch(stopbits)和switch(parity)增加默认情况，增强程序健壮性
 ** ***************************************************************************************
 **  author: itas109  date:2016-06-22
 **  Blog：blog.csdn.net/itas109
 **  Git：https://github.com/itas109
 **
 **  改进
 **  1） 增加ReceiveStr方法，用于接收字符串（接收缓冲区有多少字符就接收多少字符）。
 **      解决ReceiveChar只能接收单个字符的问题。
 ** ***************************************************************************************
 **  author: itas109  date:2016-06-29
 **  Blog：blog.csdn.net/itas109
 **  Git：https://github.com/itas109
 **
 **  改进
 **  1） 解决RestartMonitoring方法和StopMonitoring方法命令不准确引起的歧义，根据实际作用。
 **      将RestartMonitoring更改为ResumeMonitoring，将StopMonitoring更改为SuspendMonitoring。
 **  2)  增加IsThreadSuspend方法，用于判断线程是否挂起。
 **  3)  改进ClosePort方法，增加线程挂起判断，解决由于线程挂起导致串口关闭死锁的问题。
 **  4） 增加IsReceiveString宏定义，用于接收时采用单字节接收还是多字节接收
 ** ***************************************************************************************
 **  author: itas109  date:2016-08-02
 **  Blog：blog.csdn.net/itas109
 **  Git：https://github.com/itas109
 **
 **  改进
 **  1） 改进IsOpen方法，m_hComm增加INVALID_HANDLE_VALUE的情况，因为CreateFile方法失败返回的是INVALID_HANDLE_VALUE，不是NULL
 **  2） 改进ClosePort方法：增加串口句柄无效的判断(防止关闭死锁)；m_hWriteEvent不使用CloseHandle关闭
 **  3)  改进CommThread、ReceiveChar、ReceiveStr和WriteChar方法中异常处理的判断，增加三种判断：串口打开失败(error code:ERROR_INVALID_HANDLE)、连接过程中非法断开(error code:ERROR_BAD_COMMAND)和拒绝访问(error code:ERROR_ACCESS_DENIED)
 **  4)  采用安全函数sprintf_s和strcpy_s函数替换掉sprintf和strcpy
 **  5)  改进QueryKey方法，用于查询注册表的可用串口值，可以搜索到任意的可用串口
 **  6） 改进InitPort方法，串口打开失败，增加提示信息:串口不存在(error code:ERROR_FILE_NOT_FOUND)和串口拒绝访问(error code:ERROR_ACCESS_DENIED)
 **  7） 加入viruscamp 取消对 MFC 的依赖
 **  8） 改进InitPort方法，如果上次串口是打开，再次调用InitPort方法，关闭串口需要做一定的延时，否则有几率导致ERROR_ACCESS_DENIED拒绝访问，也就是串口占用问题
 **  9） 初始化默认波特率修改为9600
 **  10）修复一些释放的BUG
 **  11）规范了一些错误信息，参考winerror.h --  error code definitions for the Win32 API functions
 **  12）删除SendData和RecvData方法
 */

 #ifndef __SERIALPORT_H__
 #define __SERIALPORT_H__

 #ifndef WM_COMM_MSG_BASE
     #define WM_COMM_MSG_BASE        WM_USER + 617       //!< 消息编号的基点
 #endif

 #define WM_COMM_BREAK_DETECTED      WM_COMM_MSG_BASE + 1    // A break was detected on input.
 #define WM_COMM_CTS_DETECTED        WM_COMM_MSG_BASE + 2    // The CTS (clear-to-send) signal changed state.
 #define WM_COMM_DSR_DETECTED        WM_COMM_MSG_BASE + 3    // The DSR (data-set-ready) signal changed state.
 #define WM_COMM_ERR_DETECTED        WM_COMM_MSG_BASE + 4    // A line-status error occurred. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.
 #define WM_COMM_RING_DETECTED       WM_COMM_MSG_BASE + 5    // A ring indicator was detected.
 #define WM_COMM_RLSD_DETECTED       WM_COMM_MSG_BASE + 6    // The RLSD (receive-line-signal-detect) signal changed state.
 #define WM_COMM_RXCHAR              WM_COMM_MSG_BASE + 7    // A character was received and placed in the input buffer.
 #define WM_COMM_RXFLAG_DETECTED     WM_COMM_MSG_BASE + 8    // The event character was received and placed in the input buffer.
 #define WM_COMM_TXEMPTY_DETECTED    WM_COMM_MSG_BASE + 9    // The last character in the output buffer was sent.
 #define WM_COMM_RXSTR               WM_COMM_MSG_BASE + 10   // Receive string

 #define MaxSerialPortNum 200   ///有效的串口总个数，不是串口的号 //add by itas109 2014-01-09
 #define IsReceiveString  1     //采用何种方式接收：ReceiveString 1多字符串接收（对应响应函数为WM_COMM_RXSTR），ReceiveString 0一个字符一个字符接收（对应响应函数为WM_COMM_RXCHAR）
 class CSerialPort
 {
 public:
     // contruction and destruction
     CSerialPort();
     virtual     ~CSerialPort(   );

     // port initialisation
     // UINT stopsbits = ONESTOPBIT   stop is index 0 = 1 1=1.5 2=2
     // 切记：stopsbits = 1，不是停止位为1。
     // by itas109 20160506
     BOOL        InitPort(HWND pPortOwner, UINT portnr = 1, UINT baud = 9600,
                 char parity = 'N', UINT databits = 8, UINT stopsbits = ONESTOPBIT,
                 DWORD dwCommEvents = EV_RXCHAR | EV_CTS, UINT nBufferSize = 512,

                 DWORD ReadIntervalTimeout = 1000,
                 DWORD ReadTotalTimeoutMultiplier = 1000,
                 DWORD ReadTotalTimeoutConstant = 1000,
                 DWORD WriteTotalTimeoutMultiplier = 1000,
                 DWORD WriteTotalTimeoutConstant = 1000);

     // start/stop comm watching
     ///控制串口监视线程
     BOOL         StartMonitoring();//开始监听
     BOOL         ResumeMonitoring();//恢复监听
     BOOL         SuspendMonitoring();//挂起监听
     BOOL         IsThreadSuspend(HANDLE hThread);//判断线程是否挂起 //add by itas109 2016-06-29

     DWORD        GetWriteBufferSize();///获取写缓冲大小
     DWORD        GetCommEvents();///获取事件
     DCB          GetDCB();///获取DCB

 ///写数据到串口
     void        WriteToPort(char* string);
     void        WriteToPort(char* string,int n); // add by mrlong 2007-12-25
     void        WriteToPort(LPCTSTR string);     // add by mrlong 2007-12-25
     void        WriteToPort(LPCTSTR string,int n);//add by mrlong 2007-12-2
     void        WriteToPort(BYTE* Buffer, int n);// add by mrlong
     void        ClosePort();                     // add by mrlong 2007-12-2
     BOOL        IsOpen();

     //void SendData(LPCTSTR lpszData, const int nLength);   //串口发送函数 by mrlong 2008-2-15
     //BOOL RecvData(LPTSTR lpszData, const int nSize);    //串口接收函数 by mrlong 2008-2-15
     void QueryKey(HKEY hKey);///查询注册表的串口号，将值存于数组中
     void Hkey2ComboBox(CComboBox& m_PortNO);///将QueryKey查询到的串口号添加到CComboBox控件中

 protected:
     // protected memberfunctions
     void        ProcessErrorMessage(char* ErrorText);///错误处理
     static DWORD WINAPI CommThread(LPVOID pParam);///线程函数
     static void ReceiveChar(CSerialPort* port);
     static void ReceiveStr(CSerialPort* port); //add by itas109 2016-06-22
     static void WriteChar(CSerialPort* port);

     // thread
     //CWinThread*           m_Thread;
     HANDLE              m_Thread;
     BOOL                m_bIsSuspened;///thread监视线程是否挂起

     // synchronisation objects
     CRITICAL_SECTION    m_csCommunicationSync;///临界资源
     BOOL                m_bThreadAlive;///监视线程运行标志

     // handles
     HANDLE              m_hShutdownEvent;  //stop发生的事件
     HANDLE              m_hComm;           // 串口句柄
     HANDLE              m_hWriteEvent;   // write

     // Event array.
     // One element is used for each event. There are two event handles for each port.
     // A Write event and a receive character event which is located in the overlapped structure (m_ov.hEvent).
     // There is a general shutdown when the port is closed.
     ///事件数组，包括一个写事件，接收事件，关闭事件
     ///一个元素用于一个事件。有两个事件线程处理端口。
     ///写事件和接收字符事件位于overlapped结构体（m_ov.hEvent）中
     ///当端口关闭时，有一个通用的关闭。
     HANDLE              m_hEventArray[3];

     // structures
     OVERLAPPED          m_ov;///异步I/O
     COMMTIMEOUTS        m_CommTimeouts;///超时设置
     DCB                 m_dcb;///设备控制块

     // owner window
     //CWnd*             m_pOwner;
     HWND                m_pOwner;


     // misc
     UINT                m_nPortNr;      ///串口号
     char*               m_szWriteBuffer;///写缓冲区
     DWORD               m_dwCommEvents;
     DWORD               m_nWriteBufferSize;///写缓冲大小

     int                 m_nWriteSize;//写入字节数 //add by mrlong 2007-12-25
 };

 #endif __SERIALPORT_H__

 

 /*
 **  FILENAME            CSerialPort.cpp
 **
 **  PURPOSE             This class can read, write and watch one serial port.
 **                      It sends messages to its owner when something happends on the port
 **                      The class creates a thread for reading and writing so the main
 **                      program is not blocked.
 **
 **  CREATION DATE       15-09-1997
 **  LAST MODIFICATION   12-11-1997
 **
 **  AUTHOR              Remon Spekreijse
 **
 **  2007-12-25 mrlong    https://code.google.com/p/mycom/
 **  2011-11-06 liquanhai http://blog.csdn.net/liquanhai/article/details/6941574
 **  2013-12-04 viruscamp https://github.com/viruscamp
 **  2014-01-10 itas109   http://blog.csdn.net/itas109
 **  2014-12-18 liquanhai http://blog.csdn.net/liquanhai/article/details/6941574
 **  2016-05-06 itas109   http://blog.csdn.net/itas109
 **  2016-06-22 itas109   http://blog.csdn.net/itas109
 **  2016-06-29 itas109   http://blog.csdn.net/itas109
 **  2016-08-02 itas109   http://blog.csdn.net/itas109
 */

 #include "stdafx.h"
 #include "SerialPort.h"

 #include

 int m_nComArray[20];//存放活跃的串口号
 //
 // Constructor
 //
 CSerialPort::CSerialPort()
 {
     m_hComm = NULL;

     // initialize overlapped structure members to zero
     ///初始化异步结构体
     m_ov.Offset = 0;
     m_ov.OffsetHigh = 0;

     // create events
     m_ov.hEvent = NULL;
     m_hWriteEvent = NULL;
     m_hShutdownEvent = NULL;

     m_szWriteBuffer = NULL;

     m_bThreadAlive = FALSE;
     m_nWriteSize = 1;
     m_bIsSuspened = FALSE;
 }

 //
 // Delete dynamic memory
 //
 CSerialPort::~CSerialPort()
 {
     MSG message;

     //增加线程挂起判断，解决由于线程挂起导致串口关闭死锁的问题 add by itas109 2016-06-29
     if(IsThreadSuspend(m_Thread))
     {
         ResumeThread(m_Thread);
     }

     //串口句柄无效  add by itas109 2016-07-29
     if(m_hComm == INVALID_HANDLE_VALUE)
     {
         CloseHandle(m_hComm);
         m_hComm = NULL;
         return;
     }

     do
     {
         SetEvent(m_hShutdownEvent);
         //add by liquanhai  防止死锁  2011-11-06
         if(::PeekMessage(&message,m_pOwner,0,0,PM_REMOVE))
         {
             ::TranslateMessage(&message);
             ::DispatchMessage(&message);
         }
     } while (m_bThreadAlive);

     // if the port is still opened: close it
     if (m_hComm != NULL)
     {
         CloseHandle(m_hComm);
         m_hComm = NULL;
     }
     // Close Handles
     if(m_hShutdownEvent!=NULL)
         CloseHandle( m_hShutdownEvent);
     if(m_ov.hEvent!=NULL)
         CloseHandle( m_ov.hEvent );
     if(m_hWriteEvent!=NULL)
         CloseHandle( m_hWriteEvent );

     //TRACE("Thread ended\n");

     if(m_szWriteBuffer != NULL)
     {
         delete [] m_szWriteBuffer;
         m_szWriteBuffer = NULL;
     }
 }

 //
 // Initialize the port. This can be port 1 to MaxSerialPortNum.
 ///初始化串口。只能是1-MaxSerialPortNum
 //
 //parity:
 //  n=none
 //  e=even
 //  o=odd
 //  m=mark
 //  s=space
 //data:
 //  5,6,7,8
 //stop:
 //  1,1.5,2
 //
 BOOL CSerialPort::InitPort(HWND pPortOwner, // the owner (CWnd) of the port (receives message)
     UINT  portnr,       // portnumber (1..MaxSerialPortNum)
     UINT  baud,         // baudrate
     char  parity,       // parity
     UINT  databits,     // databits
     UINT  stopbits,     // stopbits
     DWORD dwCommEvents, // EV_RXCHAR, EV_CTS etc
     UINT  writebuffersize,// size to the writebuffer

     DWORD   ReadIntervalTimeout,
     DWORD   ReadTotalTimeoutMultiplier,
     DWORD   ReadTotalTimeoutConstant,
     DWORD   WriteTotalTimeoutMultiplier,
     DWORD   WriteTotalTimeoutConstant )

 {
     assert(portnr > 0 && portnr < MaxSerialPortNum);
     assert(pPortOwner != NULL);

     MSG message;

     //增加线程挂起判断，解决由于线程挂起导致串口关闭死锁的问题 add by itas109 2016-06-29
     if(IsThreadSuspend(m_Thread))
     {
         ResumeThread(m_Thread);
     }

     // if the thread is alive: Kill
     if (m_bThreadAlive)
     {
         do
         {
             SetEvent(m_hShutdownEvent);
             //add by liquanhai  防止死锁  2011-11-06
             if(::PeekMessage(&message,m_pOwner,0,0,PM_REMOVE))
             {
                 ::TranslateMessage(&message);
                 ::DispatchMessage(&message);
             }
         } while (m_bThreadAlive);
         //TRACE("Thread ended\n");
         //此处的延时很重要，因为如果串口开着，发送关闭指令到彻底关闭需要一定的时间，这个延时应该跟电脑的性能相关
         Sleep(50);//add by itas109 2016-08-02
     }

     // create events
     if (m_ov.hEvent != NULL)
         ResetEvent(m_ov.hEvent);
     else
         m_ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

     if (m_hWriteEvent != NULL)
         ResetEvent(m_hWriteEvent);
     else
         m_hWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

     if (m_hShutdownEvent != NULL)
         ResetEvent(m_hShutdownEvent);
     else
         m_hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

     // initialize the event objects
     ///事件数组初始化，设定优先级别
     m_hEventArray[0] = m_hShutdownEvent;    // highest priority
     //为避免有些串口设备无数据输入，但一直返回读事件，使监听线程阻塞，
     //可以将读写放在两个线程中，或者修改读写事件优先级
     //修改优先级有两个方案：
     //方案一为监听线程中WaitCommEvent()后，添加如下两条语句：
     //if (WAIT_OBJECT_O == WaitForSingleObject(port->m_hWriteEvent, 0))
     //  ResetEvent(port->m_ov.hEvent);
     //方案二为初始化时即修改，即下面两条语句：
     m_hEventArray[1] = m_hWriteEvent;
     m_hEventArray[2] = m_ov.hEvent;


     // initialize critical section
     ///初始化临界资源
     InitializeCriticalSection(&m_csCommunicationSync);

     // set buffersize for writing and save the owner
     m_pOwner = pPortOwner;

     if(m_szWriteBuffer != NULL)
     {
         delete [] m_szWriteBuffer;
         m_szWriteBuffer = NULL;
     }
     m_szWriteBuffer = new char[writebuffersize];

     m_nPortNr = portnr;

     m_nWriteBufferSize = writebuffersize;
     m_dwCommEvents = dwCommEvents;

     BOOL bResult = FALSE;
     char *szPort = new char[50];
     char *szBaud = new char[50];

     /*
     多个线程操作相同的数据时，一般是需要按顺序访问的，否则会引导数据错乱，
     无法控制数据，变成随机变量。为解决这个问题，就需要引入互斥变量，让每
     个线程都按顺序地访问变量。这样就需要使用EnterCriticalSection和
     LeaveCriticalSection函数。
     */
     // now it critical!
     EnterCriticalSection(&m_csCommunicationSync);

     // if the port is already opened: close it
     ///串口已打开就关掉
     if (m_hComm != NULL)
     {
         CloseHandle(m_hComm);
         m_hComm = NULL;
     }

     // prepare port strings
     sprintf_s(szPort,50, "\\\\.\\COM%d", portnr);///可以显示COM10以上端口//add by itas109 2014-01-09

     // stop is index 0 = 1 1=1.5 2=2
     int mystop;
     int myparity;
     switch(stopbits)
     {
     case 0:
         mystop = ONESTOPBIT;
         break;
     case 1:
         mystop = ONE5STOPBITS;
         break;
     case 2:
         mystop = TWOSTOPBITS;
         break;
         //增加默认情况，因为stopbits=1.5时，SetCommState会报错。
         //一般的电脑串口不支持1.5停止位，这个1.5停止位似乎用在红外传输上的。
         //by itas109 20160506
     default:
         mystop = ONESTOPBIT;
         break;
     }
     myparity = 0;
     parity = toupper(parity);
     switch(parity)
     {
     case 'N':
         myparity = 0;
         break;
     case 'O':
         myparity = 1;
         break;
     case 'E':
         myparity = 2;
         break;
     case 'M':
         myparity = 3;
         break;
     case 'S':
         myparity = 4;
         break;
         //增加默认情况。
         //by itas109 20160506
     default:
         myparity = 0;
         break;
     }
     sprintf_s(szBaud,50, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, mystop);

     // get a handle to the port
     /*
     通信程序在CreateFile处指定串口设备及相关的操作属性，再返回一个句柄，
     该句柄将被用于后续的通信操作，并贯穿整个通信过程串口打开后，其属性
     被设置为默认值，根据具体需要，通过调用GetCommState(hComm,&&dcb)读取
     当前串口设备控制块DCB设置，修改后通过SetCommState(hComm,&&dcb)将其写
     入。运用ReadFile()与WriteFile()这两个API函数实现串口读写操作，若为异
     步通信方式，两函数中最后一个参数为指向OVERLAPPED结构的非空指针，在读
     写函数返回值为FALSE的情况下，调用GetLastError()函数，返回值为ERROR_IO_PENDING，
     表明I/O操作悬挂，即操作转入后台继续执行。此时，可以用WaitForSingleObject()
     来等待结束信号并设置最长等待时间
     */
     m_hComm = CreateFile(szPort,                        // communication port string (COMX)
         GENERIC_READ | GENERIC_WRITE,   // read/write types
         0,                              // comm devices must be opened with exclusive access
         NULL,                           // no security attributes
         OPEN_EXISTING,                  // comm devices must use OPEN_EXISTING
         FILE_FLAG_OVERLAPPED,           // Async I/O
         0);                         // template must be 0 for comm devices

     ///创建失败
     if (m_hComm == INVALID_HANDLE_VALUE)
     {
         //add by itas109 2016-08-02
         //串口打开失败，增加提示信息
         switch(GetLastError())
         {
             //串口不存在
         case ERROR_FILE_NOT_FOUND:
             {
                 CString str;
                 str.Format("COM%d ERROR_FILE_NOT_FOUND,Error Code:%d",portnr,GetLastError());
                 AfxMessageBox(str);
                 break;
             }
             //串口拒绝访问
         case ERROR_ACCESS_DENIED:
             {
                 CString str;
                 str.Format("COM%d ERROR_ACCESS_DENIED,Error Code:%d",portnr,GetLastError());
                 AfxMessageBox(str);
                 break;
             }
         default:
             break;
         }
         // port not found
         delete [] szPort;
         delete [] szBaud;

         return FALSE;
     }

     // set the timeout values
     ///设置超时
     m_CommTimeouts.ReadIntervalTimeout       = ReadIntervalTimeout * 1000;
     m_CommTimeouts.ReadTotalTimeoutMultiplier  = ReadTotalTimeoutMultiplier * 1000;
     m_CommTimeouts.ReadTotalTimeoutConstant = ReadTotalTimeoutConstant * 1000;
     m_CommTimeouts.WriteTotalTimeoutMultiplier = WriteTotalTimeoutMultiplier * 1000;
     m_CommTimeouts.WriteTotalTimeoutConstant   = WriteTotalTimeoutConstant * 1000;

     // configure
     ///配置
     ///分别调用Windows API设置串口参数
     if (SetCommTimeouts(m_hComm, &m_CommTimeouts))///设置超时
     {
         /*
         若对端口数据的响应时间要求较严格，可采用事件驱动方式。
         事件驱动方式通过设置事件通知，当所希望的事件发生时，Windows
         发出该事件已发生的通知，这与DOS环境下的中断方式很相似。Windows
         定义了9种串口通信事件，较常用的有以下三种：
         EV_RXCHAR:接收到一个字节，并放入输入缓冲区；
         EV_TXEMPTY:输出缓冲区中的最后一个字符，发送出去；
         EV_RXFLAG:接收到事件字符(DCB结构中EvtChar成员)，放入输入缓冲区
         在用SetCommMask()指定了有用的事件后，应用程序可调用WaitCommEvent()来等待事
         件的发生。SetCommMask(hComm,0)可使WaitCommEvent()中止
         */
         if (SetCommMask(m_hComm, dwCommEvents))///设置通信事件
         {

             if (GetCommState(m_hComm, &m_dcb))///获取当前DCB参数
             {
                 m_dcb.EvtChar = 'q';
                 m_dcb.fRtsControl = RTS_CONTROL_ENABLE;     // set RTS bit high!
                 m_dcb.BaudRate = baud;  // add by mrlong
                 m_dcb.Parity   = myparity;
                 m_dcb.ByteSize = databits;
                 m_dcb.StopBits = mystop;

                 //if (BuildCommDCB(szBaud &m_dcb))///填写DCB结构
                 //{
                 if (SetCommState(m_hComm, &m_dcb))///配置DCB
                     ; // normal operation... continue
                 else
                     ProcessErrorMessage("SetCommState()");
                 //}
                 //else
                 //  ProcessErrorMessage("BuildCommDCB()");
             }
             else
                 ProcessErrorMessage("GetCommState()");
         }
         else
             ProcessErrorMessage("SetCommMask()");
     }
     else
         ProcessErrorMessage("SetCommTimeouts()");

     delete [] szPort;
     delete [] szBaud;

     // flush the port
     ///终止读写并清空接收和发送
     PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

     // release critical section
     ///释放临界资源
     LeaveCriticalSection(&m_csCommunicationSync);

     //TRACE("Initialisation for communicationport %d completed.\nUse Startmonitor to communicate.\n", portnr);

     return TRUE;
 }

 //
 //  The CommThread Function.
 ///线程函数
 ///监视线程的大致流程：
 ///检查串口-->进入循环{WaitCommEvent(不阻塞询问)询问事件-->如果有事件来到-->到相应处理(关闭\读\写)}
 //
 DWORD WINAPI CSerialPort::CommThread(LPVOID pParam)
 {
     // Cast the void pointer passed to the thread back to
     // a pointer of CSerialPort class
     CSerialPort *port = (CSerialPort*)pParam;

     // Set the status variable in the dialog class to
     // TRUE to indicate the thread is running.
     ///TRUE表示线程正在运行
     port->m_bThreadAlive = TRUE;

     // Misc. variables
     DWORD BytesTransfered = 0;
     DWORD Event = 0;
     DWORD CommEvent = 0;
     DWORD dwError = 0;
     COMSTAT comstat;

     BOOL  bResult = TRUE;

     // Clear comm buffers at startup
     ///开始时清除串口缓冲
     if (port->m_hComm)       // check if the port is opened
         PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

     // begin forever loop.  This loop will run as long as the thread is alive.
     ///只要线程存在就不断读取数据
     for (;;)
     {

         // Make a call to WaitCommEvent().  This call will return immediatly
         // because our port was created as an async port (FILE_FLAG_OVERLAPPED
         // and an m_OverlappedStructerlapped structure specified).  This call will cause the
         // m_OverlappedStructerlapped element m_OverlappedStruct.hEvent, which is part of the m_hEventArray to
         // be placed in a non-signeled state if there are no bytes available to be read,
         // or to a signeled state if there are bytes available.  If this event handle
         // is set to the non-signeled state, it will be set to signeled when a
         // character arrives at the port.

         // we do this for each port!

         /*
         WaitCommEvent函数第3个参数1pOverlapped可以是一个OVERLAPPED结构的变量指针
         ，也可以是NULL，当用NULL时，表示该函数是同步的，否则表示该函数是异步的。
         调用WaitCommEvent时，如果异步操作不能立即完成，会立即返回FALSE，系统在
         WaitCommEvent返回前将OVERLAPPED结构成员hEvent设为无信号状态，等到产生通信
         事件时，系统将其置有信号
         */

         bResult = WaitCommEvent(port->m_hComm, &Event, &port->m_ov);///表示该函数是异步的

         if (!bResult)
         {
             // If WaitCommEvent() returns FALSE, process the last error to determin
             // the reason..
             ///如果WaitCommEvent返回Error为FALSE，则查询错误信息
             switch (dwError = GetLastError())
             {
             case ERROR_IO_PENDING:  ///正常情况，没有字符可读 erroe code:997
                 {
                     // This is a normal return value if there are no bytes
                     // to read at the port.
                     // Do nothing and continue
                     break;
                 }
             case ERROR_INVALID_PARAMETER:///系统错误 erroe code:87
                 {
                     // Under Windows NT, this value is returned for some reason.
                     // I have not investigated why, but it is also a valid reply
                     // Also do nothing and continue.
                     break;
                 }
             case ERROR_ACCESS_DENIED:///拒绝访问 erroe code:5
                 {
                     port->m_hComm = INVALID_HANDLE_VALUE;
                     CString str;
                     str.Format("COM%d ERROR_ACCESS_DENIED，WaitCommEvent() Error Code:%d",port->m_nPortNr,GetLastError());
                     AfxMessageBox(str);
                     break;
                 }
             case ERROR_INVALID_HANDLE:///打开串口失败 erroe code:6
                 {
                     port->m_hComm = INVALID_HANDLE_VALUE;
                     break;
                 }
             case ERROR_BAD_COMMAND:///连接过程中非法断开 erroe code:22
                 {
                     port->m_hComm = INVALID_HANDLE_VALUE;
                     CString str;
                     str.Format("COM%d ERROR_BAD_COMMAND，WaitCommEvent() Error Code:%d",port->m_nPortNr,GetLastError());
                     AfxMessageBox(str);
                     break;
                 }
             default:///发生其他错误，其中有串口读写中断开串口连接的错误（错误22）
                 {
                     // All other error codes indicate a serious error has
                     //发生错误时，将串口句柄置为无效句柄
                     port->m_hComm = INVALID_HANDLE_VALUE;
                     // occured.  Process this error.
                     port->ProcessErrorMessage("WaitCommEvent()");
                     break;
                 }
             }
         }
         else    ///WaitCommEvent()能正确返回
         {
             // If WaitCommEvent() returns TRUE, check to be sure there are
             // actually bytes in the buffer to read.
             //
             // If you are reading more than one byte at a time from the buffer
             // (which this program does not do) you will have the situation occur
             // where the first byte to arrive will cause the WaitForMultipleObjects()
             // function to stop waiting.  The WaitForMultipleObjects() function
             // resets the event handle in m_OverlappedStruct.hEvent to the non-signelead state
             // as it returns.
             //
             // If in the time between the reset of this event and the call to
             // ReadFile() more bytes arrive, the m_OverlappedStruct.hEvent handle will be set again
             // to the signeled state. When the call to ReadFile() occurs, it will
             // read all of the bytes from the buffer, and the program will
             // loop back around to WaitCommEvent().
             //
             // At this point you will be in the situation where m_OverlappedStruct.hEvent is set,
             // but there are no bytes available to read.  If you proceed and call
             // ReadFile(), it will return immediatly due to the async port setup, but
             // GetOverlappedResults() will not return until the next character arrives.
             //
             // It is not desirable for the GetOverlappedResults() function to be in
             // this state.  The thread shutdown event (event 0) and the WriteFile()
             // event (Event2) will not work if the thread is blocked by GetOverlappedResults().
             //
             // The solution to this is to check the buffer with a call to ClearCommError().
             // This call will reset the event handle, and if there are no bytes to read
             // we can loop back through WaitCommEvent() again, then proceed.
             // If there are really bytes to read, do nothing and proceed.

             bResult = ClearCommError(port->m_hComm, &dwError, &comstat);

             if (comstat.cbInQue == 0)
                 continue;
         }   // end if bResult

         ///主等待函数，会阻塞线程
         // Main wait function.  This function will normally block the thread
         // until one of nine events occur that require action.
         ///等待3个事件：关断/读/写，有一个事件发生就返回
         Event = WaitForMultipleObjects(3, ///3个事件
             port->m_hEventArray, ///事件数组
             FALSE, ///有一个事件发生就返回
             INFINITE);///超时时间

         switch (Event)
         {
         case 0:
             {
                 // Shutdown event.  This is event zero so it will be
                 // the higest priority and be serviced first.
                 ///关断事件，关闭串口
                 CloseHandle(port->m_hComm);
                 port->m_hComm=NULL;
                 port->m_bThreadAlive = FALSE;

                 // Kill this thread.  break is not needed, but makes me feel better.
                 //AfxEndThread(100);
                 ::ExitThread(100);

                 break;
             }
         case 1: // write event 发送数据
             {
                 // Write character event from port
                 WriteChar(port);
                 break;
             }
         case 2: // read event 将定义的各种消息发送出去
             {
                 GetCommMask(port->m_hComm, &CommEvent);
                 if (CommEvent & EV_RXCHAR) //接收到字符，并置于输入缓冲区中
                 {
                     if (IsReceiveString == 1)
                     {
                         ReceiveStr(port);//多字符接收
                     }
                     else if (IsReceiveString == 0)
                     {
                         ReceiveChar(port);//单字符接收
                     }
                     else
                     {
                         //默认多字符接收
                         ReceiveStr(port);//多字符接收
                     }
                 }

                 if (CommEvent & EV_CTS) //CTS信号状态发生变化
                     ::SendMessage(port->m_pOwner, WM_COMM_CTS_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
                 if (CommEvent & EV_RXFLAG) //接收到事件字符，并置于输入缓冲区中
                     ::SendMessage(port->m_pOwner, WM_COMM_RXFLAG_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
                 if (CommEvent & EV_BREAK)  //输入中发生中断
                     ::SendMessage(port->m_pOwner, WM_COMM_BREAK_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
                 if (CommEvent & EV_ERR) //发生线路状态错误，线路状态错误包括CE_FRAME,CE_OVERRUN和CE_RXPARITY
                     ::SendMessage(port->m_pOwner, WM_COMM_ERR_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);
                 if (CommEvent & EV_RING) //检测到振铃指示
                     ::SendMessage(port->m_pOwner, WM_COMM_RING_DETECTED, (WPARAM) 0, (LPARAM) port->m_nPortNr);

                 break;
             }
         default:
             {
                 AfxMessageBox("接收有问题!");
                 break;
             }

         } // end switch

     } // close forever loop

     return 0;
 }

 //
 // start comm watching
 ///开启监视线程
 //
 BOOL CSerialPort::StartMonitoring()
 {
     //if (!(m_Thread = AfxBeginThread(CommThread, this)))
     if (!(m_Thread = ::CreateThread (NULL, 0, CommThread, this, 0, NULL )))
         return FALSE;
     //TRACE("Thread started\n");
     return TRUE;
 }

 //
 // Restart the comm thread
 ///从挂起恢复监视线程
 //
 BOOL CSerialPort::ResumeMonitoring()
 {
     //TRACE("Thread resumed\n");
     //m_Thread->ResumeThread();
     ::ResumeThread(m_Thread);
     return TRUE;
 }

 //
 // Suspend the comm thread
 ///挂起监视线程
 //
 BOOL CSerialPort::SuspendMonitoring()
 {
     //TRACE("Thread suspended\n");
     //m_Thread->SuspendThread();
     ::SuspendThread(m_Thread);
     return TRUE;
 }

 BOOL CSerialPort::IsThreadSuspend(HANDLE hThread)
 {
     DWORD   count = SuspendThread(hThread);
     if (count == -1)
     {
         return FALSE;
     }
     ResumeThread(hThread);
     return (count != 0);
 }

 //
 // If there is a error, give the right message
 ///如果有错误，给出提示
 //
 void CSerialPort::ProcessErrorMessage(char* ErrorText)
 {
     char *Temp = new char[200];

     LPVOID lpMsgBuf;

     FormatMessage(
         FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
         NULL,
         GetLastError(),
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
         (LPTSTR) &lpMsgBuf,
         0,
         NULL
         );

     sprintf_s(Temp,200,"WARNING:  %s Failed with the following error: \n%s\nPort: %d\n", (char*)ErrorText, lpMsgBuf, m_nPortNr);
     MessageBox(NULL, Temp, "Application Error", MB_ICONSTOP);

     LocalFree(lpMsgBuf);
     delete[] Temp;
 }

 //
 // Write a character.
 //
 void CSerialPort::WriteChar(CSerialPort* port)
 {
     BOOL bWrite = TRUE;
     BOOL bResult = TRUE;

     DWORD BytesSent = 0;
     DWORD SendLen   = port->m_nWriteSize;
     ResetEvent(port->m_hWriteEvent);


     // Gain ownership of the critical section
     EnterCriticalSection(&port->m_csCommunicationSync);

     if (bWrite)
     {
         // Initailize variables
         port->m_ov.Offset = 0;
         port->m_ov.OffsetHigh = 0;

         // Clear buffer
         PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

         bResult = WriteFile(port->m_hComm,                           // Handle to COMM Port
             port->m_szWriteBuffer,                   // Pointer to message buffer in calling finction
             SendLen,    // add by mrlong
             //strlen((char*)port->m_szWriteBuffer),  // Length of message to send
             &BytesSent,                             // Where to store the number of bytes sent
             &port->m_ov);                            // Overlapped structure

         // deal with any error codes
         if (!bResult)
         {
             DWORD dwError = GetLastError();
             switch (dwError)
             {
             case ERROR_IO_PENDING:
                 {
                     // continue to GetOverlappedResults()
                     BytesSent = 0;
                     bWrite = FALSE;
                     break;
                 }
             case ERROR_ACCESS_DENIED:///拒绝访问 erroe code:5
                 {
                     port->m_hComm = INVALID_HANDLE_VALUE;
                     CString str;
                     str.Format("COM%d ERROR_ACCESS_DENIED，WriteFile() Error Code:%d",port->m_nPortNr,GetLastError());
                     AfxMessageBox(str);
                     break;
                 }
             case ERROR_INVALID_HANDLE:///打开串口失败 erroe code:6
                 {
                     port->m_hComm = INVALID_HANDLE_VALUE;
                     break;
                 }
             case ERROR_BAD_COMMAND:///连接过程中非法断开 erroe code:22
                 {
                     port->m_hComm = INVALID_HANDLE_VALUE;
                     CString str;
                     str.Format("COM%d ERROR_BAD_COMMAND，WriteFile() Error Code:%d",port->m_nPortNr,GetLastError());
                     AfxMessageBox(str);
                     break;
                 }
             default:
                 {
                     // all other error codes
                     port->ProcessErrorMessage("WriteFile()");
                 }
             }
         }
         else
         {
             LeaveCriticalSection(&port->m_csCommunicationSync);
         }
     } // end if(bWrite)

     if (!bWrite)
     {
         bWrite = TRUE;

         bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
             &port->m_ov,     // Overlapped structure
             &BytesSent,     // Stores number of bytes sent
             TRUE);          // Wait flag

         LeaveCriticalSection(&port->m_csCommunicationSync);

         // deal with the error code
         if (!bResult)
         {
             port->ProcessErrorMessage("GetOverlappedResults() in WriteFile()");
         }
     } // end if (!bWrite)

     // Verify that the data size send equals what we tried to send
     if (BytesSent != SendLen /*strlen((char*)port->m_szWriteBuffer)*/)  // add by
     {
         //TRACE("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d\n", BytesSent, strlen((char*)port->m_szWriteBuffer));
     }
 }

 //
 // Character received. Inform the owner
 //
 void CSerialPort::ReceiveChar(CSerialPort* port)
 {
     BOOL  bRead = TRUE;
     BOOL  bResult = TRUE;
     DWORD dwError = 0;
     DWORD BytesRead = 0;
     COMSTAT comstat;
     unsigned char RXBuff;

     for (;;)
     {
         //add by liquanhai 2011-11-06  防止死锁
         if(WaitForSingleObject(port->m_hShutdownEvent,0)==WAIT_OBJECT_0)
             return;

         // Gain ownership of the comm port critical section.
         // This process guarantees no other part of this program
         // is using the port object.

         EnterCriticalSection(&port->m_csCommunicationSync);

         // ClearCommError() will update the COMSTAT structure and
         // clear any other errors.
         ///更新COMSTAT

         bResult = ClearCommError(port->m_hComm, &dwError, &comstat);

         LeaveCriticalSection(&port->m_csCommunicationSync);

         // start forever loop.  I use this type of loop because I
         // do not know at runtime how many loops this will have to
         // run. My solution is to start a forever loop and to
         // break out of it when I have processed all of the
         // data available.  Be careful with this approach and
         // be sure your loop will exit.
         // My reasons for this are not as clear in this sample
         // as it is in my production code, but I have found this
         // solutiion to be the most efficient way to do this.

         ///所有字符均被读出，中断循环
         if (comstat.cbInQue == 0)
         {
             // break out when all bytes have been read
             break;
         }

         EnterCriticalSection(&port->m_csCommunicationSync);

         if (bRead)
         {
             ///串口读出，读出缓冲区中字节
             bResult = ReadFile(port->m_hComm,        // Handle to COMM port
                 &RXBuff,                // RX Buffer Pointer
                 1,                  // Read one byte
                 &BytesRead,         // Stores number of bytes read
                 &port->m_ov);        // pointer to the m_ov structure
             // deal with the error code
             ///若返回错误，错误处理
             if (!bResult)
             {
                 switch (dwError = GetLastError())
                 {
                 case ERROR_IO_PENDING:
                     {
                         // asynchronous i/o is still in progress
                         // Proceed on to GetOverlappedResults();
                         ///异步IO仍在进行
                         bRead = FALSE;
                         break;
                     }
                 case ERROR_ACCESS_DENIED:///拒绝访问 erroe code:5
                     {
                         port->m_hComm = INVALID_HANDLE_VALUE;
                         CString str;
                         str.Format("COM%d ERROR_ACCESS_DENIED，ReadFile() Error Code:%d",port->m_nPortNr,GetLastError());
                         AfxMessageBox(str);
                         break;
                     }
                 case ERROR_INVALID_HANDLE:///打开串口失败 erroe code:6
                     {
                         port->m_hComm = INVALID_HANDLE_VALUE;
                         break;
                     }
                 case ERROR_BAD_COMMAND:///连接过程中非法断开 erroe code:22
                     {
                         port->m_hComm = INVALID_HANDLE_VALUE;
                         CString str;
                         str.Format("COM%d ERROR_BAD_COMMAND，ReadFile() Error Code:%d",port->m_nPortNr,GetLastError());
                         AfxMessageBox(str);
                         break;
                     }
                 default:
                     {
                         // Another error has occured.  Process this error.
                         port->ProcessErrorMessage("ReadFile()");
                         break;
                         //return;///防止读写数据时，串口非正常断开导致死循环一直执行。add by itas109 2014-01-09 与上面liquanhai添加防死锁的代码差不多
                     }
                 }
             }
             else///ReadFile返回TRUE
             {
                 // ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
                 bRead = TRUE;
             }
         }  // close if (bRead)

         ///异步IO操作仍在进行，需要调用GetOverlappedResult查询
         if (!bRead)
         {
             bRead = TRUE;
             bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
                 &port->m_ov,     // Overlapped structure
                 &BytesRead,     // Stores number of bytes read
                 TRUE);          // Wait flag

             // deal with the error code
             if (!bResult)
             {
                 port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
             }
         }  // close if (!bRead)

         LeaveCriticalSection(&port->m_csCommunicationSync);

         // notify parent that a byte was received
         //避免线程互相等待，产生死锁，使用PostMessage()代替SendMessage()
         PostMessage(port->m_pOwner, WM_COMM_RXCHAR, (WPARAM)RXBuff, (LPARAM) port->m_nPortNr);
         //::SendMessage((port->m_pOwner), WM_COMM_RXCHAR, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);
     } // end forever loop

 }

 //
 // str received. Inform the owner
 //
 void CSerialPort::ReceiveStr(CSerialPort* port)
 {
     BOOL  bRead = TRUE;
     BOOL  bResult = TRUE;
     DWORD dwError = 0;
     DWORD BytesRead = 0;
     COMSTAT comstat;

     for (;;)
     {
         //add by liquanhai 2011-11-06  防止死锁
         if(WaitForSingleObject(port->m_hShutdownEvent,0)==WAIT_OBJECT_0)
             return;

         // Gain ownership of the comm port critical section.
         // This process guarantees no other part of this program
         // is using the port object.

         EnterCriticalSection(&port->m_csCommunicationSync);

         // ClearCommError() will update the COMSTAT structure and
         // clear any other errors.
         ///更新COMSTAT

         bResult = ClearCommError(port->m_hComm, &dwError, &comstat);

         LeaveCriticalSection(&port->m_csCommunicationSync);

         // start forever loop.  I use this type of loop because I
         // do not know at runtime how many loops this will have to
         // run. My solution is to start a forever loop and to
         // break out of it when I have processed all of the
         // data available.  Be careful with this approach and
         // be sure your loop will exit.
         // My reasons for this are not as clear in this sample
         // as it is in my production code, but I have found this
         // solutiion to be the most efficient way to do this.

         ///所有字符均被读出，中断循环
         if (comstat.cbInQue == 0)
         {
             // break out when all bytes have been read
             break;
         }

         //如果遇到'\0'，那么数据会被截断，实际数据全部读取只是没有显示完全，这个时候使用memcpy才能全部获取
         unsigned char* RXBuff = new unsigned char[comstat.cbInQue+1];
         if(RXBuff == NULL)
         {
             return;
         }
         RXBuff[comstat.cbInQue] = '\0';//附加字符串结束符

         EnterCriticalSection(&port->m_csCommunicationSync);

         if (bRead)
         {
             ///串口读出，读出缓冲区中字节
             bResult = ReadFile(port->m_hComm,        // Handle to COMM port
                 RXBuff,             // RX Buffer Pointer
                 comstat.cbInQue,                    // Read cbInQue len byte
                 &BytesRead,         // Stores number of bytes read
                 &port->m_ov);        // pointer to the m_ov structure
             // deal with the error code
             ///若返回错误，错误处理
             if (!bResult)
             {
                 switch (dwError = GetLastError())
                 {
                 case ERROR_IO_PENDING:
                     {
                         // asynchronous i/o is still in progress
                         // Proceed on to GetOverlappedResults();
                         ///异步IO仍在进行
                         bRead = FALSE;
                         break;
                     }
                 case ERROR_ACCESS_DENIED:///拒绝访问 erroe code:5
                     {
                         port->m_hComm = INVALID_HANDLE_VALUE;
                         CString str;
                         str.Format("COM%d ERROR_ACCESS_DENIED，ReadFile() Error Code:%d",port->m_nPortNr,GetLastError());
                         AfxMessageBox(str);
                         break;
                     }
                 case ERROR_INVALID_HANDLE:///打开串口失败 erroe code:6
                     {
                         port->m_hComm = INVALID_HANDLE_VALUE;
                         break;
                     }
                 case ERROR_BAD_COMMAND:///连接过程中非法断开 erroe code:22
                     {
                         port->m_hComm = INVALID_HANDLE_VALUE;
                         CString str;
                         str.Format("COM%d ERROR_BAD_COMMAND，ReadFile() Error Code:%d",port->m_nPortNr,GetLastError());
                         AfxMessageBox(str);
                         break;
                     }
                 default:
                     {
                         // Another error has occured.  Process this error.
                         port->ProcessErrorMessage("ReadFile()");
                         break;
                         //return;///防止读写数据时，串口非正常断开导致死循环一直执行。add by itas109 2014-01-09 与上面liquanhai添加防死锁的代码差不多
                     }
                 }
             }
             else///ReadFile返回TRUE
             {
                 // ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
                 bRead = TRUE;
             }
         }  // close if (bRead)

         ///异步IO操作仍在进行，需要调用GetOverlappedResult查询
         if (!bRead)
         {
             bRead = TRUE;
             bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
                 &port->m_ov,     // Overlapped structure
                 &BytesRead,     // Stores number of bytes read
                 TRUE);          // Wait flag

             // deal with the error code
             if (!bResult)
             {
                 port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
             }
         }  // close if (!bRead)

         LeaveCriticalSection(&port->m_csCommunicationSync);

         // notify parent that some byte was received
         ::SendMessage((port->m_pOwner), WM_COMM_RXSTR, (WPARAM) RXBuff, (LPARAM) port->m_nPortNr);
         //如果只有一个串口收发数据，可以传输读取长度，因为RXBuff中可能包含'\0'，ASCII为00
         //::SendMessage((port->m_pOwner), WM_COMM_RXSTR, (WPARAM) RXBuff, BytesRead);

         //释放
         delete[] RXBuff;
         RXBuff = NULL;

     } // end forever loop

 }

 //
 // Write a string to the port
 //
 void CSerialPort::WriteToPort(char* string)
 {
     assert(m_hComm != 0);

     memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
     strcpy_s(m_szWriteBuffer,m_nWriteBufferSize,string);
     m_nWriteSize=strlen(string); // add by mrlong
     // set event for write
     SetEvent(m_hWriteEvent);
 }

 //
 // Return the device control block
 //
 DCB CSerialPort::GetDCB()
 {
     return m_dcb;
 }

 //
 // Return the communication event masks
 //
 DWORD CSerialPort::GetCommEvents()
 {
     return m_dwCommEvents;
 }

 //
 // Return the output buffer size
 //
 DWORD CSerialPort::GetWriteBufferSize()
 {
     return m_nWriteBufferSize;
 }

 BOOL CSerialPort::IsOpen()
 {
     return m_hComm != NULL && m_hComm!= INVALID_HANDLE_VALUE;//m_hComm增加INVALID_HANDLE_VALUE的情况 add by itas109 2016-07-29
 }

 void CSerialPort::ClosePort()
 {
     MSG message;

     //增加线程挂起判断，解决由于线程挂起导致串口关闭死锁的问题 add by itas109 2016-06-29
     if(IsThreadSuspend(m_Thread))
     {
         ResumeThread(m_Thread);
     }

     //串口句柄无效  add by itas109 2016-07-29
     if(m_hComm == INVALID_HANDLE_VALUE)
     {
         CloseHandle(m_hComm);
         m_hComm = NULL;
         return;
     }

     do
     {
         SetEvent(m_hShutdownEvent);
         //add by liquanhai  防止死锁  2011-11-06
         if(::PeekMessage(&message,m_pOwner,0,0,PM_REMOVE))
         {
             ::TranslateMessage(&message);
             ::DispatchMessage(&message);
         }
     } while (m_bThreadAlive);

     // if the port is still opened: close it
     if (m_hComm != NULL)
     {
         CloseHandle(m_hComm);
         m_hComm = NULL;
     }

     // Close Handles
     if(m_hShutdownEvent!=NULL)
     {
         ResetEvent(m_hShutdownEvent);
     }
     if(m_ov.hEvent!=NULL)
     {
         ResetEvent(m_ov.hEvent);
     }
     if(m_hWriteEvent!=NULL)
     {
         ResetEvent(m_hWriteEvent);
         //CloseHandle(m_hWriteEvent);//开发者反映，这里会导致多个串口工作时，重新打开串口异常
     }

     if(m_szWriteBuffer != NULL)
     {
         delete [] m_szWriteBuffer;
         m_szWriteBuffer = NULL;
     }
 }

 void CSerialPort::WriteToPort(char* string,int n)
 {
     assert(m_hComm != 0);
     memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
     memcpy(m_szWriteBuffer, string, n);
     m_nWriteSize = n;

     // set event for write
     SetEvent(m_hWriteEvent);
 }

 void CSerialPort::WriteToPort(LPCTSTR string)
 {
     assert(m_hComm != 0);
     memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
     strcpy_s(m_szWriteBuffer,m_nWriteBufferSize,string);
     m_nWriteSize=strlen(string);
     // set event for write
     SetEvent(m_hWriteEvent);
 }

 void CSerialPort::WriteToPort(BYTE* Buffer, int n)
 {
     assert(m_hComm != 0);
     memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
     int i;
     for(i=0; i
     {
         m_szWriteBuffer[i] = Buffer[i];
     }
     m_nWriteSize=n;

     // set event for write
     SetEvent(m_hWriteEvent);
 }


 //void CSerialPort::SendData(LPCTSTR lpszData, const int nLength)
 //{
 //  assert(m_hComm != 0);
 //  memset(m_szWriteBuffer, 0, nLength);
 //  strcpy_s(m_szWriteBuffer,m_nWriteBufferSize,lpszData);
 //  m_nWriteSize=nLength;
 //  // set event for write
 //  SetEvent(m_hWriteEvent);
 //}

 //BOOL CSerialPort::RecvData(LPTSTR lpszData, const int nSize)
 //{
 //  //
 //  //接收数据
 //  //
 //  assert(m_hComm!=0);
 //  memset(lpszData,0,nSize);
 //  DWORD mylen  = 0;
 //  DWORD mylen2 = 0;
 //  while (mylen < (DWORD)nSize) {
 //      if(!ReadFile(m_hComm,lpszData,nSize,&mylen2,NULL))
 //          return FALSE;
 //      mylen += mylen2;
 //  }
 //
 //  return TRUE;
 //}
 //
 ///查询注册表的串口号，将值存于数组中
 ///本代码参考于mingojiang的获取串口逻辑名代码
 //
 void CSerialPort::QueryKey(HKEY hKey)
 {
 #define MAX_KEY_LENGTH 255
 #define MAX_VALUE_NAME 16383
     //  TCHAR    achKey[MAX_KEY_LENGTH];   // buffer for subkey name
     //  DWORD    cbName;                   // size of name string
     TCHAR    achClass[MAX_PATH] = TEXT("");  // buffer for class name
     DWORD    cchClassName = MAX_PATH;  // size of class string
     DWORD    cSubKeys=0;               // number of subkeys
     DWORD    cbMaxSubKey;              // longest subkey size
     DWORD    cchMaxClass;              // longest class string
     DWORD    cValues;              // number of values for key
     DWORD    cchMaxValue;          // longest value name
     DWORD    cbMaxValueData;       // longest value data
     DWORD    cbSecurityDescriptor; // size of security descriptor
     FILETIME ftLastWriteTime;      // last write time

     DWORD i, retCode;

     TCHAR  achValue[MAX_VALUE_NAME];
     DWORD cchValue = MAX_VALUE_NAME;

     // Get the class name and the value count.
     retCode = RegQueryInfoKey(
         hKey,                    // key handle
         achClass,                // buffer for class name
         &cchClassName,           // size of class string
         NULL,                    // reserved
         &cSubKeys,               // number of subkeys
         &cbMaxSubKey,            // longest subkey size
         &cchMaxClass,            // longest class string
         &cValues,                // number of values for this key
         &cchMaxValue,            // longest value name
         &cbMaxValueData,         // longest value data
         &cbSecurityDescriptor,   // security descriptor
         &ftLastWriteTime);       // last write time

     for (i=0;i<20;i++)///存放串口号的数组初始化
     {
         m_nComArray[i] = -1;
     }

     // Enumerate the key values.
     if (cValues > 0) {
         for (i=0, retCode=ERROR_SUCCESS; i