SmartPDCode/Qt/QT_T113_S3_8inch_1200X1920/smartPdu/landscape.cpp

#include "landscape.h"
#include "ui_landscape.h"
#include "softkeyboard.h"
#include "QDebug"
#include <QApplication>
#include "QThread"
#include <QLineEdit>
#include <mainwindow.h>
#include <QAbstractItemView>
#include <QListView>
#include <QIntValidator>
#include <QLineEdit>
#include <QMessageBox>
#include <QDate>
#include <QDateTime>
#include <QTimeZone>

#include "time/mytime.h"
#include "fcntl.h"
#include <sys/ioctl.h>
#include <unistd.h>




Landscape::Landscape(QWidget *parent) :
    QWidget(nullptr),
    ui(new Ui::Landscape),
    m_master(parent),
    m_timer(new QTimer),
    m_kongbai_up(new kongbai),
    m_kongbai_down(new kongbai)
{
    ui->setupUi(this);
    ui->verticalLayout_4->addWidget(m_kongbai_up);
    ui->verticalLayout_5->addWidget(m_kongbai_down);

    MainWindow *main = dynamic_cast<MainWindow*>(m_master);


    keyboard = const_cast<SoftKeyBoard*>(main->get_keyboard()) ;
    ui->horizontalLayout_21->addWidget(keyboard);
   //keyboard->show();
    qApp->installEventFilter(this);
    ChannelInfo * m_channel = main ->get_channel_info();
    m_stack = 0;
    for(int i = 0;i < MAX_CHANNELS;i++)
    {
        ui->gridLayout_8->addWidget(&m_channel[i],i/5,i%5);
    }

    connect(ui->p_btn_refresh,&QPushButton::clicked,this,&Landscape::on_btn_refresh);
    connect(this,&Landscape::stop_signal,main,&MainWindow::opt_stop_or_start_signal);
    connect(ui->p_btn_open,&QPushButton::clicked,this,&Landscape::on_p_btn_open);
    connect(m_timer,&QTimer::timeout,this,&Landscape::update_ui);
    connect(ui->p_btn_send,&QPushButton::clicked,main,&MainWindow::test_modbus);
    connect(ui->p_btn_clear,&QPushButton::clicked,this,&Landscape::p_btn_clear);
    connect(ui->p_btn_save,&QPushButton::clicked,this,&Landscape::on_btn_save);
    connect(ui->screen_light,&QSlider::sliderMoved,this,&Landscape::slider_move);


    on_btn_refresh();
    ui->comboBox_saddr->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    ui->comboBox_saddr->view()->setMaximumHeight(250);
    ui->comboBox_saddr->view()->parentWidget()->setMaximumHeight(250);


    ui->line_year->setValidator(new QIntValidator(1970,9999,this));
    ui->line_mouth->setValidator(new QIntValidator(1,12,this));
    ui->line_day->setValidator(new QIntValidator(1,31,this));
    ui->line_hour->setValidator(new QIntValidator(0,23,this));
    ui->line_min->setValidator(new QIntValidator(0,59,this));
    ui->line_sec->setValidator(new QIntValidator(0,59,this));


    ui->comboBox_zone->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    ui->comboBox_zone->view()->setMaximumHeight(250);
    ui->comboBox_zone->view()->parentWidget()->setMaximumHeight(250);

    for(int i = -11;i < 12;i++)
    {
        QString str = i > 0 ? "+" +QString::number(i) : QString::number(i);

        ui->comboBox_zone->addItem("GMT/UTC "+ str);
        if(i == 8)
        {
            ui->comboBox_zone->setCurrentText("GMT/UTC "+ str);
        }
    }

    modbus_info_t info = main->get_modbus_info();
    for(int i = 0;i < 31;i++)
    {
        ui->comboBox_saddr->addItem(QString::number(i+1));
        if(info.slave_addr == (i+1))
        {
            ui->comboBox_saddr->setCurrentIndex(i);
        }
    }
    qDebug() << ui->comboBox_saddr->view()->maximumHeight();

    ui->comboBox_bound->clear();
    ui->comboBox_bound->addItem("115200");
    ui->comboBox_bound->addItem("4800");
    ui->comboBox_bound->addItem("9600");
    ui->comboBox_bound->addItem("19200");
    ui->comboBox_bound->addItem("38400");




     ui->comboBox_data_bit->clear();
     ui->comboBox_data_bit->addItem("8");
     ui->comboBox_data_bit->addItem("7");
     ui->comboBox_data_bit->addItem("6");


     ui->comboBox_stop_bit->clear();
     ui->comboBox_stop_bit->addItem("1");
     ui->comboBox_stop_bit->addItem("2");

     ui->comboBox_checkbit->clear();
     ui->comboBox_checkbit->addItem("None");
     ui->comboBox_checkbit->addItem("Even");
     ui->comboBox_checkbit->addItem("Odd");



    if(main)
    {
        for(int i = 0;i < ui->comboBox_bound->count();i++)
        {
            if( ui->comboBox_bound->itemText(i).toUInt() == info.serial_banud)
            {
                ui->comboBox_bound->setCurrentIndex(i);
                break;
            }
        }

        for(int i = 0;i < ui->comboBox_data_bit->count();i++)
        {
            if( ui->comboBox_data_bit->itemText(i).toUInt() == info.serial_data_bit)
            {
                 ui->comboBox_data_bit->setCurrentIndex(i);
                break;
            }
        }


        for(int i = 0;i < ui->comboBox_checkbit->count();i++)
        {
            QString  str = "";
            if(info.serial_parity == 'N')
            {
                str = "None";
            }else if(info.serial_parity == 'E')
            {
                str = "Even";
            }else if(info.serial_parity == 'O')
            {
                str = "Odd";
            }
            if( ui->comboBox_checkbit->itemText(i) == str)
            {
                ui->comboBox_checkbit->setCurrentIndex(i);
                break;
            }
        }

        for(int i = 0;i < ui->comboBox_stop_bit->count();i++)
        {
            if( ui->comboBox_stop_bit->itemText(i).toUInt() == info.serial_stop)
            {
                ui->comboBox_stop_bit->setCurrentIndex(i);
                break;
            }
        }
    }

    m_timer->start(1000);
}

