物流定位系统项目qt代码

#ifndef USER_INTERFACE_H
#define USER_INTERFACE_H

#include <QWidget>
#include <QLabel>
#include <QMouseEvent>
#include <qpropertyanimation.h>
#include <QProcess>
#include <QTimer>
#include <QString>
#include <QDebug>
#include <QTime>
#include <QUdpSocket>
#include <QtSql>
#include <stdio.h>//标准io定义
#include <fcntl.h>//文件控制定义
#include <unistd.h>//unix标准函数定义
#include <stdlib.h>//标准函数库定义
#include <termios.h>//PPSIX终端控制定义
#include <sys/types.h>
#include <sys/time.h>//kill函数需要用到的头文件
#include <signal.h>//kill函数需要用到的头文件
#include <errno.h>//错误号定义
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <QThread>
#include <QMessageBox>
#include <QtNetwork/QUdpSocket>
#include <malloc.h>

void gps_open(void);//打开gps模块
void gps_set_serial(int fd, int speed, int bits, char event, int stop);//gps模块串口参数设置
void gps_close(void);//关闭gps模块
void gsm_open(void);//打开gsm模块设备节点
void gsm_close(void);//关闭gsm模块设备节点
void gsm_set_serial(int fd, int speed, int bit, char event, int stop);//设置串口参数
void gsm_read(void);//读取gsm模块信息
void gsm_calling(void);//打电话
void gsm_cut(void);//挂断电话
void gsm_apn_set(void);//设置APN无线接入点
void gsm_ppp_dialing(void);//进行ppp拨号,实现PDP激活和TCPIP的初始化
void gsm_ip_open(void);//打开一条TCP或UDP连接
void gsm_data_send(char *p);//发送数据
void gsm_ip_close(void);//关闭连接
void gsm_iomode(void);//设置数据模式
char *gsm_data_transfer(char *data);//转换发送数据为数据ascii码对应的十六进制数
void socket_send(char *time,char *latitude,char *N_S ,char *longitude,char *E_W,char *satellite);//发送经纬度
void socket_close(void);//关闭socket
void socket_open(void);//创建socket

namespace Ui {
class user_interface;
class MyThread;
}

class MyThread : public QThread
{
    Q_OBJECT
public:
    int flag_thread;//线程标志位

protected:

private:
    void run();//线程函数
    QUdpSocket *udpsocket_sender;//发送卫星号信息
    QUdpSocket *udpsocket_sender_traffic;//发送预警信息
};

class user_interface : public QWidget
{
    Q_OBJECT
    
public:
    explicit user_interface(QWidget *parent = 0);
    ~user_interface();

private slots:
    /******************************home界面槽函数******************************/
    void on_button_home_clicked();//home按钮槽函数
    void on_button_music_clicked();//music按钮槽函数
    void on_button_gps_clicked();//gps按钮槽函数

    /******************************gps界面槽函数******************************/
    void read_pending_datagrams_1();//获取经纬度槽函数
    void read_pending_datagrams_2();//获取卫星号槽函数
    void on_button_run_clicked();//run按钮槽函数

    /******************************music界面槽函数******************************/
    void timer_traffic_slot();//预警计时器槽函数
    void timer_music_slot();//从预警播放跳回音乐播放计时器槽函数
    void catch_output();//进度条滚动槽函数
    void get_current_time();//获取当前播放时间槽函数
    void read_pending_datagrams();//获取预警信号槽函数
    void on_button_play_clicked();//play按钮槽函数
    void on_button_last_clicked();//last按钮槽函数
    void on_button_next_clicked();//next按钮槽函数
    void on_button_down_clicked();//down按钮槽函数
    void on_button_up_clicked();//up按钮槽函数
    void on_timeline_sliderMoved(int position);//歌曲进度条槽函数

private:
    /******************************home界面******************************/
    Ui::user_interface *ui;//ui界面指针
    QPropertyAnimation *propertyanimation_home;//home按钮动画指针
    QPropertyAnimation *propertyanimation_music;//music按钮动画指针
    QPropertyAnimation *propertyanimation_gps;//gps按钮动画指针
    void mousePressEvent(QMouseEvent *);//鼠标点击时间函数
    void time_show();//显示系统时间函数
    void home_show();//显示home界面函数
    void home_hide();//隐藏home界面函数
    int flag_event;

    /******************************gps界面******************************/
    MyThread *thread;  //创建一个线程，用于执行有关采集gps的信息函数，若直接使用会导致界面卡死
    QUdpSocket *udpsocket_receiver1;//创建一个receiver用于接收自己发出去的经纬度信息
    QUdpSocket *udpsocket_receiver2;//创建一个receiver用于接受自己发出去的卫星号和卫星强度信息
    void gps_show();//显示gps界面函数
    void gps_hide();//隐藏gps界面函数
    int flag_run;//run按钮标志位
    int flag_strength;//卫星强度标志位

    /******************************music界面******************************/
    QProcess *process_music;//音乐进程
    QProcess *process_record;//录音进程,即预警信息
    QTimer *timer_timeline;//音乐时间滑动条计时器
    QTimer *timer_traffic;//预警计时器
    QTimer *timer_music;//音乐计时器
    QString string_player;//
    QString string_name;
    QString time_transfer(int string_time);
    QUdpSocket *udpsocket_receiver;
    QStringList stringlist_song;
    QStringList stringlist_event;
    QStringList stringlist_record;
    QSqlDatabase db;
    QSqlQuery *query;
    QFileInfoList fileinfolist;
    int flag_play;
    int flag_loop;
    int flag_name;
    int time;
    int int_current_time;
    char back_name[20];
    char back_time[10];
    void music_show();//显示music界面函数
    void music_hide();//隐藏music界面函数
    void traffic_warning();//预警播放初始化函数
};

#endif // USER_INTERFACE_H

函数实现

#include "user_interface.h"
#include "ui_user_interface.h"
#define SIZE 1024
#define IP "127.0.0.1"
#define PORT1 10000
#define PORT2 20000
#define PORT3 30000
#define GPS "/dev/ttyUSB0"
#define GSM "/dev/ttyUSB1"

int gps_fd;//gps设备文件描述符
int gsm_fd;//gsm模块句柄
char a[100];//用于保存转码后的gps数据
int socket_fd;

user_interface::user_interface(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::user_interface)
{
    /******************************home界面******************************/
    ui->setupUi(this);
    home_show();//显示出home界面
    time_show();//显示实时时间
    flag_event = 0;//鼠标事件标志位

    propertyanimation_home = new QPropertyAnimation(ui->button_home, "geometry");
    propertyanimation_music = new QPropertyAnimation(ui->button_music, "geometry");
    propertyanimation_gps = new QPropertyAnimation(ui->button_gps, "geometry");

    /******************************gps界面******************************/
    thread = new MyThread();//为线程开辟空间并且初始化

    udpsocket_receiver1 = new QUdpSocket(this);//为udpsocket开辟空间并且初始化
    udpsocket_receiver1->bind(PORT1, QUdpSocket::ShareAddress);//绑定端口
    connect(udpsocket_receiver1, SIGNAL(readyRead()),this, SLOT(read_pending_datagrams_1()));

    udpsocket_receiver2 = new QUdpSocket(this);//为udpsocket开辟空间并且初始化
    udpsocket_receiver2->bind(PORT2, QUdpSocket::ShareAddress);//绑定端口
    connect(udpsocket_receiver2, SIGNAL(readyRead()),this, SLOT(read_pending_datagrams_2()));

    ui->strength1->setValue(0);
    ui->strength1->setRange(0, 99);
    ui->strength2->setValue(0);
    ui->strength2->setRange(0, 99);
    ui->strength3->setValue(0);
    ui->strength3->setRange(0, 99);
    ui->strength4->setValue(0);
    ui->strength4->setRange(0, 99);
    ui->strength5->setValue(0);
    ui->strength5->setRange(0, 99);
    ui->strength6->setValue(0);
    ui->strength6->setRange(0, 99);

    flag_run = 0;
    flag_strength = 0;

    gps_open();//打开gps模块设备节点
    gsm_open();//打开gsm模块设备节点
    socket_open();
    gps_set_serial(gps_fd, 4800, 8, 'N', 1);//设置gps串口参数
    gsm_set_serial(gsm_fd, 9600, 8, 'N', 1);//设置gsm串口参数
    thread->flag_thread = 1;
    thread->start();

    /******************************music界面******************************/
    udpsocket_receiver = new QUdpSocket(this);
    udpsocket_receiver->bind(PORT3, QUdpSocket::ShareAddress);
    connect(udpsocket_receiver, SIGNAL(readyRead()),this, SLOT(read_pending_datagrams()));

    process_music = new QProcess(this);
    connect(process_music, SIGNAL(readyReadStandardOutput()), this, SLOT(catch_output()));

    timer_timeline = new QTimer(this);
    connect(timer_timeline, SIGNAL(timeout()), this, SLOT(get_current_time()));

    process_record = new QProcess(this);

    timer_traffic = new QTimer(this);
    connect(timer_traffic, SIGNAL(timeout()), this, SLOT(timer_traffic_slot()));

    timer_music = new QTimer(this);
    connect(timer_music, SIGNAL(timeout()), this, SLOT(timer_music_slot()));

    flag_play = 0;
    flag_loop = 1;
    time = 0;

    traffic_warning();
}

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

