基于Qt 5.7 自己写一个漂亮的串口助手

最新推荐文章于 2024-06-13 17:55:24 发布
最新推荐文章于 2024-06-13 17:55:24 发布
阅读量4.2w 收藏 274
点赞数 46
分类专栏： C++ 文章标签： qt 界面设计 上位机 串口助手 基本收发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imkelt/article/details/53000523
版权

之前自己写了用于上位机做基本收发的界面，独立出来相当于一个串口助手，先贴图：

这里写图片描述

功能作为串口助手来说还算完善，五个发送槽，一个接收槽，可以检测可用串口并加上相关标志，串口设置，记数功能，还有菜单栏上的文件操作和一些选择功能。

下面说一说这个项目:
做这个串口助手分为两步，第一步是设计界面，第二部是功能的代码实现。

一、界面设计
界面设计用Qt Designer，当然用Qt Creator的界面编辑器也可以，只不过感觉Qt Designer更好用一点，因为可以随时运行查看你的界面效果而不用编译整个项目输出一个可执行程序再看看界面效果，这样会影响效率。界面设计你想界面是什么样就怎么样设计，拉控件，排版，设置大小，修改对象名等等，都在这上面做好，这些用程序写的话会很麻烦，工作量也大。这上面的对象名很重要，因为在后面的代码实现中会用到，这个界面用到的控件还是挺多的，这里也不一个一个讲，我直接贴出来：

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述
senderGB_1 - 5都是一样的，改下数就行

这里写图片描述

这里写图片描述

当然，用你自己喜欢的命名也可以，后面程序改下名字就行。

二、代码实现

先贴代码

basictransceiver.h


#ifndef BASICTRANSCEIVER_H
#define BASICTRANSCEIVER_H

#include <QMainWindow>
#include "ui_basictransceiver.h"

class QTimer;
class SerialPortSetting;
class QSerialPort;
class QPushButton;

class BasicTransceiver : public QMainWindow, public Ui::BasicTransceiver
{
    Q_OBJECT

public:
    explicit BasicTransceiver(QWidget *parent = 0);

    ~BasicTransceiver();

    void StringToHex(QString str, QByteArray &senddata);

    char ConvertHexChar(char ch);

    void startAutoSend(QPushButton *sendButton);

    void setConnections();

    void writeHex(QTextEdit *textEdit);

    void writeChr(QTextEdit *textEdit);

    void resetCnt();

protected:
    void dragEnterEvent(QDragEnterEvent *event);

    void dropEvent(QDropEvent *event);

private slots:
    void checkAutoSendCB();

    void on_cleanButton_clicked();

    void on_receiveTextBrowser_textChanged();

    void setBaudRate();

    void setParity();

    void setDataBits();

    void setStopBits();

    void setFlowCtrl();

    void on_connectButton_toggled(bool checked);

    void setComLabel();

    void setBaudLabel();

    void writeToBuf();

    void enabledSendButton();

    void disabledSendButton();

    void enabledAutoSend();

    void disabledAutoButton();

    void resetAutoSendCB();

    void readMyCom();

    void checkAvailablePorts();

    void on_checkAPButton_clicked();

    void checkPort();

    void on_resetCntButton_clicked();

    void on_exitButton_clicked();

    bool saveAs();

    void open();

    //void about();

private:
    bool loadFile(const QString &fileName);

    bool readFile(const QString &fileName);

    bool saveFile(const QString &fileName);

    bool writeFile(const QString &fileName);

    QTimer *Timer_AS;//自动发送定时器
    QTimer *Timer_UPDATE;
    QTimer *Timer_CP;//定时检测串口是否存在
    SerialPortSetting *SPSetting;
    QSerialPort *mySerialPort;
    QSet<QString> portSet;
    QVector<int> iVec;
    QString senderFlag;
    QString readData;
    bool trashFlag = false;
    bool portIsOpen = false;
    int BaudCnt = 0;
    int ParityCnt = 0;
    int DataBitsCnt = 0;
    int StopBitsCnt = 0;
    int FlowCtrlCnt = 0;


};

#endif // BASICTRANSCEIVER_H
basictransceiver.cpp



#include "basictransceiver.h"
#include "serialportsetting.h"
#include "ui_basictransceiver.h"
#include "ui_serialportsetting.h"
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include <QDebug>
#include <QMessageBox>
#include <QStatusBar>
#include <QPushButton>
#include <QByteArray>
#include <QDataStream>
#include <QTimer>
#include <QRegExp>
#include <QRegExpValidator>
#include <QFile>
#include <QFileDialog>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QMimeData>
#include <QAction>