void Landscape:: reset_widget(int index)
{
    MainWindow *main = dynamic_cast<MainWindow*>(m_master);
    ChannelInfo * m_channel = main ->get_channel_info();
    for(int i = 0;i < MAX_CHANNELS;i++)
    {
        ui->gridLayout_8->addWidget(&m_channel[i],i/5,i%5);
    }
   ui->horizontalLayout_21->addWidget(keyboard);
   if(index == 1)
   {
       ui->textEdit->clear();
       ui->l_line_send->clear();
       ui->l_line_recive->clear();
       ui->line_year->clear();
       ui->line_mouth->clear();
       ui->line_day->clear();
       ui->line_hour->clear();
       ui->line_min->clear();
       ui->line_sec->clear();
       ui->screen_light ->setValue(main->britnight);
   }
   ui->stackedWidget->setCurrentIndex(index);
   m_timer->start();
   qApp->installEventFilter(this);
}

void Landscape::block()
{
    m_timer->stop();
    qApp->removeEventFilter(this);
}



void Landscape::update_ui()
{
    QString strTemp;
    MainWindow *main = dynamic_cast<MainWindow*>(m_master);
    strTemp=QString::number(main->pdu_all_info.AllVoltage_L1, 'f', 2);
    ui->l_l1_v->setText(strTemp);
    strTemp=QString::number(main->pdu_all_info.AllVoltage_L2, 'f', 2);
    ui->l_l2_v->setText(strTemp);

    strTemp=QString::number(main->pdu_all_info.AllVoltage_L3, 'f', 2);
    ui->l_l3_v->setText(strTemp);


    strTemp=QString::number(main->pdu_all_info.AllCurrent_L1, 'f', 2);
    ui->l_l1_i->setText(strTemp);

    strTemp=QString::number(main->pdu_all_info.AllCurrent_L2, 'f', 2);
    ui->l_l2_i->setText(strTemp);

    strTemp=QString::number(main->pdu_all_info.AllCurrent_L2, 'f', 2);
    ui->l_l3_i->setText(strTemp);

    strTemp=QString::number(main->pdu_all_info.Sensor_Temperature, 'f', 2);
    ui->l_temp->setText(strTemp);

    strTemp=QString::number(main->pdu_all_info.Sensor_Humidity, 'f', 2);
    ui->l_humi->setText(strTemp);

    if(main->pdu_all_info.Sensor_LeakFlag)
    {
        ui->l_water->setText("泄露");
    }else
    {
        ui->l_water->setText("未泄露");
    }

    strTemp=QString::number(main->pdu_all_info.Sensor_INTemperature, 'f', 2);
    ui->l_in_temp->setText(strTemp);


    strTemp=QString::number(main->pdu_all_info.Sensor_IN_Pressure, 'f', 2);
    ui->l_in_pressure->setText(strTemp);


    strTemp=QString::number(main->pdu_all_info.Sensor_OUTTemperature, 'f', 2);
    ui->l_out_temp->setText(strTemp);


    strTemp=QString::number(main->pdu_all_info.Sensor_OUT_Pressure, 'f', 2);
    ui->l_out_pressure->setText(strTemp);

    ChannelInfo * m_channel = main ->get_channel_info();
    for(int i = 0 ;i < MAX_CHANNELS ;i++)
    {
        m_channel[i].chid = i+1;
        m_channel[i].chV = main->pdu_ch_info[i].CHVoltage;
        m_channel[i].chI = main->pdu_ch_info[i].CHCurrent;
        m_channel[i].chStatus = main->pdu_ch_info[i].CHStatus;
        //m_channel[i].chStatus = 1;
        m_channel[i].UpdateStatusInfo();
    }
    QDate today = QDate::currentDate();
    QTime currentTime = QTime::currentTime();
    ui->label_2->setText(today.toString("yyyy/MM/dd"));
    ui->label_3->setText(currentTime.toString("hh:mm:ss"));
}