void user_interface::on_button_home_clicked()
{
    music_hide();
    gps_hide();
    home_show();

    flag_event = 0;
}

void user_interface::on_button_music_clicked()
{
    home_hide();
    gps_hide();
    music_show();

    flag_event = 0;
}

void user_interface::on_button_gps_clicked()
{
    home_hide();
    music_hide();
    gps_show();

    flag_event = 0;
}

void user_interface::time_show()
{
    QTime time_current = QTime::currentTime();
    QString string_time = time_current.toString("hh:mm ");
    QPalette palette_time;
    palette_time.setColor(QPalette::WindowText,Qt::black);//配置颜色
    ui->time->setPalette(palette_time);//设置颜色
    ui->time->setFont(QFont( "Timers" , 30 ,  QFont::Bold) );//设置字体
    ui->time->setText (string_time);

    QDate date_date = QDate::currentDate();
    QString string_date = date_date.toString("dddd");
    palette_time.setColor(QPalette::WindowText,Qt::black);//配置颜色
    ui->day->setPalette(palette_time);//设置颜色
    QFont font_date("Timers" , 15 ,  QFont::Light);//配置字体
    ui->day->setFont(font_date);//设置字体
    ui->day->setText(string_date);
    ui->date->setPalette(palette_time);
    ui->date->setFont(QFont( "Timers" , 15 ,  QFont::Light));//设置字体
    string_date = date_date.toString("MM/dd");
    ui->date->setText(string_date);
}

void user_interface::home_show()
{
    ui->time->show();//显示时间
    ui->time->setGeometry(QRect(30, 30, 121, 35));

    ui->date->show();//显示日期
    ui->date->setGeometry(QRect(30, 60, 61, 31));

    ui->day->show();//显示星期几
    ui->day->setGeometry(QRect(85, 60, 100, 31));

    ui->background->show();//显示背景
    ui->background->setStyleSheet("border-image: url(./image/home_background.png);");
    ui->background->setGeometry(QRect(0, 0, 480, 272));

    ui->sun->show();//显示太阳
    ui->sun->setStyleSheet("border-image: url(./image/sun.png);");
    ui->sun->setGeometry(QRect(340, 5, 128, 128));

    ui->temperature->show();//显示温度
    ui->temperature->setGeometry(QRect(385, 45, 50, 50));
    ui->temperature->setText("18");
    ui->temperature->setStyleSheet("color:white");
    QFont font_temperature;
    font_temperature.setPointSize(30);
    ui->temperature->setFont(font_temperature);
}

void user_interface::home_hide()//隐藏home界面
{
    ui->time->hide();
    ui->date->hide();
    ui->day->hide();
    ui->sun->hide();
    ui->temperature->hide();
    ui->button_gps->hide();
    ui->button_home->hide();
    ui->button_music->hide();
    ui->background_mh->hide();
}

void user_interface::mousePressEvent(QMouseEvent *)//鼠标点击事件槽函数
{
    if( flag_event==0 ){
        ui->button_home->show();
        ui->button_home->setStyleSheet("QPushButton{border-image: url(./image/home.png);}"
                                       "QPushButton:hover{border-image: url(./image/home.png);}"
                                       "QPushButton:pressed{border-image: url(./image/home1.png);}");
        ui->button_home->setFocusPolicy(Qt::NoFocus);
        propertyanimation_home->setDuration(100);
        propertyanimation_home->setStartValue(QRect(176, -128, 128, 128));
        propertyanimation_home->setEndValue(QRect(176, 72, 128, 128));
        propertyanimation_home->start();

        ui->button_music->show();
        ui->button_music->setStyleSheet("QPushButton{border-image: url(./image/music.png);}"
                                        "QPushButton:hover{border-image: url(./image/music.png);}"
                                        "QPushButton:pressed{border-image: url(./image/music1.png);}");
        ui->button_music->setFocusPolicy(Qt::NoFocus);
        propertyanimation_music->setDuration(100);
        propertyanimation_music->setStartValue(QRect(-128, 72, 128, 128));
        propertyanimation_music->setEndValue(QRect(18, 72, 128, 128));
        propertyanimation_music->start();

        ui->button_gps->show();
        ui->button_gps->setStyleSheet("QPushButton{border-image: url(./image/gps.png);}"
                                      "QPushButton:hover{border-image: url(./image/gps.png);}"
                                      "QPushButton:pressed{border-image: url(./image/gps1.png);}");
        ui->button_gps->setFocusPolicy(Qt::NoFocus);
        propertyanimation_gps->setDuration(100);
        propertyanimation_gps->setStartValue(QRect(608, 72, 128, 128));
        propertyanimation_gps->setEndValue(QRect(334, 72, 128, 128));
        propertyanimation_gps->start();

        ui->background_mh->show();
        ui->background_mh->setStyleSheet("border-image: url(./image/home_background_mh.png);");
        ui->background_mh->setGeometry(QRect(0, 0, 480, 272));

        flag_event = 1;
    }else{
        ui->button_gps->hide();
        ui->button_home->hide();
        ui->button_music->hide();
        ui->background_mh->hide();

        flag_event = 0;
    }
}


void user_interface::on_button_play_clicked()
{
    int i = 0;
    QDir dir("music");
    QFileInfo fileinfo;
    QString string_song;

    if( flag_play==0 )
    {
        string_player = "mplayer";

        stringlist_song << "-slave";
        stringlist_song << "-quiet";
        stringlist_song << "-srate";//设置采样率
        stringlist_song << "48000";
        stringlist_song << "-ac";
        stringlist_song << "mad";
        stringlist_song << "*.mp3";
        dir.setNameFilters(stringlist_song);
        fileinfolist = dir.entryInfoList();
        while( i<fileinfolist.length() ){
            fileinfo = fileinfolist.at(i);
            string_song = fileinfo.filePath();
            stringlist_song << string_song;
            i++;
        }

        process_music->setProcessChannelMode(QProcess::MergedChannels);//设置播放模式
        process_music->start(string_player, stringlist_song);
        process_music->write("get_time_length\n");//获取当前歌曲的播放时长
        flag_play = 1;

        ui->button_play->setStyleSheet("QPushButton{border-image: url(./image/pause.png);}"
                                       "QPushButton:hover{border-image: url(./image/pause.png);}"
                                       "QPushButton:pressed{border-image: url(./image/pause1.png);}");//设置按钮背景,分别为常态,鼠标经过态和按下态
        ui->button_play->setFocusPolicy(Qt::NoFocus);//使图标按下时没焦点
        ui->button_play->setGeometry(QRect(3, 111, 50, 50));

        timer_timeline->start(1000);//进度条一秒后开始动
    }else if( flag_play==1 ){
        process_music->write("pause\n");
        flag_play = 2;

        ui->button_play->setStyleSheet("QPushButton{border-image: url(./image/play.png);}"
                                       "QPushButton:hover{border-image: url(./image/play.png);}"
                                       "QPushButton:pressed{border-image: url(./image/play1.png);}");
        ui->button_play->setFocusPolicy(Qt::NoFocus);//使图标按下时没焦点
        ui->button_play->setGeometry(QRect(3, 111, 50, 50));

        timer_timeline->stop();
    }else if( flag_play==2 ){
        process_music->write("pause\n");
        flag_play = 1;

        ui->button_play->setStyleSheet("QPushButton{border-image: url(./image/pause.png);}"
                                       "QPushButton:hover{border-image: url(./image/pause.png);}"
                                       "QPushButton:pressed{border-image: url(./image/pause1.png);}");
        ui->button_play->setFocusPolicy(Qt::NoFocus);//使图标按下时没焦点
        ui->button_play->setGeometry(QRect(3, 111, 50, 50));

        timer_timeline->start(1000);//进度条一秒后开始动
    }
}

