RK3588使用笔记：ubuntu/麒麟系统功能测试程序

已于 2025-03-31 00:36:07 修改
阅读量889 收藏 9
点赞数 27
分类专栏： # 瑞芯微RK3588 文章标签： 笔记 qt测试程序 qt linux demo
于 2025-03-31 00:31:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37603131/article/details/146780930
版权

一、前言

本编文章记录在使用嵌入式系统中的一些功能测试demo程序，大部分都是AI写的，哈哈哈，确实很有帮助，但是得根据自身设备实际情况和知道如何问AI，才能得出你想要的结果，本文就记录一些ubuntu/麒麟系统实际使用过程中测试程序。

目录

1.串口测试程序

2.CAN测试程序

3.背光测试程序（弥补系统pwm匹配异常）

4.电量获取程序（弥补底系统版本不支持电池管理）

5.GPIO测试程序控制状态led灯

6.时间测试程序

7.redis通信测试程序

8.温度、CPU主频测试程序

9.msata挂载稳定性测试程序

二、环境

RK3588（linux5.10.66+debian/ubuntu/麒麟是桌面文件系统）

调试笔记本window10，安装常用工具winscp，xshell，finalshell，secureRTP等等

VMware17+Ubuntu20.04源码开发环境（这里就依赖于各个硬件平台的厂家提供资料了）

QT5.7 

三、正文

程序都是QT环境开发的程序，程序内容放的都是核心代码，相关头文件简单补充，或者直接参考核心代码继续询问AI即可，大部分AI都是可以解决的

统一说明main.cpp引用了全局函数MySleep（），common.h也都是头文件

main.cpp

​//延时usetime：非阻塞时间  waittime：阻塞时间
void MySleep(uint usetime,ulong waittime)
{
    QCoreApplication::processEvents(QEventLoop::AllEvents, usetime);//进入此函数内给之前数据usetime毫秒时间处理，处理完立马退出执行之后，超时立马退出
    QThread::msleep(waittime);//阻塞延时waittime毫秒
}

 common.h

#ifndef COMMON_H
#define COMMON_H
#include <QVector>
#include <QMap>
#include <QApplication>
#include <QMainWindow>
#include <QtSql>
#include <QSqlQuery>
#include <QSqlTableModel>
#include <QDebug>
#include <QFile>
#include <QFileDialog>
#include <QMessageBox>
#include <QProcess>
#include <QPixmap>
#include <QPaintEvent>
#include <QPainter>
#include <QScrollBar>
#include <QTableWidget>
#include <QListWidgetItem>
#include <QTimer>
#include <QTime>
#include <QSystemTrayIcon>
#include <QGridLayout>
#include <QPushButton>
#include <QDoubleSpinBox>
#include <QAbstractItemView>
#include <QDoubleSpinBox>
#include <QThread>

extern void MySleep(uint usetime,ulong waittime);

#endif // COMMON_H
1.串口测试程序
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent)
  , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    this->setWindowModality(Qt::ApplicationModal);
    this->setWindowTitle("RK3588 串口接口测试软件V1.0/20241016");

    //初始化串口
    open_serialport(0,NULL);//初始化串口
    connect(ui->pushButton_refresh,&QPushButton::clicked,[=](){//刷新串口按键回调函数
        ui->comboBox->clear();
        //遍历当前存在的串口端口号
        if(!serial->portName().isNull())ui->comboBox->addItem(serial->portName());//显示已经开启的串口到列表
        foreach(const QSerialPortInfo &info, QSerialPortInfo::availablePorts()){
            QSerialPort serial;
            serial.setPort(info);
            if(serial.open(QIODevice::ReadWrite)){
                ui->comboBox->addItem(serial.portName());
                serial.close();
            }
        }
    });
    QTimer::singleShot(100,this,[=](){ui->pushButton_refresh->click();});//点击一次按键
    timeserialCOM=new QTimer(this);
    connect(timeserialCOM,&QTimer::timeout,[=](){
        timeserialCOM->stop();
        comBatAnalyze(allDataCOM);//处理串口得到的数据
    });

    //发送数据
    connect(ui->btn_send_1,&QPushButton::clicked,[=](){
        if(serial->isOpen()){
            QByteArray sd=QByteArray::fromHex("11223344556677889900aabbccddeeffAABBCCDDEEFF");
            serial->write(sd);
        }
    });
    QTimer *time1=new QTimer(this);
    time1->start(10);
    connect(time1,&QTimer::timeout,[=](){
       if(ui->checkBox_1->isChecked())ui->btn_send_1->click();
    });

    //清空数据
    connect(ui->btn_clear_1,&QPushButton::clicked,[=](){
        ui->textEdit_1->clear();
    });

}

MainWindow::~MainWindow()
{
    serial->clear();//先关闭之前的串口
    serial->close();
    delete ui;
}

//初始化/复位串口
void MainWindow::open_serialport(bool reset,QString comstr)
{
    if(reset){
        serial->clear();//先关闭之前的串口
        serial->close();
    }
    serial = new QSerialPort(comstr,this);
    serial->open(QIODevice::ReadWrite);//读写打开
    serial->setBaudRate(QSerialPort::Baud115200);  //波特率QSerialPort::Baud9600
    serial->setDataBits(QSerialPort::Data8); //数据位
    serial->setParity(QSerialPort::NoParity);    //无奇偶校验
    serial->setStopBits(QSerialPort::OneStop);   //1停止位
    serial->setFlowControl(QSerialPort::NoFlowControl);  //无控制
    connect(serial,SIGNAL(readyRead()),this,SLOT(serialRead()));//连接串口读取函数
    bool open=serial->isOpen();
    if(open){
        ui->comboBox->setCurrentText(comstr);
        if(comstr.isNull())ui->label_324->setText("当前未开启串口，请选择");
        else ui->label_324->setText("当前开启串口："+comstr);
    }
    else{
        if(comstr.isNull())ui->label_324->setText("当前未开启串口，请选择");
        else ui->label_324->setText("串口打开失败，无效或被占用");
    }
}
void MainWindow::serialRead()
{
    timeserialCOM->start(10);//设置判断10ms内接收完毕数据，在处理
    while (!serial->atEnd()){
        allDataCOM += serial->readAll().toHex();
    }
}

void MainWindow::comBatAnalyze(QByteArray &allData)
{
    QByteArray dataTemp;
    dataTemp=allData.toUpper();
//    qDebug()<<"comBatAnalyze:"<<dataTemp;

    QString str;
    QByteArray aaa=QByteArray::fromHex(dataTemp);
    for(int i=0;i<aaa.size();i++)str.append(QString("%1 ").arg((uchar)aaa[i],2,16,QChar('0')).toUpper());
    ui->textEdit_1->append(QDateTime::currentDateTime().toString("hh:mm:ss zzz : ")+str);

    dataTemp.clear();//若没有需求的数据，则清除整个数据内容，重新接收判断
    allData=dataTemp;
}

void MainWindow::on_comboBox_activated(const QString &arg1)
{
    open_serialport(1,arg1);//重新连接选择的串口
    ui->pushButton_refresh->click();//点击一次按键刷新串口资源
}

2.CAN测试程序
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent)
  , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    this->setWindowModality(Qt::ApplicationModal);
    this->setWindowTitle("RK3588 CAN接口测试软件V1.0/20240925");

#ifndef WINDOWS
    //新建CAN连接//开启原生CAN2路
    startcan(0);//开启CAN0
    startcan(1);//开启CAN1
#endif
    MySleep(1000,500);
    //新建CAN连接//开启图莫斯1个CAN盒2路 CAN3 CAN4
    canThread=new canRevThread(this);
    connect(canThread,&canRevThread::threadRev1,this,&MainWindow::canAnalyze3);
    connect(canThread,&canRevThread::threadRev2,this,&MainWindow::canAnalyze4);
    canThread->start();

    //发送数据
    connect(ui->btn_send_1,&QPushButton::clicked,[=](){
        sendcan12(0);
    });
    connect(ui->btn_send_2,&QPushButton::clicked,[=](){
        sendcan12(1);
    });
    connect(ui->btn_send_3,&QPushButton::clicked,[=](){
        sendcan3();
    });
    connect(ui->btn_send_4,&QPushButton::clicked,[=](){
        sendcan4();
    });
    QTimer *time1=new QTimer(this);
    time1->start(10);
    connect(time1,&QTimer::timeout,[=](){
       if(ui->checkBox_1->isChecked())ui->btn_send_1->click();
       if(ui->checkBox_2->isChecked())ui->btn_send_2->click();
       if(ui->checkBox_3->isChecked())ui->btn_send_3->click();
       if(ui->checkBox_4->isChecked())ui->btn_send_4->click();
    });

    //清空数据
    connect(ui->btn_clear_1,&QPushButton::clicked,[=](){
        ui->textEdit_1->clear();
    });
    connect(ui->btn_clear_2,&QPushButton::clicked,[=](){
        ui->textEdit_2->clear();
    });
    connect(ui->btn_clear_3,&QPushButton::clicked,[=](){
        ui->textEdit_3->clear();
    });
    connect(ui->btn_clear_4,&QPushButton::clicked,[=](){
        ui->textEdit_4->clear();
    });


}

