C++串口编程实例

最新推荐文章于 2024-03-11 19:19:48 发布

jiangqin115

最新推荐文章于 2024-03-11 19:19:48 发布

阅读量7.8k

点赞数 12

分类专栏：串口通讯

本文链接：https://blog.csdn.net/jiangqin115/article/details/40391289

版权

串口通讯专栏收录该内容

2 篇文章 0 订阅

订阅专栏

在windows程序设计与开发过程中，特别是涉及到开发嵌入式软硬件系统时，往往会涉及到串口编程。网上以及一些书籍上讲解windows下的串口编程知识也挺多的，但我个人觉得，看完书上的知识点有时依然不知道该如何下手开始自己的程序设计和代码编写，许多知识如果能结合着详细的例子往往能够帮助我们学习得更快，下面我将自己用C++编写的串口通信的例子贴出来，其特点如下：

1. 本例子使用了比较规范的软件设计方法，类的设计具有比较好的可扩展性和移植性、代码的注释采用doxgen支持的javaDoc风格。
2. 为了能方便初学者更快地了解和入门，几乎每一行代码都加上了详细的注释，对于注释中如果依然有不清楚的概念，相信你通过百度和google一定能找到答案。
3. 本例子设计的串口操作类可以直接移植到其他的工程中去，大家也可以根据自己的需要添加其他的接口。
4. 本例子只实现了串口数据的基本收发功能，其实为了保证串口数据传输的正确性，往往需要设计一些串口通信协议，协议的设计有待你自己完成，如果以后有时间，我也会尝试提供一种比较基本的串口通信协议设计案例给大家学习。
5. 关于本程序的验证方法，可以使用虚拟串口软件VSPM和串口调试助手进行程序的测试与验证，上述两个软件的使用方法请参考： http://ticktick.blog.51cto.com/823160/285610

下面即为例子工程的三个文件，SerialPort.h、SerialPort.cpp、maincpp

附件中是工程文件，需要使用vs2008打开。

 
 //  
///   
/// @file    SerialPort.h    
/// @brief   串口通信类头文件  
///  
/// 串口通信类的声明  
///  
//  
 
#ifndef SERIALPORT_H_  
#define SERIALPORT_H_  
 
#include <Windows.h>  
 
/** 串口通信类  
 *     
 *  本类实现了对串口的基本操作  
 *  例如监听发到指定串口的数据、发送指定数据到串口  
 */ 
class CSerialPort  
{  
public:  
    CSerialPort(void);  
    ~CSerialPort(void);  
 
public:  
      
    /** 初始化串口函数  
     *  
     *  @param:  UINT portNo 串口编号,默认值为1,即COM1,注意,尽量不要大于9  
     *  @param:  UINT baud   波特率,默认为9600  
     *  @param:  char parity 是否进行奇偶校验,'Y'表示需要奇偶校验,'N'表示不需要奇偶校验  
     *  @param:  UINT databits 数据位的个数,默认值为8个数据位  
     *  @param:  UINT stopsbits 停止位使用格式,默认值为1  
     *  @param:  DWORD dwCommEvents 默认为EV_RXCHAR,即只要收发任意一个字符,则产生一个事件  
     *  @return: bool  初始化是否成功  
     *  @note:   在使用其他本类提供的函数前,请先调用本函数进行串口的初始化  
     *　　　　　   \n本函数提供了一些常用的串口参数设置,若需要自行设置详细的DCB参数,可使用重载函数  
     *           \n本串口类析构时会自动关闭串口,无需额外执行关闭串口  
     *  @see:      
     */ 
    bool InitPort( UINT  portNo = 1,UINT  baud = CBR_9600,char  parity = 'N',UINT  databits = 8, UINT  stopsbits = 1,DWORD dwCommEvents = EV_RXCHAR);  
 