BasicTransceiver::BasicTransceiver(QWidget *parent) :
    QMainWindow(parent)
{
    setupUi(this);
    setFixedSize(1074, 627);
    receiveTextBrowser->setAcceptDrops(false);//缺省情况下，QTextEdit接受来自其他应用程序拖拽来的文本，把文件名显示出来。
    senderTextEdit_1->setAcceptDrops(false);
    senderTextEdit_2->setAcceptDrops(false);
    senderTextEdit_3->setAcceptDrops(false);
    senderTextEdit_4->setAcceptDrops(false);
    senderTextEdit_5->setAcceptDrops(false);
    setAcceptDrops(true);//通过禁止QTextEdit控件的drop事件，允许主窗口得到drop事件

    connectButton->setIcon(QIcon(":/images/open.png"));
    cleanButton->setIcon(QIcon(":/images/empty_bin.png"));
    checkAPButton->setIcon(QIcon(":/images/find.png"));
    resetCntButton->setIcon(QIcon(":/images/to_zero.png"));
    exitButton->setIcon(QIcon(":/images/exit.png"));
    actionWrite_data->setIcon(QIcon(":/images/write.png"));
    actionRead_data->setIcon(QIcon(":/images/read.png"));
    actionChoose_file->setIcon(QIcon(":/images/select_file.png"));
    exitAction->setIcon(QIcon(":/images/exit.png"));
    actionAbout->setIcon(QIcon(":/images/about.png"));
    sendButton_1->setIcon(QIcon(":/images/send.png"));
    sendButton_2->setIcon(QIcon(":/images/send.png"));
    sendButton_3->setIcon(QIcon(":/images/send.png"));
    sendButton_4->setIcon(QIcon(":/images/send.png"));
    sendButton_5->setIcon(QIcon(":/images/send.png"));

    setConnections();
    emit checkAvailablePorts();

    Timer_CP = new QTimer(this);
    Timer_UPDATE = new QTimer(this);
    connect(Timer_UPDATE, SIGNAL(timeout()), this, SLOT(repaint()));
    Timer_UPDATE->start(2000);
    Timer_AS = new QTimer(this);
}

BasicTransceiver::~BasicTransceiver()
{

}

void BasicTransceiver::checkAutoSendCB()
{
    QObject *signalSender = sender();
    if ( signalSender->objectName() == "autoSendCB_1")
    {
        if (autoSendCB_1->isChecked())
        {
            intervalSB_1->setEnabled(false);
            autoSendCB_2->setEnabled(false);
            autoSendCB_3->setEnabled(false);
            autoSendCB_4->setEnabled(false);
            autoSendCB_5->setEnabled(false);
            startAutoSend(sendButton_1);
        } else if (!autoSendCB_1->isChecked()) {
            Timer_AS->stop();
            Timer_AS->disconnect();
            intervalSB_1->setEnabled(true);
            autoSendCB_2->setEnabled(true);
            autoSendCB_3->setEnabled(true);
            autoSendCB_4->setEnabled(true);
            autoSendCB_5->setEnabled(true);
            enabledSendButton();
        }
    } else if ( signalSender->objectName() == "autoSendCB_2") {
         if (autoSendCB_2->isChecked())
         {
             intervalSB_2->setEnabled(false);
             autoSendCB_1->setEnabled(false);
             autoSendCB_3->setEnabled(false);
             autoSendCB_4->setEnabled(false);
             autoSendCB_5->setEnabled(false);
             startAutoSend(sendButton_2);
         } else if (!autoSendCB_2->isChecked()) {
             Timer_AS->stop();
             Timer_AS->disconnect();
             intervalSB_2->setEnabled(true);
             autoSendCB_1->setEnabled(true);
             autoSendCB_3->setEnabled(true);
             autoSendCB_4->setEnabled(true);
             autoSendCB_5->setEnabled(true);
             enabledSendButton();
         }
     } else if ( signalSender->objectName() == "autoSendCB_3") {
         if (autoSendCB_3->isChecked())
         {
             intervalSB_3->setEnabled(false);
             autoSendCB_1->setEnabled(false);
             autoSendCB_2->setEnabled(false);
             autoSendCB_4->setEnabled(false);
             autoSendCB_5->setEnabled(false);
             startAutoSend(sendButton_3);
         } else if (!autoSendCB_3->isChecked())  {
             Timer_AS->stop();
             Timer_AS->disconnect();
             intervalSB_3->setEnabled(true);
             autoSendCB_1->setEnabled(true);
             autoSendCB_2->setEnabled(true);
             autoSendCB_4->setEnabled(true);
             autoSendCB_5->setEnabled(true);
             enabledSendButton();
         }
     } else if ( signalSender->objectName() == "autoSendCB_4") {
         if (autoSendCB_4->isChecked())
         {
             intervalSB_4->setEnabled(false);
             autoSendCB_1->setEnabled(false);
             autoSendCB_2->setEnabled(false);
             autoSendCB_3->setEnabled(false);
             autoSendCB_5->setEnabled(false);
             startAutoSend(sendButton_4);
         } else if (!autoSendCB_4->isChecked()) {
             Timer_AS->stop();
             Timer_AS->disconnect();
             intervalSB_4->setEnabled(true);
             autoSendCB_1->setEnabled(true);
             autoSendCB_2->setEnabled(true);
             autoSendCB_3->setEnabled(true);
             autoSendCB_5->setEnabled(true);
             enabledSendButton();
         }
     } else if ( signalSender->objectName() == "autoSendCB_5") {
         if (autoSendCB_5->isChecked())
         {
             intervalSB_5->setEnabled(false);
             autoSendCB_1->setEnabled(false);
             autoSendCB_2->setEnabled(false);
             autoSendCB_3->setEnabled(false);
             autoSendCB_4->setEnabled(false);
            startAutoSend(sendButton_5);
         } else if (!autoSendCB_5->isChecked()) {
             Timer_AS->stop();
             Timer_AS->disconnect();
             intervalSB_5->setEnabled(true);
             autoSendCB_1->setEnabled(true);
             autoSendCB_2->setEnabled(true);
             autoSendCB_3->setEnabled(true);
             autoSendCB_4->setEnabled(true);
             enabledSendButton();
         }
     }
 }