MainWindow::~MainWindow()
{
    stopcan();//程序退出，关闭当前开启的CAN1/2
    canThread->stopThread();//程序退出，关闭当前开启的CAN3/4
    delete ui;
}
///can1/2通讯配置（系统自带CAN2路）/
//开启can1/2
void MainWindow::startcan(int v)
{
#ifndef WINDOWS
    if(v == 0){
//        setuid(0);
        system("sudo ifconfig can0 down");
        system("sudo ip link set can0 up type can bitrate 500000 triple-sampling on");
        system("sudo ifconfig can0 up");

        //创建套接字
        //PF_CAN 为域位 同网络编程中的AF_INET 即ipv4协议
        //SOCK_RAW使用的协议类型 SOCK_RAW表示原始套接字 报文头由自己创建
        //CAN_RAW为使用的具体协议 为can总线协议
        socket1 =  ::socket(PF_CAN,SOCK_RAW,CAN_RAW);//创建套接字

        struct ifreq ifr;//接口请求结构体
        strcpy((char *)(ifr.ifr_name),v == 0 ? "can0" : "can1");//判断开启的是can0/1

        //fcntl(socket, F_SETFL, 1);        //标志FNDELAY可以保证read函数在端口上读不到字符的时候返回0
        fcntl(socket1, F_SETFL, 0);            //回到正常（阻塞）模式

        ioctl(socket1,SIOCGIFINDEX,&ifr);//指定 CAN0/1 设备

        addr1.can_family = AF_CAN;//协议类型
        addr1.can_ifindex = ifr.ifr_ifindex;//can总线外设的具体索引 类似 ip地址
        bind(socket1,(struct sockaddr*)&addr1,sizeof(addr1));//将套接字和canbus外设进行绑定,即套接字与 can0/1 绑定

        //禁用过滤规则，进程不接收报文，只负责发送,如需接受注释掉此函数即可
        //setsockopt(stSocket_LO, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

        t1 = NULL;
        t1 = new Thread(socket1);//开启单独线程接受监听
        connect(t1,SIGNAL(message(QString,int,QString)),this,SLOT(msg1(QString,int,QString)));
        t1->start();
    }
    else{
//        setuid(0);
        system("sudo ifconfig can1 down");
        system("sudo ip link set can1 up type can bitrate 500000 triple-sampling on");
        system("sudo ifconfig can1 up");

        //创建套接字
        //PF_CAN 为域位 同网络编程中的AF_INET 即ipv4协议
        //SOCK_RAW使用的协议类型 SOCK_RAW表示原始套接字 报文头由自己创建
        //CAN_RAW为使用的具体协议 为can总线协议
        socket2 =  ::socket(PF_CAN,SOCK_RAW,CAN_RAW);//创建套接字

        struct ifreq ifr;//接口请求结构体
        strcpy((char *)(ifr.ifr_name),v == 0 ? "can0" : "can1");//判断开启的是can0/1

        //fcntl(socket, F_SETFL, 1);        //标志FNDELAY可以保证read函数在端口上读不到字符的时候返回0
        fcntl(socket2, F_SETFL, 0);            //回到正常（阻塞）模式

        ioctl(socket2,SIOCGIFINDEX,&ifr);//指定 CAN0/1 设备

        addr2.can_family = AF_CAN;//协议类型
        addr2.can_ifindex = ifr.ifr_ifindex;//can总线外设的具体索引 类似 ip地址
        bind(socket2,(struct sockaddr*)&addr2,sizeof(addr2));//将套接字和canbus外设进行绑定,即套接字与 can0/1 绑定

        //禁用过滤规则，进程不接收报文，只负责发送,如需接受注释掉此函数即可
        //setsockopt(stSocket_LO, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

        t2 = NULL;
        t2 = new Thread(socket2);//开启单独线程接受监听
        connect(t2,SIGNAL(message(QString,int,QString)),this,SLOT(msg2(QString,int,QString)));
        t2->start();
    }
#endif
}
void MainWindow::stopcan()
{
#ifndef WINDOWS
    if(t1){//如果线程已经开启，关闭线程
        t1->stop();
        t1->deleteLater();
    }
    if(t2){//如果线程已经开启，关闭线程
        t2->stop();
        t2->deleteLater();
    }
    ::close(socket1);
    ::close(socket2);
    system("sudo ifconfig can0 down");//关闭CAN0
    system("sudo ifconfig can1 down");//关闭CAN1
#endif
}
void MainWindow::sendcan12(int v)
{
#ifndef WINDOWS
    struct can_frame frame;
    memset(&frame,0,sizeof(struct can_frame));
    if(v==0){
//        frame.can_id = (0x00123456 & CAN_EFF_MASK) | CAN_EFF_FLAG;//扩展帧
        frame.can_id = (0x11 & CAN_SFF_MASK);//标准帧
        frame.can_dlc= 8;
        frame.data[0]= 0x11;
        frame.data[1]= 0xaa;
        frame.data[2]= 0x11;
        frame.data[3]= 0xaa;
        frame.data[4]= 0x11;
        frame.data[5]= 0xaa;
        frame.data[6]= 0x11;
        frame.data[7]= 0xaa;
    }
    else{
//        frame.can_id = (0x00abcdef & CAN_EFF_MASK) | CAN_EFF_FLAG;//扩展帧
        frame.can_id = (0x22 & CAN_SFF_MASK);//标准帧
        frame.can_dlc= 8;
        frame.data[0]= 0x22;
        frame.data[1]= 0xbb;
        frame.data[2]= 0x22;
        frame.data[3]= 0xbb;
        frame.data[4]= 0x22;
        frame.data[5]= 0xbb;
        frame.data[6]= 0x22;
        frame.data[7]= 0xbb;
    }
    //发送can数据：方式一
    //sendto(socket,&frame,sizeof(struct can_frame),0,(struct sockaddr*)&addr,sizeof(addr));
    //发送can数据：方式二
    if(v==0)write(socket1, &frame, sizeof(frame)); //发送 frame
    else write(socket2, &frame, sizeof(frame)); //发送 frame
    return;
#endif
}
//can1接收槽函数
void MainWindow::msg1(QString addr,int num,QString data)
{
    QString str = QString("%1\r\n%2,%3,%4").arg(QDateTime::currentDateTime().toString("hh:mm:ss zzz")).arg(addr).arg(num).arg(data);
    ui->textEdit_1->append(str);
}
//can2接收槽函数
void MainWindow::msg2(QString addr,int num,QString data)
{
    QString str = QString("%1\r\n%2,%3,%4").arg(QDateTime::currentDateTime().toString("hh:mm:ss zzz")).arg(addr).arg(num).arg(data);
    ui->textEdit_2->append(str);
}

///can3/4通讯配置(图莫斯1个盒2路)/
//发送can3
void MainWindow::sendcan3()
{
    CAN_MSG CanMsg;
    CanMsg.ExternFlag = 0;//是否是扩展帧
    CanMsg.RemoteFlag = 0;//是否是远程帧
    CanMsg.ID = 0x33;
    CanMsg.DataLen = 8;
    CanMsg.Data[0]=0x33;
    CanMsg.Data[1]=0xcc;
    CanMsg.Data[2]=0x33;
    CanMsg.Data[3]=0xcc;
    CanMsg.Data[4]=0x33;
    CanMsg.Data[5]=0xcc;
    CanMsg.Data[6]=0x33;
    CanMsg.Data[7]=0xcc;
    canThread->sendcanData(0,CanMsg);
}
//发送can4
void MainWindow::sendcan4()
{
    CAN_MSG CanMsg;
    CanMsg.ExternFlag = 0;//是否是扩展帧
    CanMsg.RemoteFlag = 0;//是否是远程帧
    CanMsg.ID = 0x44;
    CanMsg.DataLen = 8;
    CanMsg.Data[0]=0x44;
    CanMsg.Data[1]=0xdd;
    CanMsg.Data[2]=0x44;
    CanMsg.Data[3]=0xdd;
    CanMsg.Data[4]=0x44;
    CanMsg.Data[5]=0xdd;
    CanMsg.Data[6]=0x44;
    CanMsg.Data[7]=0xdd;
    canThread->sendcanData(1,CanMsg);
}
//处理can3数据
void MainWindow::canAnalyze3(CAN_MSG *CanMsgtmp,char dwRel)
{
    for(int i = 0 ; i < dwRel ; i++){
         QString address=QString().sprintf("%08X",CanMsgtmp[i].ID&0x7fffffff);
         QString datastr=NULL;
         for(int j=0;j<CanMsgtmp[i].DataLen;j++)
             datastr.append(QString().sprintf("%02X",CanMsgtmp[i].Data[j]));
         QString str = QString("%1\r\n%2,%3,%4").arg(QDateTime::currentDateTime().toString("hh:mm:ss zzz")).arg(address).arg(CanMsgtmp[i].DataLen).arg(datastr);
         ui->textEdit_3->append(str);
    }
}
//处理can4数据
void MainWindow::canAnalyze4(CAN_MSG *CanMsgtmp, char dwRel)
{
    for(int i = 0 ; i < dwRel ; i++){
         QString address=QString().sprintf("%08X",CanMsgtmp[i].ID&0x7fffffff);
         QString datastr=NULL;
         for(int j=0;j<CanMsgtmp[i].DataLen;j++)
             datastr.append(QString().sprintf("%02X",CanMsgtmp[i].Data[j]));
         QString str = QString("%1\r\n%2,%3,%4").arg(QDateTime::currentDateTime().toString("hh:mm:ss zzz")).arg(address).arg(CanMsgtmp[i].DataLen).arg(datastr);
         ui->textEdit_4->append(str);
    }
}

 mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include "common.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
	
