山寨：不是最好的，是最适合我们的！欢迎体验山寨 中文版MSDN

Blog @ Blog

当华美的叶片落尽，生命的脉络才历历可见。 －－ 聂鲁达

常用链接

统计

积分与排名

BBS

Blog

Web

最新评论

简单封装的串口通信类

#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 阅读(2709) 评论(3)  编辑 收藏 引用 所属分类: 分享代码

评论

# re: 简单封装的串口通信类 2008-01-07 21:11 isabc

在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); //设置超时
  回复  更多评论   


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


广告信息(免费广告联系)

中文版MSDN：
欢迎体验