cncomm1.3.h

一个功能强大的串口通信类库

/*
cnComm Serial Port Library(WIN32) free version 1.3
Compiled by： BC++ 5(free tool); C++ BUILDER 4, 5, 6, X; VC++ 5, 6, 7, 8;  GCC;
Writer: llbird 
Mail  : [e-mail]  
Blog  : http:///blog.csdn.net/wujian53
Copyright(c) 2004.5 - 2006.1 

Update:
2007.9 :
    将 DWORD Read(LPVOID Buffer, DWORD dwBufferLength, DWORD dwWaitTime = 10) 
    改成 DWORD Read(LPVOID Buffer, DWORD dwBufferLength, bool bOnlyGetBuffer = true)
    由于为了提高异步读的速度及成功率，通常只把读缓冲区的数据读出；
    但是发现许多网友并不会处理连续读的问题，总是希望能够一次性读够字符串，而不是断续的数据；
    所以提供参数bOnlyGetBuffer， 当    bOnlyGetBuffer为真（默认）只读缓冲区数据，否则等待异步IO结束，
    这样能够读取较完整的数据，但实际中可能还会产生其它问题，一速度较慢，二如果不能准确确字符串长度，
    还是会出现分割的情况，所以用定时器去读串口会更可靠，而不是等待消息；
    对于处理字符串被分割的问题，可以参考我博克的案例。
*/

#ifndef _CN_COMM_H_
#define _CN_COMM_H_

#include <assert.h>
#include <stdio.h>
#include <windows.h>
#include <process.h>

///送到窗口的消息  WPARAM 端口号
#define ON_COM_RECEIVE WM_USER + 618    
#define ON_COM_CTS     WM_USER + 619 //>LPARAM 1 valid 
#define ON_COM_DSR     WM_USER + 621 //>LPARAM 1 valid
#define ON_COM_RING    WM_USER + 623
#define ON_COM_RLSD    WM_USER + 624
#define ON_COM_BREAK   WM_USER + 625
#define ON_COM_TXEMPTY WM_USER + 626
#define ON_COM_ERROR   WM_USER + 627 //>LPARAM save Error ID
#define DEFAULT_COM_MASK_EVENT  EV_RXCHAR | EV_ERR | EV_CTS | EV_DSR | EV_BREAK | EV_TXEMPTY | EV_RING | EV_RLSD

class cnComm    
{
public:
    
    //////------------------------------Construction-----------------------------------
    ///第1个参数为是否在打开串口时启动监视线程， 第2个参数为IO方式 阻塞方式（0）/ 异步重叠方式（默认）
    cnComm(bool fAutoBeginThread = true, DWORD dwIOMode = FILE_FLAG_OVERLAPPED)
        : _dwIOMode(dwIOMode), _fAutoBeginThread(fAutoBeginThread)
    {
        Init(); 
    }
    
    virtual ~cnComm()
    {
        Close(); 
        Destroy();
    }
    