void Landscape :: on_p_btn_open()
{
    if(ui->p_btn_open->text() == "关闭")
    {
        qDebug() << "wocao";

        ui->comboBox_bound->setEnabled(true);
        ui->comboBox_data_bit->setEnabled(true);
        ui->comboBox_checkbit->setEnabled(true);
        ui->comboBox_stop_bit->setEnabled(true);
        ui->comboBox_serial->setEnabled(true);
        ui->comboBox_saddr->setEnabled(true);
        ui->p_btn_open->setText("打开");
    }else
    {
        qDebug() << "wocao111";
        ui->comboBox_bound->setEnabled(false);
        ui->comboBox_data_bit->setEnabled(false);
        ui->comboBox_checkbit->setEnabled(false);
        ui->comboBox_stop_bit->setEnabled(false);
        ui->comboBox_serial->setEnabled(false);
        ui->comboBox_saddr->setEnabled(false);
        MainWindow *main = dynamic_cast<MainWindow*>(m_master);
        modbus_info_t md_info = {0};
        md_info.slave_addr = ui->comboBox_saddr->currentText().toUShort();

        QByteArray ba =  ui->comboBox_serial->currentText().toUtf8();
        strcpy(md_info.serial_name,ba.data());

        md_info.serial_banud = ui->comboBox_bound->currentText().toUInt();
        md_info.serial_stop = ui->comboBox_stop_bit->currentText().toUInt();
        md_info.serial_data_bit = ui->comboBox_data_bit->currentText().toUInt();
        if(ui->comboBox_checkbit->currentText() == "None")
            md_info.serial_parity = 'N';
        else if(ui->comboBox_checkbit->currentText() == "Even")
            md_info.serial_parity = 'E';
        else if(ui->comboBox_checkbit->currentText() == "Odd")
            md_info.serial_parity = 'O';

        int ret = main->modbus_set(md_info);
        if(!ret)
            ui->p_btn_open->setText("关闭");
    }
}


Landscape::~Landscape()
{
    delete ui;
    delete keyboard;
    delete m_kongbai_up;
    delete m_kongbai_down;
}

struct disp_brightness_info {
    unsigned int screen_id;
    unsigned int brightness;
};


void Landscape::slider_move(int val)
{
    struct disp_brightness_info info;
    info.screen_id = 0;
    info.brightness = 255 - val;
    int fd = open("/dev/disp", O_RDWR);
    int ret = ioctl(fd, 0X102, &info);
     ::close(fd);
    MainWindow *main = dynamic_cast<MainWindow*>(m_master);
    main->britnight = val;
}

void Landscape::on_btn_refresh()
{
    ui->comboBox_serial->clear();
    MainWindow *main = dynamic_cast<MainWindow*>(m_master);
    const QList <QSerialPortInfo> portList = QSerialPortInfo ::availablePorts();
    for(const  QSerialPortInfo &porInfo :portList)
    {
        if(porInfo.portName() == "ttyS3")
            continue;
        if(main && porInfo.portName() == main->get_modbus_info().serial_name)
        {

            ui->comboBox_serial->insertItem(0,porInfo.portName());
            ui->comboBox_serial->setCurrentText(porInfo.portName());
            continue;
        }
        ui->comboBox_serial->addItem(porInfo.portName());
    }

}

//void Landscape :: on_p_btn_send()
//{
//    emit test_modbus();
//}

