乐居管家综合项目(QT/C++)

//乐居管家//
/guard.h
#ifndef GUARD_H
#define GUARD_H

#include <QWidget>

class Mainwindow;
namespace Ui {
class guard;
}

class guard : public QWidget
{
    Q_OBJECT

public:
    explicit guard(QWidget *parent = nullptr);
    ~guard();

private slots:
    void on_guard_withdraw_clicked();

private:
    Ui::guard *ui;
};

#endif // GUARD_H

//internectClient.h
#ifndef INTERNECTCLIENT_H
#define INTERNECTCLIENT_H

#include <QWidget>
#include <QAbstractSocket>
#include <QTcpSocket>
#include <QRandomGenerator>
#include <QDebug>
#include <QString>


//add
// 协议常量
#define PROTOCOL_HEADER       0xAAAA     // 数据头（2字节）
#define PROTOCOL_FOOTER       0x5555     // 数据尾（2字节）
#define PROTOCOL_ADDR_PROPERTY 0x10      // 物业地址
#define PROTOCOL_ADDR_USER1    0x01      // 用户1地址
#define PROTOCOL_ADDR_USER2    0x02      // 用户2地址
#define PROTOCOL_ADDR_USER3    0x03      // 用户3地址
#define PROTOCOL_FUNC_GET_TEMP 0x40      // 获取温度
#define PROTOCOL_FUNC_GET_HUMI 0x41      // 获取湿度
#define PROTOCOL_FUNC_GET_SERVO 0x42     // 获取舵机信息

// 协议结构体，发送
typedef struct {
    uint16_t header;          // 数据头 0xAAAA
    uint8_t address;          // 地址
    uint8_t func_code;        // 功能码
    uint8_t data_len;         // 数据长度
    uint8_t *data;            // 数据指针
    uint8_t crc;              // CRC校验
    uint16_t footer;          // 数据尾 0x5555
} Protocol_Packet;

// 接收状态枚举
typedef enum {
    STATE_HEADER_HIGH,    // 等待数据头高字节
    STATE_HEADER_LOW,     // 等待数据头低字节
    STATE_ADDRESS,
    STATE_FUNC_CODE,
    STATE_DATA_LEN,
    STATE_DATA,
    STATE_CRC,
    STATE_FOOTER_HIGH,    // 等待数据尾高字节
    STATE_FOOTER_LOW      // 等待数据尾低字节
} Protocol_State;


class Mainwindow;
namespace Ui {
class internectClient;
}

class internectClient : public QWidget
{
    Q_OBJECT

public:
    explicit internectClient(QWidget *parent = nullptr);
    internectClient(const QString &hostName, quint16 port);
    bool C_connect(const QString &hostName, quint16 port);
    //bool write(QTcpSocket* socket, const QByteArray& data);
    //void C_send();
    void C_recv();
    bool arg;
//    Protocol_State rx_state = STATE_HEADER_HIGH;
//    uint8_t rx_buffer[256];   // 接收缓冲区
//    uint8_t data_index = 0;
//    uint8_t expected_len = 0;
//    uint8_t Calculate_CRC8(const uint8_t *data, uint8_t len);
//    void Process_Packet(uint8_t address, uint8_t func_code, uint8_t *data, uint8_t data_len);
//    void Protocol_RX_Handler(uint8_t rx_byte);
    ~internectClient();

private:
    Ui::internectClient *ui;
    QTcpSocket socket;
    char a[128]={0};
};

#endif // INTERNECTCLIENT_H

///jiazaitupian.h
#ifndef JIAZAITUPIAN_H
#define JIAZAITUPIAN_H

#include <QWidget>
#include <QPixmap>
#include <QPaintEvent>
#include <QPainter>
class Mainwindow;
namespace Ui {
class jiazaitupian;
}

class jiazaitupian : public QWidget
{
    Q_OBJECT

public:
    explicit jiazaitupian(QWidget *parent = nullptr);
    ~jiazaitupian();
    void paintEvent(QPaintEvent *event);
private:
    Ui::jiazaitupian *ui;
};

#endif // JIAZAITUPIAN_H

mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "guard.h"
#include "user1.h"
#include "user2.h"
#include "jiazaitupian.h"
#include "ruanjiantubiao.h"
#include <stdbool.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include <QTimer>
#include "internectclient.h"

#define TEMPE _IOR('T', 0x01, unsigned long)
#define HUMI _IOR('H', 0x02, unsigned long)


QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:

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

signals:
    void user1temp();
    void user1humi();
private slots:
    void on_user1_button_clicked();
    void on_guard_button_clicked();
    void on_user2_button_clicked();
    void on_pushButton_clicked();
    void on_fan_button_clicked();
    void on_led_button_clicked();
    void on_buzzer_button_clicked();
    void on_motorm_button_clicked();

    void updateTemperature(); // 新增的槽函数，用于更新温度
    void updateHumidity();

public slots:
    void on_temp_button_clicked();
    void on_humi_button_clicked();
private:
    Ui::MainWindow *ui;
    int isfan=1;  // 用于记录风扇的开关状态
    int isbuzzer=1;
    int ismotorm=1;
    int isled=1;
    int dev_status; // 设备状态
    QTimer *timer;  // QTimer 对象，用于定时更新设备状态
    int fd[7];

    int sID = 0;
    unsigned short i2c_data_change(unsigned short data)
    {
        unsigned short temp;
        temp = data<<8;
        data =temp|(data>>8&0xff);
        return data;
    }
    int fd1,fd2;
    unsigned short read_data;
    unsigned short read_shidu;
    double tempe ; //温度
    double humi ; //湿度
//    double humi1;


    QTimer *timer1;
    QTimer *timer2;
//    QTimer *timer3;
//    QTimer *timer4;
//    QTimer *timer5;
//    QTimer *timer6;
//    QTimer *timer7;
//    QTimer *timer8;
    user1 *UR1;
public:
    int istemp=1;
    int istemp1=1;
    int ishumi=1;
    const QString hostName;
    internectClient c;
    void timerEvent(QTimerEvent *event);
    quint16 port;
};
#endif // MAINWINDOW_H


/ruanjiantubiao.h
#ifndef RUANJIANTUBIAO_H
#define RUANJIANTUBIAO_H

#include <QWidget>
#include "jiazaitupian.h"
class Mainwindow;
namespace Ui {
class ruanjiantubiao;
}

class ruanjiantubiao : public QWidget
{
    Q_OBJECT

public:
    explicit ruanjiantubiao(QWidget *parent = nullptr);
    ~ruanjiantubiao();

private slots:
    void on_pushButton_clicked();

private:
    Ui::ruanjiantubiao *ui;
};

#endif // RUANJIANTUBIAO_H

user1.h
#ifndef USER1_H
#define USER1_H

#include <QWidget>
#include <stdbool.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
#include <QTimer>

#define TEMPE _IOR('T', 0x01, unsigned long)
#define HUMI _IOR('H', 0x02, unsigned long)
class Mainwindow;
namespace Ui {
class user1;
}

class user1 : public QWidget
{
    Q_OBJECT

public:
    explicit user1(QWidget *parent = nullptr);
    ~user1();

signals:
    void huixiantemp();
    void huixianhumi();
public slots:
    void on_user1_withdraw_clicked();
    void updateTemperature1(); // 新增的槽函数，用于更新温度
    void updateHumidity1();
    void showuser1data();
public:
    Ui::user1 *ui;
    int fd3,fd4;
    int sID = 0;
    unsigned short i2c_data_change(unsigned short data)
    {
        unsigned short temp;
        temp = data<<8;
        data =temp|(data>>8&0xff);
        return data;
    }
    int istemp1,ishumi1;
    QTimer *timer3,*timer4;

    unsigned short read_data;
    unsigned short read_shidu;
    double tempe ; //温度
    double humi ; //湿度

};

#endif // USER1_H


///user2.h
#ifndef USER2_H
#define USER2_H

#include <QWidget>
class Mainwindow;
namespace Ui {
class user2;
}

class user2 : public QWidget
{
    Q_OBJECT

public:
    explicit user2(QWidget *parent = nullptr);
    ~user2();

private slots:
    void on_user2_withdraw_clicked();

private:
    Ui::user2 *ui;
};