protected:

private slots:
    //CAN12 linux自带的socketcan
    void sendcan12(int v);
    void stopcan();
    void startcan(int v);
    void msg1(QString addr, int num, QString data);
    void msg2(QString addr, int num, QString data);
    //CAN34 USB扩展图莫斯can
    void sendcan3();
    void sendcan4();
    void canAnalyze3(CAN_MSG *CanMsgtmp, char dwRel);
    void canAnalyze4(CAN_MSG *CanMsgtmp, char dwRel);



private:
    Ui::MainWindow *ui;

#ifndef WINDOWS
    int socket1;
    struct sockaddr_can addr1;//can总线的地址 同socket编程里面的 socketaddr结构体 用来设置can外设的信息
    Thread *t1;
    int socket2;
    struct sockaddr_can addr2;//can总线的地址 同socket编程里面的 socketaddr结构体 用来设置can外设的信息
    Thread *t2;
#endif


    canRevThread *canThread;

};

#endif // MAINWINDOW_H

 thread

cpp
#include "thread.h"
#include "mainwindow.h"
Thread::Thread(int s,QObject *parent) :
    QThread(parent)
{
    socket  = s;
    running = true;
}

void Thread::run()
{
#ifndef WINDOWS
    //qDebug()<<"start can receive Thread!";
    int nbytes;
//    int len;
    struct can_frame frame;
//    struct sockaddr_can addr;
//    char buf[8];

    while(running){
//        nbytes=recvfrom(socket,&frame,sizeof(struct can_frame),0,(struct sockaddr *)&addr,(socklen_t*)&len);
        //接收can数据：方式一
//        if(nbytes>0){
//            memset(buf,0,8);
//            strncpy(buf,(char*)frame.data,8);
//            //emit message(&addr,&len);
//             printf("id=%x,len=%d\n",(struct sockaddr *)&addr,(socklen_t*)&len);
//        }
        //接收can数据：方式二
          nbytes = read(socket, &frame, sizeof(frame)); //接收报文
          if(nbytes > 0){
              QString address=QString().sprintf("%08X",frame.can_id&0x7fffffff);
              QString data=NULL;
              for(int i=0;i<frame.can_dlc;i++)
                  data.append(QString().sprintf("%02X",frame.data[i]));
              emit message(address,frame.can_dlc,data);
//            printf("iiid=%x,len=%d,data=%x%x%x%x%x%x%x%x\n",frame.can_id&0x7fffffff,frame.can_dlc,frame.data[0],frame.data[1],frame.data[2],frame.data[3],frame.data[4],frame.data[5],frame.data[6],frame.data[7]);
          }
    }
#endif
}

void Thread::stop()
{
    running = false;
}

h
#ifndef THREAD_H
#define THREAD_H

#include <QThread>


#ifndef WINDOWS
extern "C" {
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <linux/can.h>
}
#endif


#ifndef PF_CAN
#define PF_CAN 29
#endif

#ifndef AF_CAN
#define AF_CAN PF_CAN
#endif

class Thread : public QThread
{
    Q_OBJECT
public:
    explicit Thread(int s,QObject *parent = 0);
    
signals:
    void message(QString addr,int num,QString data);
public slots:
    void run();
    void stop();

private:
    int socket;
    bool running;

};

#endif // THREAD_H

 usbcanthread

cpp
#include "canrevthread.h"
#include <QMessageBox>

canRevThread::canRevThread( QObject *parent):QThread(parent)
{
    DevHandle=0x04ff;
    stopped = 1;

    bool state;
    int ret;
    int DevHdle[10];
    //扫描查找设备
    ret = USB_ScanDevice(DevHdle);
    if(ret <= 0){
        qDebug()<<QString().sprintf("No device connected!");
        stopped=0;
        return;
    }
    else{
        qDebug()<<"handle:"<<DevHdle[0];
    }
    //打开设备
    DevHandle=DevHdle[0];
    state = USB_OpenDevice(DevHandle);
    if(!state){
        qDebug()<<QString().sprintf("Open device error!");
        stopped=0;
        return;
    }

    //初始化配置CAN
    CAN_INIT_CONFIG CANConfig;

   // CANConfig.CAN_Mode = 1;//环回模式

    CANConfig.CAN_Mode = 0;//正常模式

    CANConfig.CAN_ABOM = 0;//禁止自动离线
    CANConfig.CAN_NART = 1;//禁止报文重传
    CANConfig.CAN_RFLM = 0;//FIFO满之后覆盖旧报文
    CANConfig.CAN_TXFP = 1;//发送请求决定发送顺序
    //配置波特率,波特率 = 42M/(BRP*(SJW+BS1+BS2))

    //can通信波特率500k
    CANConfig.CAN_BRP = 4;//4
    CANConfig.CAN_BS1 = 16;//16
    CANConfig.CAN_BS2 = 4;//4
    CANConfig.CAN_SJW = 1;//1


    CANConfig.CAN_Mode |= 0x80; //使能接入内部终端电阻
    ret = CAN_Init(DevHandle,0,&CANConfig);
    if(ret != CAN_SUCCESS){
        qDebug()<<QString().sprintf("Config CAN 3 failed!");
        stopped=0;
        return;
    }else{
        qDebug()<<QString().sprintf("Config CAN 3 Success!");
    }
    ret = CAN_Init(DevHandle,1,&CANConfig);
    if(ret != CAN_SUCCESS){
        qDebug()<<QString().sprintf("Config CAN 4 failed!");
        stopped=0;
        return;
    }else{
        qDebug()<<QString().sprintf("Config CAN 4 Success!");
    }
    //配置过滤器，必须配置，否则可能无法收到数据
    CAN_FILTER_CONFIG CANFilter;
    CANFilter.Enable = 1;
    CANFilter.ExtFrame = 0; //过滤的帧类型标志，为1 代表要过滤的为扩展帧，为0 代表要过滤的为标准帧。
    CANFilter.FilterIndex = 0;
    CANFilter.FilterMode = 0;
    CANFilter.MASK_IDE = 0;
    CANFilter.MASK_RTR = 0;
    CANFilter.MASK_Std_Ext = 0;
    CAN_Filter_Init(DevHandle,0,&CANFilter);
    CAN_Filter_Init(DevHandle,1,&CANFilter);

}
canRevThread::~canRevThread()
{
    stopped = 0; 
    requestInterruption();
    quit();
    wait();
    USB_CloseDevice(DevHandle);
}

void canRevThread::sendcanData(uchar index,CAN_MSG &CanD)
{
    int SendedNum = CAN_SendMsg(DevHandle,index,&CanD,1);
    if(SendedNum <= 0){
//        qDebug()<<QString().sprintf("CAN1 send FAIL %1",SendedNum);
    }
}
void canRevThread::run()
{   
    CAN_MSG CanMsgBuffer1[100],CanMsgBuffer2[100];//最大支持100帧
    char CanNum1=0;
    char CanNum2=0;
    while(stopped){
        CanNum1 = CAN_GetMsg(DevHandle,0,CanMsgBuffer1);
        CanNum2 = CAN_GetMsg(DevHandle,1,CanMsgBuffer2);
        if(CanNum1 > 0){
            emit threadRev1(CanMsgBuffer1,CanNum1);
        }
        if(CanNum2 > 0){
            emit threadRev2(CanMsgBuffer2,CanNum2);
        }
        msleep(5);
    }
}
void canRevThread::stopThread()
{
    stopped = 0;
}

h
#ifndef CANREVTHREAD_H
#define CANREVTHREAD_H
 #include <QThread>
 #include <QString>
 #include <QDebug>
#include <QtCore/qglobal.h>
//#define OS_UNIX
#include "usb_device.h"
#include "usb2can.h"
#if defined(CANTHREAD_COMPILE_LIBRARY)
#  define CANTHREAD_LIB_DECL Q_DECL_EXPORT
#elif defined(CANTHREAD_USE_LIBRARY)
#  define CANTHREAD_LIB_DECL Q_DECL_IMPORT
#else
#  define CANTHREAD_LIB_DECL
#endif