    /** 串口初始化函数  
     *  
     *  本函数提供直接根据DCB参数设置串口参数  
     *  @param:  UINT portNo  
     *  @param:  const LPDCB & plDCB  
     *  @return: bool  初始化是否成功  
     *  @note:   本函数提供用户自定义地串口初始化参数  
     *  @see:      
     */ 
    bool InitPort( UINT  portNo ,const LPDCB& plDCB );  
 
    /** 开启监听线程  
     *  
     *  本监听线程完成对串口数据的监听,并将接收到的数据打印到屏幕输出  
     *  @return: bool  操作是否成功  
     *  @note:   当线程已经处于开启状态时,返回flase  
     *  @see:      
     */ 
    bool OpenListenThread();  
 
    /** 关闭监听线程  
     *  
     *    
     *  @return: bool  操作是否成功  
     *  @note:   调用本函数后,监听串口的线程将会被关闭  
     *  @see:      
     */ 
    bool CloseListenTread();  
 
    /** 向串口写数据  
     *  
     *  将缓冲区中的数据写入到串口  
     *  @param:  unsigned char * pData 指向需要写入串口的数据缓冲区  
     *  @param:  unsigned int length 需要写入的数据长度  
     *  @return: bool  操作是否成功  
     *  @note:   length不要大于pData所指向缓冲区的大小  
     *  @see:      
     */ 
    bool WriteData(unsigned char* pData, unsigned int length);  
 
    /** 获取串口缓冲区中的字节数  
     *  
     *    
     *  @return: UINT  操作是否成功  
     *  @note:   当串口缓冲区中无数据时,返回0  
     *  @see:      
     */ 
    UINT GetBytesInCOM();  
 
    /** 读取串口接收缓冲区中一个字节的数据  
     *  
     *    
     *  @param:  char & cRecved 存放读取数据的字符变量  
     *  @return: bool  读取是否成功  
     *  @note:     
     *  @see:      
     */ 
    bool ReadChar(char &cRecved);  
 
private:  
 
    /** 打开串口  
     *  
     *    
     *  @param:  UINT portNo 串口设备号  
     *  @return: bool  打开是否成功  
     *  @note:     
     *  @see:      
     */ 
    bool openPort( UINT  portNo );  
 
    /** 关闭串口  
     *  
     *    
     *  @return: void  操作是否成功  
     *  @note:     
     *  @see:      
     */ 
    void ClosePort();  
      
    /** 串口监听线程  
     *  
     *  监听来自串口的数据和信息  
     *  @param:  void * pParam 线程参数  
     *  @return: UINT WINAPI 线程返回值  
     *  @note:     
     *  @see:      
     */ 
    static UINT WINAPI ListenThread(void* pParam);  
 
private:  
 
    /** 串口句柄 */   
    HANDLE  m_hComm;  
 
    /** 线程退出标志变量 */   
    static bool s_bExit;  
 
    /** 线程句柄 */   
    volatile HANDLE    m_hListenThread;  
 
    /** 同步互斥,临界区保护 */   
    CRITICAL_SECTION   m_csCommunicationSync;       //!< 互斥操作串口  
 
};  
 
#endif //SERIALPORT_H_

 
 //  
/// COPYRIGHT NOTICE  
/// Copyright (c) 2009, 华中科技大学tickTick Group  （版权声明）  
/// All rights reserved.  
///  
/// @file    SerialPort.cpp    
/// @brief   串口通信类的实现文件 
///    
//  
 
#include "StdAfx.h"  
#include "SerialPort.h"  
#include <process.h>  
#include <iostream>  
 
/** 线程退出标志 */   
bool CSerialPort::s_bExit = false;  
/** 当串口无数据时,sleep至下次查询间隔的时间,单位:秒 */   
const UINT SLEEP_TIME_INTERVAL = 5;  
 
CSerialPort::CSerialPort(void)  
: m_hListenThread(INVALID_HANDLE_VALUE)  
{  
    m_hComm = INVALID_HANDLE_VALUE;  
    m_hListenThread = INVALID_HANDLE_VALUE;  
 
    InitializeCriticalSection(&m_csCommunicationSync);  
 
}  
 
