简单封装的串口通信类

#include "stdafx.h"

#include "SerialPort.h"



#include "assert.h"



CSerialPort::CSerialPort()

{

    memset(&m_OverlappedRead, 0, sizeof(m_OverlappedRead));

    memset(&m_OverlappedWrite, 0, sizeof(m_OverlappedWrite));

    m_bOpened = false;

    m_ReadComThread = NULL;

    m_hIDCom = NULL;

    m_dwReadLen = 0;

}



CSerialPort::~CSerialPort()

{



}



BOOL CSerialPort::OpenPort(UINT nPort, UINT nBaud)

{

    ASSERT(nPort > 0 && nPort < 5);  

    if(m_bOpened)

        return true;

    

    TCHAR szPort[15];

    TCHAR szComParams[50];

    DCB dcb;



    wsprintf(szPort, _T("COM%d"), nPort);

    m_hIDCom = ::CreateFile(szPort, 

        GENERIC_READ | GENERIC_WRITE, 

        0, 

        NULL,

        OPEN_EXISTING,

        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,

        NULL);

    if(m_hIDCom == NULL)

        return false;



    memset(&m_OverlappedRead, 0, sizeof(OVERLAPPED));

    memset(&m_OverlappedWrite, 0, sizeof(OVERLAPPED));



    COMMTIMEOUTS CommTimeOuts;

    CommTimeOuts.ReadIntervalTimeout = 0xFFFFFFFF;

    CommTimeOuts.ReadTotalTimeoutConstant = 0;

    CommTimeOuts.ReadTotalTimeoutMultiplier = 0;

    CommTimeOuts.WriteTotalTimeoutMultiplier = 0;

    CommTimeOuts.WriteTotalTimeoutConstant = 5000;

    ::SetCommTimeouts(m_hIDCom, &CommTimeOuts);



    wsprintf(szComParams, _T("COM%d:%d,N,8,1"), nPort, nBaud);

    m_OverlappedRead.Offset = 0;

    m_OverlappedRead.OffsetHigh = 0;

    m_OverlappedRead.hEvent = ::CreateEvent(NULL, true, false, NULL);

    m_OverlappedWrite.Offset = 0;

    m_OverlappedWrite.OffsetHigh = 0;

    m_OverlappedWrite.hEvent = ::CreateEvent(NULL, true, false, NULL);



    dcb.DCBlength = sizeof(DCB);

    ::GetCommState(m_hIDCom, &dcb);

    dcb.BaudRate = nBaud;

    dcb.ByteSize = 8;

    dcb.Parity = 0;



    if(!SetCommState(m_hIDCom, &dcb) || !SetupComm(m_hIDCom, 4096, 4096) ||

        m_OverlappedRead.hEvent == NULL || m_OverlappedWrite.hEvent == NULL)

    {

        DWORD dwError = ::GetLastError();

        if(m_OverlappedRead.hEvent != NULL)

            ::CloseHandle(m_OverlappedRead.hEvent);

        if(m_OverlappedWrite.hEvent != NULL)

            ::CloseHandle(m_OverlappedWrite.hEvent);

        ::CloseHandle(m_hIDCom);

        return false;

    }

    ::SetCommMask(m_hIDCom, EV_RXCHAR);

    ::PurgeComm(m_hIDCom, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);

    ::EscapeCommFunction(m_hIDCom, SETDTR);



    m_bOpened =true;

    m_bExitThread =false;



    StartMonitoring();

    return m_bOpened;

}



BOOL CSerialPort::Close()

{

    if(!m_bOpened || m_hIDCom == NULL)

        return true;

    m_bExitThread = true;

    ::SetCommMask(m_hIDCom, 0);

    StopMonitoring();

    

    if(m_OverlappedRead.hEvent != NULL)

        ::CloseHandle(m_OverlappedRead.hEvent);



    if(m_OverlappedWrite.hEvent != NULL)

        ::CloseHandle(m_OverlappedWrite.hEvent);



    ::CloseHandle(m_hIDCom);



    m_bOpened = false;

    m_hIDCom = NULL;



    return true;

}





//向串口写数据

void CSerialPort::WriteToPort(BYTE *Byte, int Len)

