SmartPDCode/Qt/QT_T113_S3_8inch_800X1280/smartPdu/portraitmode.cpp

#include "portraitmode.h"
#include "ui_portraitmode.h"
#include "mainwindow.h"
#include "QLineEdit"
#include <QAbstractItemView>
#include <QMessageBox>
#include <QtDebug>
#include "time/mytime.h"
#include "QSerialPort"
#include "QSerialPortInfo"
#include "fcntl.h"
#include <sys/ioctl.h>
#include <unistd.h>
Portraitmode::Portraitmode(QWidget *parent) :
    QWidget(nullptr)
    , ui(new Ui::Portraitmode)
    , m_main((MainWindow*)parent)
    , m_keyboard(nullptr)
    , m_timer(new QTimer)
    , m_stack(0)
    , m_send_counter(0)
    , m_recive_counter(0)

{
    ui->setupUi(this);
    m_keyboard = const_cast<SoftKeyBoard *>( m_main->get_keyboard());
    ui->horizontalLayout_17->addWidget(m_keyboard);
    qApp->installEventFilter(this);
    show_init();
    connect(ui->pushButton,&QPushButton::clicked,this,&Portraitmode::on_pushButton_clicked);
    connect(ui->p_btn_reflash,&QPushButton::clicked,this,&Portraitmode::on_btn_refresh);
    connect(this,&Portraitmode::stop_signal,m_main,&MainWindow::opt_stop_or_start_signal);
    connect(ui->p_btn_open,&QPushButton::clicked,this,&Portraitmode::on_p_btn_open);
    connect(m_timer,&QTimer::timeout,this,&Portraitmode::update_ui);
    connect(ui->p_btn_send,&QPushButton::clicked,m_main,&MainWindow::test_modbus);
    connect(ui->p_btn_clear,&QPushButton::clicked,this,&Portraitmode::p_btn_clear);
    connect(ui->p_btn_save,&QPushButton::clicked,this,&Portraitmode::on_btn_save);
    connect(ui->slider_screen,&QSlider::sliderMoved,this,&Portraitmode::slider_move);

    on_btn_refresh();

    m_timer->start(1000);

}
void Portraitmode:: reset_widget(int index)
{
    ChannelInfo * m_channel = m_main ->get_channel_info();
    for(int i = 0;i < MAX_CHANNELS;i++)
    {
        ui->gridLayout_7->addWidget(&m_channel[i],i%5,i/5);
    }
    ui->horizontalLayout_17->addWidget(m_keyboard);
    m_timer->start();
    if(index == 1)
    {
        ui->textEdit->clear();
        ui->p_line_send->clear();
        ui->p_line_recive->clear();
        ui->line_year->clear();
        ui->line_mon->clear();
        ui->line_day->clear();
        ui->line_hour->clear();
        ui->line_min->clear();
        ui->line_sec->clear();
        ui->slider_screen ->setValue(m_main->britnight);

    }
    ui->stackedWidget->setCurrentIndex(index);
    qApp->installEventFilter(this);
}

void Portraitmode:: test_modbus_info(QString &send,QString &recived,uint8_t send_flag,uint8_t recive_flag)
{
    if(send_flag)
    {
        ui->textEdit->append(send);
        m_send_counter++;
    }
    if(recive_flag)
    {
        ui->textEdit->append(recived);
        m_recive_counter++;
    }

    ui->p_line_send->setText(QString::number(m_send_counter));
    ui->p_line_recive->setText(QString::number(m_recive_counter));
}


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

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


    bool flag = QDate::isValid(ui->line_year->text().toInt(),ui->line_mon->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_mon->text(),
             ui->line_day->text(),ui->line_hour->text(),
             ui->line_min->text(),ui->line_sec->text(),
             ui->comboBox_zone->currentText());

}

