基于QT的“串口调试工具”源码

一、ui界面制作如下截图

二、程序源码

1、circular_buffer.cpp

#include "circular_buffer.h"
#include "protocol.h"

 
Circular_buffer::Circular_buffer()
{
    m_recv_msg_buffer[BUFFER_MAX_LINE] = {0};
    m_pointer_write = 0;
    m_pointer_read  = 0;
    m_read_byte     = 0;
}

 
Circular_buffer::~Circular_buffer()
{
}

 
void Circular_buffer::write_circular_buffer(char write_byte)
{
    m_pointer_write %= BUFFER_MAX_LINE;
    m_recv_msg_buffer[m_pointer_write++] = write_byte;
}

 
char Circular_buffer::read_circular_buffer(void)
{
    m_pointer_read %= BUFFER_MAX_LINE;
    m_read_byte = m_recv_msg_buffer[m_pointer_read];
    m_recv_msg_buffer[m_pointer_read] = 0;
    m_pointer_read++;
    return m_read_byte;
}

 
void Circular_buffer::cpynbyte2buffer(char *data,char len)
{
    int i = 0;
    for(i = 0; i < len; i++)
    {
        write_circular_buffer(data[i]);
    }
}

 
void Circular_buffer::traverse_circular_buffer(void)
{
}

2、main.cpp

#include "mainwindow.h"
#include <QApplication>

 
#include <QFile>

 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

 
    QFile skinFile(":/new/skins.css");
    if(skinFile.open(QIODevice::ReadOnly))
    {
        a.setStyleSheet(skinFile.readAll());
        skinFile.close();
    }

 
    MainWindow w;
    w.show();

 
    return a.exec();
}