CSerialPort::~CSerialPort(void)  
{  
    CloseListenTread();  
    ClosePort();  
    DeleteCriticalSection(&m_csCommunicationSync);  
}  
 
bool CSerialPort::InitPort( UINT portNo /*= 1*/,UINT baud /*= CBR_9600*/,char parity /*= 'N'*/,  
                            UINT databits /*= 8*/, UINT stopsbits /*= 1*/,DWORD dwCommEvents /*= EV_RXCHAR*/ )  
{  
 
    /** 临时变量,将制定参数转化为字符串形式,以构造DCB结构 */   
    char szDCBparam[50];  
    sprintf_s(szDCBparam, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopsbits);  
 
    /** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */   
    if (!openPort(portNo))  
    {  
        return false;  
    }  
 
    /** 进入临界段 */   
    EnterCriticalSection(&m_csCommunicationSync);  
 
    /** 是否有错误发生 */   
    BOOL bIsSuccess = TRUE;  
 
    /** 在此可以设置输入输出的缓冲区大小,如果不设置,则系统会设置默认值.  
     *  自己设置缓冲区大小时,要注意设置稍大一些,避免缓冲区溢出  
     */ 
    /*if (bIsSuccess )  
    {  
        bIsSuccess = SetupComm(m_hComm,10,10);  
    }*/ 
 
    /** 设置串口的超时时间,均设为0,表示不使用超时限制 */ 
    COMMTIMEOUTS  CommTimeouts;  
    CommTimeouts.ReadIntervalTimeout         = 0;  
    CommTimeouts.ReadTotalTimeoutMultiplier  = 0;  
    CommTimeouts.ReadTotalTimeoutConstant    = 0;  
    CommTimeouts.WriteTotalTimeoutMultiplier = 0;  
    CommTimeouts.WriteTotalTimeoutConstant   = 0;   
    if ( bIsSuccess)  
    {  
        bIsSuccess = SetCommTimeouts(m_hComm, &CommTimeouts);  
    }  
 
    DCB  dcb;  
    if ( bIsSuccess )  
    {  
        // 将ANSI字符串转换为UNICODE字符串  
        DWORD dwNum = MultiByteToWideChar (CP_ACP, 0, szDCBparam, -1, NULL, 0);  
        wchar_t *pwText = new wchar_t[dwNum] ;  
        if (!MultiByteToWideChar (CP_ACP, 0, szDCBparam, -1, pwText, dwNum))  
        {  
            bIsSuccess = TRUE;  
        }  
 
        /** 获取当前串口配置参数,并且构造串口DCB参数 */   
        bIsSuccess = GetCommState(m_hComm, &dcb) && BuildCommDCB(pwText, &dcb) ;  
        /** 开启RTS flow控制 */   
        dcb.fRtsControl = RTS_CONTROL_ENABLE;   
 
        /** 释放内存空间 */   
        delete [] pwText;  
    }  
 
    if ( bIsSuccess )  
    {  
        /** 使用DCB参数配置串口状态 */   
        bIsSuccess = SetCommState(m_hComm, &dcb);  
    }  
          
    /**  清空串口缓冲区 */ 
    PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);  
 
    /** 离开临界段 */   
    LeaveCriticalSection(&m_csCommunicationSync);  
 
    return bIsSuccess==TRUE;  
}  
 
bool CSerialPort::InitPort( UINT portNo ,const LPDCB& plDCB )  
{  
    /** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */   
    if (!openPort(portNo))  
    {  
        return false;  
    }  
      
    /** 进入临界段 */   
    EnterCriticalSection(&m_csCommunicationSync);  
 
    /** 配置串口参数 */   
    if (!SetCommState(m_hComm, plDCB))  
    {  
        return false;  
    }  
 
    /**  清空串口缓冲区 */ 
    PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);  
 
    /** 离开临界段 */   
    LeaveCriticalSection(&m_csCommunicationSync);  
 
    return true;  
}  
 