//清除接收区的内容
void BasicTransceiver::on_cleanButton_clicked()
{
    if (trashFlag == true) {
        receiveTextBrowser->clear();
        cleanButton->setIcon(QIcon(":/images/empty_bin.png"));
    }
}

void BasicTransceiver::on_receiveTextBrowser_textChanged()
{
    QString tempStr = receiveTextBrowser->toPlainText();
    if (!tempStr.isEmpty()) {
        trashFlag = true;
        if (autoClean->isChecked()){
            if (tempStr.size() >6200 ){
                receiveTextBrowser->clear();
                cleanButton->setIcon(QIcon(":/images/empty_bin.png"));
            }
        } else {
        cleanButton->setIcon(QIcon(":/images/clean.png"));
        }
    } else {
        trashFlag = false;
        cleanButton->setIcon(QIcon(":/images/empty_bin.png"));
    }
}


void BasicTransceiver::setBaudRate()
{
    if (portIsOpen) {
        if (BAUDCB->currentText() == "115200")
            mySerialPort->setBaudRate(QSerialPort::Baud115200);
        else if (BAUDCB->currentText() == "9600")
            mySerialPort->setBaudRate(QSerialPort::Baud9600);
        else if (BAUDCB->currentText() == "1200")
            mySerialPort->setBaudRate(QSerialPort::Baud1200);
        else if (BAUDCB->currentText() == "2400")
            mySerialPort->setBaudRate(QSerialPort::Baud2400);
        else if (BAUDCB->currentText() == "4800")
            mySerialPort->setBaudRate(QSerialPort::Baud4800);
        else if (BAUDCB->currentText() == "19200")
            mySerialPort->setBaudRate(QSerialPort::Baud19200);
        else if (BAUDCB->currentText() == "38400")
            mySerialPort->setBaudRate(QSerialPort::Baud38400);
        else if (BAUDCB->currentText() == "57600")
            mySerialPort->setBaudRate(QSerialPort::Baud57600);
        emit setBaudLabel();
        if (BaudCnt) {
            statusBar()->showMessage("BaudRate set successfully", 2000);
        }
        ++BaudCnt;
    }
}

void BasicTransceiver::setParity()
{
    if (portIsOpen) {
        if (ParityCB->currentText() == QString::fromLocal8Bit("无校验"))
            mySerialPort->setParity(QSerialPort::NoParity);
        else if (ParityCB->currentText() == QString::fromLocal8Bit("奇校验"))
            mySerialPort->setParity(QSerialPort::OddParity);
        else if (ParityCB->currentText() == QString::fromLocal8Bit("偶校验"))
            mySerialPort->setParity(QSerialPort::EvenParity);
        if (ParityCnt) {
            statusBar()->showMessage("Parity set successfully", 2000);
        }
        ++ParityCnt;
    }
}

void BasicTransceiver::setDataBits()
{
    if (portIsOpen) {
        if (DataBitsCB->currentText() == "8")
            mySerialPort->setDataBits(QSerialPort::Data8);
        else if (DataBitsCB->currentText() == "7")
            mySerialPort->setDataBits(QSerialPort::Data7);
        else if (DataBitsCB->currentText() == "6")
            mySerialPort->setDataBits(QSerialPort::Data6);
        else if (DataBitsCB->currentText() == "5")
            mySerialPort->setDataBits(QSerialPort::Data5);
        if (DataBitsCnt) {
             statusBar()->showMessage("DataBits set successfully", 2000);
        }
        ++DataBitsCnt;
    }
}

void BasicTransceiver::setStopBits()
{
    if (portIsOpen) {
        if (StopBitsCB->currentText() == "1")
            mySerialPort->setStopBits(QSerialPort::OneStop);
        else if (StopBitsCB->currentText() == "1.5")
            mySerialPort->setStopBits(QSerialPort::OneAndHalfStop);
        else if (StopBitsCB->currentText() == "2")
            mySerialPort->setStopBits(QSerialPort::TwoStop);
        if (StopBitsCnt) {
            statusBar()->showMessage("StopBits set successfully", 2000);
        }
        ++StopBitsCnt;
    }
}

