c++ 讀取window下的USB輸入數據 及 linux下的USB讀取

先使用arduino，做一個串口的重復輸入，我手頭使用的就是mega版。

在arduino自己的ide中做好配置

這里需要配置好，開發板，處理器還有端口。

程序中先要初始化端口，而后要不斷打印“Hello world”

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  Serial.println("Hello world");
  delay(1000);
}

setup中插入的是初始化的代碼，后面的loop中寫的是重復執行的指令。

而后就需要編譯，並且燒錄到板中。我們可以在工具>串口監視器中查看串口輸入輸出情況

這里需要注意，串口的波特率為9600，校正位 None, 數據位8， 停止位1。

 

windows下的c++串口讀取

在windows下讀取USB的做法就是使用 window.h文件。

使用CSerialPort類的 windows.h讀取方式。這里附上SerialPort.h

#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(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_

對應的SerialPort.cpp

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

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_115200*/, 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 rxByteArray = 0x00;
        do
        {
            rxByteArray = 0x00;
            if (pSerialPort->ReadChar(rxByteArray) == true)
            {

                std::cout << rxByteArray;
            }
        }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(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程序。

#include "stdafx.h"

#include <windows.h>
#include <iostream>
#include <string>
#include "SerialPort.h"

using namespace std;

int port;
CSerialPort mySerialPort;

void PortOpen() {
    cout << "Please insert your port number : " << endl;
    cin >> port;

    if (!mySerialPort.InitPort(port, 9600, 'N', 8, 1, EV_RXCHAR))
    {
        std::cout << "initPort fail !" << std::endl;
        PortOpen();
    }
    else
    {
        std::cout << "initPort success !" << std::endl;
    }
}

int main()
{
    PortOpen();
    if (!mySerialPort.OpenListenThread()){
        std::cout << "OpenListenThread fail !" << std::endl;
    }
    else {
        std::cout << "OpenListenThread success !" << std::endl;
    }

    while (1) 
    {
            UINT BytesInQue = mySerialPort.GetBytesInCOM();
    }

    Sleep(1000);
    return 0;
}

運行結果如下

 

如果想要以txt文件保存串口數據的話，可以在文件里面加入存儲的部分，參考例程如下：

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

int main()
{
    ofstream outfile;      //終端輸入--》內存--》文本
    outfile.open("2.txt");//(輸入流) （變量）（輸出文件流）
    if(!outfile) cout<<"error"<<endl;         

    string str;
    int t1;
    int i=0;
    while(cin>>t1)             //按空格讀取，遇到空白符結束
    {   if(i!=0&&i%3==0)
            outfile<<"\n";
        outfile<<t1<<" "; 
        i++;
    }

    outfile.close();
    return 0;
}

修改的時候，我們可以在SerialPort.h的文件中加入

#include <iostream>
#include <fstream>
#include <string>
#include <vector>　　

如果要在串口打印的同時，存入txt文件，在SerialPort.cpp的ListenTread函數中改動加入存儲功能

UINT WINAPI CSerialPort::ListenThread(void* pParam)
{
    ofstream outfile;
    outfile.open("data.txt");
    if (!outfile) cout << "error" << endl;

    /** 得到本類的指針 */
    CSerialPort *pSerialPort = reinterpret_cast<CSerialPort*>(pParam);

    // 線程循環,輪詢方式讀取串口數據    
    while (!pSerialPort->s_bExit)
    {
        UINT BytesInQue = pSerialPort->GetBytesInCOM();
        /** 如果串口輸入緩沖區中無數據,則休息一會再查詢 */
        if (BytesInQue == 0)
        {
            Sleep(SLEEP_TIME_INTERVAL);
            continue;
        }

        /** 讀取輸入緩沖區中的數據並輸出顯示 */
        char rxByteArray = 0x00;
        do
        {
            rxByteArray = 0x00;
            if (pSerialPort->ReadChar(rxByteArray) == true)
            {
                int out = rxByteArray;
                outfile.put(out);
                std::cout << rxByteArray ;
            }
        }while (--BytesInQue);
    }
    return 0;
}

這就會在你項目的根目錄下產生一個存儲數據的txt啦。

 

 

ubuntu的串口讀取

在ubuntu下使用的讀取方式是用的boost庫，如果電腦中沒有，需要安裝。

直接使用 apt-get進行安裝

sudo apt-get install libboost-dev

 系統中，想要查看串口號的話，terminal中使用

ls -l /dev/tty*

我們使用的是ttyUSB0。因為是配合ros平台使用的，所以引入了ros頭文件,並且存儲數據成txt，存儲位置在workspace根目錄下，主程序如下：

#include <string>
#include <ros/ros.h>

#include "boost/asio.hpp"
#include "boost/bind.hpp"

#include <iostream>
#include <fstream>

using namespace std;
using namespace boost::asio;
unsigned char buf[24];

int main(int argc, char** argv) 
　　{
      ros::init(argc, argv, "usb");
      ros::NodeHandle n;
　　　 std::ofstream out("test.txt");

//ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
      ros::Rate loop_rate(10);
      io_service iosev;
      serial_port sp(iosev, "/dev/ttyUSB0");
      sp.set_option(serial_port::baud_rate(9600));
      sp.set_option(serial_port::flow_control());
      sp.set_option(serial_port::parity());
      sp.set_option(serial_port::stop_bits());
      sp.set_option(serial_port::character_size(8));

      while(n.ok()){

        char rxData[100];
        boost::system::error_code err;
        //scanf("%s\n",rxData);
        sp.read_some(buffer(rxData,39),err);
        if (err)
        {
            ROS_INFO("Serial port read_some Error!");
            return -1;
        }
        //std_msgs::String msg;
        //std::stringstream ss;
        ROS_INFO("MPU6050 : %s\n",rxData);
　　　　　out <<" "<<rxData<<" \n";
　　　　　loop_rate.sleep();

 　　} 
return 0; 
}

其中boost部分，主要是

      io_service iosev;
      serial_port sp(iosev, "/dev/ttyUSB0");
      sp.set_option(serial_port::baud_rate(9600));
      sp.set_option(serial_port::flow_control());
      sp.set_option(serial_port::parity());
      sp.set_option(serial_port::stop_bits());
      sp.set_option(serial_port::character_size(8));

設置端口號，波特率，校正值等等。

    boost::system::error_code err;
    sp.read_some(buffer(rxData,39),err);

上面這兩句主要是要讀取串口數值，buffer里為傳入字符串，39代表傳入字符串的長度。編譯成功后就可以運行了。

 

在運行程序前，需要給端口添加權限。

sudo chmod 666 /dev/ttyUSB0