#endif // USER2_H


//guard.cpp
#include "guard.h"
#include "ui_guard.h"
#include "mainwindow.h"
guard::guard(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::guard)
{
    ui->setupUi(this);
}

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

void guard::on_guard_withdraw_clicked()
{
    MainWindow *MW=new MainWindow;
    MW->show();
    close();
}


//internectClient.cpp
#include "internectclient.h"
#include "ui_internectclient.h"
#include "mainwindow.h"
#include <QDebug>
internectClient::internectClient(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::internectClient)
{
    ui->setupUi(this);
}

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


// 多项式: x8 + x2 + x + 1 (0x07)
//uint8_t internectClient::Calculate_CRC8(const uint8_t *data, uint8_t len) {
//    uint8_t crc = 0x00;
//    for (uint8_t i = 0; i < len; i++) {
//        crc ^= data[i];
//        for (uint8_t j = 0; j < 8; j++) {
//            if (crc & 0x80) {
//                crc = (crc << 1) ^ 0x07;
//            } else {
//                crc <<= 1;
//            }
//        }
//    }
//    return crc;
//}

// 处理接收到的完整数据包
//void internectClient::Process_Packet(uint8_t address, uint8_t func_code, uint8_t *data, uint8_t data_len) {
//    switch (func_code) {
//        case PROTOCOL_FUNC_GET_TEMP:
//            qDebug() << "Received GET_TEMP command";
//            break;
//        case PROTOCOL_FUNC_GET_HUMI:
//            qDebug() << "Received GET_HUMI command";
//            break;
//        case PROTOCOL_FUNC_GET_SERVO:
//            qDebug() << "Received GET_SERVO command";
//            break;
//    }
//}

// 协议接收处理函数
//void internectClient::Protocol_RX_Handler(uint8_t rx_byte) {
//    static uint8_t crc_calc;
//    qDebug() << "[State" << rx_state << "] Received: 0x" << QString::number(rx_byte, 16);
//    switch (rx_state) {
//        // 处理数据头（0xAAAA）
//        case STATE_HEADER_HIGH:
//            if (rx_byte == (PROTOCOL_HEADER >> 8)) {
//                qDebug() << "Header High OK";
//                rx_state = STATE_HEADER_LOW;
//            } else {
//                qDebug() << "rx_state != STATE_HEADER_LOW";
//            }
//            break;
//        case STATE_HEADER_LOW:
//            if (rx_byte == (PROTOCOL_HEADER & 0xFF)) {
//                rx_state = STATE_ADDRESS;
//            } else {
//                rx_state = STATE_HEADER_HIGH; // 头不匹配，重置
//            }
//            break;

//        // 处理地址、功能码、数据长度
//        case STATE_ADDRESS:
//            rx_buffer[0] = rx_byte; // 存储地址
//            rx_state = STATE_FUNC_CODE;
//            break;
//        case STATE_FUNC_CODE:
//            rx_buffer[1] = rx_byte; // 功能码
//            rx_state = STATE_DATA_LEN;
//            break;
//        case STATE_DATA_LEN:
//            expected_len = rx_byte; // 数据长度
//            rx_buffer[2] = rx_byte;
//            data_index = 0;
//            if (expected_len > 0) {
//                rx_state = STATE_DATA;
//            } else {
//                rx_state = STATE_CRC;
//            }
//            break;
//        case STATE_DATA:
//            rx_buffer[3 + data_index] = rx_byte;
//            data_index++;
//            if (data_index >= expected_len) {
//                rx_state = STATE_CRC;
//            }
//            break;

//        // 处理CRC
//        case STATE_CRC:
//            crc_calc = Calculate_CRC8(rx_buffer, 3 + expected_len);
//            if (crc_calc == rx_byte) {
//                rx_state = STATE_FOOTER_HIGH; // CRC通过，继续检查数据尾
//            } else {
//                rx_state = STATE_HEADER_HIGH; // CRC错误，重置
//            }
//            break;