class CANTHREAD_LIB_DECL canRevThread: public QThread
{
   Q_OBJECT
signals:
   void threadRev1(CAN_MSG *data,char dwRel);
   void threadRev2(CAN_MSG *data,char dwRel);

public:
    canRevThread(QObject *parent);
     ~canRevThread();
    void sendcanData(uchar index,CAN_MSG &CanD);
    void run();
    void stopThread();
private:
    int stopped;
    int DevHandle;
};
#endif

pro

QT       += core gui sql network printsupport
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
TARGET = RK3588porttest
TEMPLATE = app
DEFINES += QT_DEPRECATED_WARNINGS
DEPENDPATH += .
INCLUDEPATH += .

# Input
HEADERS += \
           mainwindow.h \
           common.h \
           CustomWidget/Thread/thread.h \
    CustomWidget/usbcanthread/canrevthread.h \
    CustomWidget/usbcanthread/usb_device.h \
    CustomWidget/usbcanthread/usb2can.h

SOURCES += \
           main.cpp \
           mainwindow.cpp \
           CustomWidget/Thread/thread.cpp \
    CustomWidget/usbcanthread/canrevthread.cpp

FORMS += \
    mainwindow.ui


CONFIG += mobility
MOBILITY =



win32{
    message($$QT_ARCH)
    contains(QT_ARCH, i386) {
        LIBS += -L$$PWD/CustomWidget/usbcanthread/window/ -lUSB2XXX
    } else {
    }
}

unix:!macx{
    message($$QMAKE_HOST.arch)
    unix:contains(QMAKE_HOST.arch, x86_64){
#        LIBS += -L$$PWD/CustomWidget/usbcanthread/linux-A40i/ -lUSB2XXX
        LIBS += -L$$PWD/CustomWidget/usbcanthread/linux-RK3588/ -lUSB2XXX -lusb-1.0
    }
    unix:contains(QMAKE_HOST.arch, x86){
    }
    unix:contains(QMAKE_HOST.arch, aarch64){
    }
    unix:contains(QMAKE_HOST.arch, armv7){
    }
    unix:contains(QMAKE_HOST.arch, mips64){
    }
}

win32: DEFINES += WINDOWS
!win32: DEFINES += OS_UNIX

前两路2是调用系统自带的CAN，用socketcan，可以参考我A40i帖子中的一个CAN文章

后两路CAN是其他厂家的一个USB转CAN模块，需要匹配相关的驱动，与厂家要驱动文件，引用，可能需要重新根据系统编译一下libusb-1.0.so，才能在交叉编译环境中编译通过

3.背光测试程序（弥补系统pwm匹配异常）

麒麟系统连接edp或mipi屏幕时，会出现pwm不受控现象，麒麟系统与硬件没有完成适配兼容，因为在系统设置中调节亮度不好使

下面通过第三方软件或其他方法尝试解决此问题

1第三方软件方式

未找到合适工具，最终通过自己写程序修改亮度

2自写脚本定时设置亮度方式。

命令参考手册的亮度设置章节

ls /sys/class/backlight

cat /sys/class/backlight/backlight-edp1/brightness

echo 0 > /sys/class/backlight/backlight-edp1/brightness

echo 125 > /sys/class/backlight/backlight-edp1/brightness

echo 255 > /sys/class/backlight/backlight-edp1/brightness

写了一个test_backlight测试程序，当检测到亮度为0时自动设置亮度信息为上次配置的

缺点是会出现一下黑屏，闪一下

最佳解决方式是后期更换稳定系统

后续测试高版本的linux源码尝试

#include "mainwindow.h"
#include <QVBoxLayout>
#include <QFile>
#include <QDebug>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), currentBrightness(200)
{
    // 初始化滑动条和标签
    brightnessSlider = new QSlider(Qt::Horizontal, this);
    brightnessSlider->setRange(0, 255);
    brightnessSlider->setValue(currentBrightness);

    brightnessLabel = new QLabel("亮度: " + QString::number(currentBrightness), this);
    brightnessLabel->setFont(QFont("黑体",50));
    // 布局
    QWidget *centralWidget = new QWidget(this);
    centralWidget->setMinimumSize(500,300);
    QVBoxLayout *layout = new QVBoxLayout(centralWidget);
    layout->addWidget(brightnessLabel);
    layout->addWidget(brightnessSlider);
    centralWidget->setLayout(layout);
    setCentralWidget(centralWidget);

    // 连接滑动条信号
    connect(brightnessSlider, &QSlider::valueChanged, this, &MainWindow::onSliderValueChanged);

    // 初始化定时器
    brightnessTimer = new QTimer(this);
    connect(brightnessTimer, &QTimer::timeout, this, &MainWindow::checkAndRestoreBrightness);
    brightnessTimer->start(1000); // 每1s检查一次

    // 初始设置亮度
    setBrightness(currentBrightness);
}

MainWindow::~MainWindow()
{
    delete brightnessSlider;
    delete brightnessLabel;
    delete brightnessTimer;
}

void MainWindow::onSliderValueChanged(int value)
{
    currentBrightness = value;
    brightnessLabel->setText("亮度: " + QString::number(currentBrightness));
    setBrightness(currentBrightness);
}

void MainWindow::checkAndRestoreBrightness()
{
    int actualBrightness = getBrightness();
    if (actualBrightness == 0) {
        qDebug() << "亮度被重置为 0，恢复为" << currentBrightness;
        setBrightness(currentBrightness);
    }
}

void MainWindow::setBrightness(int value)
{
    QFile brightnessFile("/sys/class/backlight/backlight-edp1/brightness");
    if (brightnessFile.open(QIODevice::WriteOnly)) {
        brightnessFile.write(QString::number(value).toUtf8());
        brightnessFile.close();
    } else {
        qWarning() << "无法设置亮度，请检查权限或路径。";
    }
}

int MainWindow::getBrightness()
{
    QFile brightnessFile("/sys/class/backlight/backlight-edp1/brightness");
    if (brightnessFile.open(QIODevice::ReadOnly)) {
        QString brightnessValue = brightnessFile.readAll().trimmed();
        brightnessFile.close();
        return brightnessValue.toInt();
    } else {
        qWarning() << "无法读取亮度，请检查权限或路径。";
        return -1;
    }
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QSlider>
#include <QLabel>
#include <QTimer>

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void onSliderValueChanged(int value);
    void checkAndRestoreBrightness();

private:
    QSlider *brightnessSlider;
    QLabel *brightnessLabel;
    QTimer *brightnessTimer;
    int currentBrightness;

    void setBrightness(int value);
    int getBrightness();
};

#endif // MAINWINDOW_H

4.电量获取程序（弥补底系统版本不支持电池管理）

麒麟系统V10 2303默认不支持电源管理功能，没有电池图标右下角的显示

使用xx电源模块在国防版麒麟系统可以显示电量信息，但是国防版系统镜像不好用缺图标

最终还是使用2303系统，需要自己通过软件获取电量信息

等以后有了2403系统，就没有这个问题了

方法：

upower -e

upower -i /org/freedesktop/UPower/devices/ups_hiddev0

后续写了一个demo程序 test_power，用于监测电源模块电量信息，等以后写程序可以集成在程序之中

#include "mainwindow.h"
#include <QApplication>
#include <QMenu>
#include <QAction>
#include <QProcess>
#include <QMessageBox>
#include <QDebug>
#include <QPainter>
#include <QFontMetrics>
#include <QVBoxLayout>
#include <QWidget>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), isCharging(false), batteryPercentage(0), timeToEmpty(0)
{
    // 创建托盘图标
    createTrayIcon();

    // 创建桌面 UI
    QWidget *centralWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(centralWidget);

    percentageLabel = new QLabel("电量: 未知", centralWidget);
    timeToEmptyLabel = new QLabel("剩余时长: 未知", centralWidget);

    layout->addWidget(percentageLabel);
    layout->addWidget(timeToEmptyLabel);
    centralWidget->setLayout(layout);
    setCentralWidget(centralWidget);
centralWidget->show();
    // 定时器，每分钟更新一次电量信息
    timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, &MainWindow::updateBatteryStatus);
    timer->start(60000); // 每分钟更新一次

    // 初始更新
    updateBatteryStatus();
}

MainWindow::~MainWindow()
{
    delete trayIcon;
    delete timer;
}

void MainWindow::createTrayIcon()
{
    trayIcon = new QSystemTrayIcon(this);
    updateTrayIcon(); // 初始化图标

    QMenu *menu = new QMenu(this);
    QAction *quitAction = new QAction("退出", this);
    connect(quitAction, &QAction::triggered, qApp, &QApplication::quit);
    menu->addAction(quitAction);

    trayIcon->setContextMenu(menu);
    trayIcon->show();

    connect(trayIcon, &QSystemTrayIcon::activated, this, &MainWindow::iconActivated);
}