    //////----------------------------------Attributes----------------------------------
    ///判断串口是或打开
    inline bool IsOpen()
    {
        return _hCommHandle != INVALID_HANDLE_VALUE;
    }
    ///判断串口是或打开
    operator bool ()
    {
        return _hCommHandle != INVALID_HANDLE_VALUE;
    }
    ///获得串口句炳
    HANDLE GetHandle()
    {
        return _hCommHandle;
    }
    ///获得串口句炳
    operator HANDLE()
    {
        return _hCommHandle;
    }
    ///获得串口序号
    const int GetPortID()
    {
        return _dwPort;
    }
    ///获得串口全名
    const char *GetPortName()
    {
        return _szCommStr;
    }
    ///获得串口参数 DCB
    DCB *GetState()
    {
        return IsOpen() && ::GetCommState(_hCommHandle, &_DCB) == TRUE ? &_DCB : NULL;
    }
    ///设置串口参数 DCB
    bool SetState(DCB *pdcb = NULL)
    {
        return IsOpen() ? ::SetCommState(_hCommHandle, pdcb == NULL ? &_DCB : pdcb) == TRUE : false;
    }
    ///设置串口参数：波特率，停止位，等 支持设置字符串 "9600, n, 8, 1"
    bool SetState(char *szSetStr) 
    {
        if(IsOpen())
        {
            if(::GetCommState(_hCommHandle, &_DCB) != TRUE)
                return false;
            if(::BuildCommDCB(szSetStr, &_DCB) != TRUE)
                return false;
            return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
        }
        return false;
    }
    ///设置串口参数：波特率，停止位，等
    bool SetState(DWORD dwBaudRate, DWORD dwByteSize = 8, DWORD dwParity = NOPARITY, DWORD dwStopBits = ONESTOPBIT)
    {
        if(IsOpen())
        {
            if(::GetCommState(_hCommHandle, &_DCB) != TRUE)
                return false;
            _DCB.BaudRate = dwBaudRate;
            _DCB.ByteSize = (unsigned char)dwByteSize;
            _DCB.Parity   = (unsigned char)dwParity;
            _DCB.StopBits = (unsigned char)dwStopBits;
            return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
        }
        return false;
    }
    ///获得超时结构
    LPCOMMTIMEOUTS GetTimeouts(void)
    {
        return IsOpen() && ::GetCommTimeouts(_hCommHandle, &_CO) == TRUE  ? &_CO : NULL;
    }
    ///设置超时
    bool SetTimeouts(LPCOMMTIMEOUTS lpCO)
    {
        return IsOpen() ? ::SetCommTimeouts(_hCommHandle, lpCO) == TRUE : false;
    }
    ///设置串口的I/O缓冲区大小
    bool SetBufferSize(DWORD dwInputSize, DWORD dwOutputSize)
    {
        return IsOpen() ? ::SetupComm(_hCommHandle, dwInputSize, dwOutputSize) == TRUE : false; 
    }
    ///清除接受缓冲区
    void ClearInputBuffer()
    {
        if(IsOpen())
            ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR );
    }
    ///清除发送缓冲区
    void ClearOutputBuffer()
    {
        if(IsOpen())
            ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR );
    }
    ///关联消息的窗口句柄
    inline void SetWnd(HWND hWnd)
    {
        assert(::IsWindow(hWnd));
        _hNotifyWnd = hWnd;
    }
    ///设定发送通知, 接受字符最小值
    inline void SetNotifyNum(DWORD dwNum)
    {
        _dwNotifyNum = dwNum;
    }
    ///线程是否运行
    inline bool IsThreadRunning()
    {
        return _hThreadHandle != NULL;
    }
    ///获得线程句柄
    inline HANDLE GetThread()
    {
        return _hThreadHandle;
    }
    ///设置要监视的事件， 打开前设置有效
    void SetMaskEvent(DWORD dwEvent = DEFAULT_COM_MASK_EVENT)
    {
        _dwMaskEvent = dwEvent;
    }
    ///获得读缓冲区的字符数
    int GetInputSize()
    {
        COMSTAT Stat;
        DWORD dwError;
        
        return ::ClearCommError(_hCommHandle, &dwError, &Stat) == TRUE  ? Stat.cbInQue : (DWORD)-1L;
    }
    
    //////----------------------------------Operations----------------------------------
    ///打开串口 缺省 9600, n, 8, 1
    bool Open(DWORD dwPort)
    {
        return Open(dwPort, 9600);
    }
    ///打开串口 缺省 baud_rate, n, 8, 1
    bool Open(DWORD dwPort, DWORD dwBaudRate)
    {
        if(dwPort < 1 || dwPort > 1024)
            return false;
        
        BindCommPort(dwPort);
        
        if(!OpenCommPort())
            return false;
        
        if(!SetupPort())
            return false;
        
        return SetState(dwBaudRate);
    }
    ///打开串口, 使用类似"9600, n, 8, 1"的设置字符串设置串口
    bool Open(DWORD dwPort, char *szSetStr)
    {
        if(dwPort < 1 || dwPort > 1024)
            return false;
        
        BindCommPort(dwPort);
        
        if(!OpenCommPort())
            return false;
        
        if(!SetupPort())
            return false;
        
        return SetState(szSetStr);
    }
    ///读取串口 dwBufferLength个字符到 Buffer 返回实际读到的字符数  可读任意数据
    DWORD Read(LPVOID Buffer, DWORD dwBufferLength, bool bOnlyGetBuffer = true)
    {
        if(!IsOpen())
            return 0;
        
        COMSTAT  Stat;
        DWORD dwError;
        
        if(::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0)
        {
            ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR);
            return 0;
        }
        
        if(bOnlyGetBuffer)
            dwBufferLength = dwBufferLength > Stat.cbInQue ? Stat.cbInQue : dwBufferLength;

        unsigned long uReadLength = 0;
        if(!::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, &_ReadOverlapped)) 
        {
            if(::GetLastError() == ERROR_IO_PENDING) 
            {
                while(!::GetOverlappedResult(_hCommHandle, &_ReadOverlapped, &uReadLength, TRUE))     
                {
                    if(::GetLastError() != ERROR_IO_INCOMPLETE)
                    {
                        ::ClearCommError(_hCommHandle, &dwError, &Stat);
                        break;
                    }
                }
            }
            else
                ::ClearCommError(_hCommHandle, &dwError, &Stat);
        }
        
        return uReadLength;
    }
    
    ///读取串口 dwBufferLength - 1 个字符到 szBuffer 返回ANSI C 模式字符串指针 适合一般字符通讯
    char * ReadString(char *szBuffer, DWORD dwBufferLength, bool bOnlyGetBuffer = true)
    {
        unsigned long uReadLength = Read(szBuffer, dwBufferLength - 1, bOnlyGetBuffer);
        szBuffer[uReadLength] = '\0';
        return szBuffer;
    }
    ///写串口 可写任意数据 "abcd" or "x0x1x2"
    DWORD Write(LPVOID Buffer, DWORD dwBufferLength)
    {
        if(!IsOpen())
            return 0;
        
        DWORD dwError;
        
        if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) 
            ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR); 
        
        unsigned long uWriteLength = 0;
        
        if(!::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, &_WriteOverlapped))
            if(::GetLastError() != ERROR_IO_PENDING)
                uWriteLength = 0;
            
            return uWriteLength;
    }
    ///写串口 写ANSI C 模式字符串指针 
    DWORD Write(const char *szBuffer)
    {
        assert(szBuffer);
        
        return Write((void *)szBuffer, strlen(szBuffer));
    }
    ///读串口    同步应用
    DWORD ReadSync(LPVOID Buffer, DWORD dwBufferLength)
    {
        if(!IsOpen())
            return 0;
        
        DWORD dwError;
        if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
        {
            ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR);
            return 0;
        }

        DWORD uReadLength = 0;
        ::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, NULL);
        return uReadLength;
    }
    ///写串口 同步应用
    DWORD WriteSync(LPVOID Buffer, DWORD dwBufferLength)
    {
        if(!IsOpen())
            return 0;
        
        DWORD dwError;
        if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0) 
            ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR); 
        
        unsigned long uWriteLength = 0;
        ::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, NULL);
        return uWriteLength;
    }
    ///写串口 szBuffer 可以输出格式字符串 包含缓冲区长度
    DWORD Write(char *szBuffer, DWORD dwBufferLength, char * szFormat, ...)
    {
        if(!IsOpen())
            return 0;
        
        va_list va;
        va_start(va, szFormat);
        _vsnprintf(szBuffer, dwBufferLength, szFormat, va);
        va_end(va);
        
        return Write(szBuffer);
    }
    ///写串口 szBuffer 可以输出格式字符串 不检查缓冲区长度 小心溢出
    DWORD Write(char *szBuffer, char * szFormat, ...)
    {
        if(!IsOpen())
            return 0;
        
        va_list va;
        va_start(va, szFormat);
        vsprintf(szBuffer, szFormat, va);
        va_end(va);
        
        return Write(szBuffer);
    }
    ///关闭串口 同时也关闭关联线程
    virtual void Close()
    {
        if(IsOpen())  
        {
            PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR); 
            
            EndThread();
            ::CloseHandle(_hCommHandle);
            
            _hCommHandle = INVALID_HANDLE_VALUE;
        }
    }

    struct InnerLock