void BasicTransceiver::setFlowCtrl()
{
    if (portIsOpen) {
        if (FlowCtrlCB->currentText() == "off")
            mySerialPort->setFlowControl(QSerialPort::NoFlowControl);
        else if (FlowCtrlCB->currentText() == "hardware")
            mySerialPort->setFlowControl(QSerialPort::HardwareControl);
        else if (FlowCtrlCB->currentText() == "xonxoff")
            mySerialPort->setFlowControl(QSerialPort::SoftwareControl);
        if (FlowCtrlCnt) {
            statusBar()->showMessage("FlowCtrl set successfully", 2000);
        }
        ++FlowCtrlCnt;
    }
}

void BasicTransceiver::resetCnt()
{
    BaudCnt = 0;
    ParityCnt = 0;
    DataBitsCnt = 0;
    StopBitsCnt = 0;
    FlowCtrlCnt = 0;
}

//打开和关闭串口
void BasicTransceiver::on_connectButton_toggled(bool checked)
{
    if (checked == true) {
        mySerialPort = new QSerialPort(this);
        QString tempStr = COMCB->currentText();
        tempStr.remove("  avail", Qt::CaseSensitive);
        mySerialPort->setPortName(tempStr);
        if (mySerialPort->open(QIODevice::ReadWrite)) {
                portIsOpen = true;
                emit setBaudRate();
                emit setParity();
                emit setDataBits();
                emit setStopBits();
                emit setFlowCtrl();
                statusBar()->showMessage(mySerialPort->portName() + " is opened", 2000);
                emit setComLabel();
                emit enabledSendButton();
                emit enabledAutoSend();
                COMCB->setEnabled(false);
                connect(Timer_CP, SIGNAL(timeout()), this, SLOT(checkPort()));
                Timer_CP->start(1000);
                connect(mySerialPort, SIGNAL(readyRead()), this, SLOT(readMyCom()));
                connectButton->setText(QString::fromLocal8Bit("关闭连接"));
                connectButton->setIcon(QIcon(":/images/close.png"));
            } else {
                QMessageBox::warning(this,
                                                       QString::fromLocal8Bit("串口打开失败"),
                                                       QString::fromLocal8Bit("串口不存在或本串口"
                                                                                             "已经被占用，请重试！"),
                                                       QMessageBox::Cancel);
                connectButton->setChecked(false);
                return;
           }
    } else  if (checked == false) {
            if (Timer_AS->isActive()) {
                Timer_AS->stop();
                emit resetAutoSendCB();
            }
            if (Timer_CP->isActive()) Timer_CP->stop();
            Timer_CP->disconnect();
            if (mySerialPort->isOpen()) mySerialPort->close();
            emit disabledSendButton();
            emit disabledAutoButton();
            emit setComLabel();
            emit setBaudLabel();
            resetCnt();
            COMCB->setEnabled(true);
            connectButton->setText(QString::fromLocal8Bit("打开连接"));
            connectButton->setIcon(QIcon(":/images/open.png"));
            portIsOpen = false;
    }
}

//设置显示串口号和波特率的Label
void BasicTransceiver::setComLabel()
{
    if (mySerialPort->isOpen()) {
        comLabel->setText(QString(mySerialPort->portName()));
    } else if (!mySerialPort->isOpen()) {
        comLabel->setText(QString::fromLocal8Bit("COM：#"));
    }
}

void BasicTransceiver::setBaudLabel()
{
    if (mySerialPort->isOpen()) {
        int i_baud = mySerialPort->baudRate();
        QString s_baud;
        baudLabel->setText(s_baud.setNum(i_baud));
    } else if (!mySerialPort->isOpen()) {
        baudLabel->setText(QString::fromLocal8Bit("BAUD：#"));
    }
}

void BasicTransceiver::writeToBuf()
{
    QObject *signalSender = sender();
    if (signalSender->objectName() == "sendButton_1") {
        if (hexRB_1->isChecked()) {
            writeHex(senderTextEdit_1);
        } else {
            writeChr(senderTextEdit_1);
        }
    } else if (signalSender->objectName() == "sendButton_2") {
        if (hexRB_2->isChecked()) {
            writeHex(senderTextEdit_2);
        } else {
            writeChr(senderTextEdit_2);
        }
    } else if (signalSender->objectName() == "sendButton_3") {
        if (hexRB_3->isChecked()) {
            writeHex(senderTextEdit_3);
        } else {
            writeChr(senderTextEdit_3);
        }
    } else if (signalSender->objectName() == "sendButton_4") {
        if (hexRB_4->isChecked()) {
            writeHex(senderTextEdit_4);
        } else {
            writeChr(senderTextEdit_4);
        }
    } else if (signalSender->objectName() == "sendButton_5") {
        if (hexRB_5->isChecked()) {
            writeHex(senderTextEdit_5);
        } else {
            writeChr(senderTextEdit_5);
        }
    }
}

