C++实现串口通信问题（与Arduino）

参考1（已验证稍加修改可与Arduino通信）：https://blog.csdn.net/qq_36106219/article/details/81701368

参考2（比较全，main函数需要自己写）：https://blog.csdn.net/qq_27251141/article/details/83054850

1. （已验证稍加修改可与Arduino通信）

/***********************************************

文件名：Comm.h

类型：C++头文件

 功能：实现对串口操作的封装

 时间：2018.7.30

 **********************************************/

 #ifndef COMM_H    /**文件保护符，确保头文件多次包含，但是只进行一次编译*/

 #define COMM_H

 #pragma once     /**文件保护符，确保头文件只进行一次编译*/

 #include  <iostream>

 #include  <Windows.h>

 #include  <string>

 #include  <atlstr.h>

 using namespace std;

 class CComm

 {

 public:

     CComm();

     ~CComm();

 public:

     void CloseComm();            /**串口关闭函数*/

     BOOL ReadByte(BYTE &byByte); /*读取数据函数*/

     BOOL WriteByte(BYTE bybyte);/*写入数据函数*/

     BOOL OpenComm(CString sCommName);   /*串口打开函数*/

     BOOL CleanComm();                   /*清理串口缓存区*/

    /*对串口超时参数进行设置*/

     BOOL SetCommunicationTimeouts(DWORD ReadIntervalTimeout,  /*读间隔超时时间*/

         DWORD ReadTotalTimeoutMultiplier,  /*读时间系数*/

         DWORD ReadTotalTimeoutConstant,    /*读时间常量*/

         DWORD WriteTotalTimeoutMultiplier, /*写时间系数*/

         DWORD WriteTotalTimeoutConstant);  /*写时间常量*/

     /*对串口超时参数进行设置*/

     BOOL ConfigureComm(

         DWORD BaudRate,  /*波特率*/

         BYTE ByteSize,   /*通信字节位数*/

         BYTE  Parity,    /*指定奇偶校验位*/

         BYTE StopBits);  /*指定停止位的位数*/

     HANDLE hComm;               /*串口COM句柄*/

     DCB    m_dcb;               /*串口状态信息*/

     COMMTIMEOUTS m_CommTimeouts;

     BOOL  m_bCommReady;

     BOOL  bWriteRC;

     BOOL  bReadRC;

     DWORD  iBytesWritten;

     DWORD  iBytesRead;

     DWORD  dwBytesRead;

 };

#endif 

/***********************************************

文件名：Comm.cpp

类型：Comm.h的实现文件

 功能：实现Class CComml类中的成员函数

 时间：2018.7.31(经过近三天的修改)

 **********************************************/

 #include "stdafx.h"

 #include "Comm.h"

/*默认构造函数*/

CComm::CComm()

 {

 }

/*默认析构函数*/

CComm::~CComm()

 {

 }

/*打开串口函数 参数为“COM1”、“COM2”之类的串口名字符串*/

BOOL CComm::OpenComm(CString sCommName)

 {

     sCommName = "//./" + sCommName;          /*利用字符串拼接*/

    hComm = CreateFile(sCommName,            /* 合法的标准设备名,//./COM1,//./COM2等 */

         GENERIC_READ | GENERIC_WRITE,        /* 访问模式,可同时读写 */

         0,                                   /* 共享模式,0表示不共享 */

         0,                                   /*安全性设置,一般使用NULL */

         OPEN_EXISTING,                       /* 该参数表示设备必须存在,否则创建失败 */

         0,

         0);

     if (hComm == INVALID_HANDLE_VALUE) /*判断打开COM操作是否成功*/

     {

         //MessageBox("Cannot open Communication Port.Please\nQuit the program and Re-start your PC.","Com Port Error",MB_OK+MB_ICONERROR);

         return false;

     }

     else

         return true;

}

/*通过设置串口控制参数控制串口*/

