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