同步串口通信代码

最近做了一个串口通信相关的项目。主要涉及到同步串口通信。把代码保存下来以便以后使用。同时也能和大家一起共享，希望对大家有所帮助.

头文件:SerialPort.h

#pragma once

#include <Windows.h>
#include "DataTypes.h"


#define COM_BUFFER_LENGTH 409600

class CSerialPort
{
public:
    CSerialPort(void);
    ~CSerialPort(void);
public:
    bool InitPort(UINT nPortNo=1,UINT baud=CBR_115200,char parity='N',UINT databits=8,UINT stopbits=1,DWORD dwCommEvents=EV_RXCHAR);
    bool WriteData(char* pData,int length);//向串口中写入数据
    UINT GetBytesInCom();//获取串口缓冲区中的字节数
    bool ReadChar(char &cRecved);//从串口缓冲区读取一个字节的数据
public:
    bool OpenPort(UINT portNo);//打开串口
    void ClosePort();//关闭串口
    bool ReadData(char* pData);
    char* m_data;
public:
    HANDLE m_hCom;//串口句柄
    CRITICAL_SECTION m_cs;
};

实现文件:SerialPort.cpp

#include "StdAfx.h"
#include "SerialPort.h"
#include<iostream>
#include <process.h>

UINT const SLEEP_TIMEINTERVAL=5;//串口无数据时，休眠，单位是s

CSerialPort::CSerialPort(void)
{
    m_hCom=INVALID_HANDLE_VALUE;
    m_data=new char[COM_BUFFER_LENGTH];
    memset(m_data,0,COM_BUFFER_LENGTH);
    InitializeCriticalSection(&m_cs);
}

CSerialPort::~CSerialPort(void)
{
    if (m_hCom!=INVALID_HANDLE_VALUE)
    {
        CloseHandle(m_hCom);
    }
    if (m_data!=NULL)
    {
        delete[] m_data;
    }
    DeleteCriticalSection(&m_cs);
}

bool CSerialPort::InitPort(UINT nPortNo,UINT baud,char parity,UINT databits,UINT stopbits,DWORD dwCommEvents)
{
    char szDCBparam[50];
    sprintf_s(szDCBparam,"baud=%d parity=%c data=%d stop=%d",CBR_115200,parity,databits,stopbits);

    if (OpenPort(nPortNo)==false)
    {
        return false;
    }

    EnterCriticalSection(&m_cs);

    BOOL bIsSuccess=TRUE;
    
    if (bIsSuccess)
    {
        bIsSuccess=SetupComm(m_hCom,COM_BUFFER_LENGTH,COM_BUFFER_LENGTH);//输入输出缓冲区设置为4k
    }

    //设置串口超时时间。全为0，则不使用串口超时设置,超时
    COMMTIMEOUTS comTms;
    comTms.ReadIntervalTimeout=MAXWORD;
    comTms.ReadTotalTimeoutConstant=1000;
    comTms.ReadTotalTimeoutMultiplier=1000;
    comTms.WriteTotalTimeoutConstant=1000;
    comTms.WriteTotalTimeoutMultiplier=1000;
    if (bIsSuccess)
    {
        bIsSuccess=SetCommTimeouts(m_hCom,&comTms);
    }

    //设置DCB结构
    DCB dcb;
    if (bIsSuccess)
    {
        bIsSuccess=GetCommState(m_hCom,&dcb);
        dcb.BaudRate=128000;
        dcb.ByteSize=8;
        dcb.Parity=NOPARITY;
        dcb.StopBits=stopbits;
    }

    if (bIsSuccess)
    {
        //使用dcb参数配置串口状态
        bIsSuccess=SetCommState(m_hCom,&dcb);
    }

    //清空串口缓冲区
    PurgeComm(m_hCom,PURGE_RXABORT|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_TXCLEAR);
    LeaveCriticalSection(&m_cs);

    return (bIsSuccess==TRUE);
}


bool CSerialPort::OpenPort(UINT portNo)
{
    EnterCriticalSection(&m_cs);
    char szPort[50];
    sprintf_s(szPort,"COM%d",portNo);
    
    m_hCom=CreateFile(szPort,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,0);
    if (m_hCom==INVALID_HANDLE_VALUE)
    {
        LeaveCriticalSection(&m_cs);
        return false;
    }
    LeaveCriticalSection(&m_cs);
    return true;
}

void CSerialPort::ClosePort()
{
    if (m_hCom!=INVALID_HANDLE_VALUE)
    {
        CloseHandle(m_hCom);
        m_hCom=INVALID_HANDLE_VALUE;
    }
}

bool CSerialPort::WriteData(char* pData,int length)
{
    BOOL bResult=TRUE;
    DWORD bytesToSend=0;
    if (m_hCom==INVALID_HANDLE_VALUE)
    {
        return false;
    }
    EnterCriticalSection(&m_cs);

    bResult=WriteFile(m_hCom,pData,(unsigned int)length,&bytesToSend,NULL);
    if (bResult==FALSE)
    {
        DWORD dwErr=GetLastError();
        PurgeComm(m_hCom,PURGE_TXABORT|PURGE_TXCLEAR);
        LeaveCriticalSection(&m_cs);
        return false;
    }
    LeaveCriticalSection(&m_cs);
    return true;
}


bool CSerialPort::ReadData(char* pData)
{
    DWORD bytes=0;
    DWORD err=0;
    COMSTAT cmt={0};
    DWORD readSize=0;
    bool bResult=false;
    int bufferLen=COM_BUFFER_LENGTH;
    int offset=0;

    //轮询读取串口数据
    while (true)
    {
        //设置读取1个字节数据，当缓存中有数据到达时则会立即返回，否则直到超时 
        bResult=ReadFile(m_hCom,m_data+offset,1,&readSize,NULL);
        if (bResult==false||readSize==0)
        {
            break;
        }
        offset+=readSize;

        //若有数据到达，则bResult为true,同时readsize等于1
        if (bResult==true&&readSize==1)
        {
            int readLen=0;
            ClearCommError(m_hCom,&err,&cmt);
            readLen=((int)cmt.cbInQue>bufferLen) ? bufferLen : cmt.cbInQue;
            if (readLen>0)
            {
                bResult=ReadFile(m_hCom,m_data+offset,readLen,&readSize,NULL);
                if (bResult==false||readSize<COM_BUFFER_LENGTH)
                {
                    break;
                }
                offset+=readSize;
                PurgeComm(m_hCom,PURGE_RXABORT|PURGE_RXCLEAR);
            }
        }
    }
    memcpy(pData,m_data,COM_BUFFER_LENGTH);
    return true;
}