3、mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

 
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    m_flag_recv(false)
{
    ui->setupUi(this);
    connect(ui->pb_open_com,SIGNAL(clicked()),this,SLOT(Slot_Open_com()));
    ui->te_recv_text->append(tr("检测到端口列表："));
    foreach(const QSerialPortInfo &info,QSerialPortInfo::availablePorts())
    {
        QSerialPort serial_port;
        serial_port.setPort(info);
        if(serial_port.open(QIODevice::ReadWrite))
        {
            ui->cb_com_port->addItem(info.portName());
            ui->te_recv_text->append(info.portName());
            ui->te_recv_text->append(info.description());
            serial_port.close();
        }
    }
    m_clock = new QTimer(this);
    connect(m_clock, SIGNAL(timeout()), this, SLOT(Slot_Clock_Update()));
    m_clock->start(1000);
    ui->cb_baud_rate->setCurrentIndex(3);                     //默认波特率是9600
    ui->cb_data_bit->setCurrentIndex(3);                      //默认数据位是8位
    ui->pb_open_com->setText(tr("打开串口"));
    ui->pb_send->setEnabled(false);
    m_sendMsg = new Protocol();
    m_circularBuffer = new Circular_buffer();
}
MainWindow::~MainWindow()
{
    delete ui;
}
void MainWindow::Slot_My_readusart()
{
    QByteArray resquesdata;
    resquesdata = m_serialport->readAll();
    if(resquesdata != NULL)
    {
        for(int i = 0; i < resquesdata.size(); i++)
        {
            m_circularBuffer->write_circular_buffer(resquesdata.at(i));
        }
        ui->te_recv_text->append(tr(resquesdata));
    }
    resquesdata.clear();
}
void MainWindow::Slot_Timer_Update()
{
    int data_n = 0;
    Protocol recvMsg;
    if(m_circularBuffer->read_circular_buffer() == BGN_RESD_MSG)
    {
        recvMsg.m_potocol_len     = m_circularBuffer->read_circular_buffer();
        recvMsg.m_device     = m_circularBuffer->read_circular_buffer();
        recvMsg.m_device_cmd     = m_circularBuffer->read_circular_buffer();
        recvMsg.m_data_len       = m_circularBuffer->read_circular_buffer();
        if(recvMsg.m_data_len > 0)
        {
            recvMsg.m_data = (char *)malloc(sizeof(char)*recvMsg.m_data_len);
            for(data_n = 0; data_n < recvMsg.m_data_len; data_n++)
            {
                recvMsg.m_data[data_n] = m_circularBuffer->read_circular_buffer();
            }
        }else
        {
            m_circularBuffer->read_circular_buffer();
        }
        if(m_circularBuffer->read_circular_buffer() == END_RESD_MSG)
        {
            analyticalMsg(recvMsg);
        }
    }
}
void MainWindow::analyticalMsg(Protocol &recvMsg)
{
    switch(recvMsg.m_device)
    {
    case MODULE_BEEP:     exec_module_beep(recvMsg); break;
    case MODULE_LED:      exec_module_led(recvMsg); break;
    case MODULE_NOTE:     exec_module_note(recvMsg); break;
    case MODULE_LCD12864: exec_module_12864(recvMsg); break;
    case MODULE_INFRARED: exec_module_infrared(recvMsg); break;
    }
}
void MainWindow::Slot_Open_com()
{
    if(ui->pb_open_com->text()==tr("打开串口"))
    {
        m_serialport = new QSerialPort();
        m_serialport->setPortName(ui->cb_com_port->currentText());
        m_serialport->open(QIODevice::ReadWrite);
        m_serialport->setBaudRate(ui->cb_baud_rate->currentText().toInt());
        switch(ui->cb_data_bit->currentIndex())
        {
        case 0: m_serialport->setDataBits(QSerialPort::Data5);break;
        case 1: m_serialport->setDataBits(QSerialPort::Data6);break;
        case 2: m_serialport->setDataBits(QSerialPort::Data7);break;
        case 3: m_serialport->setDataBits(QSerialPort::Data8);break;
        default: break;
        }
        switch(ui->cb_stop_bit->currentIndex())
        {
        case 0: m_serialport->setStopBits(QSerialPort::OneStop);break;
        case 1: m_serialport->setStopBits(QSerialPort::OneAndHalfStop);break;
        case 2: m_serialport->setStopBits(QSerialPort::TwoStop);break;
        default: break;
        }
        switch(ui->cb_crc_test->currentIndex())
        {
        case 0: m_serialport->setParity(QSerialPort::NoParity);break;
        case 1: m_serialport->setParity(QSerialPort::OddParity);break;
        case 2: m_serialport->setParity(QSerialPort::EvenParity);break;
        case 3: m_serialport->setParity(QSerialPort::MarkParity);break;
        case 4: m_serialport->setParity(QSerialPort::SpaceParity);break;
        default: break;
        }
        switch(ui->cb_flow_control->currentIndex())
        {
        case 0: m_serialport->setFlowControl(QSerialPort::NoFlowControl);break;
        case 1: m_serialport->setFlowControl(QSerialPort::HardwareControl);break;
        case 2: m_serialport->setFlowControl(QSerialPort::SoftwareControl);break;
        case 3: m_serialport->setFlowControl(QSerialPort::UnknownFlowControl);break;
        default: break;
        }
        connect(m_serialport,SIGNAL(readyRead()),
                this,SLOT(Slot_My_readusart()));
        connect(m_sendMsg,SIGNAL(signal_sendMsg(QByteArray&)),
                this,SLOT(Slot_sendMsg(QByteArray&)));
        m_timer = new QTimer(this);
        connect(m_timer, SIGNAL(timeout()), this, SLOT(Slot_Timer_Update()));
        m_timer->start(5);
        ui->cb_com_port->setEnabled(false);
        ui->cb_baud_rate->setEnabled(false);
        ui->cb_data_bit->setEnabled(false);
        ui->cb_stop_bit->setEnabled(false);
        ui->cb_crc_test->setEnabled(false);
        ui->cb_flow_control->setEnabled(false);
        ui->lb_statu_flag->setStyleSheet("background-color:red");
        ui->pb_open_com->setText(tr("关闭串口"));
        ui->pb_send->setEnabled(true);
    }else
    {
        if (m_timer->isActive())
        {
            m_timer->stop();
        }
        m_serialport->clear();
        m_serialport->deleteLater();
        ui->cb_com_port->setEnabled(true);
        ui->cb_baud_rate->setEnabled(true);
        ui->cb_data_bit->setEnabled(true);
        ui->cb_stop_bit->setEnabled(true);
        ui->cb_crc_test->setEnabled(true);
        ui->cb_flow_control->setEnabled(true);
        ui->lb_statu_flag->setStyleSheet("background-color:rgb(130,130,130)");
        ui->pb_open_com->setText(tr("打开串口"));
        ui->pb_send->setEnabled(false);
    }
}
void MainWindow::Slot_sendMsg(QByteArray &byteArray)
{
    qDebug() << "Send: " << byteArray.toHex();
    m_serialport->write(byteArray);
}
void MainWindow::exec_module_beep(Protocol &protocol)
{
    switch(protocol.m_device_cmd)
    {
    case CMD_BEEP_ON:  break;
    case CMD_BEEP_OFF: break;
    }
}
void MainWindow::exec_module_led(Protocol &protocol)
{
    switch(protocol.m_device_cmd)
    {
    case CMD_LED_ON:  break;
    case CMD_LED_OFF: break;
    }
}
void MainWindow::exec_module_note(Protocol &protocol)
{
    switch(protocol.m_device_cmd)
    {
    case CMD_NOTE_ON:  break;
    case CMD_NOTE_OFF: break;
    }
}
void MainWindow::exec_module_12864(Protocol &protocol)
{
    switch(protocol.m_device_cmd)
    {
    case CMD_LCD12864_ON:  break;
    case CMD_LCD12864_OFF: break;
    }
}
void MainWindow::exec_module_infrared(Protocol &protocol)
{
    switch(protocol.m_device_cmd)
    {
    case CMD_INFRARED_ON:  break;
    case CMD_INFRARED_OFF: break;
    }
}
void MainWindow::on_pb_led_clicked()
{
    if(ui->pb_led->text() == tr("开"))
    {
        m_sendMsg->send_data(MODULE_LED, CMD_LED_ON);
        ui->pb_led->setText(tr("关"));
    }else if(ui->pb_led->text() == tr("关"))
    {
        m_sendMsg->send_data(MODULE_LED, CMD_LED_OFF);
        ui->pb_led->setText(tr("开"));
    }
}
void MainWindow::on_pb_beep_clicked()
{
    if(ui->pb_beep->text() == tr("开"))
    {
        m_sendMsg->send_data(MODULE_BEEP, CMD_BEEP_ON);
        ui->pb_beep->setText(tr("关"));
    }else if(ui->pb_beep->text() == tr("关"))
    {
        m_sendMsg->send_data(MODULE_BEEP, CMD_BEEP_OFF);
        ui->pb_beep->setText(tr("开"));
    }

 
}

 
void MainWindow::on_pb_note_send_clicked()
{
    if(ui->pb_note_send->text() == tr("开"))
    {
        m_sendMsg->send_data(MODULE_NOTE, CMD_NOTE_ON);
        ui->pb_note_send->setText(tr("关"));
    }else if(ui->pb_note_send->text() == tr("关"))
    {
        m_sendMsg->send_data(MODULE_NOTE, CMD_NOTE_OFF);
        ui->pb_note_send->setText(tr("开"));
    }
}
void MainWindow::on_pb_lcd12864_clicked()
{
    if(ui->pb_lcd12864 ->text() == tr("开"))
    {
        m_sendMsg->send_data(MODULE_LCD12864, CMD_LCD12864_ON);
        ui->pb_lcd12864->setText(tr("关"));
    }else if(ui->pb_lcd12864->text() == tr("关"))
    {
        m_sendMsg->send_data(MODULE_LCD12864, CMD_LCD12864_OFF);
        ui->pb_lcd12864->setText(tr("开"));
    }
}
void MainWindow::on_pb_test_people_clicked()
{
    if(ui->pb_test_people->text() == tr("开"))
    {
        m_sendMsg->send_data(MODULE_INFRARED, CMD_INFRARED_ON);
        ui->pb_test_people->setText(tr("关"));
    }else if(ui->pb_test_people->text() == tr("关"))
    {
        m_sendMsg->send_data(MODULE_INFRARED, CMD_INFRARED_OFF);
        ui->pb_test_people->setText(tr("开"));
    }
}

 
void MainWindow::on_pb_send_clicked()
{
    if(ui->pb_send->text() == tr("开"))
    {
        ui->pb_send->setText(tr("关"));
    }else if(ui->pb_send->text() == tr("关"))
    {
        ui->pb_send->setText(tr("开"));
    }
}
void MainWindow::Slot_Clock_Update()
{
    QTime time = QTime::currentTime();
    QString text = time.toString("hh:mm");
    if ((time.second() % 2) == 0)
    {
        text[2] = ' ';
    }
    ui->lb_time->setText(text);
}