void user_interface::on_button_last_clicked()
{
    flag_loop--;
    if( flag_loop!=0 ){
        process_music->write("pausing pt_step -1\n");
        ui->label->setPixmap(QPixmap(QString("./image/song" + QString::number(flag_loop).toUtf8() + ".png")));//设置背景
    }else if( flag_loop==0 ){
        process_music->write(QString("pausing pt_step +" + QString::number(fileinfolist.length()-1)).toUtf8() + "\n");
        ui->label->setPixmap(QPixmap(QString("./image/song" + QString::number(flag_loop+6).toUtf8() + ".png")));//设置背景
        flag_loop = fileinfolist.length();
    }

    process_music->write("get_time_length\n");//获取当前歌曲的播放时长
}

void user_interface::on_button_next_clicked()
{
    if( flag_loop<fileinfolist.length() ){
        process_music->write("pausing pt_step +1\n");
        ui->label->setPixmap(QPixmap(QString("./image/song" + QString::number(flag_loop + 1).toUtf8() + ".png")));//设置背景
    }else if( flag_loop==fileinfolist.length() ){
        process_music->write(QString("pausing pt_step -" + QString::number(fileinfolist.length()-1) + "\n").toUtf8());
        ui->label->setPixmap(QPixmap("./image/song1.png"));//设置背景
        flag_loop = 0;
    }
    flag_loop++;

    process_music->write("get_time_length\n");//获取当前歌曲的播放时长
}

void user_interface::on_button_down_clicked()
{
    process_music->write("volume -1\n");
}

void user_interface::on_button_up_clicked()
{
    process_music->write("volume +1\n");
}

void user_interface::on_timeline_sliderMoved(int position)
{
    process_music->write(QString("seek " + QString::number(position) + " 2\n").toUtf8());
}

void user_interface::catch_output()//进度条滚动函数
{
    while(process_music->canReadLine()){
        QByteArray bytearray_buffer(process_music->readLine());

        if(bytearray_buffer.startsWith("Playing music/")){
            bytearray_buffer.remove(0,14);
            bytearray_buffer.replace(QByteArray("'"), QByteArray(""));
            bytearray_buffer.replace(QByteArray(" "), QByteArray(""));
            bytearray_buffer.replace(QByteArray("."), QByteArray(""));
            bytearray_buffer.replace(QByteArray("mp3"), QByteArray(""));//把mp3替换成空
            bytearray_buffer.replace(QByteArray("\n"), QByteArray(""));
            bytearray_buffer.replace(QByteArray("\r"), QByteArray(""));
            ui->song_info->setText(bytearray_buffer);
            bytearray_buffer.append(".mp3");
            string_name = QString::fromAscii(bytearray_buffer.data());
        }

        if(bytearray_buffer.startsWith("ANS_VIDEO_RESOLUTION")){
            bytearray_buffer.remove(0, 21); // vire ANS_VIDEO_RESOLUTION=
            bytearray_buffer.replace(QByteArray("'"), QByteArray(""));
            bytearray_buffer.replace(QByteArray(" "), QByteArray(""));
            bytearray_buffer.replace(QByteArray("\n"), QByteArray(""));
            bytearray_buffer.replace(QByteArray("\r"), QByteArray(""));
        }

        if(bytearray_buffer.startsWith("ANS_LENGTH")){
            bytearray_buffer.remove(0, 11); // vire ANS_LENGTH=
            bytearray_buffer.replace(QByteArray("'"), QByteArray(""));
            bytearray_buffer.replace(QByteArray(" "), QByteArray(""));
            bytearray_buffer.replace(QByteArray("\n"), QByteArray(""));
            bytearray_buffer.replace(QByteArray("\r"), QByteArray(""));
            float maxTime = bytearray_buffer.toFloat();
            int string_timeLength = (int)bytearray_buffer.toFloat();
            QString string_time = time_transfer(string_timeLength);
            ui->end->setText(string_time);
            ui-> timeline->setMaximum(static_cast<int>(maxTime+1));
        }else if(bytearray_buffer.startsWith("ANS_TIME_POSITION")){
            bytearray_buffer.remove(0, 18); // vire ANS_TIME_POSITION=
            bytearray_buffer.replace(QByteArray("'"), QByteArray(""));
            bytearray_buffer.replace(QByteArray(" "), QByteArray(""));
            bytearray_buffer.replace(QByteArray("\n"), QByteArray(""));
            bytearray_buffer.replace(QByteArray("\r"), QByteArray(""));
            float float_current_time = bytearray_buffer.toFloat();//进度条
            int_current_time = (int)bytearray_buffer.toFloat();//播放实时时间
            QString string_current_time = time_transfer(int_current_time);
            ui->start->setText(string_current_time);
            ui->timeline->setValue(static_cast<int>(float_current_time+1));
        }
    }
}

void user_interface::get_current_time()//获取当前播放时间
{
    process_music->write("get_time_pos \n");
    process_music->write("get_time_length\n");//获取当前歌曲的播放时长
}

QString user_interface::time_transfer(int string_time)
{
    int time1;
    int time2;
    QStringList stringlist_time;

    time1 = (string_time / 60)% 60;
    if(time1<10){
        stringlist_time << "0";
        stringlist_time << QString::number((unsigned int)((string_time / 60)% 60));
    }else{
        stringlist_time << QString::number((unsigned int)((string_time / 60)% 60));
    }

    stringlist_time <<":";


    time2 = string_time%60;
    if(time2 < 10){
        stringlist_time <<"0";
        stringlist_time << QString::number((unsigned int)(string_time%60));
    }else{
        stringlist_time << QString::number((unsigned int)(string_time%60));
    }

    QString string_return = stringlist_time.join("");

    return string_return;
}

