串口编程C++实例（CE） .

* 文件名称：CESeries.cpp

----------------------------------------*/

#include "StdAfx.h"

#include "CESeries1.h"

 

//HANDLE CCESeries1::m_hComm =  INVALID_HANDLE_VALUE;

//BOOL CCESeries11::m_bOpened = FALSE; //串口是否打开
//构造函数
CCESeries1::CCESeries1()

{

    //初始化内部变量
    m_hComm = INVALID_HANDLE_VALUE;

    m_OnSeriesRead = NULL;

    m_bOpened = 0;
}

 

//析构函数
CCESeries1::~CCESeries1()

{

    if (m_bOpened)

    {
        //关闭串口
        ClosePort();

    }
}

 

//串口读线程函数
DWORD CCESeries1::ReadThreadFunc(LPVOID lparam)

{

    CCESeries1 *ceSeries = (CCESeries1*)lparam;

    
    DWORD    evtMask;

    BYTE * readBuf = NULL;//读取的字节
    DWORD actualReadLen=0;//实际读取的字节数
    DWORD willReadLen;

    
    DWORD dwReadErrors;

    COMSTAT  cmState;

 

    // 清空缓冲，并检查串口是否打开。
    ASSERT(ceSeries->m_hComm !=INVALID_HANDLE_VALUE); 

    
    //清空串口
    PurgeComm(ceSeries->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR );

    
    SetCommMask (ceSeries->m_hComm, EV_RXCHAR | EV_CTS | EV_DSR );

    while (TRUE)

    {   
        if (WaitCommEvent(ceSeries->m_hComm,&evtMask,0))

        {           
            SetCommMask (ceSeries->m_hComm, EV_RXCHAR | EV_CTS | EV_DSR );

            //表示串口收到字符     

            if (evtMask & EV_RXCHAR) 

            {
                ClearCommError(ceSeries->m_hComm,&dwReadErrors,&cmState);

        //willReadLen = cmState.cbInQue-1 ;

                willReadLen = cmState.cbInQue ;

                if (willReadLen <= 0)
                {
                    continue;

                }
                
                //分配内存
        //readBuf = new BYTE[willReadLen-1];

                readBuf = new BYTE[willReadLen];

                ZeroMemory(readBuf,willReadLen);

                //读取串口数据
                ReadFile(ceSeries->m_hComm, readBuf, willReadLen, &actualReadLen,0);

                
                //如果读取的数据大于，
                if (actualReadLen>0)

                {
        //CString Check;            

        //Check.Format(_T("%d %d"),willReadLen,actualReadLen);

        //AfxMessageBox(Check);

                //触发读取回调函数
                    if (ceSeries->m_OnSeriesRead)

                    {
                        ceSeries->m_OnSeriesRead(ceSeries->m_pOwner,readBuf,actualReadLen);

                        actualReadLen = 0;
                    }
                }
 

                //释放内存
                delete[] readBuf;

                readBuf = NULL;

            }
        }
        //如果收到读线程退出信号，则退出线程
        if (WaitForSingleObject(ceSeries->m_hReadCloseEvent,500) == WAIT_OBJECT_0)

        {
            break;

        }
    }
    return 0;
}

 

//关闭读线程
void CCESeries1::CloseReadThread()

{

    SetEvent(m_hReadCloseEvent);

    //设置所有事件无效无效
    SetCommMask(m_hComm, 0);

    //清空所有将要读的数据
    PurgeComm( m_hComm,  PURGE_RXCLEAR );

    //等待秒，如果读线程没有退出，则强制退出
    if (WaitForSingleObject(m_hReadThread,4000) == WAIT_TIMEOUT)

    {
        TerminateThread(m_hReadThread,0);

    }
    m_hReadThread = NULL;

}

 

/*

*函数介绍：打开串口
*入口参数：pPortOwner  :使用此串口类的窗体句柄
            portNo     :串口号
            baud            :波特率
            parity     :奇偶校验
            databits        :数据位
            stopbits        :停止位
*出口参数：(无)

*返回值：TRUE:成功打开串口;FALSE:打开串口失败
*/