//        // 处理数据尾（0x5555）
//        case STATE_FOOTER_HIGH:
//            if (rx_byte == (PROTOCOL_FOOTER >> 8)) {
//                rx_state = STATE_FOOTER_LOW;
//            } else {
//                rx_state = STATE_HEADER_HIGH; // 数据尾错误，重置
//            }
//            break;
//        case STATE_FOOTER_LOW:
//            if (rx_byte == (PROTOCOL_FOOTER & 0xFF)) {
//                // 完整包接收成功！
//                Process_Packet(rx_buffer[0], rx_buffer[1],
//                               &rx_buffer[3], rx_buffer[2]);
//            }
//            rx_state = STATE_HEADER_HIGH; // 重置状态机
//            break;
//    }
//}
//internectClient::internectClient(const QString &hostName, quint16 port)
//    : rx_state(STATE_HEADER_HIGH), data_index(0), expected_len(0)
//{
//    memset(rx_buffer, 0, sizeof(rx_buffer));
//    C_connect(hostName, port);
//    C_send();
//    C_recv();
//}

bool internectClient::C_connect(const QString &hostName, quint16 port)
{
    arg = false;
    // 连接到服务器
    socket.connectToHost(hostName, port);
    if (socket.waitForConnected()) {
        arg = true;
        qDebug() << "link successfully.";
        return true;
    }
    else
    {
        qDebug() << "Failed to connect to server: " << socket.errorString();
        return false;
    }
}

//void internectClient::C_send()
//{
//        qDebug() << "C_send";
//        // 准备要发送的数据
//        const char *d;
//        d = "hello";
//        QByteArray byteArray;
//        byteArray.resize(sizeof(d));
//        memcpy(byteArray.data(), &d, sizeof(d));
//        socket.write(byteArray);
//        socket.waitForBytesWritten();
//        qDebug() << "Data sent successfully.";
//}

void internectClient::C_recv()
{

//        qDebug() << "C_recv";
//        char a[128];
//        qint64 bytesRead = socket.read(a, sizeof(a));

//        if (bytesRead == -1) {
//            qDebug() << "Error reading data from socket:" << socket.errorString();
//            return;
//        } else if (bytesRead == 0) {
//            qDebug() << "No data received.";
//            return;
//        }

//        qDebug() << "Data recv successfully.";

//        for (qint64 i = 0; i < bytesRead; ++i) {
//            Protocol_RX_Handler(static_cast<uint8_t>(a[i]));
//        }

    qDebug() << "recv data";

    socket.read(a,sizeof(a));
    int length=strlen(a);
    for(int i=0;i<length;i++)
    {
        qDebug()<<a[i];
    }
    qDebug()<<"data successful";
}

//bool internectClient::write(QTcpSocket* socket, const QByteArray& data) {
//    if (!socket) {
//        qDebug() << "Socket 指针为空";
//        return false;
//    }

//    if (socket->state() != QAbstractSocket::ConnectedState) {
//        qDebug() << "网络未连接，无法发送数据";
//        return false;
//    }

//    qint64 bytesWritten = socket->write(data);
//    if (bytesWritten == -1) {
//        qDebug() << "网络数据发送失败:" << socket->errorString();
//        return false;
//    }

//    if (!socket->waitForBytesWritten(5000)) {  // 等待数据发送完成，超时时间为 5000 毫秒
//        qDebug() << "数据发送超时:" << socket->errorString();
//        return false;
//    }

//    qDebug() << "网络数据发送成功，发送字节数:" << bytesWritten;
//    return true;
//}


//jiazaitubiao.cpp
#include "jiazaitupian.h"
#include "ui_jiazaitupian.h"
#include "mainwindow.h"
jiazaitupian::jiazaitupian(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::jiazaitupian)
{
    ui->setupUi(this);
}

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

void jiazaitupian::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    painter.drawPixmap(0,0,width(),height(),QPixmap(":/new/prefix1/66.jpg"));
}


///mainwindow.cpp
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <QDebug>
#include <QString>
#include <arpa/inet.h>
#include <unistd.h>