void user_interface::music_show()
{
    ui->background->show();
    ui->background->setStyleSheet("border-image: url(./image/music_background.png);");//设置背景
    ui->background->setGeometry(QRect(0, 0, 480, 272));

    ui->button_play->show();
    if( flag_play==0 ){
        ui->button_play->setStyleSheet("QPushButton{border-image: url(./image/play.png);}"
                                   "QPushButton:hover{border-image: url(./image/play.png);}"
                                   "QPushButton:pressed{border-image: url(./image/play1.png);}");//设置按钮背景，分别为常态，鼠标扫过和按下三种状态
    }else if( flag_play==1 ){
        ui->button_play->setStyleSheet("QPushButton{border-image: url(./image/pause.png);}"
                                   "QPushButton:hover{border-image: url(./image/pause.png);}"
                                   "QPushButton:pressed{border-image: url(./image/pause1.png);}");//设置按钮背景，分别为常态，鼠标扫过和按下三种状态
    }
    ui->button_play->setFocusPolicy(Qt::NoFocus);
    ui->button_play->setGeometry(QRect(3, 111, 50, 50));
    ui->button_play->setFlat(true);

    ui->button_up->show();
    ui->button_up->setStyleSheet("QPushButton{border-image: url(./image/up.png);}"
                                 "QPushButton:hover{border-image: url(./image/up.png);}"
                                 "QPushButton:pressed{border-image: url(./image/up1.png);}");
    ui->button_up->setFocusPolicy(Qt::NoFocus);
    ui->button_up->setGeometry(QRect(3, 1, 50, 50));

    ui->button_down->show();
    ui->button_down->setStyleSheet("QPushButton{border-image: url(./image/down.png);}"
                                   "QPushButton:hover{border-image: url(./image/down.png);}"
                                   "QPushButton:pressed{border-image: url(./image/down1.png);}");
    ui->button_down->setFocusPolicy(Qt::NoFocus);//使图标按下时没焦点
    ui->button_down->setGeometry(QRect(3, 216, 50, 50));

    ui->button_last->show();
    ui->button_last->setStyleSheet("QPushButton{border-image: url(./image/last.png);}"
                                   "QPushButton:hover{border-image: url(./image/last.png);}"
                                   "QPushButton:pressed{border-image: url(./image/last1.png);}");
    ui->button_last->setFocusPolicy(Qt::NoFocus);
    ui->button_last->setGeometry(QRect(3, 56, 50, 50));

    ui->button_next->show();
    ui->button_next->setStyleSheet("QPushButton{border-image: url(./image/next.png);}"
                                   "QPushButton:hover{border-image: url(./image/next.png);}"
                                   "QPushButton:pressed{border-image: url(./image/next1.png);}");
    ui->button_next->setFocusPolicy(Qt::NoFocus);
    ui->button_next->setGeometry(QRect(3, 161, 50, 50));

    ui->song_info->show();
    ui->song_info->setGeometry(QRect(230, -5, 100, 30));
    ui->song_info->setStyleSheet("color:white");//设置字体为白色
    QFont font_song_info;
    font_song_info.setPointSize(13);
    ui->song_info->setFont(font_song_info);

    ui->timeline->show();
    ui->timeline->setStyleSheet("background:");
    ui->timeline->setGeometry(QRect(105, 250, 330, 30));

    ui->start->show();
    ui->start->setGeometry(QRect(73, 255, 40, 20));
    ui->start->setStyleSheet("color:white");
    QFont font_start;
    font_start.setPointSize(10);
    ui->start->setFont(font_start);

    ui->end->show();
    ui->end->setGeometry(QRect(440, 255, 40, 20));
    ui->end->setStyleSheet("color:white");
    QFont font_end;
    font_end.setPointSize(10);
    ui->end->setFont(font_end);

    ui->label->show();
    ui->label->setStyleSheet("border-image: url(./image/song1.png);");
    ui->label->setGeometry(QRect(130, 35, 280, 210));
}

void user_interface::music_hide()
{
    ui->button_down->hide();
    ui->button_last->hide();
    ui->button_next->hide();
    ui->button_play->hide();
    ui->button_up->hide();
    ui->label->hide();
    ui->end->hide();
    ui->song_info->hide();
    ui->start->hide();
    ui->timeline->hide();
    ui->button_gps->hide();
    ui->button_music->hide();
    ui->button_home->hide();
    ui->background_mh->hide();

}

void user_interface::traffic_warning()
{
    stringlist_event << "traffic lights" << "traffic accidents" << "tunnel" << "dialing";
    stringlist_record << "record/record1.mp3" << "record/record2.mp3" << "record/record3.mp3" << "record/record4.mp3" << "record/record5.mp3" << "record/record6.mp3" << "record/record7.mp3" << "record/record8.mp3";

    db = QSqlDatabase::addDatabase("QSQLITE"); //添加数据库驱动
    db.setDatabaseName("traffic_warning.db"); //数据库连接命名
    if( db.open()==0 ) //打开数据库
    {
        perror("open db error\n");
    }

    query = new QSqlQuery(db);
}

void user_interface::read_pending_datagrams()
{
    int i = 0;
    int j = -1;
    int k = 0;
    int longitude;
    int latitude;
    QString string_type;
    QByteArray bytearray_receiver;

    while(udpsocket_receiver->hasPendingDatagrams()){//拥有等待的数据报
        bytearray_receiver.resize(udpsocket_receiver->pendingDatagramSize());//让bytearray_receiver的大小为等待处理的数据报的大小，这样才能接收到完整的数据
        udpsocket_receiver->readDatagram(bytearray_receiver.data(),bytearray_receiver.size());//接收数据报，将其存放到gps_receive中
        QString string_data(bytearray_receiver);//将数据报内容显示出来
        if( time%90==0 ){
            if(string_data.contains(",",Qt::CaseSensitive)){//当收到符合条件的数据时执行以下语句
                QStringList stringlist_data = string_data.split(",");//开始对数据进行加工处理 举例如下原始数据：2305.8111,11339.9111 加工后的数据23058,113399
                QString string_latitude = stringlist_data[1];
                string_latitude.remove(4,1);
                string_latitude.remove(5,3);
                QString string_longitude = stringlist_data[0];
                string_longitude.remove(5,1);
                string_longitude.remove(6,3);
                longitude = string_longitude.toInt();
                latitude = string_latitude.toInt();
                QString string_longitude1 = QString::number(longitude-1, 10);//调整经纬度范围，满足此范围的数据就播放预警信息
                QString string_longitude2 = QString::number(longitude+1, 10);
                QString string_latitude1 = QString::number(latitude-1,10);
                QString string_latitude2 = QString::number(latitude+1,10);
                QString string_sqlite = "select * from location where";
                string_sqlite.append("(" + string_longitude1 + "<=" + "longitude) and (longitude <=" + string_longitude2 + ") and (" + string_latitude1 + " <= latitude) and (latitude <=" + string_latitude2 +")");// (longitude-1 <= longtitude)&&(longtitude <= longitude+1)&&(latitude-1 <= latitude)&& (latitude <= latitude);

                //通过执行数据库语句返回所需要的结果集
                query->exec(string_sqlite);
                while( query->next() ){       //当取到的数据与数据库匹配，获取数据库的相应的事件类型，即表的第三项(event_type)的值
                    string_type = query->value(2).toString();
                }
                QStringList stringlist_record_play;
                for(i=0; i<4; i++){
                    k = QString::compare(string_type, stringlist_event[i]);//将事件类型与原有的数组进行匹配，进而确定播放的预警信息
                    if( k==0 ){
                        j = i;
                        break;
                    }
                }

                if( j>-1 && j<4 ){
                    string_player = "mplayer";//设置播放信息
                    stringlist_record_play << "-slave";
                    stringlist_record_play << "-quiet";
                    stringlist_record_play << "-ac";
                    stringlist_record_play << "mad";
                    stringlist_record_play << stringlist_record[j];
                    stringlist_record_play << stringlist_record[j+4];

                    process_music->write("quit\n");

                    process_record->write("volume +10\n");
                    process_record->setProcessChannelMode(QProcess::MergedChannels);//设置播放模式
                    process_record->start(string_player, stringlist_record_play);//进程开始工作，播放音乐
                    timer_traffic->start(1000);

                    if( flag_play==1 ){
                        strcpy(back_name, string_name.toLatin1());
                        string_name.sprintf("music/%s", back_name);
                        for(i=0; i<stringlist_song.length(); i++){
                            QString string_tmp(stringlist_song[i]);
                            if( QString::compare(string_name, string_tmp)==0 ){
                                flag_name = i;
                            }
                        }
                        timer_music->start(9000);
                    }
                }
            }
        }
    }
}

void user_interface::timer_traffic_slot()
{
    time++;
    if( time==90 ){
        time = 0;
        timer_traffic->stop();
    }
}

