modularization/src/driver/driver_cloud_grpc_client_BS/main.cpp

#include <QCoreApplication>

#include <QFile>
#include <QString>
#include <QStringList>
#include <QMetaType>

#include <yaml-cpp/yaml.h>

#include "vehicle_upload.h"
#include "vehicle_control.h"
#include "vehicle_patrol.h"
#include "fsm_unit.h"

#include "ivversion.h"
#include "modulecomm.h"

#ifndef IV_MSGUNIT
#define IV_MSGUNIT

namespace iv {
struct msgunit
{
    char mstrmsgname[256];
    int mnBufferSize = 10000;
    int mnBufferCount = 1;
    void * mpa = nullptr;
    std::shared_ptr<char> mpstrmsgdata;
    int mndatasize = 0;
    bool mbRefresh = false;
    bool mbImportant = false;
    int mnkeeptime = 100;
};
}

#endif

#ifndef GLOBAL_GPS_POINT
#define GLOBAL_GPS_POINT
struct gGPSPoint
{
    double latitude = 0.0;
    double longitude = 0.0;
    double height = 0.0;
};
#endif
QVector<gGPSPoint> gPOIPoints;

uint8_t gShift_Status = 3; //3 p 4 r 5 n 6 d
uint8_t gCtrlMode_Status = 0; //0 auto 1 remote 2 stop 3 platform
uint8_t gNavagationSwitch = 0;

std::string gstrserverip =  "111.33.136.150";//"123.57.212.138";
std::string gstruploadPort = "10591";//"9000";
std::string gstrpatrolPort = "10592";//"9000";
std::string gstrcontrolPort = "20591";//"9000";
std::string gstruploadInterval = "100";
std::string gstrpatrolInterval = "1000";
std::string gstrcontrolInterval = "100";
std::string gstruploadMapInterval = "1000";
std::string gstrid = "1234567890123456789H";
std::string gstrplateNumber = "津A123456";
std::string gvehicleType = "0"; //0 delevery 1 guid 2 clear

double gspeedWantAvg = 4.1; // m/s
double gwaitTime = 600; // s

char stryamlpath[256];

void dec_yaml(const char * stryamlpath)
{

    YAML::Node config;
    try
    {
        config = YAML::LoadFile(stryamlpath);
    }
    catch(YAML::BadFile &e)
    {
        std::cout<<e.what()<<std::endl;
        std::cout<<"yaml file load fail."<<std::endl;
        return;
    }
    catch(YAML::ParserException &e)
    {
        std::cout<<e.what()<<std::endl;
        std::cout<<"yaml file is malformed."<<std::endl;
        return;
    }

    if(config["server"])
    {
        gstrserverip = config["server"].as<std::string>();
        std::cout<<"server:"<<gstrserverip<<std::endl;
    }
    if(config["upload_port"])
    {
        gstruploadPort = config["upload_port"].as<std::string>();
        std::cout<<"upload_port:"<<gstruploadPort<<std::endl;
    }
    if(config["patrol_port"])
    {
        gstrpatrolPort = config["patrol_port"].as<std::string>();
        std::cout<<"patrol_port:"<<gstrpatrolPort<<std::endl;
    }
    if(config["control_port"])
    {
        gstrcontrolPort = config["control_port"].as<std::string>();
        std::cout<<"control_port:"<<gstrcontrolPort<<std::endl;
    }
    if(config["uploadinterval"])
    {
        gstruploadInterval = config["uploadinterval"].as<std::string>();
        std::cout<<"uploadinterval:"<<gstruploadInterval<<"ms"<<std::endl;
    }
    if(config["patrolinterval"])
    {
        gstrpatrolInterval = config["patrolinterval"].as<std::string>();
        std::cout<<"patrolinterval:"<<gstrpatrolInterval<<"ms"<<std::endl;
    }
    if(config["controlinterval"])
    {
        gstrcontrolInterval = config["controlinterval"].as<std::string>();
        std::cout<<"controlinterval:"<<gstrcontrolInterval<<"ms"<<std::endl;
    }
    if(config["uploadmapinterval"])
    {
        gstruploadMapInterval = config["uploadmapinterval"].as<std::string>();
        std::cout<<"uploadmapinterval:"<<gstruploadMapInterval<<"ms"<<std::endl;
    }

    if(config["id"])
    {
        gstrid = config["id"].as<std::string>();
        std::cout<<"id:"<<gstrid<<std::endl;
    }
    if(config["plateNumber"])
    {
        gstrplateNumber = config["plateNumber"].as<std::string>();
        std::cout<<"plateNumber:"<<gstrplateNumber<<std::endl;
    }
    if(config["vehicleType"])
    {
        gvehicleType = config["vehicleType"].as<std::string>();
        std::cout<<"vehicleType:"<<gstrplateNumber<<std::endl;
    }
    if(config["speedWantAvg"])
    {
        gspeedWantAvg = config["speedWantAvg"].as<double>();
        std::cout<<"speedWantAvg: "<<gspeedWantAvg<<" m/s"<<std::endl;
    }
    if(config["waitTime"])
    {
        gwaitTime = config["waitTime"].as<double>();
        std::cout<<"waitTime: "<<gwaitTime<<std::endl;
    }

    return;
}

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

    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 ;