MainWindow::MainWindow(QWidget *parent)
  : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , dev_status(0)
    , timer(new QTimer(this))
    , hostName("192.168.50.116")
    , port(8088)
{
    ui->setupUi(this);
    startTimer(5000);
    c.C_connect(hostName, port);
    for (int i = 0; i < 7; i++) {
        fd[i] = -1; // 初始化文件描述符数组
    }
    fd[3] = open("/dev/drv_fan", O_RDWR);
    if(fd[3] < 0)
    {
        printf("app:fd[3]open_fan_err\r\n");
        exit(3);
    }
    fd[0] = open("/dev/drv_led", O_RDWR);
    if(fd[0] < 0)
    {
        printf("app:fd[0]open_led_err\r\n");
        exit(1);
    }
    fd[4] = open("/dev/drv_LED_1", O_RDWR);
    if(fd[4] < 0)
    {
        printf("app:fd[4]open_LED_1_err\r\n");
        exit(4);
    }
    fd[5] = open("/dev/drv_LED_2", O_RDWR);
    if(fd[5] < 0)
    {
        printf("app:fd[5]open_LED_2_err\r\n");
        exit(5);
    }
    fd[6] = open("/dev/drv_LED_3", O_RDWR);
    if(fd[6] < 0)
    {
        printf("app:fd[6]open_LED_3_err\r\n");
        exit(6);
    }
    fd[1] = open("/dev/drv_beep", O_RDWR);
    if(fd[1] < 0)
    {
        printf("app:fd[1]open_beep_err\r\n");
        exit(3);
    }
    fd[2] = open("/dev/drv_motor", O_RDWR);
    if(fd[2] < 0)
    {
        printf("app:fd[2]open_motor_err\r\n");
        exit(3);
    }
    fd1 = open("/dev/drv_i2c_si7600", O_RDWR); // 阻塞方式
    if (fd1 < 0)
    {
        printf("app:open_err\r\n");
        timer1->stop(); // 若打开失败，停止定时器
        return;
    }
    fd2 = open("/dev/drv_i2c_si7600", O_RDWR); // 阻塞方式
    if (fd2 < 0)
    {
        printf("app:open_err\r\n");
        timer2->stop(); // 若打开失败，停止定时器
        return;
    }
    // 启动定时器,temp
    timer1 = new QTimer(this);
    connect(timer1, &QTimer::timeout, this, &MainWindow::updateTemperature);

    // 启动定时器,humi
    timer2 = new QTimer(this);
    connect(timer2, &QTimer::timeout, this, &MainWindow::updateHumidity);

}

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

void MainWindow::timerEvent(QTimerEvent *event)
{
     //c.C_send();
     c.C_recv();
}

void MainWindow::on_user1_button_clicked()
{

    user1 *UR1=new user1;
    connect(this, &MainWindow::user1temp, UR1, &user1::showuser1data);
    UR1->show();
    user1temp();
    user1humi();
    close();

}

void MainWindow::on_guard_button_clicked()
{
    guard *GD=new guard;
    GD->show();
    close();
}

void MainWindow::on_user2_button_clicked()
{
    user2 *UR2=new user2;
    UR2->show();
    close();
}

void MainWindow::on_pushButton_clicked()
{
    ruanjiantubiao *RT=new ruanjiantubiao;
    RT->show();
    close();
}


void MainWindow::on_fan_button_clicked()
{
    qDebug()<<"isfan:"<<isfan<<endl;
    if(isfan%2)
    {
        QString data="开";
        QString text = QString("   %1").arg(data);
        ui->fan_data->setText(text);
        dev_status =1;
        qDebug()<<"dev_status:"<<dev_status<<endl;
        write(fd[3], &dev_status, sizeof(int));
    }else{
        QString data1="关";
        QString text1 = QString("   %1").arg(data1);
        ui->fan_data->setText(text1);
        dev_status=0;
        write(fd[3], &dev_status, sizeof(int));
    }
    isfan++;
}