BOOL CCESeries1::OpenPort(void * pOwner,

                         UINT portNo  ,           /*串口号*/

                         UINT baud       ,           /*波特率*/

                         UINT parity  ,           /*奇偶校验*/

                         UINT databits    ,           /*数据位*/

                         UINT stopbits               /*停止位*/

                         )
{

    DCB commParam;

    TCHAR szPort[15];  

 

    ASSERT(pOwner!=NULL);

    m_pOwner = pOwner;

    
    // 已经打开的话，直接返回
    if (m_hComm != INVALID_HANDLE_VALUE)

    {
        return TRUE;

    }
    
    //设置串口名
    wsprintf(szPort, L"COM%d:", portNo);

    //打开串口
    m_hComm = CreateFile(

        szPort,

        GENERIC_READ | GENERIC_WRITE,   //允许读和写
        0,                              //独占方式（共享模式）
        NULL,

        OPEN_EXISTING,                       //打开而不是创建（创建方式）
        0,
        NULL 
        );
    
    if (m_hComm == INVALID_HANDLE_VALUE)

    {
        // 无效句柄,返回。     

        TRACE(_T("CreateFile 返回无效句柄/n"));

        return FALSE;

        
    }
    
    memset(&commParam,0,sizeof(DCB));

    // 得到打开串口的当前属性参数，修改后再重新设置串口。
    if (!GetCommState(m_hComm,&commParam))

    {       
        //关闭串口
        CloseHandle (m_hComm);

        m_hComm = INVALID_HANDLE_VALUE;

        return FALSE;

    }
    
    //设置串口参数
    commParam.BaudRate = baud;                    // 设置波特率
    commParam.fBinary = TRUE;                     // 设置二进制模式，此处必须设置TRUE

    commParam.fParity = TRUE;                     // 支持奇偶校验
    commParam.ByteSize = databits;                // 数据位,范围:4-8 

    commParam.Parity = NOPARITY;                  // 校验模式
    commParam.StopBits = stopbits;                // 停止位
    
    commParam.fOutxCtsFlow = FALSE;               // No CTS output flow control 

    commParam.fOutxDsrFlow = FALSE;               // No DSR output flow control 

    commParam.fDtrControl = DTR_CONTROL_ENABLE; 

    // DTR flow control type 

    commParam.fDsrSensitivity = FALSE;            // DSR sensitivity 

    commParam.fTXContinueOnXoff = TRUE;           // XOFF continues Tx 

    commParam.fOutX = FALSE;                      // No XON/XOFF out flow control 

    commParam.fInX = FALSE;                            // No XON/XOFF in flow control 

    commParam.fErrorChar = FALSE;                 // Disable error replacement 

    commParam.fNull = FALSE;                      // Disable null stripping 

    commParam.fRtsControl = RTS_CONTROL_ENABLE; 

    // RTS flow control 

    commParam.fAbortOnError = FALSE;              // 当串口发生错误，并不终止串口读写
    
    //设置串口参数
    if (!SetCommState(m_hComm, &commParam))

    {
        TRACE(_T("SetCommState error")); 

        //关闭串口
        CloseHandle (m_hComm);

        m_hComm = INVALID_HANDLE_VALUE;      

        return FALSE;

    }
    
    //设置串口读写时间
    COMMTIMEOUTS CommTimeOuts;

    GetCommTimeouts (m_hComm, &CommTimeOuts);

    CommTimeOuts.ReadIntervalTimeout = MAXDWORD;  

    CommTimeOuts.ReadTotalTimeoutMultiplier = 0;  

    CommTimeOuts.ReadTotalTimeoutConstant = 0;    

    CommTimeOuts.WriteTotalTimeoutMultiplier = 10;  

    CommTimeOuts.WriteTotalTimeoutConstant = 1000;  

    if(!SetCommTimeouts( m_hComm, &CommTimeOuts ))

    {
        TRACE( _T("SetCommTimeouts 返回错误") );

        //关闭串口
        CloseHandle (m_hComm);

 

        m_hComm = INVALID_HANDLE_VALUE;

        return FALSE;

    }
    
    //指定端口监测的事件集
    SetCommMask (m_hComm, EV_RXCHAR);

    //分配串口设备缓冲区
    SetupComm(m_hComm,512,512);

    //初始化缓冲区中的信息
    PurgeComm(m_hComm,PURGE_TXCLEAR|PURGE_RXCLEAR);

    
    CString strEvent;

    strEvent.Format(L"Com_ReadCloseEvent%d",portNo);

    m_hReadCloseEvent = CreateEvent(NULL,TRUE,FALSE,strEvent);

 

    //创建串口读数据监听线程
    m_hReadThread = CreateThread(NULL,0,ReadThreadFunc,this,0,&m_dwReadThreadID);

    
    TRACE(_T("串口打开成功"));

    m_bOpened = TRUE;

    return TRUE;

}

 

/*

*函数介绍：关闭串口
*入口参数：(无)

*出口参数：(无)

*返回值： (无)

*/

void CCESeries1::ClosePort()