int Portraitmode :: 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;

    QTimeZone m_zone = m_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 Portraitmode::on_btn_refresh()
{
    ui->comboBox_port->clear();
    const QList <QSerialPortInfo> portList = QSerialPortInfo ::availablePorts();
    for(const  QSerialPortInfo &porInfo :portList)
    {
        if(porInfo.portName() == "ttyS3")
            continue;
        if(m_main && porInfo.portName() == m_main->get_modbus_info().serial_name)
        {

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

}


void Portraitmode::p_btn_clear()
{
    ui->textEdit->clear();
    ui->p_line_send->clear();
    ui->p_line_recive->clear();
    m_send_counter = 0;
    m_recive_counter = 0;
}
void Portraitmode :: update_ui()
{
    QString strTemp;
    strTemp=QString::number(m_main->pdu_all_info.AllVoltage_L1, 'f', 2);
    ui->l_l1_v->setText(strTemp);
    strTemp=QString::number(m_main->pdu_all_info.AllVoltage_L2, 'f', 2);
    ui->l_l2_v->setText(strTemp);

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


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

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

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

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

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

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

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


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


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


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

    ChannelInfo * m_channel = m_main ->get_channel_info();
    for(int i = 0 ;i < MAX_CHANNELS ;i++)
    {
        m_channel[i].chid = i+1;
        m_channel[i].chV = m_main->pdu_ch_info[i].CHVoltage;
        m_channel[i].chI = m_main->pdu_ch_info[i].CHCurrent;
        m_channel[i].chStatus = m_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 Portraitmode:: on_p_btn_open()
{
    if(ui->p_btn_open->text() == "关闭")
    {

        ui->comboBox_band->setEnabled(true);
        ui->comboBox_data->setEnabled(true);
        ui->comboBox_priaty->setEnabled(true);
        ui->comboBox_stop->setEnabled(true);
        ui->comboBox_port->setEnabled(true);
        ui->comboBox_addr->setEnabled(true);
        //send  single to main and stop read data
        //emit stop_signal(false);
        ui->p_btn_open->setText("打开");
    }else
    {
        ui->comboBox_band->setEnabled(false);
        ui->comboBox_data->setEnabled(false);
        ui->comboBox_priaty->setEnabled(false);
        ui->comboBox_stop->setEnabled(false);
        ui->comboBox_port->setEnabled(false);
        ui->comboBox_addr->setEnabled(false);
        modbus_info_t md_info = {0};
        md_info.slave_addr = ui->comboBox_addr->currentText().toUShort();

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

        md_info.serial_banud = ui->comboBox_band->currentText().toUInt();
        md_info.serial_stop = ui->comboBox_stop->currentText().toUInt();
        md_info.serial_data_bit = ui->comboBox_data->currentText().toUInt();
        if(ui->comboBox_priaty->currentText() == "None")
            md_info.serial_parity = 'N';
        else if(ui->comboBox_priaty->currentText() == "Even")
            md_info.serial_parity = 'E';
        else if(ui->comboBox_priaty->currentText() == "Odd")
            md_info.serial_parity = 'O';

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


void Portraitmode::on_pushButton_clicked()
{
    if(m_stack == 0)
    {
        emit stop_signal(true);
        m_timer->stop();
        ui->stackedWidget->setCurrentIndex(1);
        m_stack = 1;

        ui->comboBox_band->setEnabled(false);
        ui->comboBox_data->setEnabled(false);
        ui->comboBox_priaty->setEnabled(false);
        ui->comboBox_stop->setEnabled(false);
        ui->comboBox_port->setEnabled(false);
        ui->comboBox_addr->setEnabled(false);
        ui->p_btn_open->setText("关闭");
        m_send_counter = 0;
        m_recive_counter = 0;

    }else
    {
       ui->textEdit->clear();
        m_keyboard->hide();
        ui->stackedWidget->setCurrentIndex(0);
        emit stop_signal(false);
        m_timer->start();
        m_stack = 0;
        m_send_counter = 0;
        m_recive_counter = 0;
    }
    m_main->page = m_stack;
}

void Portraitmode::show_init()
{
    ChannelInfo * m_channel = m_main ->get_channel_info();
    for(int i = 0;i < MAX_CHANNELS;i++)
    {
        ui->gridLayout_7->addWidget(&m_channel[i],i%5,i/5);
    }

    ui->line_year->setValidator(new QIntValidator(1970,9999,this));
    ui->line_mon->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_addr->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    ui->comboBox_addr->view()->setMaximumHeight(250);
    ui->comboBox_addr->view()->parentWidget()->setMaximumHeight(250);

    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 = m_main->get_modbus_info();
    for(int i = 0;i < 31;i++)
    {
        ui->comboBox_addr->addItem(QString::number(i+1));
        if(info.slave_addr == (i+1))
        {
            ui->comboBox_addr->setCurrentIndex(i);
        }
    }
    ui->comboBox_band->clear();
    ui->comboBox_band->addItem("115200");
    ui->comboBox_band->addItem("4800");
    ui->comboBox_band->addItem("9600");
    ui->comboBox_band->addItem("19200");
    ui->comboBox_band->addItem("38400");




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


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

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

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

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


         for(int i = 0;i < ui->comboBox_priaty->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_priaty->itemText(i) == str)
             {
                 ui->comboBox_priaty->setCurrentIndex(i);
                 break;
             }
         }

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



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

void Portraitmode::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);
    m_main->britnight = val;
}



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



void Portraitmode::on_FocustChanged(QWidget* old,QWidget *now)
{
    if(now && qobject_cast<QLineEdit*>(now) && qobject_cast<QLineEdit*>(now) != ui->p_line_send && qobject_cast<QLineEdit*>(now) != ui->p_line_recive)
    {
        qDebug() << "????????";
        if(m_cur_edit != now || m_keyboard->isHidden()==true)
        {
            m_keyboard->show();
            m_keyboard->SetMaster(now);
            m_cur_edit = now;
        }
    }
}

bool Portraitmode::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);
}