void MainWindow::on_led_button_clicked()
{
    qDebug()<<"isled:"<<isled<<endl;
    if(isled%2)
    {
        QString data="开";
        QString text = QString("   %1").arg(data);
        ui->led_data->setText(text);
        dev_status =1;
        qDebug()<<"dev_status:"<<dev_status<<endl;
        write(fd[0], &dev_status, sizeof(int));
        write(fd[4], &dev_status, sizeof(int));
        write(fd[5], &dev_status, sizeof(int));
        write(fd[6], &dev_status, sizeof(int));
    }else{
        QString data1="关";
        QString text1 = QString("   %1").arg(data1);
        ui->led_data->setText(text1);
        dev_status=0;
        write(fd[0], &dev_status, sizeof(int));
        write(fd[4], &dev_status, sizeof(int));
        write(fd[5], &dev_status, sizeof(int));
        write(fd[6], &dev_status, sizeof(int));
    }
    isled++;
}

void MainWindow::on_buzzer_button_clicked()
{
    qDebug()<<"isbuzzer:"<<isbuzzer<<endl;
    if(isbuzzer%2)
    {
        QString data="开";
        QString text = QString("   %1").arg(data);
        ui->buzzer_data->setText(text);
        dev_status =1;
        qDebug()<<"dev_status:"<<dev_status<<endl;
        write(fd[1], &dev_status, sizeof(int));
    }else{
        QString data1="关";
        QString text1 = QString("   %1").arg(data1);
        ui->buzzer_data->setText(text1);
        dev_status=0;
        write(fd[1], &dev_status, sizeof(int));
    }
    isbuzzer++;
}

void MainWindow::on_motorm_button_clicked()
{
    qDebug()<<"ismotorm:"<<ismotorm<<endl;
    if(ismotorm%2)
    {
        QString data="开";
        QString text = QString("   %1").arg(data);
        ui->motorm_data->setText(text);
        dev_status =1;
        qDebug()<<"dev_status:"<<dev_status<<endl;
        write(fd[2], &dev_status, sizeof(int));
    }else{
        QString data1="关";
        QString text1 = QString("   %1").arg(data1);
        ui->motorm_data->setText(text1);
        dev_status=0;
        write(fd[2], &dev_status, sizeof(int));
    }
    ismotorm++;
}

void MainWindow::on_temp_button_clicked()
{
    qDebug()<<"istemp:"<<istemp<<endl;

    if (istemp % 2)
    {
        timer1->start(1000);
    }else{
        timer1->stop();
    }
    istemp++;
}

void MainWindow::updateTemperature()
{
    int fandata,buzzerdata;
    ioctl(fd1, TEMPE, &read_data);
    printf("app:read_data = %d\r\n", read_data);
    read_data = i2c_data_change(read_data);
    tempe = (175.72 * read_data) / 65536 - 46.85;
    QString text = QString(" %1").arg(tempe,0,'f',2);
    ui->temp_data->setText(text);
    if(tempe>=24)
    {
        fandata=1;buzzerdata=1;
        ui->temp_data->setStyleSheet("QLabel{background-color: red;}");
        write(fd[3], &fandata, sizeof(int));
        write(fd[1], &buzzerdata, sizeof(int));
    }else{
        fandata=0;buzzerdata=0;
        ui->temp_data->setStyleSheet("");
        write(fd[3], &fandata, sizeof(int));
        write(fd[1], &buzzerdata, sizeof(int));
    }
}

void MainWindow::on_humi_button_clicked()
{
    if (ishumi % 2)
    {
        // 设定更新时间，这里设置为 4000 毫秒（即 4 秒），可按需调整
        timer2->start(1000);
    }else{
        timer2->stop();
    }
    ishumi++;
}

void MainWindow::updateHumidity()
{
    int motormdata;
    ioctl(fd2,HUMI , &read_shidu);
    printf("app:read_shidu = %d\r\n",read_shidu);
    read_shidu = i2c_data_change(read_shidu);
    humi = (125*read_shidu)/65536-6;
    QString text = QString(" %1").arg(humi,0,'f',2);
    ui->humi_data->setText(text);
    if(humi>=93)
    {
        motormdata=1;
        ui->humi_data->setStyleSheet("QLabel{background-color: red;}");
        write(fd[2], &motormdata, sizeof(int));
    }else{
        motormdata=0;
        ui->humi_data->setStyleSheet("");
        write(fd[2], &motormdata, sizeof(int));
    }

}