BOOL CComm::ConfigureComm(DWORD BaudRate, BYTE ByteSize, BYTE Parity, BYTE StopBits)

 {

     char szDCBparam[50];

    sprintf_s(szDCBparam, "baud=%d parity=%c data=%d stop=%d", BaudRate, Parity, ByteSize, StopBits);

     if (GetCommState(hComm, &m_dcb) && BuildCommDCB(szDCBparam, &m_dcb))

     {

         return true;

     }

     CloseHandle(hComm);

     return false;

 //    SetupComm(hComm, 1024, 1024);

     if ((m_bCommReady = GetCommState(hComm, &m_dcb)) == 0) /*判断串口信息是否获取情况*/

     {

        CloseHandle(hComm);

         return false;

     }

     m_bCommReady = 0;

     m_dcb.BaudRate = BaudRate;/*波特率*/

     m_dcb.ByteSize = ByteSize;/*通信字节位数*/

     m_dcb.Parity = Parity;    /*指定奇偶校验位*/

     m_dcb.StopBits = StopBits;/*指定停止位的位数*/

     //m_dcb.fParity = fParity;  /*指定奇偶校验位*/

 #if 0

     m_dcb.fBinary = TRUE;

     m_dcb.fDsrSensitivity = false;

     m_dcb.fOutX = false;

     m_dcb.fInX = false;

     m_dcb.fNull = false;

     m_dcb.fAbortOnError = TRUE;

     m_dcb.fOutxCtsFlow = FALSE;

     m_dcb.fOutxDsrFlow = false;

     m_dcb.fDtrControl = DTR_CONTROL_DISABLE;

     m_dcb.fDsrSensitivity = false;

     m_dcb.fRtsControl = RTS_CONTROL_DISABLE;

     m_dcb.fOutxCtsFlow = false;

     m_dcb.fOutxCtsFlow = false;

 #endif

     m_bCommReady = SetCommState(hComm, &m_dcb);/*将hComm的控制参数设置成m_dcb的参数*/

     if (m_bCommReady == 0) /*判断设置是否成功*/

     {

         //MessageBox("SetCommState Error", "Error", MB_OK + MB_ICONERROR);

         CloseHandle(hComm);

         //return false;

     }

     return true;

 }

/*设置串口超时参数*/

BOOL CComm::SetCommunicationTimeouts(DWORD ReadIntervalTimeout, DWORD ReadTotalTimeoutMultiplier, DWORD ReadTotalTimeoutConstant, DWORD WriteTotalTimeoutMultiplier, DWORD WriteTotalTimeoutConstant)

 {

     if ((m_bCommReady = GetCommTimeouts(hComm, &m_CommTimeouts)) == 0)

         return false;

     m_CommTimeouts.ReadIntervalTimeout = ReadIntervalTimeout;                /*读间隔超时时间*/

     m_CommTimeouts.ReadTotalTimeoutConstant = ReadTotalTimeoutConstant;      /*读时间系数*/

     m_CommTimeouts.ReadTotalTimeoutMultiplier = ReadTotalTimeoutMultiplier;  /*读时间常量*/

     m_CommTimeouts.WriteTotalTimeoutConstant = WriteTotalTimeoutConstant;    /*写时间系数*/

     m_CommTimeouts.WriteTotalTimeoutMultiplier = WriteTotalTimeoutMultiplier;/*写时间常量*/

     m_bCommReady = SetCommTimeouts(hComm, &m_CommTimeouts);/*将串口hCom超时参数设置成传入的超时参数*/

     if (m_bCommReady == 0)    /*判断设置是否成功*/

     {

         //MessageBox("StCommTimeouts function failed", "Com Port Error", MB_OK + MB_ICONERROR);

         CloseHandle(hComm);

         return false;

     }

     return true;

 }

/*向串口写入1字节的数据*/