void user_interface::timer_music_slot()
{
    int i = 0;
    char tmp[64];
    QDir dir("music");
    QStringList stringlist_song;
    QFileInfoList fileinfolist;
    QFileInfo fileinfo;
    QString string_song;

    timer_music->stop();

    string_player = "mplayer";

    stringlist_song << "-slave";
    stringlist_song << "-quiet";
    stringlist_song << "-srate";//设置采样率
    stringlist_song << "48000";
    stringlist_song << "-ac";
    stringlist_song << "mad";
    stringlist_song << "*.mp3";
    dir.setNameFilters(stringlist_song);
    fileinfolist = dir.entryInfoList();
    while( i<fileinfolist.length() ){
        fileinfo = fileinfolist.at(i);
        string_song = fileinfo.filePath();
        stringlist_song << string_song;
        i++;
    }

    process_music->setProcessChannelMode(QProcess::MergedChannels);//设置播放模式
    process_music->start(string_player, stringlist_song);

    if( (flag_name-7)!=0 ){
        sprintf(tmp, "pausing pt_step +%d\n", flag_name - 7);
        QByteArray bytearray_name(tmp);
        process_music->write(bytearray_name);
    }

    if( int_current_time!=0 ){
        sprintf(tmp, "seek %d\n", int_current_time);
        QByteArray bytearray_time(tmp);
        process_music->write(bytearray_time);
    }
}

void user_interface::on_button_run_clicked()
{

    if( thread->flag_thread==0 ){
        gps_open();//打开gps模块设备节点

        gsm_open();//打开gsm模块设备节点

        socket_open();

        gps_set_serial(gps_fd, 4800, 8, 'N', 1);//设置gps串口参数

        gsm_set_serial(gsm_fd, 9600, 8, 'N', 1);//设置gsm串口参数

        thread->flag_thread = 1;
        thread->start();
    }else{
        gps_close();//关闭gps模块设备节点

        gsm_close();//关闭gsm模块设备节点

        socket_close();

        thread->flag_thread = 0;
        thread->wait();
    }
}

void MyThread::run()
{
    char *p = NULL;//strtok函数返回指针,以"$"分割
    int i = -1;
    int j = -1;
    int k = 1;
    char *data[20];
    fd_set readfd;
    struct timeval timeout;
    char *buf;
    QHostAddress hostaddress = QHostAddress(IP);

    udpsocket_sender = new QUdpSocket();
    udpsocket_sender_traffic = new QUdpSocket();

    buf = (char*)malloc(SIZE);

    FD_ZERO(&readfd);//初始化readfd
    FD_SET(gps_fd, &readfd);//把gps_fd加入readfd
    timeout.tv_sec = 3;//设置3秒超时
    timeout.tv_usec = 0;

    while(flag_thread){
        j = select(gps_fd+1, &readfd, NULL, NULL, &timeout);//用select对gps_fd进行轮循
        if( j>0 ){
            if( FD_ISSET(gps_fd, &readfd) ){//如果gps_fd可读
                i = read(gps_fd, buf, SIZE);
                buf[i] = '\0';
            }
        }
        sleep(1);

        if( buf==NULL ){
            break;
        }

        p = strtok(buf, "$,");//把buf中的数据以"$"为分隔符分割
        while(flag_thread){
            if( p==NULL ){//strtok函数会在最后返回一次NULL指针，所以需要判断然后跳出循环，否则会出现段错误
                break;
            }

            if( strcmp(p, "GPGSV")==0 ){
                for(k=0; k<20; k++){
                    data[k] = NULL;
                }

                for(k=1; k<16; k++){
                    p = strtok(NULL, "$,");
                    data[k] = p;
                }

                if( data[4]==NULL || data[7]==NULL || data[8]==NULL || data[11]==NULL || data[12]==NULL || data[15]==NULL ){
                    break;
                }

                QString string_1(data[4]);
                QString string_2(data[8]);
                QString string_3(data[12]);
                if( string_1.toInt()<=32 && string_2.toInt()<=32 && string_3.toInt()<=32 ){
                    sprintf(data[4], "%s,%s,%s,%s,%s,%s", data[4], data[7], data[8], data[11], data[12], data[15]);
                    QString string_satellite_data(data[4]);
                    QByteArray bytearray_datagram = string_satellite_data.toAscii();
                    udpsocket_sender->writeDatagram(bytearray_datagram.data(), bytearray_datagram.size(), hostaddress, PORT2);
                }
            }

            if( p==NULL ){//strtok函数会在最后返回一次NULL指针，所以需要判断然后跳出循环，否则会出现段错误
                break;
            }

            if( strcmp(p, "GPGGA")==0 ){//比较字符串，若p中的字符串为GPGGA则执行以下代码
                for(k=0; k<20; k++){
                    data[k] = NULL;
                }

                for(k=1; k<10; k++){
                    p = strtok(NULL, "$,");//执行第一次strtok时需要写变量，之后调用strtok第一个变量填NULL
                    data[k] = p;//把k指针中的值保存在data数组中
                }

                if( data[1]==NULL || data[2]==NULL || data[3]==NULL || data[4]==NULL || data[5]==NULL || data[7]==NULL ){
                    break;
                }

                if( strcmp(data[3], "N")==0 || strcmp(data[3], "S")==0 ){//比较data[3]中的字符串是否为N或S，若是则执行以下代码
                    if( strcmp(data[5], "E")==0 || strcmp(data[5], "W")==0 ){//比较data[5]中的字符串是否为E或W，若是则执行以下代码，两次if是为了确保经纬度数据正常才打印和发送
                        socket_send(data[1], data[2], data[3], data[4], data[5], data[7]);//把经纬度传参给socket_send函数
                        sprintf(data[4], "%s,%s", data[4], data[2]);

                        QString string_traffic(data[4]);
                        QByteArray bytearray_traffic = string_traffic.toAscii();
                        udpsocket_sender_traffic->writeDatagram(bytearray_traffic.data(), bytearray_traffic.size(), hostaddress, PORT3);

                        data[4] = gsm_data_transfer(data[4]);//gsm数据转码
                        gsm_apn_set();//设置APN无线接入点
                        gsm_ppp_dialing();//进行ppp拨号，实现PDP激活和TCPIP的初始化
                        gsm_ip_open();//打开一条TCP或UDP连接
                        gsm_iomode();//设置数据模式
                        gsm_data_send(data[4]);//gsm数据发送
                        gsm_ip_close();//关闭udp连接
                    }
                }
            }
            p = strtok(NULL, "$,");//再次以"$"分割buf中的数据，等于获取下一行数据
            usleep(100000);
        }
        usleep(100000);
    }
    free(buf);
    delete(udpsocket_sender);
    delete(udpsocket_sender_traffic);
}

void user_interface::read_pending_datagrams_1()//获取经纬度函数
{
    QByteArray bytearray_receiver;

    while(udpsocket_receiver1->hasPendingDatagrams()){  //拥有等待的数据报
        bytearray_receiver.resize(udpsocket_receiver1->pendingDatagramSize());               //让 bytearray_receiver 的大小为等待处理的数据报的大小，这样才能接收到完整的数据
        udpsocket_receiver1->readDatagram(bytearray_receiver.data(),bytearray_receiver.size());   //接收数据报，将其存放到bytearray_receiver中

        QString string_data1(bytearray_receiver);                                                    //将数据报内容显示出来
        QStringList stringlist_data = string_data1.split(",");
        QString string_data2 = stringlist_data[0];
        string_data2.remove(2,8);
        stringlist_data[0].remove(0,2);

        int hour = string_data2.toInt(0,10);
        hour = hour+8;
        if(hour > 24){
            hour = hour-24;
        }

        QString string_time = QString::number(hour, 10);
        stringlist_data[0].insert(0,QString(string_time));
        stringlist_data[0].insert(2,QString(":"));
        stringlist_data[0].insert(5,QString(":"));
        stringlist_data[1].remove(4,1);
        stringlist_data[3].remove(5,1);
        stringlist_data[1].insert(2,QString("."));
        stringlist_data[3].insert(3,QString("."));

        ui->latitude->setText(stringlist_data.at(1));
        ui->label_latitude->setText(stringlist_data.at(2));
        ui->longitude->setText(stringlist_data.at(3));
        ui->label_longitude->setText(stringlist_data.at(4));
        ui->satellite->setText(stringlist_data.at(5));
    }
}