void CSerialPort::ClosePort()  
{  
    /** 如果有串口被打开，关闭它 */ 
    if( m_hComm != INVALID_HANDLE_VALUE )  
    {  
        CloseHandle( m_hComm );  
        m_hComm = INVALID_HANDLE_VALUE;  
    }  
}  
 
bool CSerialPort::openPort( UINT portNo )  
{  
    /** 进入临界段 */   
    EnterCriticalSection(&m_csCommunicationSync);  
 
    /** 把串口的编号转换为设备名 */   
    char szPort[50];  
    sprintf_s(szPort, "COM%d", portNo);  
 
    /** 打开指定的串口 */   
    m_hComm = CreateFileA(szPort,  /** 设备名,COM1,COM2等 */   
              GENERIC_READ | GENERIC_WRITE, /** 访问模式,可同时读写 */     
              0,                            /** 共享模式,0表示不共享 */   
              NULL,                         /** 安全性设置,一般使用NULL */   
              OPEN_EXISTING,                /** 该参数表示设备必须存在,否则创建失败 */   
              0,      
              0);      
 
    /** 如果打开失败，释放资源并返回 */   
    if (m_hComm == INVALID_HANDLE_VALUE)  
    {  
        LeaveCriticalSection(&m_csCommunicationSync);  
        return false;  
    }  
 
    /** 退出临界区 */   
    LeaveCriticalSection(&m_csCommunicationSync);  
 
    return true;  
}  
 
bool CSerialPort::OpenListenThread()  
{  
    /** 检测线程是否已经开启了 */   
    if (m_hListenThread != INVALID_HANDLE_VALUE)  
    {  
        /** 线程已经开启 */   
        return false;  
    }  
 
    s_bExit = false;  
    /** 线程ID */   
    UINT threadId;  
    /** 开启串口数据监听线程 */   
    m_hListenThread = (HANDLE)_beginthreadex(NULL, 0, ListenThread, this, 0, &threadId);  
    if (!m_hListenThread)  
    {  
        return false;  
    }  
    /** 设置线程的优先级,高于普通线程 */   
    if (!SetThreadPriority(m_hListenThread, THREAD_PRIORITY_ABOVE_NORMAL))  
    {  
        return false;  
    }  
 
    return true;  
}  
 
bool CSerialPort::CloseListenTread()  
{     
    if (m_hListenThread != INVALID_HANDLE_VALUE)  
    {  
        /** 通知线程退出 */   
        s_bExit = true;  
 
        /** 等待线程退出 */   
        Sleep(10);  
 
        /** 置线程句柄无效 */   
        CloseHandle( m_hListenThread );  
        m_hListenThread = INVALID_HANDLE_VALUE;  
    }  
    return true;  
}  
 
UINT CSerialPort::GetBytesInCOM()  
{  
    DWORD dwError = 0;  /** 错误码 */   
    COMSTAT  comstat;   /** COMSTAT结构体,记录通信设备的状态信息 */   
    memset(&comstat, 0, sizeof(COMSTAT));  
 
    UINT BytesInQue = 0;  
    /** 在调用ReadFile和WriteFile之前,通过本函数清除以前遗留的错误标志 */   
    if ( ClearCommError(m_hComm, &dwError, &comstat) )  
    {  
        BytesInQue = comstat.cbInQue; /** 获取在输入缓冲区中的字节数 */   
    }  
 
    return BytesInQue;  
}  
 