void BasicTransceiver::writeHex(QTextEdit *textEdit)
{
    QString dataStr = textEdit->toPlainText();
    //如果发送的数据个数为奇数的，则在前面最后落单的字符前添加一个字符0
    if (dataStr.length() % 2){
        dataStr.insert(dataStr.length()-1, '0');
    }
    QByteArray sendData;
    StringToHex(dataStr, sendData);
    mySerialPort->write(sendData);
    RxLCD->display(RxLCD->value() + sendData.size());
}

void BasicTransceiver::writeChr(QTextEdit *textEdit)
{
    QByteArray sendData = textEdit->toPlainText().toUtf8();
    if (!sendData.isEmpty() && !sendData.isNull()) {
        mySerialPort->write(sendData);
    }
    RxLCD->display(RxLCD->value() + sendData.size());
}

void BasicTransceiver::StringToHex(QString str, QByteArray &senddata) //字符串转换为十六进制数据0-F
{
    int hexdata,lowhexdata;
    int hexdatalen = 0;
    int len = str.length();
    senddata.resize(len / 2);
    char lstr,hstr;
    for (int i = 0; i < len; ) {
        hstr = str[i].toLatin1();
        if (hstr == ' ') {
            ++i;
            continue;
        }
        ++i;
        if (i  >= len) break;
        lstr = str[i].toLatin1();
        hexdata = ConvertHexChar(hstr);
        lowhexdata = ConvertHexChar(lstr);
        if ((hexdata == 16) || (lowhexdata == 16))
            break;
        else
            hexdata = hexdata*16 + lowhexdata;
        ++i;
        senddata[hexdatalen] = (char)hexdata;
        ++hexdatalen;
    }
    senddata.resize(hexdatalen);
}

char BasicTransceiver::ConvertHexChar(char ch)
{
    if ((ch >= '0') && (ch <= '9'))
        return ch - 0x30;
    else if ((ch >= 'A') && (ch <= 'F'))
        return ch - 'A' + 10;
    else if ((ch >= 'a') && (ch <= 'f'))
        return ch - 'a' + 10;
    else return ch -  ch;
}

void BasicTransceiver::enabledSendButton()
{
    sendButton_1->setEnabled(true);
    sendButton_2->setEnabled(true);
    sendButton_3->setEnabled(true);
    sendButton_4->setEnabled(true);
    sendButton_5->setEnabled(true);
}

void BasicTransceiver::disabledSendButton()
{
    sendButton_1->setEnabled(false);
    sendButton_2->setEnabled(false);
    sendButton_3->setEnabled(false);
    sendButton_4->setEnabled(false);
    sendButton_5->setEnabled(false);
}

void BasicTransceiver::startAutoSend(QPushButton *sendButton)
{
    connect(Timer_AS, SIGNAL(timeout()), sendButton, SIGNAL(clicked()));
    QString interval;
    if (sendButton->objectName() == "sendButton_1") {
        disabledSendButton();
        Timer_AS->start(intervalSB_1->value());
        statusBar()->showMessage(QString::fromLocal8Bit("每 ") + interval.setNum(intervalSB_1->value())+ QString::fromLocal8Bit("ms 自动发送一次") , 2000);
    } else if (sendButton->objectName() == "sendButton_2") {
        disabledSendButton();
        Timer_AS->start(intervalSB_2->value());
        statusBar()->showMessage(QString::fromLocal8Bit("每 ") + interval.setNum(intervalSB_2->value())+ QString::fromLocal8Bit("ms 自动发送一次") , 2000);
    } else if (sendButton->objectName() == "sendButton_3") {
        disabledSendButton();
        Timer_AS->start(intervalSB_3->value());
        statusBar()->showMessage(QString::fromLocal8Bit("每 ") + interval.setNum(intervalSB_3->value())+ QString::fromLocal8Bit("ms 自动发送一次") , 2000);
    } else if (sendButton->objectName() == "sendButton_4") {
        disabledSendButton();
        Timer_AS->start(intervalSB_4->value());
        statusBar()->showMessage(QString::fromLocal8Bit("每 ") + interval.setNum(intervalSB_4->value())+ QString::fromLocal8Bit("ms 自动发送一次") , 2000);
    } else if (sendButton->objectName() == "sendButton_5") {
        disabledSendButton();
        Timer_AS->start(intervalSB_5->value());
        statusBar()->showMessage(QString::fromLocal8Bit("每 ") + interval.setNum(intervalSB_5->value())+ QString::fromLocal8Bit("ms 自动发送一次") , 2000);
    }
}