void user_interface::read_pending_datagrams_2()//获取卫星号函数
{
    QByteArray bytearray_receiver;

    while(udpsocket_receiver2->hasPendingDatagrams()){//拥有等待的数据报
        bytearray_receiver.resize(udpsocket_receiver2->pendingDatagramSize());
        udpsocket_receiver2->readDatagram(bytearray_receiver.data(), bytearray_receiver.size());

        QString string_data(bytearray_receiver);
        if( string_data.contains("G", Qt::CaseInsensitive) ){
            continue;
        }

        if( string_data.contains(",", Qt::CaseInsensitive) ){
            QStringList stringlist_data = string_data.split(",");
            QString string_1 = stringlist_data[0];
            QString string_2 = stringlist_data[1];
            int number1 = string_2.toInt();
            QString string_3 = stringlist_data[2];
            QString string_4 = stringlist_data[3];
            int number2 = string_4.toInt();
            QString string_5 = stringlist_data[4];
            QString string_6 = stringlist_data[5];
            int number3 = string_6.toInt();

            if( flag_strength==0 ){
                ui->dot1->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot2->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot3->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot4->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot5->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot6->setStyleSheet("border-image: url(./image/red_dot.png);");

                ui->dot1->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength1;
                font_strength1.setPointSize(9);
                ui->dot1->setFont(font_strength1);
                ui->dot1->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot1->setText(string_1);
                ui->strength1->setValue(number1);//实时显示卫星信号强度

                ui->dot3->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength2;
                font_strength2.setPointSize(9);
                ui->dot3->setFont(font_strength2);
                ui->dot3->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot3->setText(string_3);
                ui->strength3->setValue(number2);//实时显示卫星信号强度

                ui->dot5->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength3;
                font_strength3.setPointSize(9);
                ui->dot5->setFont(font_strength3);
                ui->dot5->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot5->setText(string_5);
                ui->strength5->setValue(number3);//实时显示卫星信号强度

                flag_strength = 1;
            }else if( flag_strength==1 ){
                ui->dot1->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot2->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot3->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot4->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot5->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot6->setStyleSheet("border-image: url(./image/red_dot.png);");

                ui->dot4->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength1;
                font_strength1.setPointSize(9);
                ui->dot4->setFont(font_strength1);
                ui->dot4->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot4->setText(string_1);
                ui->strength4->setValue(number1);//实时显示卫星信号强度

                ui->dot2->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength2;
                font_strength2.setPointSize(9);
                ui->dot2->setFont(font_strength2);
                ui->dot2->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot2->setText(string_3);
                ui->strength2->setValue(number2);//实时显示卫星信号强度

                ui->dot6->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength3;
                font_strength3.setPointSize(9);
                ui->dot6->setFont(font_strength3);
                ui->dot6->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot6->setText(string_5);
                ui->strength6->setValue(number3);//实时显示卫星信号强度

                flag_strength = 2;
            }else if( flag_strength==2 ){
                ui->dot1->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot2->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot3->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot4->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot5->setStyleSheet("border-image: url(./image/red_dot.png);");
                ui->dot6->setStyleSheet("border-image: url(./image/red_dot.png);");

                ui->dot6->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength1;
                font_strength1.setPointSize(9);
                ui->dot6->setFont(font_strength1);
                ui->dot6->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot6->setText(string_1);
                ui->strength6->setValue(number1);//实时显示卫星信号强度

                ui->dot3->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength2;
                font_strength2.setPointSize(9);
                ui->dot3->setFont(font_strength2);
                ui->dot3->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot3->setText(string_3);
                ui->strength3->setValue(number2);//实时显示卫星信号强度

                ui->dot2->setStyleSheet("border-image: url(./image/green_dot.png);");
                QFont font_strength3;
                font_strength3.setPointSize(9);
                ui->dot2->setFont(font_strength3);
                ui->dot2->setAlignment(Qt::AlignCenter);//居中显示
                ui->dot2->setText(string_5);
                ui->strength2->setValue(number3);//实时显示卫星信号强度

                flag_strength = 0;
            }
        }
    }
}

void user_interface::gps_show()
{
    ui->satellite->show();
    ui->satellite->setStyleSheet("color:white");
    ui->satellite->setGeometry(QRect(73, 225, 30, 10));
    QFont font_satellite;
    font_satellite.setPointSize(10);
    ui->satellite->setFont(font_satellite);

    ui->label_satellite->show();
    ui->label_satellite->setStyleSheet("color:white");
    ui->label_satellite->setGeometry(QRect(3, 225, 70, 10));
    QFont font_label_satellite;
    font_label_satellite.setPointSize(10);
    ui->label_satellite->setFont(font_label_satellite);

    ui->latitude->show();
    ui->latitude->setStyleSheet("color:white");
    ui->latitude->setGeometry(QRect(33, 240, 100, 10));
    QFont font_latitude;
    font_latitude.setPointSize(10);
    ui->latitude->setFont(font_latitude);

    ui->label_latitude->show();
    ui->label_latitude->setStyleSheet("color:white");
    ui->label_latitude->setGeometry(QRect(3, 235, 30, 20));
    QFont font_label_latitude;
    font_label_latitude.setPointSize(10);
    ui->label_latitude->setFont(font_label_latitude);

    ui->longitude->show();
    ui->longitude->setStyleSheet("color:white");
    ui->longitude->setGeometry(QRect(33, 255, 100, 10));
    QFont font_longitude;
    font_longitude.setPointSize(10);
    ui->longitude->setFont(font_longitude);

    ui->label_longitude->show();
    ui->label_longitude->setStyleSheet("color:white");
    ui->label_longitude->setGeometry(QRect(3, 250, 30, 20));
    QFont font_label_longitude;
    font_label_longitude.setPointSize(10);
    ui->label_longitude->setFont(font_label_longitude);

    ui->background->show();
    ui->background->setStyleSheet("border-image: url(./image/gps_background.png);");//设置背景
    ui->background->setGeometry(QRect(0, 0, 480, 272));

    ui->earth->show();
    ui->earth->setStyleSheet("border-image: url(./image/earth.png);");
    ui->earth->setGeometry(QRect(25, -20, 250, 250));

    ui->button_run->show();
    ui->button_run->setStyleSheet("QPushButton{border-image: url(./image/run.png);}"
                                  "QPushButton:hover{border-image: url(./image/run.png);}"
                                  "QPushButton:pressed{border-image: url(./image/run1.png);}");
    ui->button_run->setFocusPolicy(Qt::NoFocus);
    ui->button_run->setGeometry(QRect(400, 222, 40, 40));

    ui->dot1->show();
    ui->dot1->setStyleSheet("border-image: url(./image/red_dot.png);");
    ui->dot1->setFocusPolicy(Qt::NoFocus);
    ui->dot1->setGeometry(QRect(90, 40, 26, 26));

    ui->dot2->show();
    ui->dot2->setStyleSheet("border-image: url(./image/red_dot.png);");
    ui->dot2->setFocusPolicy(Qt::NoFocus);
    ui->dot2->setGeometry(QRect(133, 80, 26, 26));

    ui->dot3->show();
    ui->dot3->setStyleSheet("border-image: url(./image/red_dot.png);");
    ui->dot3->setFocusPolicy(Qt::NoFocus);
    ui->dot3->setGeometry(QRect(178, 53, 26, 26));

    ui->dot4->show();
    ui->dot4->setStyleSheet("border-image: url(./image/red_dot.png);");
    ui->dot4->setFocusPolicy(Qt::NoFocus);
    ui->dot4->setGeometry(QRect(159, 159, 26, 26));

    ui->dot5->show();
    ui->dot5->setStyleSheet("border-image: url(./image/red_dot.png);");
    ui->dot5->setFocusPolicy(Qt::NoFocus);
    ui->dot5->setGeometry(QRect(80, 132, 26, 26));

    ui->dot6->show();
    ui->dot6->setStyleSheet("border-image: url(./image/red_dot.png);");
    ui->dot6->setFocusPolicy(Qt::NoFocus);
    ui->dot6->setGeometry(QRect(200, 108, 26, 26));

    ui->strength1->show();
    ui->strength1->setGeometry(QRect(310, 30, 10, 150));
    ui->strength1->setOrientation(Qt::Vertical);
    ui->strength1->setTextVisible(false);

    ui->strength2->show();
    ui->strength2->setGeometry(QRect(330, 30, 10, 150));
    ui->strength2->setOrientation(Qt::Vertical);
    ui->strength2->setTextVisible(false);

    ui->strength3->show();
    ui->strength3->setGeometry(QRect(350, 30, 10, 150));
    ui->strength3->setOrientation(Qt::Vertical);
    ui->strength3->setTextVisible(false);

    ui->strength4->show();
    ui->strength4->setGeometry(QRect(370, 30, 10, 150));
    ui->strength4->setOrientation(Qt::Vertical);
    ui->strength4->setTextVisible(false);

    ui->strength5->show();
    ui->strength5->setGeometry(QRect(390, 30, 10, 150));
    ui->strength5->setOrientation(Qt::Vertical);
    ui->strength5->setTextVisible(false);

    ui->strength6->show();
    ui->strength6->setGeometry(QRect(410, 30, 10, 150));
    ui->strength6->setOrientation(Qt::Vertical);
    ui->strength6->setTextVisible(false);
}