void MainWindow::updateBatteryStatus()
{
    QProcess process;
    process.start("upower -i /org/freedesktop/UPower/devices/ups_hiddev0");
    process.waitForFinished();

    QString output = process.readAllStandardOutput();
    parseBatteryStatus(output);

    // 更新托盘图标和桌面 UI
    updateTrayIcon();
    updateDesktopUI();
}

void MainWindow::parseBatteryStatus(const QString &output)
{
    QStringList lines = output.split("\n");

    for (const QString &line : lines) {
        if (line.contains("percentage")) {
            batteryPercentage = line.split(":").last().trimmed().replace("%", "").toInt();
        }
        if (line.contains("time to empty")) {
            timeToEmpty = line.split(":").last().trimmed().replace("hours", "").toDouble();
            // 如果剩余时长为 18.2 小时，则认为充电器接入
            isCharging = (timeToEmpty == 18.2);
        }
    }
}

void MainWindow::updateTrayIcon()
{
    // 创建一个 64x64 的画布
    QPixmap pixmap(64, 64);
    pixmap.fill(Qt::transparent); // 透明背景

    QPainter painter(&pixmap);
    painter.setRenderHint(QPainter::Antialiasing);

    // 绘制电池外框
    painter.setPen(Qt::white);
    painter.setBrush(Qt::transparent);
    painter.drawRect(15, 20, 34, 20); // 电池外框

    // 绘制电池正极
    painter.drawRect(49, 25, 4, 10);

    // 绘制电量填充
    int fillWidth = static_cast<int>(32 * (batteryPercentage / 100.0));
    painter.setBrush(Qt::green);
    painter.drawRect(16, 21, fillWidth, 18);

    // 绘制百分比文字
    painter.setPen(Qt::white);
    QFont font = painter.font();
    font.setPixelSize(16); // 增大字体大小
    painter.setFont(font);

    // 计算文字居中位置
    QFontMetrics metrics(font);
    QString text = QString::number(batteryPercentage) + "%";
    int textWidth = metrics.width(text); // 使用 width 替代 horizontalAdvance
    int textHeight = metrics.height();
    int textX = (pixmap.width() - textWidth) / 2;
    int textY = (pixmap.height() + textHeight) / 2;

    painter.drawText(textX, textY, text);

    // 如果是充电状态，绘制闪电符号
    if (isCharging) {
        QPolygon lightning;
        lightning << QPoint(32, 10) << QPoint(40, 20) << QPoint(32, 20)
                  << QPoint(44, 40) << QPoint(32, 30) << QPoint(40, 30);
        painter.setBrush(Qt::yellow);
        painter.drawPolygon(lightning);
    }

    // 设置托盘图标
    trayIcon->setIcon(QIcon(pixmap));
}

void MainWindow::updateDesktopUI()
{
    // 更新电量百分比
    percentageLabel->setText(QString("电量: %1%").arg(batteryPercentage));

    // 更新剩余使用时长
    if (isCharging) {
        timeToEmptyLabel->setText("状态: 充电中");
    } else {
        timeToEmptyLabel->setText(QString("剩余时长: %1 小时").arg(timeToEmpty));
    }
}

void MainWindow::iconActivated(QSystemTrayIcon::ActivationReason reason)
{
    if (reason == QSystemTrayIcon::Trigger) {
        updateBatteryStatus();
    }
}


#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QSystemTrayIcon>
#include <QTimer>
#include <QPixmap>
#include <QPainter>
#include <QLabel>

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void updateBatteryStatus();
    void iconActivated(QSystemTrayIcon::ActivationReason reason);

private:
    QSystemTrayIcon *trayIcon;
    QTimer *timer;
    bool isCharging;
    int batteryPercentage;
    double timeToEmpty; // 剩余使用时长（小时）

    QLabel *percentageLabel;
    QLabel *timeToEmptyLabel;

    void createTrayIcon();
    void updateTrayIcon();
    void updateDesktopUI();
    void parseBatteryStatus(const QString &output);
};

#endif // MAINWINDOW_H
5.GPIO测试程序控制状态led灯
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    static bool ledflag=false;
#ifdef WINDOWS

#else
        //开机指令初始化指示灯gpio
        system("echo 24 > /sys/class/gpio/export");//led1
        system("echo out > /sys/class/gpio/gpio24/direction");
        system("echo 27 > /sys/class/gpio/export");//led2
        system("echo out > /sys/class/gpio/gpio27/direction");
        QTimer *timeled=new QTimer(this);
        timeled->start(500);
        connect(timeled,&QTimer::timeout,[=](){
            ledflag=!ledflag;
            if(ledflag){
                system("echo 0 > /sys/class/gpio/gpio24/value");
                system("echo 1 > /sys/class/gpio/gpio27/value");
                ui->label->setStyleSheet("background-color: rgb(0, 255, 0);");
                ui->label_2->setStyleSheet("background-color: rgb(255, 0, 0);");
            }
            else{
                system("echo 1 > /sys/class/gpio/gpio24/value");
                system("echo 0 > /sys/class/gpio/gpio27/value");
                ui->label->setStyleSheet("background-color: rgb(255, 0, 0);");
                ui->label_2->setStyleSheet("background-color: rgb(0, 255, 0);");
            }
            qDebug()<<"ledflag:"<<QString::number(ledflag);
        });//绑定定时分析数据函数槽
#endif


        qDebug()<<"ledflag:"<<QString::number(ledflag);
        ui->label->setStyleSheet("background-color: rgb(0, 255, 0);");
        ui->label_2->setStyleSheet("background-color: rgb(255, 0, 0);");


}
MainWindow::~MainWindow()
{
    delete ui;
}
6.时间测试程序
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDate>
#include <QTime>
#include <QPalette>
#include <stdio.h>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

	//setWindowState(Qt::WindowMaximized);
	setWindowFlags(Qt::FramelessWindowHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint);

    QPalette pal;
    pal.setColor(QPalette::Text,QColor(255,0,0));

    ui->year->setPalette(pal);
    ui->month->setPalette(pal);
    ui->day->setPalette(pal);
    ui->hour->setPalette(pal);
    ui->minute->setPalette(pal);
    ui->second->setPalette(pal);

    QDate d = QDate::currentDate();
    QTime t = QTime::currentTime();

    ui->year->setValue(d.year());
    ui->month->setValue(d.month());
    ui->day->setValue(d.day());
    ui->hour->setValue(t.hour());
    ui->minute->setValue(t.minute());
    ui->second->setValue(t.second());

    ui->year->setEnabled(false);
    ui->month->setEnabled(false);
    ui->day->setEnabled(false);
    ui->hour->setEnabled(false);
    ui->minute->setEnabled(false);
    ui->second->setEnabled(false);

    timer.start(1000,this);

    connect(ui->exitBtn, &QPushButton::clicked, this, [=](){
	close();		    
    });
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::timerEvent(QTimerEvent *event)
{
    QDate d = QDate::currentDate();
    QTime t = QTime::currentTime();

    if(ui->set->text()=="set")
    {
        ui->year->setValue(d.year());
        ui->month->setValue(d.month());
        ui->day->setValue(d.day());
        ui->hour->setValue(t.hour());
        ui->minute->setValue(t.minute());
        ui->second->setValue(t.second());
    }

    QWidget::timerEvent(event);
}

void MainWindow::on_set_clicked()
{
    if(ui->set->text()=="set")
    {
        ui->set->setText("save");
        ui->year->setEnabled(true);
        ui->month->setEnabled(true);
        ui->day->setEnabled(true);
        ui->hour->setEnabled(true);
        ui->minute->setEnabled(true);
        ui->second->setEnabled(true);

        timer.stop();

    }
    else
    {
        char buf[128];
        ui->set->setText("set");

        memset(buf,0,128);

        sprintf(buf,"date -s '%4d-%02d-%02d %02d:%02d:%02d'",ui->year->text().toInt(),ui->month->text().toInt(),ui->day->text().toInt(),
                ui->hour->text().toInt(),ui->minute->text().toInt(),ui->second->text().toInt());

        system(buf);
        system("hwclock -w");

        ui->year->setEnabled(false);
        ui->month->setEnabled(false);
        ui->day->setEnabled(false);
        ui->hour->setEnabled(false);
        ui->minute->setEnabled(false);
        ui->second->setEnabled(false);

        timer.start(1000,this);
    }
}



void MainWindow::closeEvent(QCloseEvent *)
{
    //system("killall matrix_gui");
    //system("/etc/init.d/qt.sh");
    exit(0);
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QBasicTimer>
#include <QTimerEvent>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
protected:
   void timerEvent(QTimerEvent *event);
   void closeEvent(QCloseEvent *);
private slots:
    void on_set_clicked();

private:
    Ui::MainWindow *ui;
    QBasicTimer timer;
};

#endif // MAINWINDOW_H

7.redis通信测试程序
#include "mainwindow.h"
#include "ui_mainwindow.h"


MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    // 连接到 Redis 服务器，用于发布命令
    publishContext = redisConnect("127.0.0.1", 6379);
    if (publishContext == NULL || publishContext->err) {
        if (publishContext) {
            qDebug() << "Error: " << publishContext->errstr;
            ui->textEdit->setText(QString("Error: %1").arg(publishContext->errstr));
            redisFree(publishContext);
        } else {
            qDebug() << "Can't allocate redis context for publishing";
            ui->textEdit->setText("Can't allocate redis context for publishing");
        }
        return;
    }else {
        ui->textEdit->append("redis 发布 connect successful");
    }
    // 连接到 Redis 服务器，用于订阅命令
    subscribeContext = redisConnect("127.0.0.1", 6379);
    if (subscribeContext == NULL || subscribeContext->err) {
        if (subscribeContext) {
            qDebug() << "Error: " << subscribeContext->errstr;
            ui->textEdit->setText(QString("Error: %1").arg(subscribeContext->errstr));
            redisFree(subscribeContext);
        } else {
            qDebug() << "Can't allocate redis context for subscribing";
            ui->textEdit->setText("Can't allocate redis context for subscribing");
        }
        return;
    }else {
        ui->textEdit->append("redis 订阅 connect successful");
    }

    // 订阅结果频道
    if (subscribeContext && !subscribeContext->err) {
        redisReply *reply = static_cast<redisReply*>(redisCommand(subscribeContext, "SUBSCRIBE numpy_result pandas_result tensorflow_result sklearn_result matplotlib_result"));
        if (reply) {
            freeReplyObject(reply);
        }
    }

    // 创建并启动 Redis 订阅线程
    subscriberThread = new RedisSubscriberThread(subscribeContext, this);
    connect(subscriberThread, &RedisSubscriberThread::messageReceived, this, [this](const QString &channel, const QString &message) {
        ui->textEdit->append(channel + ": " + message);
    });
    subscriberThread->start();
}

MainWindow::~MainWindow()
{
    if (publishContext) {
        redisFree(publishContext);
    }
    if (subscribeContext) {
        redisFree(subscribeContext);
    }
    if (subscriberThread) {
        subscriberThread->quit();
        subscriberThread->wait();
    }
    delete ui;
}

void MainWindow::on_pushButton_clicked()
{
    if (publishContext && !publishContext->err) {
        redisReply *reply = static_cast<redisReply*>(redisCommand(publishContext, "PUBLISH numpy_command run_numpy"));
        if (reply) {
            if (reply->type == REDIS_REPLY_ERROR) {
                qDebug() << "Error publishing to Redis: " << reply->str;
            } else {
                qDebug() << "Message published successfully to numpy_command";
            }
            freeReplyObject(reply);
        } else {
            qDebug() << "Error: Failed to execute Redis command";
        }
    } else {
        qDebug() << "Redis publish context is invalid";
    }
}

void MainWindow::on_pushButton_2_clicked()
{
    if (publishContext && !publishContext->err) {
        redisReply *reply = static_cast<redisReply*>(redisCommand(publishContext, "PUBLISH pandas_command run_pandas"));
        if (reply) {
            if (reply->type == REDIS_REPLY_ERROR) {
                qDebug() << "Error publishing to Redis: " << reply->str;
            } else {
                qDebug() << "Message published successfully to pandas_command";
            }
            freeReplyObject(reply);
        } else {
            qDebug() << "Error: Failed to execute Redis command";
        }
    } else {
        qDebug() << "Redis publish context is invalid";
    }
}

void MainWindow::on_pushButton_3_clicked()
{
    if (publishContext && !publishContext->err) {
        redisReply *reply = static_cast<redisReply*>(redisCommand(publishContext, "PUBLISH tensorflow_command run_tensorflow"));
        if (reply) {
            if (reply->type == REDIS_REPLY_ERROR) {
                qDebug() << "Error publishing to Redis: " << reply->str;
            } else {
                qDebug() << "Message published successfully to tensorflow_command";
            }
            freeReplyObject(reply);
        } else {
            qDebug() << "Error: Failed to execute Redis command";
        }
    } else {
        qDebug() << "Redis publish context is invalid";
    }
}

void MainWindow::on_pushButton_4_clicked()
{
    if (publishContext && !publishContext->err) {
        redisReply *reply = static_cast<redisReply*>(redisCommand(publishContext, "PUBLISH sklearn_command run_sklearn"));
        if (reply) {
            if (reply->type == REDIS_REPLY_ERROR) {
                qDebug() << "Error publishing to Redis: " << reply->str;
            } else {
                qDebug() << "Message published successfully to sklearn_command";
            }
            freeReplyObject(reply);
        } else {
            qDebug() << "Error: Failed to execute Redis command";
        }
    } else {
        qDebug() << "Redis publish context is invalid";
    }
}

void MainWindow::on_pushButton_5_clicked()
{
    if (publishContext && !publishContext->err) {
        redisReply *reply = static_cast<redisReply*>(redisCommand(publishContext, "PUBLISH matplotlib_command run_matplotlib"));
        if (reply) {
            if (reply->type == REDIS_REPLY_ERROR) {
                qDebug() << "Error publishing to Redis: " << reply->str;
            } else {
                qDebug() << "Message published successfully to matplotlib_command";
            }
            freeReplyObject(reply);
        } else {
            qDebug() << "Error: Failed to execute Redis command";
        }
    } else {
        qDebug() << "Redis publish context is invalid";
    }
}

void MainWindow::on_pushButton_6_clicked()
{
    ui->textEdit->clear();
}


#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QDebug>
#include <QThread>
#include <QTimer>
#include <QMetaObject>
#include "QtHiRedis/hiredis.h" // 包含 hiredis 头文件


// 定义一个新的线程类来处理 Redis 订阅
class RedisSubscriberThread : public QThread {
    Q_OBJECT
public:
    RedisSubscriberThread(redisContext *context, QObject *parent = nullptr)
        : QThread(parent), subscribeContext(context) {}

signals:
    void messageReceived(const QString &channel, const QString &message);

protected:
    void run() override {
        if (subscribeContext && !subscribeContext->err) {
            redisReply *reply;
            while (true) {
                int retval = redisGetReply(subscribeContext, (void**)&reply);
                if (retval == REDIS_OK && reply != NULL && reply->type == REDIS_REPLY_ARRAY && reply->elements == 3) {
                    QString messageType = QString::fromUtf8(reply->element[0]->str);
                    if (messageType == "message") {
                        QString channel = QString::fromUtf8(reply->element[1]->str);
                        QString result = QString::fromUtf8(reply->element[2]->str);
                        emit messageReceived(channel, result);
                    }
                }
                if (reply) {
                    freeReplyObject(reply);
                }
            }
        }
    }

private:
    redisContext *subscribeContext;
};


namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:

    void on_pushButton_clicked();
    void on_pushButton_2_clicked();
    void on_pushButton_3_clicked();
    void on_pushButton_4_clicked();
    void on_pushButton_5_clicked();
    void on_pushButton_6_clicked();

private:
    Ui::MainWindow *ui;
    redisContext *publishContext; // 使用 hiredis 的上下文
    redisContext *subscribeContext; // 使用 hiredis 的上下文

    RedisSubscriberThread *subscriberThread;
};

#endif // MAINWINDOW_H

 

附件太多了，自己下载开源的，或者下载我的全套资源吧

文章参考链接

程序下载链接

8.温度、CPU主频测试程序
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

#ifdef WINDOWS
        m_path=qApp->applicationDirPath();
#else
        m_path="/media/root/sata";//sata是更改挂载点后的文件名，默认是UUID，没法通过程序去识别每个设备的硬盘
#endif

    ///timer定时器初始化，3秒进行一次数据分析，不管数据是否接收，定时分析数据以UDP形式发送到指定目标IP
    QTimer *time1=new QTimer(this);
    time1->start(3000);
    connect(time1,&QTimer::timeout,[=](){
        AnalyseData();
    });//绑定定时分析数据函数槽


}
MainWindow::~MainWindow()
{
    delete ui;
}