`4、protocol.cpp`

#include "protocol.h"
Protocol::Protocol(void)
{
    clearProtocoldata();
}
Protocol::~Protocol(void)
{

 
}
void Protocol::send_data(char drive, char drive_cmd, char data_len, char *data)
{
    if(data_len > 0)
    {
        m_potocol_len 	= PROTOCOL_BASIC_SIZE + data_len - 1;
    }else
    {
        m_potocol_len 	= PROTOCOL_BASIC_SIZE;
    }
    m_device        = drive;
    m_device_cmd 	= drive_cmd;
    m_data_len 		= data_len;
    m_data 			= data;
    QByteArray send_array;
    send_array.append(m_send_begin);
    send_array.append(m_potocol_len);
    send_array.append(m_device);
    send_array.append(m_device_cmd);
    send_array.append(m_data_len);
    if(m_data_len > 0)
    {
        for(int i = 0; i < m_data_len; i++)
        {
            send_array.append(m_data[i]);
        }
    }else
    {
        send_array.append('\0');
    }
    send_array.append(m_send_end);
    emit signal_sendMsg(send_array);
}
void Protocol::clearProtocoldata(void)
{
    m_send_begin    = BGN_RESD_MSG;
    m_potocol_len   = PROTOCOL_BASIC_SIZE;
    m_device        = PROTOCOL_FULL_CMD;
    m_device_cmd    = PROTOCOL_FULL_CMD;
    m_data_len      = PROTOCOL_ZERO_LEN;
    m_data          = PROTOCOL_FULL_DATA;
    m_send_end      = END_RESD_MSG;
}
void Protocol::printProtocoldata(void)
{
    qDebug() << "起始标志: " << m_send_begin;						//起始标志 	以“@”开始
    qDebug() << "信息长度: " << m_potocol_len;					//信息长度   	可变长
    qDebug() << "模块命令: " << m_device_cmd;						//模块命令   	以大写字母 A~Z 为命令
    qDebug() << "数据长度: " << m_data_len;						//数据长度   	没有为0
    for(int i = 0; i < 5; i++)
    {
        qDebug() << "数据内容: " << m_data[i];				    //数据		没有指向空
    }
    qDebug() << "结束标志: " << m_send_end;						//结束标志	以“#”结束
}

原文链接：https://blog.csdn.net/lidongli1060939183/article/details/85618410