{

    if(!m_bOpened || m_hIDCom == NULL)

        return;



    BOOL bWriteStat;

    DWORD dwBytesWritten;

    ClearReadBuf();

    bWriteStat = ::WriteFile(m_hIDCom, Byte, Len, &dwBytesWritten, &m_OverlappedWrite);



    if(!bWriteStat && (::GetLastError() == ERROR_IO_PENDING))

    {

        //WaitForSingleObject函数用来检测hHandle事件的信号状态，当函数的执行时间超过dwMilliseconds就

        //返回，但如果参数dwMilliseconds为INFINITE时函数将直到相应时间事件变成有信号状态才返回，

        //否则就一直等待下去，直到WaitForSingleObject有返回直才执行后面的代码。

        DWORD dw = ::WaitForSingleObject(m_OverlappedWrite.hEvent, INFINITE );

        if(dw == WAIT_TIMEOUT)

        {

            dwBytesWritten = 0;

            DCB dcb;

            ::GetCommState(m_hIDCom, &dcb);

            ::PurgeComm(m_hIDCom, PURGE_TXCLEAR);

            return;

        }

        else

        {

            ::GetOverlappedResult(m_hIDCom, &m_OverlappedWrite, &dwBytesWritten, false);//等待服务器完成IO操作

            m_OverlappedWrite.Offset += dwBytesWritten;

        }

    }

    return ;

}





//从串口读取数据

int CSerialPort::ReadFromPort(BYTE *lpszBlock, int nRLen)

{

    if(!m_bOpened || m_hIDCom == NULL)

        return 0;



    BOOL bReadStat;

    DWORD dwBytesRead, dwErrorFlags;

    COMSTAT ComStat;

    ::ClearCommError(m_hIDCom, &dwErrorFlags, &ComStat);

    if(!ComStat.cbInQue)

        return 0;



    dwBytesRead = (DWORD) ComStat.cbInQue;

    if(nRLen < (int)dwBytesRead)

        dwBytesRead = (DWORD) nRLen;



    bReadStat = ::ReadFile(m_hIDCom, lpszBlock, dwBytesRead, &dwBytesRead, &m_OverlappedRead);

    if(!bReadStat)

    {

        if(::GetLastError() == ERROR_IO_PENDING)

        {

            ::WaitForSingleObject(m_OverlappedRead.hEvent, INFINITE);

            return (int)dwBytesRead;

        }

        return 0;

    }

    return (int)dwBytesRead;

}







UINT CSerialPort::CommThread(LPVOID pParam)

{

    CSerialPort* pSerialPort = (CSerialPort*)pParam;

    BYTE Buffer[4096];

    DWORD dwEvent, dwError;

    COMSTAT ComStat;

    int ReadLen = 0;

    memset(pSerialPort->m_ReadBuf, '\0', sizeof(pSerialPort->m_ReadBuf));

    ::SetCommMask(pSerialPort->m_hIDCom, EV_RXCHAR);

    while(!pSerialPort->m_bExitThread)

    {

        memset(Buffer, '\0', 4096);

        ::WaitCommEvent(pSerialPort->m_hIDCom, &dwEvent, NULL);

        ::ClearCommError(pSerialPort->m_hIDCom, &dwError, &ComStat);

        if((dwEvent & EV_RXCHAR) && ComStat.cbInQue)

        {

            pSerialPort->m_dwReadLen = pSerialPort->ReadFromPort(Buffer,4096);

            pSerialPort->m_dwReadLen = ReadLen >4096 ? 4096 : ReadLen;

            if(pSerialPort->m_dwReadLen > 0)

            {

                memcpy(pSerialPort->m_ReadBuf, Buffer,pSerialPort->m_dwReadLen);

            }

        }

        ::PurgeComm(pSerialPort->m_hIDCom, PURGE_RXCLEAR);

    }

    return 0;

}



BOOL CSerialPort::StartMonitoring()

{

    if(m_ReadComThread == NULL)

    {

        if(!(m_ReadComThread = ::AfxBeginThread(CommThread, this)))

            return false;

    }

    return true;

}



BOOL CSerialPort::StopMonitoring()

{

    if(m_ReadComThread != NULL)

    {

        ::TerminateThread(m_ReadComThread->m_hThread, 0); //终结线程

        m_ReadComThread = NULL;

    }

    return true;

}



void CSerialPort::ClearReadBuf()

{

    memset(m_ReadBuf, '\0', sizeof(m_ReadBuf));

    m_dwReadLen = 0;

}