///******************************************************************定时分析数据**************************************************************///
//在时钟和硬盘挂载正常的情况下分析内存容量是否充足，大于80%要删除到60%以下，最少保留当天日期数据不可删除
//分析数据采集盒状态：时钟状态、时间、固态硬盘挂载状态、固态硬盘容量、CPU温度、CPU主频、采集盒版本信息，将数据打包放入待发送缓存中
//分析整车全部系统状态：xxx，将数据打包放入待发送缓存中
//
void MainWindow::AnalyseData()
{
///分析硬盘容量
    ui->textEdit->clear();
    qDebug()<<"\r\n";
    qDebug()<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
    ui->textEdit->append(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));
    qDebug()<<"/*****************check disk used******************/";
    ui->textEdit->append("/*****************check disk used******************/");
    if(QFile::exists(m_path)){//判断硬盘状态是否正常，异常后出正常也不给予正常状态，只要出现判断不到即报错，单次即一直触发,不消除故障
        m_mSATAstatus=true;//mSATA挂载正常
        QTime get_disk_usetime;//记录查询日志数据列表消耗时间
        get_disk_usetime.start();
        //计算mSATA_size,mSATA_used,mSATA_persent
        QStorageInfo storage = QStorageInfo::root();
        storage.refresh();  //获得最新磁盘信息
        storage.device();
        storage.setPath(m_path);
        mSATA_size=storage.bytesTotal()/(1024*1024);//单位MByte
        mSATA_used=mSATA_size-storage.bytesFree()/(1024*1024);
        mSATA_persent=mSATA_used*100/mSATA_size;
        qDebug()<<"mSATA used:"<<getsize(mSATA_used)<<",mSATA allsize:"<<getsize(mSATA_size);
        qDebug()<<"mSATA use persent is "<<QString::number(mSATA_persent)<<"%,get mSATA used persent usetime:"<<QString::number(get_disk_usetime.elapsed())<<"ms";
        ui->textEdit->append("mSATA used:"+getsize(mSATA_used)+",mSATA allsize:"+getsize(mSATA_size));
        ui->textEdit->append("mSATA use persent is "+QString::number(mSATA_persent)+"%,get mSATA used persent usetime:"+QString::number(get_disk_usetime.elapsed())+"ms");
    }
    else{
        qDebug()<<"mSATA err!";
        ui->textEdit->append("mSATA err!");
        m_mSATAstatus=false;//赋值硬盘错误状态
    }
///获取数据采集盒状态
    QString m_freq0,m_freq4,m_temp;//本机工作频率和温度
    QString m_cpu0,m_cpu4;
#ifndef WINDOWS
    QFile file("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_cur_freq");//获取cpu工作主频
    if (file.open(QIODevice::ReadOnly | QIODevice::Text)){
        m_freq0 = file.readLine();
        file.close();
    }
    QFile file2("/sys/devices/system/cpu/cpu4/cpufreq/cpuinfo_cur_freq");//获取cpu工作主频
    if (file2.open(QIODevice::ReadOnly | QIODevice::Text)){
        m_freq4 = file2.readLine();
        file2.close();
    }
    QFile file1("/sys/class/thermal/thermal_zone0/temp");//获取cpu工作温度
    if (file1.open(QIODevice::ReadOnly | QIODevice::Text)){
        m_temp = file1.readLine();
        file1.close();
    }
    QFile file3("/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies");//获取cpu主频范围
    if (file3.open(QIODevice::ReadOnly | QIODevice::Text)){
        m_cpu0 = file3.readLine();
        file3.close();
    }
    QFile file4("/sys/devices/system/cpu/cpu4/cpufreq/scaling_available_frequencies");//获取cpu主频范围
    if (file4.open(QIODevice::ReadOnly | QIODevice::Text)){
        m_cpu4 = file4.readLine();
        file4.close();
    }
#else
    m_freq0="99999";
    m_freq4="99999";
    m_temp="99.99";
    m_cpu0="";
    m_cpu4="";
#endif
    qDebug()<<"/*****************check CPU used******************/";
    qDebug()<<tr("cpu0 range %1").arg(m_cpu0);
    qDebug()<<tr("cpu4 range %1").arg(m_cpu4);
    qDebug()<<tr("cpu0 freq %1,cpu4 freq %2,now temp %3").arg(m_freq0).arg(m_freq4).arg(m_temp);
    qDebug()<<"/*****************check end******************/";

    ui->textEdit->append("/*****************check CPU used******************/");
    ui->textEdit->append(tr("cpu0 range %1").arg(m_cpu0));
    ui->textEdit->append(tr("cpu4 range %1").arg(m_cpu4));
    ui->textEdit->append(tr("cpu0 freq %1,cpu4 freq %2,now temp %3").arg(m_freq0).arg(m_freq4).arg(m_temp));
    ui->textEdit->append("/*****************check end******************/");
}
QString MainWindow::getsize(qint64 m_allsizie)
{
    QString fileSize;
    if (m_allsizie >= 0 && m_allsizie < 1024){
        fileSize = QString::number(m_allsizie) + "Byte";
    }
    else if (m_allsizie >= 1024 && m_allsizie < 1024 * 1024){
        fileSize = QString::number(m_allsizie / 1024.0, 'f', 2) + "KB";
    }
    else if (m_allsizie >= 1024 * 1024 && m_allsizie < 1024 * 1024 * 1024){
        fileSize = QString::number(m_allsizie / 1024 / 1024.0, 'f', 2) + "MB";
    }
    else if (m_allsizie >= 1024 * 1024 * 1024){
        fileSize = QString::number(m_allsizie / 1024 / 1024 / 1024.0, 'f', 2) + "GB";
    }
    return fileSize;
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include "header.h"

namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
    Q_OBJECT
    
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

protected:

private slots:
    void AnalyseData();
    QString getsize(qint64 m_allsizie);
private:
    Ui::MainWindow *ui;
    bool m_mSATAstatus=false;//固态硬盘是否正常，不正常不能建立文件夹存储数据
    QString m_path;//记录当前存储文件的路径，在WINDOWS的路径还是在linux中的固态硬盘中路径
    qint64 mSATA_size,mSATA_used,mSATA_persent;//mSATA硬盘总容量，已经使用容量，容量使用百分比

};

#endif // MAINWINDOW_H

9.msata挂载稳定性测试程序
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    //读取配置信息
    QString line_config;
    QFile file_config(qApp->applicationDirPath()+"/test_msata_config.txt");
    if(file_config.open(QIODevice::ReadOnly|QIODevice::Text)){
        while(!file_config.atEnd()){
            line_config=file_config.readLine();
        }
        file_config.close();
    }
    else{
        file_config.open(QIODevice::WriteOnly|QIODevice::Text);
        QTextStream in(&file_config);
        in<<"0";
        line_config="0";
        file_config.close();
    }
    qDebug()<<"config："<<line_config;
    ui->spinBox->setValue(line_config.toInt());
    if(line_config=="0")ui->checkBox->setChecked(false);
    else ui->checkBox->setChecked(true);

    //读取配置信息
    QString line_path;
    QFile file_path(qApp->applicationDirPath()+"/test_msata_path.txt");
    if(file_path.open(QIODevice::ReadOnly|QIODevice::Text)){
        while(!file_path.atEnd()){
            line_path=file_path.readLine();
        }
        file_path.close();
    }
    else{
        file_path.open(QIODevice::WriteOnly|QIODevice::Text);
        QTextStream in(&file_path);
        in<<"/dev/sda5";
        line_path="/dev/sda5";
        file_path.close();
    }
    qDebug()<<"path:"<<line_path;
    ui->lineEdit->setText(line_path);

    //读取配置信息
    QString line_history;
    QFile file_history(qApp->applicationDirPath()+"/test_msata_history.txt");
    if(file_history.open(QIODevice::ReadOnly|QIODevice::Text)){
        while(!file_history.atEnd()){
            line_history=file_history.readLine().replace("\n","");
            qDebug()<<"history:"<<line_history;
            if(line_history.contains("yes")){
                QTextCharFormat fmt;
                fmt.setForeground(Qt::green);
                ui->textEdit->setCurrentCharFormat(fmt);
                ui->textEdit->append(line_history);
            }
            else if(line_history.contains("err")){
                QTextCharFormat fmt;
                fmt.setForeground(Qt::red);
                ui->textEdit->setCurrentCharFormat(fmt);
                ui->textEdit->append(line_history);
            }
        }
        file_history.close();
    }







    QTimer *time1=new QTimer(this);
    time1->start(2000);//20s
    connect(time1,&QTimer::timeout,[=](){
        AnalyseData();
    });//绑定定时分析数据函数槽


}
MainWindow::~MainWindow()
{
    delete ui;
}

///******************************************************************定时分析数据**************************************************************///