void BasicTransceiver::setConnections()
{
    connect(autoSendCB_1, SIGNAL(stateChanged(int)), this, SLOT(checkAutoSendCB()));
    connect(autoSendCB_2, SIGNAL(stateChanged(int)), this, SLOT(checkAutoSendCB()));
    connect(autoSendCB_3, SIGNAL(stateChanged(int)), this, SLOT(checkAutoSendCB()));
    connect(autoSendCB_4, SIGNAL(stateChanged(int)), this, SLOT(checkAutoSendCB()));
    connect(autoSendCB_5, SIGNAL(stateChanged(int)), this, SLOT(checkAutoSendCB()));

    connect(actionWrite_data, SIGNAL(triggered()), this, SLOT(saveAs()));
    connect(actionRead_data, SIGNAL(triggered()), this, SLOT(open()));
    connect(actionChoose_file, SIGNAL(triggered()), this, SLOT(open()));
    connect(exitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
    connect(actionAbout, SIGNAL(triggered()), qApp, SLOT(aboutQt()));

    connect(sendButton_1, SIGNAL(clicked()), this, SLOT(writeToBuf()));
    connect(sendButton_2, SIGNAL(clicked()), this, SLOT(writeToBuf()));
    connect(sendButton_3, SIGNAL(clicked()), this, SLOT(writeToBuf()));
    connect(sendButton_4, SIGNAL(clicked()), this, SLOT(writeToBuf()));
    connect(sendButton_5, SIGNAL(clicked()), this, SLOT(writeToBuf()));

    connect(BAUDCB, SIGNAL(currentIndexChanged(int)), this, SLOT(setBaudRate()));
    connect(ParityCB, SIGNAL(currentIndexChanged(int)), this, SLOT(setParity()));
    connect(DataBitsCB, SIGNAL(currentIndexChanged(int)), this, SLOT(setDataBits()));
    connect(StopBitsCB, SIGNAL(currentIndexChanged(int)), this, SLOT(setStopBits()));
    connect(FlowCtrlCB, SIGNAL(currentIndexChanged(int)), this, SLOT(setFlowCtrl()));
}

void BasicTransceiver::enabledAutoSend()
{
    autoSendCB_1->setEnabled(true);
    autoSendCB_2->setEnabled(true);
    autoSendCB_3->setEnabled(true);
    autoSendCB_4->setEnabled(true);
    autoSendCB_5->setEnabled(true);
}

void BasicTransceiver::disabledAutoButton()
{
    autoSendCB_1->setEnabled(false);
    autoSendCB_2->setEnabled(false);
    autoSendCB_3->setEnabled(false);
    autoSendCB_4->setEnabled(false);
    autoSendCB_5->setEnabled(false);
}



void BasicTransceiver::resetAutoSendCB()
{
    autoSendCB_1->setChecked(false);
    autoSendCB_2->setChecked(false);
    autoSendCB_3->setChecked(false);
    autoSendCB_4->setChecked(false);
    autoSendCB_5->setChecked(false);
}

void BasicTransceiver::readMyCom()
{
    QByteArray temp = mySerialPort->readAll();
    QString buf;

    if (actionAlways_show->isChecked()) {
        if(!temp.isEmpty()){
                if(chrReceive->isChecked()){
                    buf = temp;
                }else if(hexReceive->isChecked()){
                    for(int i = 0; i < temp.count(); i++){
                        QString s;
                        s.sprintf("0x%02x, ", (unsigned char)temp.at(i));
                        buf += s;
                    }
                }
            receiveTextBrowser->setText(receiveTextBrowser->document()->toPlainText() + buf);
            receiveTextBrowser->moveCursor(QTextCursor::End);


            //ui->statusBar->showMessage(tr("成功读取%1字节数据").arg(temp.size()));
        }
    }
    TxLCD->display(TxLCD->value() + temp.size());
}

//检测可用串口并在可用串口号后面加上可用标志
void BasicTransceiver::checkAvailablePorts()
{//找不到存在串口是不会进入到foreach内部的。。。存在不一定可用
    foreach ( const QSerialPortInfo &Info, QSerialPortInfo::availablePorts()) {
        QSerialPort availablePort;
        availablePort.setPortName(Info.portName());
        if (availablePort.open(QIODevice::ReadWrite)) {
            int index = COMCB->findText(Info.portName());
            COMCB->setItemText(index, Info.portName() + "  avail");
            COMCB->setCurrentIndex(index);
            iVec.push_back(index);//将修改了内容的项索引添加到容器中
            checkAPButton->setIcon(QIcon(":/images/find_it.png"));
            availablePort.close();
            }
    }
    if (iVec.size() == 0) {checkAPButton->setIcon(QIcon(":/images/find.png"));}
    QString availPortCnt;
    statusBar()->showMessage(availPortCnt.setNum(iVec.size()) + " available ports", 2000);
}
//将选择串口号的checkBox重置并重新检测可用串口
void BasicTransceiver::on_checkAPButton_clicked()
{
    if (!iVec.isEmpty()) {
        for (int i = 0; i != iVec.size(); ++i) {
            QString tempStr;
            COMCB->setItemText(iVec[i], QString("COM") +
                                                            tempStr.setNum(iVec[i]));
        }
        COMCB->setCurrentIndex(0);
        iVec.clear();
    }
    emit checkAvailablePorts();
}

void BasicTransceiver::checkPort()
{
    QSet<QString> portSet;
    foreach ( const QSerialPortInfo &Info, QSerialPortInfo::availablePorts()) {
        portSet.insert(Info.portName());
    }
    if (portSet.find(mySerialPort->portName()) == portSet.end()) {
        QMessageBox::warning(this,
                                               QString::fromLocal8Bit("Application error"),
                                               QString::fromLocal8Bit("Fail with the following error : \n串口访问失败\n\nPort:%1")
                                               .arg(mySerialPort->portName()),
                                               QMessageBox::Close);
        emit on_connectButton_toggled(false);
    }
}

void BasicTransceiver::on_resetCntButton_clicked()
{
    RxLCD->display(0);
    TxLCD->display(0);
}

void BasicTransceiver::on_exitButton_clicked()
{
    qApp->quit();
}
//另存为
bool BasicTransceiver::saveAs()
{
    QString fileName = QFileDialog::getSaveFileName(this,
                                                    tr("Save Data"), ".",
                                                    tr("Text File (*.txt)"));
    if (fileName.isEmpty()) {
        return false;
    }
    return saveFile(fileName);
}
//保存文件
bool BasicTransceiver::saveFile(const QString &fileName)
{
    if (!writeFile(fileName)) {
        statusBar()->showMessage(tr("Saving canceled"), 2000);
        return false;
    }
    statusBar()->showMessage(tr("Data saved"), 2000);
    return true;
}

bool BasicTransceiver::writeFile(const QString &fileName)
{
    QFile file(fileName);
    if (!file.open(QIODevice::WriteOnly | QFile::Text)) {
        QMessageBox::warning(this, tr("Save Data"),
                                                       tr("Cannot write file %1 : \n%2")
                                                       .arg(file.fileName())
                                                       .arg(file.errorString()));
        return false;
    }
    QTextStream out(&file);
    out << receiveTextBrowser->toPlainText();
    return true;
}

//打开文件的函数
void BasicTransceiver::open()
{
    QString fileName = QFileDialog::getOpenFileName(this,
                                                            tr("Choose Text File"), ".",
                                                            tr("Text File (*.txt)"));
    if (!fileName.isEmpty()) {
        loadFile(fileName);
    }
}
//加载文件
bool BasicTransceiver::loadFile(const QString &fileName)
{
    if (!readFile(fileName)) {
            statusBar()->showMessage(tr("Loading canceled"), 2000);
            return false;
        }
        statusBar()->showMessage(tr("Data loaded"), 2000);
        return true;
}
//读取文件
bool BasicTransceiver::readFile(const QString &fileName)
{
    QFile file(fileName);
        if (!file.open(QIODevice::ReadOnly)) {
            QMessageBox::warning(this, tr("Read failed"),
                                                     tr("Cannot read file %1 : \n%2.")
                                                     .arg(file.fileName())
                                                     .arg(file.errorString()));
            return false;
        }
        QTextStream in(&file);
        QObject *signalSender = sender();
        if (signalSender->objectName() == "actionRead_data"){
            receiveTextBrowser->setText(in.readAll());
        } else if (signalSender->objectName() == "actionChoose_file") {
            senderTextEdit_1->setText(in.readAll());
        }
        return true;
}

void BasicTransceiver::dragEnterEvent(QDragEnterEvent *event)
{
    if (event->mimeData()->hasFormat("text/uri-list"))
            event->acceptProposedAction();
}

void BasicTransceiver::dropEvent(QDropEvent *event)
{
    QList<QUrl> urls = event->mimeData()->urls();
        if (urls.isEmpty())
            return;
        QString fileName = urls.first().toLocalFile();
        if (fileName.isEmpty()){
            return;
        }
        loadFile(fileName);
}

程序完全是面向对象的，每个功能都是用相应函数实现的，这也提高了函数的重用性，程序比较大，不怎么好讲，都是一个一个功能的，比较好理解。

imkelt
关注
  • 46
    点赞
  • 踩
  • 274
    收藏
    觉得还不错? 一键收藏
  • 43
    评论
专栏目录
Qt版串口调试助手
09-02
Qt版本的串口调试助手,开发环境Qt5.6.1，windows和ubuntu两者都可以例用（验证），是基于Qt自带的串口类实现的。希望对和我一样的初学者有帮助。效果还不错，可以用噢，欢迎交流。
QT串口调试助手
03-27
实现功能： 1． 实现串口的自动检测，可接受和发送ASCII码字符串，支持发送接受汉字； 2． 实现发送和接收16进制字符（支持汉字），可显示发送和接受的时间，可自动换行及焦点锁定最后一行； 3． 实现状态栏显示发送和接受字节数，以及串口状态，可记录上次设置选项； 4． 重复发送时可设置发送间隔时间，实现每隔T ms发送一次消息，可记录以往发送的消息记录，点击可添加到发送区。 5. 界面控件可自行扩展铺满窗口，设置窗口背景颜色和图标
QT串口助手（二）：参数配置
zzssdd2的博客
01-25 2319
作者：zzssdd2 E-mail：zzssdd2@foxmail.com 一、前言 主要实现功能 串口参数的配置：波特率、数据位、停止位、校验位 本机串口设备的查询与添加显示 串口设备的手动更新与打开关闭 涉及的知识点 串口类QSerialPort及QSerialPortInfo的使用 自定义波特率的实现 QComboBox下拉列表自适应文本长度显示 控件QPushButton、QComboBox的使用 二、功能实现 下面开始逐步讲解以上列举的功能 2.1、串口设备的查询添加 创建一.
分享一款自己开发的串口调试助手（macOS系统，界面简介，使用方便）
三岁牧羊的博客
04-12 4079
Mac版本串口调试工具，界面简单，使用方便
【QT5】＜重点＞ QT串口编程
最新发布
致力于Linux的博客
06-13 1034
本篇记录QT串口编程相关内容，并制作一个串口助手来巩固理论知识。
QT—串口调试助手
qq_47944751的博客
02-09 1286
检测并列举系统中的可用串口配置波特率，校验位，停止位，数据位多文本发送启动串口发送数据接收数据。
基于QT的串口调试助手
weixin_45789941的博客
11-22 2201
基于QT的串口调试助手
qt6.3写的一个串口助手例子
08-02
有时候，我们经常需要打开多个串口助手或者多个串口同时发送数据，然后我在网上常见例子的基础上改动了一下，可以在一个窗口打开多个串口，并且可以同时发送数据，也可以单独发送。用的QT版本是qt6.3，需要在默认...
基于Qt和C++实现的串口助手+源码
04-01
例如指定收到0x16 0x00 0xFF 0x01需要回复0x16 0x00 0xFE 0x01，则只需要在SendData.txt中添加一条数据16 00 FF 01:16 00 FE 01即可。 可定时发送数据和保存数据到文本文件:，默认间隔5秒钟，可更改间隔时间。 在...
基于QT5.7给STM32F103进行串口升级的上位机源码
01-17
【基于QT5.7给STM32F103进行串口升级的上位机源码】是一个实用的软件开发项目，它利用了Qt 5.7框架来创建一个上位机工具，专用于通过串行接口（Serial Port）对STM32F103微控制器进行固件更新。这个过程称为串口IAP...
qt串口助手
01-13
之前写的关于qt实现串口助手博客，有人需要源码，由于当初是为项目需要些，里面有很多不必要的控制，现在重新整理了一份较为纯净的代码，和大家交流学习注意目录不要有中文路径名，尽量在顶层目录下编译，，源博客地址：http://blog.csdn.net/mao19931004/article/details/51852573
qt版串口助手
08-23
基于qt5实现的串口小助手，功能齐全，简单实用，适合初学者！
基于QT5开发漂亮的串口调试助手源码+详细注释+波形分析
12-17
基于QT Creator开发的兼容QT 5.6版本的（语言C++）串口调试助手源码，界面超级漂亮、功能齐全，接收区和来显示串口消息，在调试时，可指定串口、波特率、校验位、数据位、停止位，关闭串口和清空接收区、以十六进制调试、保存显示数据、在同一周期后自动发送数据、选择发送文件、计数器清零、串口调试波形图版,将接收到的数据以波形方式表示出来，非常直观，并且有很详细的源码注释。
QT 串口通讯助手
03-27
效果看https://blog.csdn.net/Sakuya__/article/details/88840809。该程序为串口助手，基于QT5编写。各种串口需要的功能都有，包括串口设置，hex和chr发送。源代码都在里面。
QT实现的串口助手（有界面，C++）
05-16
1.QT实现串口助手 2.收发数据，hex,string显示 3.自定义帧头帧尾，可显示帧长 4.显示收发次数，并可清零
Qt5.7 linux 串口调试助手 图形界面
11-23
基于Qt5.7 ubuntu16.04开发，串口调试助手。多功能默认按钮配置，简单方便。
QT5.7串口助手
12-23
QT5.7串口助手是一款基于QT5.7框架开发的实用工具，主要功能是提供串行通信的支持，便于用户进行数据的发送和接收。在本文中，我们将深入探讨QT5.7框架以及如何利用它来创建串口助手，同时也会涉及到串口通信的基本...
QT编写串口助手
weixin_43999800的博客
12-09 206
QT编写串口助手 1.pro文件添加中serialport
用Qt写一个网络串口助手
05-29
2. 在项目中添加一个串口类和网络类，以便使用串口和网络功能。您可以使用 Qt 的 QSerialPort 类和 QTcpSocket 类。 3. 创建一个用户界面，包括串口和网络设置、数据发送和接收窗口等。您可以使用 Qt Designer 工具...
评论 43
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值