/ruanjiantubiao.cpp
#include "ruanjiantubiao.h"
#include "ui_ruanjiantubiao.h"
#include "mainwindow.h"
#include <QElapsedTimer>
ruanjiantubiao::ruanjiantubiao(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::ruanjiantubiao)
{
    ui->setupUi(this);
}

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

void ruanjiantubiao::on_pushButton_clicked()
{
    jiazaitupian *splash=new jiazaitupian;
    QElapsedTimer timer;
    timer.start();
    while (timer.elapsed() < 3000) {
        splash->show();
        QCoreApplication::processEvents();
    }
    splash->close();
    close();
    MainWindow* CI = new MainWindow;
    CI->show();
}


/user1.cpp
#include "user1.h"
#include "ui_user1.h"
#include "mainwindow.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <QDebug>
#include <QString>

user1::user1(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::user1)
{
    ui->setupUi(this);
    fd3 = open("/dev/drv_i2c_si7600", O_RDWR); // 阻塞方式
    if (fd3 < 0)
    {
        printf("app:open_err\r\n");
        timer3->stop(); // 若打开失败，停止定时器
        return;
    }
    fd4 = open("/dev/drv_i2c_si7600", O_RDWR); // 阻塞方式
    if (fd4 < 0)
    {
        printf("app:open_err\r\n");
        timer4->stop(); // 若打开失败，停止定时器
        return;
    }
}

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

void user1::on_user1_withdraw_clicked()
{
    timer3->stop();
    timer4->stop();
    MainWindow *MW=new MainWindow;
    connect(this,&user1::huixiantemp,MW,&MainWindow::on_temp_button_clicked);
    connect(this,&user1::huixianhumi,MW,&MainWindow::on_humi_button_clicked);
    MW->show();
    huixiantemp();
    huixianhumi();
    close();
}

void user1::showuser1data()
{
    istemp1=1,ishumi1=1;
    if (istemp1 % 2)
    {
        // 启动定时器
        timer3 = new QTimer(this);
        connect(timer3, &QTimer::timeout, this, &user1::updateTemperature1);
        // 设定更新时间，这里设置为 2000 毫秒（即 2 秒），可按需调整
        timer3->start(1000);
    }else{
        timer3->stop();
    }

    if (ishumi1 % 2)
    {
        // 启动定时器
        timer4 = new QTimer(this);
        connect(timer4, &QTimer::timeout, this, &user1::updateHumidity1);
        // 设定更新时间，这里设置为 2000 毫秒（即 2 秒），可按需调整
        timer4->start(1000);
    }else{
        timer4->stop();
    }

}

void user1::updateTemperature1()
{

    ioctl(fd3, TEMPE, &read_data);
    printf("app:read_data = %d\r\n", read_data);
    read_data = i2c_data_change(read_data);
    tempe = (175.72 * read_data) / 65536 - 46.85;
    QString text = QString("     %1").arg(tempe,0,'f',2);
    ui->temp_data_1->setText(text);
    if(tempe>=24)
    {
        ui->temp_data_1->setStyleSheet("QLabel{background-color: red;}");
    }else{
        ui->temp_data_1->setStyleSheet("");
    }
}

void user1::updateHumidity1()
{
    ioctl(fd4,HUMI , &read_shidu);
    printf("app:read_shidu = %d\r\n",read_shidu);
    read_shidu = i2c_data_change(read_shidu);
    humi = (125*read_shidu)/65536-6;
    QString text = QString("     %1").arg(humi,0,'f',2);
    ui->humi_data_1->setText(text);
    if(humi>=93)
    {
        ui->humi_data_1->setStyleSheet("QLabel{background-color: red;}");
    }else{
        ui->humi_data_1->setStyleSheet("");
    }
}


user2.cpp
#include "user2.h"
#include "ui_user2.h"
#include "mainwindow.h"
user2::user2(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::user2)
{
    ui->setupUi(this);
}

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

void user2::on_user2_withdraw_clicked()
{
    MainWindow *MW=new MainWindow;
    MW->show();
    close();
}