int Landscape :: set_time(QString year,QString mon,QString day,QString hour,QString min,QString sec,QString zone)
{
    QRegularExpression re("[-+]?\\d+(\\.\\d+)?");
    QRegularExpressionMatch m = re.match(zone);
    int num = 0;
    int sys_num = 0;
    MainWindow *main = dynamic_cast<MainWindow*>(m_master);

    QTimeZone m_zone = main->get_zone();
    if (m.hasMatch()) {
        QString numStr = m.captured(0);
        num = numStr.toInt();
        qDebug() << "第一个数字:" << num;
    }
    m = re.match(QString(m_zone.id()));

    if (m.hasMatch()) {
        QString numStr = m.captured(0);
        sys_num = numStr.toInt();
        qDebug() << "第?个数字:" << sys_num;
    }
    if((num+sys_num) != 0)
    {
        char buff[128] = {0};
        sprintf(buff,"ln -sf /usr/share/zoneinfo/GMT%s%d /etc/localtime",(num < 0)?"+":"-", abs(num));
        system(buff);
    }

    struct tm tm_new;

    tm_new.tm_year = year.toUInt();
    tm_new.tm_mon  = mon.toUInt();
    tm_new.tm_mday = day.toUInt();

    tm_new.tm_hour = hour.toUInt();
    tm_new.tm_min = min.toUInt();
    tm_new.tm_sec = sec.toUInt();
    return  set_time_zone(&tm_new,num);
}




void Landscape:: on_btn_save()
{
    QString wanning="";


    bool flag = QDate::isValid(ui->line_year->text().toInt(),ui->line_mouth->text().toInt(),ui->line_day->text().toInt());
    if(flag == false)
    {
         QMessageBox::warning(this, "警告", "日期错误警告");
         return;
    }

    flag = QTime::isValid(ui->line_hour->text().toInt(),ui->line_min->text().toInt(),ui->line_sec->text().toInt());
    if(flag == false)
    {
         QMessageBox::warning(this, "警告", "时间错误警告");
         return;
    }
    set_time(ui->line_year->text(),ui->line_mouth->text(),
             ui->line_day->text(),ui->line_hour->text(),
             ui->line_min->text(),ui->line_sec->text(),
             ui->comboBox_zone->currentText());

}
void Landscape::on_pushButton_clicked()
{
    MainWindow *main = dynamic_cast<MainWindow*>(m_master);
    if(m_stack == 0)
    {
        emit stop_signal(true);
        m_timer->stop();
        ui->stackedWidget->setCurrentIndex(1);
        m_stack = 1;

        ui->comboBox_bound->setEnabled(false);
        ui->comboBox_data_bit->setEnabled(false);
        ui->comboBox_checkbit->setEnabled(false);
        ui->comboBox_stop_bit->setEnabled(false);
        ui->comboBox_serial->setEnabled(false);
        ui->comboBox_saddr->setEnabled(false);
        ui->p_btn_open->setText("关闭");
        send_counter = 0;
        recive_counter = 0;
    }else
    {
       ui->textEdit->clear();
        keyboard->hide();
        ui->stackedWidget->setCurrentIndex(0);
        emit stop_signal(false);
        m_timer->start();
        m_stack = 0;
        send_counter = 0;
        recive_counter = 0;
    }
    main->page = m_stack;
}
void Landscape::on_FocustChanged(QWidget* old,QWidget *now)
{
    if(now && qobject_cast<QLineEdit*>(now) && qobject_cast<QLineEdit*>(now) != ui->l_line_send &&qobject_cast<QLineEdit*>(now) != ui->l_line_recive)
    {
        qDebug() << "!!!!!!!!";
        if(m_cur_edit != now || keyboard->isHidden()==true)
        {
            keyboard->show();
            keyboard->SetMaster(now);
            m_cur_edit = now;
        }
    }
}
void Landscape::p_btn_clear()
{
    ui->textEdit->clear();
    ui->l_line_send->clear();
    ui->l_line_recive->clear();
    send_counter = 0;
    recive_counter = 0;
}


void Landscape:: test_modbus_info(QString &send,QString &recived,uint8_t send_flag,uint8_t recive_flag)
{
    if(send_flag)
    {
        ui->textEdit->append(send);
        send_counter++;
    }
    if(recive_flag)
    {
        ui->textEdit->append(recived);
        recive_counter++;
    }

    ui->l_line_send->setText(QString::number(send_counter));
    ui->l_line_recive->setText(QString::number(recive_counter));
}

bool Landscape::eventFilter(QObject *watched, QEvent *event)
{
    if (event->type() == QEvent::FocusIn) {
        QWidget *now = qobject_cast<QWidget*>(watched);
        on_FocustChanged(nullptr,now);

    } else if (event->type() == QEvent::FocusOut) {
    }
    return QObject::eventFilter(watched, event);
}