void user_interface::gps_hide()
{
    ui->button_run->hide();
    ui->earth->hide();
    ui->label_latitude->hide();
    ui->label_longitude->hide();
    ui->label_satellite->hide();
    ui->latitude->hide();
    ui->longitude->hide();
    ui->satellite->hide();
    ui->dot1->hide();
    ui->dot2->hide();
    ui->dot3->hide();
    ui->dot4->hide();
    ui->dot5->hide();
    ui->dot6->hide();
    ui->strength1->hide();
    ui->strength2->hide();
    ui->strength3->hide();
    ui->strength4->hide();
    ui->strength5->hide();
    ui->strength6->hide();
    ui->button_gps->hide();
    ui->button_home->hide();
    ui->button_music->hide();
    ui->background_mh->hide();
}

void gps_open(void)//打开gps设备节点
{
    gps_fd = open (GPS, O_RDONLY);
    if( gps_fd==-1 ){
        perror("open gps error\n");
    }else{
        printf("open gps successfully\n");
    }
}

void gps_close(void)//关闭gps设备节点
{
    int i = -1;

    i = close(gps_fd);
    if( i!=0 ){
        perror("close gps fail\n");
    }else if( i==0 ){
        printf("close gps successfully\n");
    }
}

void gps_set_serial(int fd, int speed, int bit, char event, int stop)//设置串口参数
{
    int i = -1;
    int j = -1;
    struct termios serial;//串口类
    int speed_in;//输入波特率
    int speed_out;//输出波特率
    static int speed_array[] = {0,50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400,57600,115200,230400};//如果不加static会出现重定义错误

    i = tcgetattr(fd, &serial);//用tcgetattr函数获取串口终端参数
    if( i!=0 ){
        perror("get gps serial data error\n");
    }else if( i==0 ){
        printf("get gps serial data successfully\n");
    }

    memset(&serial, 0, sizeof(struct termios));
    serial.c_cflag |= CLOCAL | CREAD;//设置数据接收器使能和本地模式
    serial.c_cflag &= ~CSIZE;//通过位掩码的方式激活

    switch( bit )//设置字符大小
    {
        case 8 : serial.c_cflag |= CS8;
                 break;
        case 7 : serial.c_cflag |= CS7;
                 break;
    }

    switch( speed )//设置波特率
    {
        case 2400 : cfsetispeed(&serial, B2400);
                    cfsetospeed(&serial, B2400);
                    break;
        case 4800 : cfsetispeed(&serial, B4800);
                    cfsetospeed(&serial, B4800);
                    break;
        case 9600 : cfsetispeed(&serial, B9600);
                    cfsetospeed(&serial, B9600);
                    break;
        case 115200 : cfsetispeed(&serial, B115200);
                      cfsetospeed(&serial, B115200);
                      break;
    }

    switch( event )//设置奇偶校验位
    {
        case 'O' : //奇数
                   serial.c_cflag |= PARENB;
                   serial.c_cflag |= PARODD;
                   serial.c_iflag |= (INPCK | ISTRIP);
                   break;
        case 'E' : //偶数
                   serial.c_iflag |= (INPCK | ISTRIP);
                   serial.c_cflag |= PARENB;
                   serial.c_cflag &= ~PARODD;
                   break;
        case 'N' : //无奇偶校验位
                   serial.c_cflag &= ~PARENB;
                   break;
    }

    if( stop==1 ){//设置停止位
        serial.c_cflag &= ~CSTOPB;
    }else if( stop==2 ){
        serial.c_cflag |= CSTOPB;
    }

    serial.c_cc[VTIME] = 0;//设置等待时间
    serial.c_cc[VMIN] = 0;//设置最少接受字符
    tcflush(fd,TCIFLUSH);//用tcflush函数重置缓存
    j = tcsetattr(fd, TCSANOW, &serial);//用tcsetattr函数设置串口终端参数
    if( j!=0 ){
        perror("set gps serial data error\n");
    }else if( j==0 ){
        printf("set gps serial data successfully\n");
        speed_in = cfgetispeed(&serial);//获取输入波特率
        speed_out = cfgetospeed(&serial);//获取输出波特率
        printf("speed_in=%d, speed_out=%d, gps_fd=%d\n\n", speed_array[speed_in], speed_array[speed_out], fd);
    }
}

void socket_send(char *time,char *latitude,char *N_S ,char *longitude,char *E_W,char *satellite)
//发送gps数据函数
{
    int numbytes;
    struct sockaddr_in server;
    const char *server_ip = IP;//主机ip地址 在socket_init处被引用
    char buf[128];

    server.sin_family = AF_INET;//协议簇，AF_INET表示TCP/IP协议
    server.sin_port = htons(PORT1);//设置端口
    server.sin_addr.s_addr = inet_addr(server_ip);//设置ip地址
    bzero(&(server.sin_zero), 8);//把其余部分设置为0

    sprintf(buf, "%s,%s,%s,%s,%s,%s", time, latitude, N_S, longitude, E_W, satellite);

    numbytes = sendto(socket_fd, buf, 128, 0, (struct sockaddr *)&server, sizeof(server));//发送经度
    if( numbytes==-1 ){
        perror("send error\n");
    }
}

void gsm_open(void)//打开gsm模块设备节点
{
    gsm_fd = open(GSM, O_RDWR);
    if( gsm_fd==-1 ){
        perror("open gsm error\n");
    }else{
        printf("open gsm successfully\n");
    }
}

void gsm_close(void)//关闭gsm模块设备节点
{
    int i = -1;

    i = close(gsm_fd);
    if( i==-1 ){
        perror("close gsm error\n");
    }else if( i==0 ){
        printf("close gsm successfully\n");
    }
}