//    std::cout<<upload_str<<std::endl;
    DataExchangeClient *vehicleuploaddata = new DataExchangeClient(grpc::CreateChannel(upload_str, grpc::InsecureChannelCredentials()));
    vehicleuploaddata->start();

//    std::cout<<control_str<<std::endl;
    VehicleChangeCtrlModeClient *vehiclechangectrlmode = new VehicleChangeCtrlModeClient(grpc::CreateChannel(control_str, grpc::InsecureChannelCredentials()));
    VehicleControlClient *vehiclecontrol = new VehicleControlClient(grpc::CreateChannel(control_str, grpc::InsecureChannelCredentials()));
    qRegisterMetaType<org::jeecg::defsControl::grpc::CtrlMode>("org::jeecg::defsControl::grpc::CtrlMode"); //< to solve the problem of signal and slot being in different threads
    QObject::connect(vehiclechangectrlmode,&VehicleChangeCtrlModeClient::ctrlMode_Changed,vehiclecontrol,&VehicleControlClient::ctrlMode_Changed_Slot);
    vehiclechangectrlmode->start();
    vehiclecontrol->start();

    VehicleUploadMapClient *vehicleuploadmap = new VehicleUploadMapClient(grpc::CreateChannel(control_str, grpc::InsecureChannelCredentials()));
    qRegisterMetaType<std::string>("std::string");
    QObject::connect(vehicleuploadmap,&VehicleUploadMapClient::patrolPOI_Recieved,vehicleuploaddata,&DataExchangeClient::patrolPOI_Recieved_Slot);
    QObject::connect(vehicleuploaddata,&DataExchangeClient::uploadPath_Finished,vehicleuploadmap,&VehicleUploadMapClient::uploadPath_Finished_Slot);
    vehicleuploadmap->start();

//    std::cout<<patrol_str<<std::endl;
//    VehiclePatrolExceptionClient vehiclepatrol(grpc::CreateChannel(patrol_str, grpc::InsecureChannelCredentials()));
//    vehiclepatrol.start();

    FSMUnit *fsmunit = new FSMUnit();
    QObject::connect(fsmunit,&FSMUnit::setAllowPlan,vehicleuploadmap,&VehicleUploadMapClient::setAllowPlan_Slot);
    QObject::connect(fsmunit,&FSMUnit::useStatusChanged,vehicleuploaddata,&DataExchangeClient::useStatusChanged_Slot);
    QObject::connect(vehicleuploaddata,&DataExchangeClient::setFSMDestination,fsmunit,&FSMUnit::setFSMDestination_Slot);
    QObject::connect(vehicleuploaddata,&DataExchangeClient::setMissionFinished,fsmunit,&FSMUnit::setMissionFinished_Slot);
    QObject::connect(vehiclechangectrlmode,&VehicleChangeCtrlModeClient::remoteCtrlModeChanged,fsmunit,&FSMUnit::remoteCtrlModeChanged_Slot);
    QObject::connect(vehiclechangectrlmode,&VehicleChangeCtrlModeClient::navagationSwitchChanged,fsmunit,&FSMUnit::navagationSwitchChanged_Slot);
    QObject::connect(vehiclechangectrlmode,&VehicleChangeCtrlModeClient::useStatusCMDChanged,fsmunit,&FSMUnit::useStatusCMDChanged_Slot);

    return a.exec();
}