modularization/src/driver/driver_cloud_grpc_client_BS/main.cpp

#include <QCoreApplication>

#include "ivversion.h"

#include <yaml-cpp/yaml.h>
#include "vehicle_upload.h"
#include "vehicle_control.h"
#include "vehicle_patrol.h"

#include <QFile>
#include <QString>
#include <QStringList>
#include <QThread>

std::string gstrserverip =  "139.9.235.66";//"123.57.212.138";
std::string gstruploadPort = "10591";//"9000";
std::string gstrpatrolPort = "10592";//"9000";
std::string gstrcontrolPort = "20591";//"9000";
std::string gstruploadInterval = "500";
std::string gstrpatrolInterval = "500";
std::string gstrcontrolInterval = "100";
std::string gstruploadMapInterval = "500";
std::string gstrid = "1234567890123456789H";
std::string gstrplateNumber = "津A123456";

class mainloop : public QThread
{
//    Q_OBJECT
public:
    mainloop(VehicleControlClient *pCC,DataExchangeClient *pUC);
    void run();
private:
    VehicleControlClient *pControlClient;
    DataExchangeClient *pUploadClient;
};

mainloop::mainloop(VehicleControlClient *pCC,DataExchangeClient *pUC)
{
    pControlClient = pCC;
    pUploadClient = pUC;
}

void mainloop::run()
{
    while (1) {
//        msleep(100);
        if(pControlClient->get_isNeedMap() == true)
        {
            std::cout<<"patrol path calculating"<<std::endl;
            QFile mapfile("/home/samuel/Documents/path1.txt");
            QVector<org::jeecg::defsDetails::grpc::MapPoint> somePoints;
            if(mapfile.open(QIODevice::ReadOnly | QIODevice::Text))
            {
                while(!mapfile.atEnd())
                {
                    QByteArray line = mapfile.readLine();
                    QString map_str(line);
                    QStringList oneline = map_str.split(",");
                    org::jeecg::defsDetails::grpc::MapPoint onePoint;
                    onePoint.set_index(oneline.at(0).toInt());
                    onePoint.mutable_mappoint()->set_longitude(oneline.at(1).toDouble());
                    onePoint.mutable_mappoint()->set_latitude(oneline.at(2).toDouble());
                    onePoint.mutable_mappoint()->set_height(oneline.at(3).toDouble());
                    somePoints.append(onePoint);
                }
            }
            pUploadClient->updatePath(pControlClient->get_patrolPathID(),somePoints);
            pUploadClient->uploadPath();
            pControlClient->set_isNeedMap(false);
        }
    }
}

void dec_yaml(const char * stryamlpath)
{

    YAML::Node config;
    try
    {
        config = YAML::LoadFile(stryamlpath);
    }
    catch(...)
    {
        qDebug("yaml file has some unknown code or load fail.");
        return;
    }

    if(config["server"])
    {
        gstrserverip = config["server"].as<std::string>();
    }
    if(config["uploadPort"])
    {
        gstruploadPort = config["uploadPort"].as<std::string>();
    }
    if(config["patrolPort"])
    {
        gstrpatrolPort = config["patrolPort"].as<std::string>();
    }
    if(config["controlPort"])
    {
        gstrcontrolPort = config["controlPort"].as<std::string>();
    }
    if(config["uploadInterval"])
    {
        gstruploadInterval = config["uploadInterval"].as<std::string>();
    }
    if(config["patrolInterval"])
    {
        gstrpatrolInterval = config["patrolInterval"].as<std::string>();
    }
    if(config["controlinterval"])
    {
        gstrcontrolInterval = config["controlinterval"].as<std::string>();
    }
    if(config["uploadmapinterval"])
    {
        gstruploadMapInterval = config["uploadmapinterval"].as<std::string>();
    }

    if(config["id"])
    {
        gstrid = config["id"].as<std::string>();
    }
    if(config["plateNumber"])
    {
        gstrplateNumber = config["plateNumber"].as<std::string>();
    }

    return;
}

int main(int argc, char *argv[])
{
    showversion("driver_cloud_grpc_client_BS");
    QCoreApplication a(argc, argv);

    char stryamlpath[256];
    if(argc<2)
    {
        snprintf(stryamlpath,255,"driver_cloud_grpc_client_BS.yaml");
    }
    else
    {
        strncpy(stryamlpath,argv[1],255);
    }
    dec_yaml(stryamlpath);

    std::string control_str = gstrserverip+":";
    control_str = control_str + gstrcontrolPort ;

    std::string patrol_str = gstrserverip+":";
    patrol_str = patrol_str + gstrpatrolPort;

    std::string upload_str = gstrserverip+":";
    upload_str = upload_str + gstruploadPort ;

    DataExchangeClient *vehicleupload = new DataExchangeClient(grpc::CreateChannel(upload_str, grpc::InsecureChannelCredentials()));

    VehicleControlClient *vehiclecontrol = new VehicleControlClient(grpc::CreateChannel(control_str, grpc::InsecureChannelCredentials()));

    VehiclePatrolExceptionClient vehiclepatrol(grpc::CreateChannel(patrol_str, grpc::InsecureChannelCredentials()));

    mainloop loop(vehiclecontrol,vehicleupload);
    loop.start();

    return a.exec();
}