Blog @ Blog

當華美的葉片落盡，生命的脈絡才歷歷可見。－－聶魯達

公告

留言簿(20)

隨筆分類(156)

文章分類(1)

隨筆檔案(198)

文章檔案(2)

相冊

Meet or get-together

閱讀排行榜

評論排行榜

常用鏈接

統計

隨筆 - 198
文章 - 2
評論 - 156
引用 - 0

積分與排名

積分 - 662706
排名 - 24

BBS

Sohu Club

Blog

Web

CSDN
VC KBase

簡單封裝的串口通信類

#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;
}

posted on 2008-01-07 21:11 isabc 閱讀(2820) 評論(3) 編輯收藏引用所屬分類: 分享代碼

在C語言中格式化字符串可以使用printf
但是在WINDOWS編程設計中卻行不通了，但是卻有變通的方法
那就是用 wsprintf這個函數它的格式如下：
wsprintf(緩沖區,格式，要格式化的值)；
第一個參數是字符緩沖區，后面是格式字符串，wsprintf不是將格式化結果寫到標準輸出，而是將其寫入緩沖區中，該函數返回該字符串的長度。

比如我們想通過MessageBox來輸出一個整形變量的值，可以用以下代碼實現：

char szBuffer[100];
ing number=100;
wsprintf(szBuffer, “%d”,number);
MessgaeBox(NULL,szBrffer,TEXT(“格式化字符串”),0);

這個函數除了將內容格式化輸出到第一個參數所提供的字符串緩沖區以外，其它功能與printf函數相同。
回復更多評論

# re: 簡單封裝的串口通信類 2008-01-08 10:09 isabc

HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,
// 指定對象的安全描述符，一般設為NULL （安全屬性結構如下）
BOOL bManualReset, // 指定是否人工重置
BOOL bInitialState, // 返回的句柄是否可繼承
LPCTSTR lpName // 對象的名字，用于多進程間共享對象
);
返回的為event對象的句柄
安全屬性結構
typedef struct _SECURITY_ATTRIBUTES {
DWORD nLength;
LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;
} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES;

回復更多評論

# re: 簡單封裝的串口通信類 2008-01-08 16:58 isabc

查詢當前的超時設置應調用GetCommTimeouts函數，該函數會填充一個COMMTIMEOUTS結構。調用SetCommTimeouts可以用某一個COMMTIMEOUTS結構的內容來設置超時。
　　讀寫串口的超時有兩種：間隔超時和總超時。間隔超時是指在接收時兩個字符之間的最大時延。總超時是指讀寫操作總共花費的最大時間。寫操作只支持總超時，而讀操作兩種超時均支持。用COMMTIMEOUTS結構可以規定讀寫操作的超時。
COMMTIMEOUTS結構的定義為： typedef struct _COMMTIMEOUTS {
DWORD ReadIntervalTimeout; //讀間隔超時
DWORD ReadTotalTimeoutMultiplier; //讀時間系數
DWORD ReadTotalTimeoutConstant; //讀時間常量
DWORD WriteTotalTimeoutMultiplier; // 寫時間系數
DWORD WriteTotalTimeoutConstant; //寫時間常量
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;

COMMTIMEOUTS結構的成員都以毫秒為單位。總超時的計算公式是：
總超時＝時間系數×要求讀/寫的字符數＋時間常量
例如，要讀入10個字符，那么讀操作的總超時的計算公式為：
讀總超時＝ReadTotalTimeoutMultiplier×10＋ReadTotalTimeoutConstant
可以看出：間隔超時和總超時的設置是不相關的，這可以方便通信程序靈活地設置各種超時。

如果所有寫超時參數均為0，那么就不使用寫超時。如果ReadIntervalTimeout為0，那么就不使用讀間隔超時。如果ReadTotalTimeoutMultiplier 和 ReadTotalTimeoutConstant 都為0，則不使用讀總超時。如果讀間隔超時被設置成MAXDWORD并且讀時間系數和讀時間常量都為0，那么在讀一次輸入緩沖區的內容后讀操作就立即返回，而不管是否讀入了要求的字符。
　　在用重疊方式讀寫串口時，雖然ReadFile和WriteFile在完成操作以前就可能返回，但超時仍然是起作用的。在這種情況下，超時規定的是操作的完成時間，而不是ReadFile和WriteFile的返回時間。
配置串口的示例代碼： SetupComm(hCom,1024,1024); //輸入緩沖區和輸出緩沖區的大小都是1024

COMMTIMEOUTS TimeOuts;
//設定讀超時
TimeOuts.ReadIntervalTimeout=1000;
TimeOuts.ReadTotalTimeoutMultiplier=500;
TimeOuts.ReadTotalTimeoutConstant=5000;
//設定寫超時
TimeOuts.WriteTotalTimeoutMultiplier=500;
TimeOuts.WriteTotalTimeoutConstant=2000;
SetCommTimeouts(hCom,&TimeOuts); //設置超時
回復更多評論

刷新評論列表

只有注冊用戶登錄后才能發表評論。


相關文章: 存儲過程示例 SQL創建數據庫示例代碼封裝ADO編程Connection對象的類連接服務流程代碼 GSM短信息部分代碼！簡單封裝的串口通信類

網站導航: 博客園 IT新聞 BlogJava 博問 Chat2DB 管理

# re: 簡單封裝的串口通信類 2008-01-07 21:11 isabc