{    

    //表示串口还没有打开
    if (m_hComm == INVALID_HANDLE_VALUE)

    {
        return ;
    }
    
    //关闭读线程
    CloseReadThread();

    
    //关闭串口
    CloseHandle (m_hComm);

    //关闭事件
    CloseHandle(m_hReadCloseEvent);

 

    m_hComm = INVALID_HANDLE_VALUE;

    m_bOpened = FALSE;

}

 

/*

*函数介绍：往串口写入数据
*入口参数：buf ：待写入数据缓冲区
            bufLen : 待写入缓冲区长度
*出口参数：(无)

*返回值：TRUE:设置成功;FALSE:设置失败
*/

BOOL CCESeries1::WriteSyncPort(const BYTE*buf , DWORD bufLen)

{

    //AfxMessageBox(L"WriteSyncPort Start");

    DWORD dwNumBytesWritten;

    DWORD dwHaveNumWritten =0 ; //已经写入多少
    
    int iInc = 0; //如果次写入不成功，返回FALSE

    ASSERT(m_hComm != INVALID_HANDLE_VALUE);

    do

    {
        if (WriteFile (m_hComm,                       //串口句柄
            buf+dwHaveNumWritten,                //被写数据缓冲区
            //"ABCDEFG",

            bufLen - dwHaveNumWritten,          //被写数据缓冲区大小
            //8,

            &dwNumBytesWritten,                       //函数执行成功后，返回实际向串口写的个数  

            NULL))                                    //此处必须设置NULL

        {
            dwHaveNumWritten = dwHaveNumWritten + dwNumBytesWritten;

            //写入完成
            if (dwHaveNumWritten == bufLen)

            {
                break;

            }
            iInc++;

            if (iInc >= 3)
            {
                //AfxMessageBox(L"WriteSyncPort >+3 End");

                return FALSE;

            }
            Sleep(10);

        }
        else

        {
            //AfxMessageBox(L"WriteSyncPort Can Not Open");

            return FALSE;

        }
    }while (TRUE);

    //AfxMessageBox(L"WriteSyncPort End");    

    return TRUE;       

}

 

/*

*函数介绍：设置串口读取、写入超时
*入口参数：CommTimeOuts : 指向COMMTIMEOUTS结构
*出口参数：(无)

*返回值：TRUE:设置成功;FALSE:设置失败
*/

BOOL CCESeries1::SetSeriesTimeouts(COMMTIMEOUTS CommTimeOuts)

{

    ASSERT(m_hComm != INVALID_HANDLE_VALUE);

    return SetCommTimeouts(m_hComm,&CommTimeOuts);

}

 

 

//得到串口是否打开
BOOL CCESeries1::GetComOpened()

{

    return m_bOpened;

}

 

//END OF FILE-----------------------------------

 

 

* 文件名称：CESeries1.h
/* 文件标识：
* 摘要：用于封装WINCE 串口通信
----------------------------------------*/

#pragma once

//定义串口接收数据函数类型,一个函数指针。
typedef void (CALLBACK* ONSERIESREAD)(void * pOwner /*父对象指针*/

                                      ,BYTE* buf  /*接收到的缓冲区*/

                                      ,DWORD dwBufLen /*接收到的缓冲区长度*/);

 

 

class CCESeries1

{

public:

    CCESeries1(void);

    ~CCESeries1(void);

public:

    //打开串口
    BOOL OpenPort(void* pOwner,/*指向父指针*/

                  UINT portNo = 1,        /*串口号*/

                  UINT baud      = 9600, /*波特率*/

                  UINT parity = NOPARITY, /*奇偶校验*/

                  UINT databits   = 8,        /*数据位*/

                  UINT stopbits   = 0        /*停止位*/

                  );
    //关闭串口
    void ClosePort();

    //同步写入数据
    BOOL WriteSyncPort(const BYTE*buf , DWORD bufLen);

    //设置串口读取、写入超时
    BOOL SetSeriesTimeouts(COMMTIMEOUTS CommTimeOuts);

    //得到串口是否打开
    BOOL GetComOpened();

private:

    //串口读线程函数
    static  DWORD WINAPI ReadThreadFunc(LPVOID lparam);

private:

    //关闭读线程
    void CloseReadThread();

private:

    //已打开的串口句柄
    //static HANDLE    m_hComm;

    //HANDLE m_hComm;

    //读线程句柄
    HANDLE m_hReadThread;

    //读线程ID标识
    DWORD m_dwReadThreadID;

    //读线程退出事件
    HANDLE m_hReadCloseEvent;

    //static BOOL m_bOpened; //串口是否打开
    BOOL m_bOpened;

    void * m_pOwner; //指定父对象指针
public:

    HANDLE   m_hComm;

    ONSERIESREAD m_OnSeriesRead; //串口读取回调函数
};