void MainWindow::AnalyseData()
{
///获取数据采集盒状态
    QString m_temp="66666";//本机工作频率和温度
    QFile file1("/sys/class/thermal/thermal_zone0/temp");//获取cpu工作温度
    if (file1.open(QIODevice::ReadOnly | QIODevice::Text)){
        m_temp = file1.readLine();
        file1.close();
    }
    m_temp = QString::number((double)m_temp.toInt()/1000,'f',2);
    if(ui->checkBox->isChecked()){
        int num=ui->spinBox->value();
        if(num>0){
            ui->spinBox->setValue(num-1);
            QFile file(ui->lineEdit->text());
            if(file.exists()) {// 文件存在
                QTextCharFormat fmt;
                fmt.setForeground(Qt::green);
                ui->textEdit->setCurrentCharFormat(fmt);
                ui->textEdit->append(QString("%1,msata fstab yes,CPU temp %2,has %3").arg(QDateTime::currentDateTime().toString("hh:mm:ss")).arg(m_temp).arg(ui->spinBox->value()));
            }else {// 文件不存在
                QTextCharFormat fmt;
                fmt.setForeground(Qt::red);
                ui->textEdit->setCurrentCharFormat(fmt);
                ui->textEdit->append(QString("%1,msata fstab err,CPU temp %2,has %3").arg(QDateTime::currentDateTime().toString("hh:mm:ss")).arg(m_temp).arg(ui->spinBox->value()));
            }
            QFile file_path(qApp->applicationDirPath()+"/test_msata_history.txt");
            file_path.open(QIODevice::WriteOnly|QIODevice::Text);
            QTextStream in(&file_path);
            in<<ui->textEdit->toPlainText();
            file_path.close();

            qDebug()<<"重启";
            system("reboot");
        }
//        else
//            ui->textEdit->append("测试完毕！");
    }
}
//按键点击事件
void MainWindow::on_checkBox_clicked()
{
//    QFile file_config(qApp->applicationDirPath()+"/test_msata_config.txt");
//    file_config.open(QIODevice::WriteOnly|QIODevice::Text);
//    QTextStream in(&file_config);
//    QString res;
//    if(ui->checkBox->isChecked()==false)
//        res="0";
//    in<<res;
//    file_config.close();
}
void MainWindow::on_pushButton_clicked()
{
    QFile file_path(qApp->applicationDirPath()+"/test_msata_path.txt");
    file_path.open(QIODevice::WriteOnly|QIODevice::Text);
    QTextStream in(&file_path);
    in<<ui->lineEdit->text();
    file_path.close();
}
void MainWindow::on_pushButton_2_clicked()
{
    QFile file_path(qApp->applicationDirPath()+"/test_msata_history.txt");
    file_path.open(QIODevice::WriteOnly|QIODevice::Text);
    QTextStream in(&file_path);
    in<<"";
    file_path.close();
    ui->textEdit->clear();
}

void MainWindow::on_spinBox_valueChanged(int arg1)
{
    QFile file_config(qApp->applicationDirPath()+"/test_msata_config.txt");
    file_config.open(QIODevice::WriteOnly|QIODevice::Text);
    QTextStream in(&file_config);
    in<<QString::number(arg1);
    file_config.close();
}

四、结语

未完待续。。。

可以用AI生成，很多平台都可以，描述清楚就可以对症下药，用起来

RK3588适配Ubuntu系统
m0_60805802的博客
02-13 4157
RKsdk上支持buildroot以及Debian系统，但是Ubuntu需要自己移植，有很多公司都移植好了可以直接用，这里就总结记录一下我制作Ubuntu的过程。
RK356X/RK3588构建Ubuntu20.04根文件系统
目前从事linux驱动开发，多交流多学习吧
10-23 5873
很多厂商没有吧文件系统的构建方法开源出来，只是提供了一个rootfs.img的固件包，这不利于我们做二次开发，本文章实现一个自己构建的文件系统，并移植到RK的平台上使用。
Rockchip RK3588 - uboot引导方式介绍
最新发布
weixin_48721556的博客
03-04 2106
early_init_dt_scan_chosen用于扫描chosen节点，并把bootargs属性值拷贝到boot_command_line中，如果内核定义了CONFIG_CMDLINE这个宏，则把配置的命令行参数也拷贝到boot_command_line；其中uboot传递的bootargs参数优先级高于设备树中定义的bootargs，如果是uboot传递的bootargs，在内核启动阶段就会调用fdt_chosen函数将环境变量中的bootargs参数写进dtb数据中；
RK3588 Ubuntu系统编译
u010881504的博客
05-15 2163
RK3588 Ubuntu系统编译
rk3588 麒麟系统
qirui24432的专栏
12-12 866
rk3588 启动麒麟系统居然成功了。
rk3588 及系统安装 ubuntu
xie__jin__cheng的博客
07-24 5903
rk3588 及系统安装 ubuntu
迅为RK3588开发部可移植银河麒麟和开放麒麟系统
weixin_36887888的博客
07-04 440
迅为在RK3588开发板移植了银河麒麟和开放麒麟系统迅为优先RK3588开发板上支持Android13系统迅为在RK3588开发板移植了银河麒麟和开放麒麟系统迅为优先RK3588开发板上支持Android13系统性能强--iTOP-3588开发板采用瑞芯微RK3588处理器，是全新一代ALoT高端应用芯片，采用8nm L...
RK3588_ubuntu根文件系统定制
u011326325的博客
10-18 1661
rk3588 定制ubuntu根文件系统
【RK3588 开发笔记——Ubuntu系统的制作与使用】
W_B_C的博客
01-04 5526
【RK3588 开发笔记——Ubuntu系统的制作与使用】
YOLOV8-seg部署在RK3568/RK3588上面
yourhjt的博客
11-14 1121
下载好以后进入文件夹下的 目录，注意自己的电脑版本和python版本，在下面找到对应的arm64_requirements_cp38.txt 文件，进行安装。1.返回到rknn_model_zoo的根目录中，运行以下代码，进行C++代码的编译。下面标注了，需要修改的地方（置信度也可以根据自己需要修改）去github上面下载瑞芯微官方给的环境配置代码，还需要下载一个瑞芯微的模型库，用来转rknn模型，推荐阅读该目录下的readme文档，里面写的很详细。官方给的转换代码，修改pt路径为自己的模型路径。
56、香橙派pi5B-RK3588S开发记录以及推理
sxj731533730
05-05 1566
基本思想：纯粹为了记录，做个笔记。
RK3568平台（环境篇） ubuntu18.04环境搭建
weixin_49303682的博客
08-16 1166
打开Windows 10控制面板，选择“应用“点击右上角“程序与功能”点击“启用或关闭Windows 功能”，勾选“适用于Linux 的Windows 子系统”和“虚 拟机平台”
国产【操作系统】产品库总结整理
小北的博客
03-01 2133
中国操作系统产品库是一个汇集了各类优化针对云计算环境的操作系统的资源库。这些操作系统由中国各大科技公司开发，旨在为云端应用提供高效、稳定的基础支持。从阿里云到腾讯云，再到华为和品高等公司，这些操作系统覆盖了多种硬件架构，并在开源和闭源方面提供了不同的选择。该产品库为中国云计算产业的发展注入了新的活力，为用户提供了更多元、更具竞争力的操作系统解决方案。
Qt开发经验总结
热门推荐
草上爬的博客
12-02 1万+
增加了很多轮子，同时原有模块拆分的也更细致，估计为了方便拓展个管理。把一些过度封装的东西移除了（比如同样的功能有多个函数），保证了只有一个函数执行该功能。把一些Qt5中兼容Qt4的方法废弃了，必须用Qt5中对应的新的函数。跟随时代脚步，增加了不少新特性以满足日益增长的客户需求。对某些模块和类型及处理进行了革命性的重写，运行效率提高不少。有参数类型的变化，比如 long * 到 qintptr * 等，更加适应后续的拓展以及同时对32 64位不同系统的兼容。
双麒麟系统！RK3588+银河麒麟/开放麒麟，全国产让您的产品更具竞争力
BeiJingXunWei的博客
06-27 1119
OpenKylin1.0.2是一个基于Linux内核的开源操作系统，由OpenKylin社区主导开发，具有安全、稳定、高效的特点，支持多种硬件平台和主流开源软件，提供现代化的用户界面和丰富的开发工具，适用于台式机、笔记本和嵌入式设备，致力于推动国产操作系统的自主研发和生态建设。它广泛应用于工业制造、公共交通、能源电力、金融科技、汽车电子、数字通信、医疗卫生和智慧城市等领域，如地铁AFC、ETC收费、机器人控制、智能驾驶和智慧网点等。《iTOP-3588开发板快速测试手册》联系旺旺客服加入售后技术支持群。
RK3588的Ubuntu 22.04.2使用方法
alaolv的博客
07-01 1199
Ubuntu 22.04桌面系统的特点：桌面环境采用 GNOME 42;默认使用Wayland 会话, 性能更好;提供基于 Mali GPU 的 OpenGL ES 支持;支持Rockhip MPP视频硬编和硬解码;预装基于mpv与kodi, 支持视频硬解码;支持安装Docker和Plex, 玩法丰富;
迅为RK3588开发板运行openkylin麒麟系统
mucheni的博客
08-19 695
性能强--iTOP-3588开发板采用瑞芯微RK3588处理器，是全新一代ALoT高端应用芯片，采用8nm LP制程，搭载八核64位CPU，四核Cortex-A76和四核Cortex-A55架构，主频高达2.4GHZ，8GB内存，32GB EMMC。强大的视频编解码--8K编码+8K解码，多路视频源同时解码。接口丰富--双路千兆以太网、5G/4G模块、HDMI输入、HDMI输出、PCle3.0、PCle2.0SATA3.0、USB3.0、USB2.0、TypeC等接口一应俱全。
RK1808开发者指南：Linux/Unix C/C++编程
6. 应用程序开发：介绍如何使用C/C++开发RK1808平台上的应用程序，可能包括API的使用、多线程编程、网络编程等。 7. 性能优化：讲述在RK1808平台上进行性能调优的技巧和方法，以及如何分析和优化应用程序性能。 8....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大桶矿泉水

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值