UINT WINAPI CSerialPort::ListenThread( void* pParam )  
{  
    /** 得到本类的指针 */   
    CSerialPort *pSerialPort = reinterpret_cast<CSerialPort*>(pParam);  
 
    // 线程循环,轮询方式读取串口数据  
    while (!pSerialPort->s_bExit)   
    {  
        UINT BytesInQue = pSerialPort->GetBytesInCOM();  
        /** 如果串口输入缓冲区中无数据,则休息一会再查询 */   
        if ( BytesInQue == 0 )  
        {  
            Sleep(SLEEP_TIME_INTERVAL);  
            continue;  
        }  
 
        /** 读取输入缓冲区中的数据并输出显示 */ 
        char cRecved = 0x00;  
        do 
        {  
            cRecved = 0x00;  
            if(pSerialPort->ReadChar(cRecved) == true)  
            {  
                std::cout << cRecved ;   
                continue;  
            }  
        }while(--BytesInQue);  
    }  
 
    return 0;  
}  
 
bool CSerialPort::ReadChar( char &cRecved )  
{  
    BOOL  bResult     = TRUE;  
    DWORD BytesRead   = 0;  
    if(m_hComm == INVALID_HANDLE_VALUE)  
    {  
        return false;  
    }  
 
    /** 临界区保护 */   
    EnterCriticalSection(&m_csCommunicationSync);  
 
    /** 从缓冲区读取一个字节的数据 */   
    bResult = ReadFile(m_hComm, &cRecved, 1, &BytesRead, NULL);  
    if ((!bResult))  
    {   
        /** 获取错误码,可以根据该错误码查出错误原因 */   
        DWORD dwError = GetLastError();  
 
        /** 清空串口缓冲区 */   
        PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);  
        LeaveCriticalSection(&m_csCommunicationSync);  
 
        return false;  
    }  
 
    /** 离开临界区 */   
    LeaveCriticalSection(&m_csCommunicationSync);  
 
    return (BytesRead == 1);  
 
}  
 
bool CSerialPort::WriteData( unsigned char* pData, unsigned int length )  
{  
    BOOL   bResult     = TRUE;  
    DWORD  BytesToSend = 0;  
    if(m_hComm == INVALID_HANDLE_VALUE)  
    {  
        return false;  
    }  
 
    /** 临界区保护 */   
    EnterCriticalSection(&m_csCommunicationSync);  
 
    /** 向缓冲区写入指定量的数据 */   
    bResult = WriteFile(m_hComm, pData, length, &BytesToSend, NULL);  
    if (!bResult)    
    {  
        DWORD dwError = GetLastError();  
        /** 清空串口缓冲区 */   
        PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);  
        LeaveCriticalSection(&m_csCommunicationSync);  
 
        return false;  
    }  
 
    /** 离开临界区 */   
    LeaveCriticalSection(&m_csCommunicationSync);  
 
    return true;  
}

 
 // main.cpp : Defines the entry point for the console application.  
//  
 
#include "stdafx.h"  
#include "SerialPort.h"  
#include <iostream>  
 
int _tmain(int argc, _TCHAR* argv[])  
{  
 
    CSerialPort mySerialPort;  
 
    if (!mySerialPort.InitPort(2))  
    {  
        std::cout << "initPort fail !" << std::endl;  
    }  
    else 
    {  
        std::cout << "initPort success !" << std::endl;  
    }  
 
    if (!mySerialPort.OpenListenThread())  
    {  
        std::cout << "OpenListenThread fail !" << std::endl;  
    }  
    else 
    {  
        std::cout << "OpenListenThread success !" << std::endl;  
    }  
 
    int temp;  
    std::cin >> temp;  
 
    return 0;  
}

jiangqin115

关注

12
点赞
踩
25

收藏

觉得还不错? 一键收藏
2
评论
C++串口编程实例

在windows程序设计与开发过程中，特别是涉及到开发嵌入式软硬件系统时，往往会涉及到串口编程。网上以及一些书籍上讲解windows下的串口编程知识也挺多的，但我个人觉得，看完书上的知识点有时依然不知道该如何下手开始自己的程序设计和代码编写，许多知识如果能结合着详细的例子往往能够帮助我们学习得更快，所以，在此，我专门为串口编程初学者设计了一个详细的例子，供大家参考和学习。下面我将自
复制链接

扫一扫