BOOL CComm::WriteByte(BYTE byByte)

 {

     if (WriteFile(hComm, &byByte, 1, &iBytesWritten, NULL) == 0)/*写入指定字节个数的数据并判断写入是否成功*/

         return false;

     else return true;

 }

 BOOL CComm::CleanComm()

 {

     return PurgeComm(hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

 }

 /*从串口读取指定字节个数的数据*/

BOOL CComm::ReadByte(BYTE &byByte)

 {

     BYTE m_brx;

     DWORD dwBytesTransferred = 0;/*定义实际读取字节数的变量*/

    if (ReadFile(hComm, &m_brx, 1, &dwBytesTransferred, 0))

     {

         if (dwBytesTransferred == 1)

         {

             byByte=m_brx;

             return true;

         }

     }

    return false;

 }

/*串口关闭函数*/

void CComm::CloseComm()

 {

     if (hComm == INVALID_HANDLE_VALUE)

         return ;

     CloseHandle(hComm);/*关闭串口*/

     return ;

 }

// CommComunication_Send.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

 #include "Comm.h"

 int main()

 {

     CComm cComm;

     char szCommName[] = "COM1";

     //{ 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 };

     if (cComm.OpenComm(szCommName))

     {

#if 0

         DCB dcb;

         //GetCommState(cComm.hComm, &dcb);//获取端口状态信息

                                  //定义初始化dcb,用dcb的参数对串口的参数进行设置

        dcb.BaudRate = 9600;

         dcb.ByteSize = 8;

         dcb.Parity = 0;

         dcb.StopBits = 1;

         //if (SetCommState(cComm.hComm, &dcb))

         char szDCBparam[50];

         sprintf_s(szDCBparam, "baud=%d parity=%c data=%d stop=%d", CBR_9600, 'N', 8, 1);

         if (GetCommState(cComm.hComm, &dcb) && BuildCommDCB(szDCBparam, &dcb))

         {

             cout << "SetCommState OK." << endl;

        }

         system("pause");

 #endif

        /*定义一个COMMTIMEOUTES结构并初始化设置参数*/

         COMMTIMEOUTS  ctTimSet;

         ctTimSet.ReadIntervalTimeout = 0;

         ctTimSet.ReadTotalTimeoutMultiplier = 0;

         ctTimSet.ReadTotalTimeoutConstant = 0;

         ctTimSet.WriteTotalTimeoutMultiplier = 0;

         ctTimSet.WriteTotalTimeoutConstant = 0;

         /*用接构当中的参数设置串口超时参数*/

         if (cComm.SetCommunicationTimeouts(ctTimSet.ReadIntervalTimeout, ctTimSet.ReadTotalTimeoutMultiplier, ctTimSet.ReadTotalTimeoutConstant, ctTimSet.WriteTotalTimeoutMultiplier, ctTimSet.WriteTotalTimeoutConstant))

         {        

             DWORD BaudRate = CBR_9600;

             BYTE ByteSize = 8;

             DWORD fParity =1;

             BYTE  Parity = 'N';

             BYTE  StopBits = 1;

             //if (cComm.ConfigureComm(BaudRate, ByteSize, fParity, Parity, StopBits))

             if (cComm.ConfigureComm(BaudRate, ByteSize, Parity, StopBits))

             {

                     while (1)

                     {

                         int byDataNum = 0;

                         BYTE  byData[9] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h','\t' };//定义要写入的数据

                         int iByteCount = sizeof(byData) / sizeof(byData[0]);

                         for (int i = 0; i != iByteCount; )

                         {

                             if (cComm.WriteByte(byData[i]))

                             {

                                 i++;

                                 continue;

                             }

                             else

                             {

                                 cout << "dog";

                                 Sleep(4000);

                            }

                             cout << endl;

                         }

                     }

                     cout << "dog1"<< endl;

             }

                 cout << "dog2" << endl;

        }

        cout << "dog3" << endl;

     }

     else

     {

         return  false;

     }

     PurgeComm(cComm.hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);//清空COM1输入缓存的数据

    cComm.CloseComm();

     system("pause");

     return 0;

 }

//程序类实现了串口操作的feng封装

2. （比较全，main函数需要自己写未验证）

windows下C++读取串口数据

这里提供一个类：

SerialPort.h

#pragma once

#ifndef SERIALPORT_H_

#define SERIALPORT_H_    

#include <Windows.h>

/** 串口通信类

*

*  本类实现了对串口的基本操作

*  例如监听发到指定串口的数据、发送指定数据到串口

*/

class CSerialPort

{

public:

    CSerialPort(void);

    ~CSerialPort(void);

    /*缓存数据*/

    bool Readexit;

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_115200, 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);

    void ReadOpen()

    {

        this->Readexit = false;

    }

    void ReadExit()

    {

        this->Readexit = true;

    }

    void ReadData(uint8 *buff);

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_

SerialPort.cpp

#include "StdAfx.h"

#include "SerialPort.h"

#include <process.h>

#include <iostream>

using  namespace std;

/** 线程退出标志 */

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;

        int count = 0;

        do

        {

            cRecved = 0x00;

            if (pSerialPort->ReadChar(cRecved) == true)

            {

                cout << (unsigned)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);

}

void CSerialPort::ReadData(uint8 * buff)

{

    // 线程循环,轮询方式读取串口数据

    while (!this->Readexit)

    {

        UINT BytesInQue = this->GetBytesInCOM();

        /** 如果串口输入缓冲区中无数据,则休息一会再查询 */

        if (BytesInQue == 0)

        {

            Sleep(SLEEP_TIME_INTERVAL);

            continue;

        }

        memset(buff, 0x00, sizeof(buff));

        /** 读取输入缓冲区中的数据并输出显示 */

        char cRecved = 0x00;

        int count = 0;

        do

        {

            cRecved = 0x00;

            if (this->ReadChar(cRecved) == true)

            {

                if (Readexit)

                {

                    break;

                }

                cout << (unsigned)cRecved<<" ";

                continue;

            }

        } while (--BytesInQue);

    }

}

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

int main()

{

    if (!mySerialPort.InitPort(3))

    {

        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;

    }

    return 0;

}

巴特西

C++实现串口通信问题（与Arduino）

windows下C++读取串口数据

SerialPort.h

最新文章

热门文章