void gsm_set_serial(int fd, int speed, int bit, char event, int stop)//设置串口参数
{
    int i = 0;
    int j = 0;
    struct termios serial;//串口参数类
    int speed_in;//输入波特率
    int speed_out;//输出波特率
    static int speed_array[] = {0,50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400,57600,115200,230400};//如果不加static会出现重定义错误

    i = tcgetattr(fd, &serial);//用tcgetattr函数获取串口终端参数
    if( i!=0 ){
        perror("get gsm serial data error\n");
    }else if( i==0 ){
        printf("get gsm serial data successfully\n");
    }

    memset(&serial, 0, sizeof(struct termios));
    serial.c_cflag |= CLOCAL | CREAD;//数据接收器使能和打开本地模式
    serial.c_cflag &= ~CSIZE;//通过位掩码的方式激活

    switch( speed )//设置波特率
    {
        case 0 : cfsetispeed(&serial, B0);
                 cfsetospeed(&serial, B0);
                 break;
        case 50 : cfsetispeed(&serial, B50);
                  cfsetospeed(&serial, B50);
                  break;
        case 75 : cfsetispeed(&serial, B75);
                  cfsetospeed(&serial, B75);
                  break;
        case 110 : cfsetispeed(&serial, B110);
                   cfsetospeed(&serial, B110);
                   break;
        case 134 : cfsetispeed(&serial, B134);
                   cfsetospeed(&serial, B134);
                   break;
        case 150 : cfsetispeed(&serial, B150);
                   cfsetospeed(&serial, B150);
                   break;
        case 200 : cfsetispeed(&serial, B200);
                   cfsetospeed(&serial, B200);
                   break;
        case 300 : cfsetispeed(&serial, B300);
                   cfsetospeed(&serial, B300);
                   break;
        case 600 : cfsetispeed(&serial, B600);
                   cfsetospeed(&serial, B600);
                   break;
        case 1200 : cfsetispeed(&serial, B1200);
                    cfsetospeed(&serial, B1200);
                    break;
        case 1800 : cfsetispeed(&serial, B1800);
                    cfsetospeed(&serial, B1800);
                    break;
        case 2400 : cfsetispeed(&serial, B2400);
                    cfsetospeed(&serial, B2400);
                    break;
        case 4800 : cfsetispeed(&serial, B4800);
                    cfsetospeed(&serial, B4800);
                    break;
        case 9600 : cfsetispeed(&serial, B9600);
                    cfsetospeed(&serial, B9600);
                    break;
        case 19200 : cfsetispeed(&serial, B19200);
                     cfsetospeed(&serial, B19200);
                     break;
        case 38400 : cfsetispeed(&serial, B38400);
                     cfsetospeed(&serial, B38400);
                     break;
        case 57600 : cfsetispeed(&serial, B57600);
                     cfsetospeed(&serial, B57600);
                     break;
        case 115200 : cfsetispeed(&serial, B115200);
                      cfsetospeed(&serial, B115200);
                      break;
        case 230400 : cfsetispeed(&serial, B230400);
                      cfsetospeed(&serial, B230400);
                      break;
    }

    switch( bit )//设置字符大小
    {
        case 8 : serial.c_cflag |= CS8;//8位
                 break;
        case 7 : serial.c_cflag |= CS7;//7位
                 break;
    }

    switch( event )//设置奇偶校验位
    {
        case 'O' : //奇数
                   serial.c_cflag |= PARENB;
                   serial.c_cflag |= PARODD;
                   serial.c_iflag |= (INPCK | ISTRIP);
                   break;
        case 'E' : //偶数
                   serial.c_iflag |= (INPCK | ISTRIP);
                   serial.c_cflag |= PARENB;
                   serial.c_cflag &= ~PARODD;
                   break;
        case 'N' : //无奇偶校验位
                   serial.c_cflag &= ~PARENB;
                   break;
    }

    if( stop==1 ){//设置停止位
        serial.c_cflag &= ~CSTOPB;//1位
    }else if( stop==2 ){
        serial.c_cflag |= CSTOPB;//两位
    }

    serial.c_cc[VTIME] = 1;//设置等待时间，单位百毫秒，此处必须延时至少0.1秒，否则读取不到数据
    serial.c_cc[VMIN] = 128;//设置最少接受字符，单位字节，此处最少接受字节数必须大于接接收到的数据字节数
    tcflush(fd,TCIFLUSH);//用tcflush函数重置缓存

    j = tcsetattr(fd, TCSANOW, &serial);//用tcsetattr函数设置串口终端参数
    if( j!=0 ){
        perror("set gsm serial data error\n");
    }else if( j==0 ){
        printf("set gsm serial data successfully\n");
        speed_in = cfgetispeed(&serial);//获取输入波特率
        speed_out = cfgetospeed(&serial);//获取输出波特率
        printf("speed_in=%d, apeed_out=%d, gsm_fd=%d\n\n", speed_array[speed_in], speed_array[speed_out], fd);
    }
}

void gsm_read(void)//读取gsm模块信息
{
    int i = -1;
    char r[128];
    fd_set readfd;
    struct timeval timeout;

    memset(r, 0, 128);//初始化数组
    FD_ZERO(&readfd);//初始化用于检查可读性的fd_set
    FD_SET(gsm_fd, &readfd);//把gsm模块fd加入监听行列
    timeout.tv_sec = 3;//设置3秒轮询
    timeout.tv_usec = 0;//

    i = select(gsm_fd+1, &readfd, NULL, NULL, &timeout);//select函数对行列中的fd轮询
    if( i>0 ){
        if( FD_ISSET(gsm_fd, &readfd) ){//当gsm模块fd可读
            read(gsm_fd, r, 128);
        }
    }

    printf("%s\n", r);
}

void gsm_calling(void)//打电话
{
    char w[128];
    int i = -1;

    strcpy(w , "atd15521219871;\r");
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write ATD error\n");
    }

    gsm_read();
    sleep(1);
}

void gsm_cut(void)//挂断电话
{
    char w[128];
    int i = -1;

    strcpy(w , "ATH\r");
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write ATH error\n");
    }

    gsm_read();
    sleep(1);
}

void gsm_apn_set(void)//设置APN无线接入点
{
    char w[128];
    int i = -1;

    strcpy(w , "at+cgdcont=1,\"IP\",\"CMNET\"\r");
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write AT+CGDCONT error\n");
    }

    gsm_read();
    sleep(1);
}

void gsm_ppp_dialing(void)//进行ppp拨号,实现PDP激活和TCPIP的初始化
{
    char w[128];
    int i = -1;

    strcpy(w , "at%etcpip=\"\",\"\"\r");
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write AT%ETCPIP error\n");
    }

    gsm_read();
    sleep(1);
}

void gsm_ip_open(void)//打开一条TCP或UDP链接
{
    char w[128];
    int i = -1;

    strcpy(w , "at%ipopen=\"UDP\",\"58.215.187.148\",8000\r");
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write AT%IPOPEN error\n");
    }

    gsm_read();
    sleep(1);
}

void gsm_data_send(char *p)//发送数据
{
    char w[128];
    int i = -1;

    sprintf(w, "at%%ipsend=\"%s\"\r", p);
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write AT%IPSEND error\n");
    }

    gsm_read();
    sleep(1);
}

void gsm_ip_close(void)//关闭连接
{
    char w[128];
    int i = -1;

    strcpy(w , "at%ipclose=5\r");
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write AT%IPCLOSE error\n");
    }

    gsm_read();
    sleep(1);//需要延时一下,关闭连接需要时间
}

void gsm_iomode(void)//设置数据模式
{
    char w[128];
    int i = -1;

    strcpy(w , "at%iomode=1,1,1\r");
    i = write(gsm_fd, w, strlen(w));
    if( i==-1 ){
        perror("write AT%IOMODE error\n");
    }

    gsm_read();
    sleep(1);
}

char *gsm_data_transfer(char *data)//转换发送数据为数据ascii码对应的十六进制数
{
    unsigned int i = 0;
    char b[100];
    char *p = data;

    memset(a, 0, 100);
    memset(b, 0, 100);

    while( i<strlen(p) ){//对传入的gps数据进行转码
        switch( p[i] )
        {
            case ',' : strcpy(b, "2c");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '.' : strcpy(b, "2e");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '0' : strcpy(b, "30");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '1' : strcpy(b, "31");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '2' : strcpy(b, "32");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '3' : strcpy(b, "33");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '4' : strcpy(b, "34");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '5' : strcpy(b, "35");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '6' : strcpy(b, "36");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '7' : strcpy(b, "37");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '8' : strcpy(b, "38");
                       sprintf(a, "%s%s", a, b);
                       break;
            case '9' : strcpy(b, "39");
                       sprintf(a, "%s%s", a, b);
                       break;
        }
        i++;
    }

    return a;
}

void socket_close(void)
{
    int i;

    i = close(socket_fd);
    if( i==-1 ){//关闭socket
        perror("close socket error\n");
    }else if( i==0 ){
        printf("close socket successfully\n");
    }
}

void socket_open(void)
{
    socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if( socket_fd==-1 ){//创建socket
        perror("socket create error!\n");
    }else{
        printf("open socket successfully\n");
    }
}

主函数

#include <QApplication>
#include <QWSServer>
#include "user_interface.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    user_interface w;
    w.setWindowFlags(Qt::FramelessWindowHint);
    QWSServer::setCursorVisible(false);
    w.show();
    
    return a.exec();
}