fix(grpcBS):finish test version code

src/driver/driver_cloud_grpc_client_BS/VehicleControl_service.proto

@@ -13,7 +13,7 @@ service VehicleControl {
   // 车辆远程控制
   rpc vehicleControl (Empty) returns (ControlReply) {}
   // 路径生成
-  rpc UploadMap(Empty) returns(UploadMapReply) {}
+  rpc UploadMap(Empty) returns(UploadMapReply) {}  //this service may change into uploadMap in future
   // 控制模式改变
   rpc changeCtrlMode(Empty) returns(CtrlModeReply) {}
 }

src/driver/driver_cloud_grpc_client_BS/VehiclePatrol.proto

@@ -37,5 +37,5 @@ message PatrolRequest{
     string plateNumber = 18;
 }
 
-message Empty{
-}
+message Empty{ //this message need a id in future
+}

src/driver/driver_cloud_grpc_client_BS/VehicleUpload_service.proto

@@ -10,7 +10,7 @@ option java_outer_classname = "VehicleService";
 import "VehicleUpload.proto";
 
 service DataExchange {
-  rpc uploadVehicleOInfo (UplinkRequest) returns (ResponseMessage) {}
+  rpc uploadVehicleInfo (UplinkRequest) returns (ResponseMessage) {}
   
   rpc uploadPath (UploadPathRequest) returns (Empty) {}
 }

src/driver/driver_cloud_grpc_client_BS/driver_cloud_grpc_client_BS.pro

@@ -30,7 +30,9 @@ SOURCES += \
         VehicleUpload_service.grpc.pb.cc \
         VehicleUpload_service.pb.cc \
         main.cpp \
-        grpcclient.cpp
+        vehicle_control.cpp \
+        vehicle_patrol.cpp \
+        vehicle_upload.cpp
 
 # Default rules for deployment.
 qnx: target.path = /tmp/$${TARGET}/bin
@@ -72,6 +74,8 @@ HEADERS += \
         VehicleUpload.pb.h \
         VehicleUpload_service.grpc.pb.h \
         VehicleUpload_service.pb.h \
-        grpcclient.h
+        vehicle_control.h \
+        vehicle_patrol.h \
+        vehicle_upload.h
 
 #before compile in ubuntu20.04 : sudo apt install libyaml-cpp-dev libgrpc++-dev

src/driver/driver_cloud_grpc_client_BS/driver_cloud_grpc_client_BS.yaml

@@ -3,9 +3,10 @@ upload_port : 10591
 patrol_port : 10592
 control_port : 20591
 
-uploadinterval : 100 //ms
-patrolinterval : 100
+uploadinterval : 500 //ms
+patrolinterval : 500
 controlinterval : 100
+uploadmapinterval : 1000
 
-ID : 1
-
+id : 1234567890123456789H
+plateNumber : 津A123456

src/driver/driver_cloud_grpc_client_BS/main.cpp

@@ -1,309 +1,78 @@
 #include <QCoreApplication>
 
-#include "grpcclient.h"
-
 #include "ivversion.h"
 
-/*
 #include <yaml-cpp/yaml.h>
-
-#include <QDateTime>
-
-#include <iostream>
-
-#include <vector>
-
-#include <memory>
-
-#include <QMutex>
-
-#include <thread>
-
-#include "modulecomm.h"
-
-#include "cloud.pb.h"
-
-#include <iostream>
-#include <memory>
-#include <string>
-
-#include <grpcpp/grpcpp.h>
-
-#include "uploadmsg.grpc.pb.h"
-
-
-using grpc::Channel;
-using grpc::ClientContext;
-using grpc::Status;
-
-
-void test()
+#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
 {
-    std::string target_str = "0.0.0.0:50051";
-
-    auto cargs = grpc::ChannelArguments();
-    cargs.SetMaxReceiveMessageSize(1024 * 1024 * 1024); // 1 GB
-    cargs.SetMaxSendMessageSize(1024 * 1024 * 1024);
-
-    std::shared_ptr<Channel> channel = grpc::CreateCustomChannel(
-             target_str, grpc::InsecureChannelCredentials(),cargs);
-
-    std::unique_ptr<iv::Upload::Stub> stub_ = iv::Upload::NewStub(channel);
-
-
-    iv::UploadRequest request;
-
-
-
-    // Container for the data we expect from the server.
-    iv::UploadReply reply;
-
-    int nid = 0;
-
-    nid = 1;
-
-    while(1)
-    {
-
-
-
-
-        // Context for the client. It could be used to convey extra information to
-        // the server and/or tweak certain RPC behaviors.
-
-
-        ClientContext context ;
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        qint64 time1 = QDateTime::currentMSecsSinceEpoch();
-
-        request.set_id(nid);
-        request.set_ntime(time1);
-        nid++;
-        // The actual RPC.
-        Status status = stub_->upload(&context, request, &reply);
-        if (status.ok()) {
-            std::cout<<nid<<" upload successfully"<<std::endl;
-//            qint64 time2;
-
-//            memcpy(&time2,reply.data().data(),8);
-//            qint64 time3 = QDateTime::currentMSecsSinceEpoch();
-//            std::cout<<"reply data size is "<<reply.data().size()<<std::endl;
-//            std::cout<<" latency is "<<(time2 - time1)<<" 2 is "<<(time3 - time2)<<std::endl;
-//          return reply.message();
-        } else {
-          std::cout << status.error_code() << ": " << status.error_message()
-                    << std::endl;
-          std::cout<<"RPC failed"<<std::endl;
-          std::this_thread::sleep_for(std::chrono::milliseconds(900));
-
-//          delete pcontext;
-//          pcontext = new ClientContext;
-
-//          channel = grpc::CreateCustomChannel(
-//                   target_str, grpc::InsecureChannelCredentials(),cargs);
-
-//          stub_ = iv::Upload::NewStub(channel);
-        }
-    }
-}
-
-std::string gstrserverip =  "0.0.0.0";//"123.57.212.138";
-std::string gstrserverport = "50051";//"9000";
-std::string gstruploadinterval = "1000";
-void * gpa;
-QMutex gMutexMsg;
-std::thread * guploadthread;
-
-
-
-
-std::vector<iv::msgunit> mvectormsgunit;
-
-std::vector<iv::msgunit> mvectorctrlmsgunit;
-
-
-std::string gstrVIN = "AAAAAAAAAAAAAAAAA";
-std::string gstrqueryMD5 = "5d41402abc4b2a76b9719d911017c591";//"5d41402abc4b2a76b9719d911017c592";
-std::string gstrctrlMD5 = "5d41402abc4b2a76b9719d911017c591";
-
-
-
-int gindex = 0;
-
-void ListenData(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
+//    Q_OBJECT
+public:
+    mainloop(VehicleControlClient *pCC,DataExchangeClient *pUC);
+    void run();
+private:
+    VehicleControlClient *pControlClient;
+    DataExchangeClient *pUploadClient;
+};
+
+mainloop::mainloop(VehicleControlClient *pCC,DataExchangeClient *pUC)
 {
-
-    int nsize = mvectormsgunit.size();
-    int i;
-    for(i=0;i<nsize;i++)
-    {
-        if(strncmp(strmemname,mvectormsgunit[i].mstrmsgname,255) == 0)
-        {
-            gMutexMsg.lock();
-            char * strtem = new char[nSize];
-            memcpy(strtem,strdata,nSize);
-            mvectormsgunit[i].mpstrmsgdata.reset(strtem);
-            mvectormsgunit[i].mndatasize = nSize;
-            mvectormsgunit[i].mbRefresh = true;
-            gMutexMsg.unlock();
-            break;
-        }
-    }
+    pControlClient = pCC;
+    pUploadClient = pUC;
 }
 
-
-void sharectrlmsg(iv::cloud::cloudmsg * pxmsg)
+void mainloop::run()
 {
-    int i;
-    int nsize = pxmsg->xclouddata_size();
-    for(i=0;i<nsize;i++)
-    {
-        int j;
-        int nquerysize = mvectorctrlmsgunit.size();
-        for(j=0;j<nquerysize;j++)
+    while (1) {
+        msleep(100);
+//        if(pControlClient->get_isNeedMap() == true)
         {
-            if(strncmp(pxmsg->xclouddata(i).msgname().data(), mvectorctrlmsgunit[j].mstrmsgname,255) == 0)
+            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))
             {
- //               qDebug("size is %d ",pxmsg->xclouddata(i).data().size());
-                iv::modulecomm::ModuleSendMsg(mvectorctrlmsgunit[j].mpa,pxmsg->xclouddata(i).data().data(),pxmsg->xclouddata(i).data().size());
-                break;
-            }
-        }
-    }
-}
-
-
-void threadupload()
-{
-    int nsize = mvectormsgunit.size();
-    int i;
-
-    int ninterval = atoi(gstruploadinterval.data());
-    if(ninterval<=0)ninterval = 100;
-
-    QTime xTime;
-    xTime.start();
-    int nlastsend = xTime.elapsed();
-
-    std::string target_str = gstrserverip+":";
-    target_str = target_str + gstrserverport ;//std::to_string()
-    auto cargs = grpc::ChannelArguments();
-    cargs.SetMaxReceiveMessageSize(1024 * 1024 * 1024); // 1 GB
-    cargs.SetMaxSendMessageSize(1024 * 1024 * 1024);
-
-    std::shared_ptr<Channel> channel = grpc::CreateCustomChannel(
-             target_str, grpc::InsecureChannelCredentials(),cargs);
-
-    std::unique_ptr<iv::Upload::Stub> stub_ = iv::Upload::NewStub(channel);
-
-
-    iv::UploadRequest request;
-
-    int nid = 0;
-
-    // Container for the data we expect from the server.
-    iv::UploadReply reply;
-
-    gpr_timespec timespec;
-      timespec.tv_sec = 30;//设置阻塞时间为2秒
-      timespec.tv_nsec = 0;
-      timespec.clock_type = GPR_TIMESPAN;
-
- //   ClientContext context;
-
-
-
-    while(true)
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        if((xTime.elapsed()-nlastsend)<ninterval)
-        {
-            continue;
-        }
-
-            bool bImportant = false;
-            int nkeeptime = 0;
-            iv::cloud::cloudmsg xmsg;
-            xmsg.set_xtime(QDateTime::currentMSecsSinceEpoch());
-            gMutexMsg.lock();
-            for(i=0;i<nsize;i++)
-            {
-                if(mvectormsgunit[i].mbRefresh)
+                while(!mapfile.atEnd())
                 {
-                    mvectormsgunit[i].mbRefresh = false;
-                    if(mvectormsgunit[i].mbImportant)
-                    {
-                        bImportant = true;
-                    }
-                    if(mvectormsgunit[i].mnkeeptime > nkeeptime)
-                    {
-                        nkeeptime = mvectormsgunit[i].mnkeeptime;
-                    }
-                    iv::cloud::cloudunit xcloudunit;
-                    xcloudunit.set_msgname(mvectormsgunit[i].mstrmsgname);
-                    xcloudunit.set_data(mvectormsgunit[i].mpstrmsgdata.get(),mvectormsgunit[i].mndatasize);
-                    iv::cloud::cloudunit * pcu = xmsg.add_xclouddata();
-                    pcu->CopyFrom(xcloudunit);
-                }
-
-            }
-            gMutexMsg.unlock();
-
-            int nbytesize = xmsg.ByteSize();
-            char * strbuf = new char[nbytesize];
-            std::shared_ptr<char> pstrbuf;
-            pstrbuf.reset(strbuf);
-            if(xmsg.SerializeToArray(strbuf,nbytesize))
-            {
-
-                ClientContext context ;
-                context.set_deadline(timespec);
-                qint64 time1 = QDateTime::currentMSecsSinceEpoch();
-
-                request.set_id(nid);
-                request.set_ntime(time1);
-                request.set_strquerymd5(gstrqueryMD5);
-                request.set_strctrlmd5(gstrctrlMD5);
-                request.set_strvin(gstrVIN);
-                request.set_xdata(strbuf,nbytesize);
-                request.set_kepptime(nkeeptime);
-                request.set_bimportant(bImportant);
-                nid++;
-                // The actual RPC.
-                Status status = stub_->upload(&context, request, &reply);
-                if (status.ok()) {
-                    std::cout<<nid<<" upload successfully"<<std::endl;
-                    if(reply.nres() == 1)
-                    {
-                        iv::cloud::cloudmsg xmsg;
-                        if(xmsg.ParseFromArray(reply.xdata().data(),reply.xdata().size()))
-                        {
-                            sharectrlmsg(&xmsg);
-                        }
-                    }
-                } else {
-                  std::cout << status.error_code() << ": " << status.error_message()
-                            << std::endl;
-                  std::cout<<"RPC failed"<<std::endl;
-                  if(status.error_code() == 4)
-                  {
-                      std::cout<<" RPC Exceed Time, Create New stub_"<<std::endl;
-                      channel = grpc::CreateCustomChannel(
-                               target_str, grpc::InsecureChannelCredentials(),cargs);
-
-                      stub_ = iv::Upload::NewStub(channel);
-                  }
-                  std::this_thread::sleep_for(std::chrono::milliseconds(900));
-
+                    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);
                 }
-
             }
-            nlastsend = xTime.elapsed();
-
+//            pUploadClient->updatePath(pControlClient->get_patrolPathID(),somePoints);
+            pUploadClient->updatePath("testpath1",somePoints);
+            pUploadClient->uploadPath();
+            pControlClient->set_isNeedMap(false);
+        }
+//        std::cout<<"thread running"<<std::endl;
     }
 }
 
-
 void dec_yaml(const char * stryamlpath)
 {
 
@@ -312,161 +81,90 @@ void dec_yaml(const char * stryamlpath)
     {
         config = YAML::LoadFile(stryamlpath);
     }
-    catch(YAML::BadFile e)
+    catch(...)
     {
-        qDebug("load error.");
+        qDebug("yaml file has some unknown code or load fail.");
         return;
     }
 
-    std::vector<std::string> vecmodulename;
-
-
     if(config["server"])
     {
         gstrserverip = config["server"].as<std::string>();
     }
-    if(config["port"])
+    if(config["uploadPort"])
     {
-        gstrserverport = config["port"].as<std::string>();
+        gstruploadPort = config["uploadPort"].as<std::string>();
     }
-    if(config["uploadinterval"])
+    if(config["patrolPort"])
     {
-        gstruploadinterval = config["uploadinterval"].as<std::string>();
+        gstrpatrolPort = config["patrolPort"].as<std::string>();
     }
-
-    if(config["VIN"])
+    if(config["controlPort"])
     {
-        gstrVIN = config["VIN"].as<std::string>();
+        gstrcontrolPort = config["controlPort"].as<std::string>();
     }
-
-    if(config["queryMD5"])
+    if(config["uploadInterval"])
     {
-        gstrqueryMD5 = config["queryMD5"].as<std::string>();
+        gstruploadInterval = config["uploadInterval"].as<std::string>();
     }
-    else
+    if(config["patrolInterval"])
     {
-        return;
+        gstrpatrolInterval = config["patrolInterval"].as<std::string>();
     }
-
-    if(config["ctrlMD5"])
+    if(config["controlinterval"])
     {
-        gstrctrlMD5 = config["ctrlMD5"].as<std::string>();
+        gstrcontrolInterval = config["controlinterval"].as<std::string>();
     }
-
-
-    std::string strmsgname;
-
-    if(config["uploadmessage"])
-    {
-
-        for(YAML::const_iterator it= config["uploadmessage"].begin(); it != config["uploadmessage"].end();++it)
-        {
-            std::string strtitle = it->first.as<std::string>();
-            std::cout<<strtitle<<std::endl;
-
-            if(config["uploadmessage"][strtitle]["msgname"]&&config["uploadmessage"][strtitle]["buffersize"]&&config["uploadmessage"][strtitle]["buffercount"])
-            {
-                iv::msgunit xmu;
-                strmsgname = config["uploadmessage"][strtitle]["msgname"].as<std::string>();
-                strncpy(xmu.mstrmsgname,strmsgname.data(),255);
-                xmu.mnBufferSize = config["uploadmessage"][strtitle]["buffersize"].as<int>();
-                xmu.mnBufferCount = config["uploadmessage"][strtitle]["buffercount"].as<int>();
-                if(config["uploadmessage"][strtitle]["bimportant"])
-                {
-                   std::string strimportant =    config["uploadmessage"][strtitle]["bimportant"].as<std::string>();
-                   if(strimportant == "true")
-                   {
-                       xmu.mbImportant = true;
-                   }
-                }
-                if(config["uploadmessage"][strtitle]["keeptime"])
-                {
-                   std::string strkeep =    config["uploadmessage"][strtitle]["keeptime"].as<std::string>();
-                   xmu.mnkeeptime = atoi(strkeep.data());
-                }
-                mvectormsgunit.push_back(xmu);
-            }
-        }
-    }
-    else
+    if(config["uploadmapinterval"])
     {
-
-
+        gstruploadMapInterval = config["uploadmapinterval"].as<std::string>();
     }
 
-    if(!config["ctrlMD5"])
+    if(config["id"])
     {
-       return;
+        gstrid = config["id"].as<std::string>();
     }
-
-    if(config["ctrlmessage"])
+    if(config["plateNumber"])
     {
-        std::string strnodename = "ctrlmessage";
-        for(YAML::const_iterator it= config[strnodename].begin(); it != config[strnodename].end();++it)
-        {
-            std::string strtitle = it->first.as<std::string>();
-            std::cout<<strtitle<<std::endl;
-
-            if(config[strnodename][strtitle]["msgname"]&&config[strnodename][strtitle]["buffersize"]&&config[strnodename][strtitle]["buffercount"])
-            {
-                iv::msgunit xmu;
-                strmsgname = config[strnodename][strtitle]["msgname"].as<std::string>();
-                strncpy(xmu.mstrmsgname,strmsgname.data(),255);
-                xmu.mnBufferSize = config[strnodename][strtitle]["buffersize"].as<int>();
-                xmu.mnBufferCount = config[strnodename][strtitle]["buffercount"].as<int>();
-                mvectorctrlmsgunit.push_back(xmu);
-            }
-        }
-    }
-    else
-    {
-
+        gstrplateNumber = config["plateNumber"].as<std::string>();
     }
 
     return;
-
 }
 
-
-*/
-
 int main(int argc, char *argv[])
 {
-    showversion("driver_cloud_grpc_client");
+    showversion("driver_cloud_grpc_client_BS");
     QCoreApplication a(argc, argv);
 
- //   std::thread * ptest = new std::thread(test);
-
- //   return a.exec();
-
     char stryamlpath[256];
     if(argc<2)
     {
-        snprintf(stryamlpath,255,"driver_cloud_grpc_client.yaml");
-//        strncpy(stryamlpath,abs_ymlpath,255);
+        snprintf(stryamlpath,255,"driver_cloud_grpc_client_BS.yaml");
     }
     else
     {
         strncpy(stryamlpath,argv[1],255);
     }
-//    dec_yaml(stryamlpath);
+    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 ;
 
-    grpcclient * pgrpcclient = new grpcclient(stryamlpath);
-    pgrpcclient->start();
+    VehicleControlClient *vehiclecontrol = new VehicleControlClient(grpc::CreateChannel(control_str, grpc::InsecureChannelCredentials()));
 
-//    int i;
-//    for(i=0;i<mvectormsgunit.size();i++)
-//    {
-//        mvectormsgunit[i].mpa = iv::modulecomm::RegisterRecv(mvectormsgunit[i].mstrmsgname,ListenData);
-//    }
+    DataExchangeClient *vehicleupload = new DataExchangeClient(grpc::CreateChannel(upload_str, grpc::InsecureChannelCredentials()));
 
-//    for(i=0;i<mvectorctrlmsgunit.size();i++)
-//    {
-//        mvectorctrlmsgunit[i].mpa = iv::modulecomm::RegisterSend(mvectorctrlmsgunit[i].mstrmsgname,mvectorctrlmsgunit[i].mnBufferSize,
-//                                                                 mvectorctrlmsgunit[i].mnBufferCount);
-//    }
+    VehiclePatrolExceptionClient vehiclepatrol(grpc::CreateChannel(patrol_str, grpc::InsecureChannelCredentials()));
 
-//    guploadthread = new std::thread(threadupload);
+    mainloop loop(vehiclecontrol,vehicleupload);
+    loop.start();
 
     return a.exec();
 }

src/driver/driver_cloud_grpc_client_BS/prototocpp.txt

@@ -1,3 +1,3 @@
-protoc -I . --plugin=protoc-gen-grpc=/home/samuel/grpc/cmake/build/grpc_cpp_plugin --grpc_out=. driver_cloud_grpc_client_BS.proto
+protoc -I . --plugin=protoc-gen-grpc=/home/samuel/grpc/cmake/build/grpc_cpp_plugin --grpc_out=. VehicleUpload.proto VehiclePatrol.proto VehicleControl.proto VehicleUpload_service.proto VehiclePatrol_service.proto VehicleControl_service.proto
 
-protoc -I . --cpp_out=. driver_cloud_grpc_client_BS.proto 
+protoc -I . --cpp_out=. VehicleUpload.proto VehiclePatrol.proto VehicleControl.proto VehicleUpload_service.proto VehiclePatrol_service.proto VehicleControl_service.proto 

src/driver/driver_cloud_grpc_client_BS/vehicle_control.cpp

@@ -0,0 +1,201 @@
+#include "vehicle_control.h"
+
+extern std::string gstrserverip;
+extern std::string gstrcontrolPort;
+extern std::string gstrcontrolInterval;
+extern std::string gstruploadMapInterval;
+extern std::string gstrid;
+extern std::string gstrplateNumber;
+
+using org::jeecg::defsControl::grpc::Empty; ///< other message
+using org::jeecg::defsControl::grpc::GPSPoint;
+using org::jeecg::defsControl::grpc::MapPoint;
+
+using org::jeecg::defsControl::grpc::CtrlMode; ///< other enum
+using org::jeecg::defsControl::grpc::ShiftStatus;
+
+VehicleControlClient::VehicleControlClient(std::shared_ptr<Channel> channel)
+{
+    stub_ = VehicleControl::NewStub(channel);
+
+    controlTimer = new QTimer();
+    connect(controlTimer,SIGNAL(timeout()),this,SLOT(controlTimeout()));
+//    controlTimer->start(std::atoi(gstrcontrolInterval.c_str()));
+
+    uploadMapTimer = new QTimer();
+    connect(uploadMapTimer,SIGNAL(timeout()),this,SLOT(uploadMapTimeout()));
+    uploadMapTimer->start(std::atoi(gstruploadMapInterval.c_str()));
+}
+
+VehicleControlClient::~VehicleControlClient(void)
+{
+    delete controlTimer;
+    delete uploadMapTimer;
+}
+
+std::string VehicleControlClient::vehicleControl(void)
+{
+    // Data we are sending to the server.
+    Empty request;
+    request.set_id(gstrid);
+
+    // Container for the data we expect from the server.
+    ControlReply reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweak certain RPC behaviors.
+    ClientContext context;
+
+    // The actual RPC.
+    Status status = stub_ -> vehicleControl(&context,request,&reply);
+
+    // Act upon its status.
+    if (status.ok()) {
+        if(reply.id() == gstrid)
+        {
+            shiftCMD = reply.shiftcmd();
+            steeringWheelAngleCMD = reply.steeringwheelanglecmd();
+            throttleCMD = reply.throttlecmd();
+            brakeCMD = reply.brakecmd();
+        }
+        return "vehicleControl RPC successed";
+    } else {
+        std::cout << status.error_code() << ": " << status.error_message()
+                  << std::endl;
+        return "vehicleControl RPC failed";
+    }
+}
+
+std::string VehicleControlClient::uploadMap(void)
+{
+    // Data we are sending to the server.
+    Empty request;
+    request.set_id(gstrid);
+
+    // Container for the data we expect from the server.
+    UploadMapReply reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweak certain RPC behaviors.
+    ClientContext context;
+
+    // The actual RPC.
+    Status status = stub_ -> UploadMap(&context,request,&reply);
+
+    // Act upon its status.
+    if (status.ok()) {
+        if(reply.id() == gstrid)
+        {
+            std::cout<<reply.id()<<std::endl;
+            isNeedMap = false;
+            patrolPathID = "noPath";
+            POIPoints.clear();
+
+            isNeedMap = reply.isneedmap();
+            std::cout<<reply.isneedmap()<<std::endl;
+            patrolPathID = reply.patrolpathid();
+            std::cout<<reply.patrolpathid()<<std::endl;
+            for(int i = 0;i < reply.mappoints_size();i++)
+            {
+                POIPoints.append(reply.mappoints(i));
+                std::cout<<reply.mappoints(i).index()<<std::endl;
+            }
+        }
+        return "UploadMap RPC successed";
+    } else {
+        std::cout << status.error_code() << ": " << status.error_message()
+                  << std::endl;
+        return "UploadMap RPC failed";
+    }
+}
+
+std::string VehicleControlClient::changeCtrlMode(void)
+{
+    // Data we are sending to the server.
+    Empty request;
+    request.set_id(gstrid);
+
+    // Container for the data we expect from the server.
+    CtrlModeReply reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweastd::cout<<"shift:"<<shiftCMD<<std::endl;k certain RPC behaviors.
+    ClientContext context;
+
+    // The actual RPC.
+    Status status = stub_ -> changeCtrlMode(&context,request,&reply);
+
+    // Act upon its status.
+    if (status.ok()) {
+        if(reply.id() == gstrid)
+        {
+            modeCMD = reply.modecmd();
+        }
+        return "changeCtrlMode RPC successed";
+    } else {
+        std::cout << status.error_code() << ": " << status.error_message()
+                  << std::endl;
+        return "changeCtrlMode RPC failed";
+    }
+}
+
+void VehicleControlClient::updateControlData(void)
+{
+    std::cout<<"shift:"<<shiftCMD<<std::endl;
+    std::cout<<"steeringWheelAngle:"<<steeringWheelAngleCMD<<std::endl;
+    std::cout<<"throttle:"<<throttleCMD<<std::endl;
+    std::cout<<"brake:"<<brakeCMD<<std::endl;
+}
+
+void VehicleControlClient::updateMapPOIData(void)
+{
+    std::cout<<"isNeedMap:"<<isNeedMap<<std::endl;
+    std::cout<<"patrolPathID:"<<patrolPathID<<std::endl;
+}
+
+void VehicleControlClient::updateCtrolMode(void)
+{
+    std::cout<<"modeCMD:"<<modeCMD<<std::endl;
+}
+
+void VehicleControlClient::controlTimeout(void)
+{
+    std::string reply = changeCtrlMode();
+    std::cout<< reply <<std::endl;
+    updateCtrolMode();
+
+    reply = vehicleControl();
+    std::cout<< reply <<std::endl;
+    if(modeCMD == CtrlMode::CMD_REMOTE)
+    {
+        updateControlData();
+    }
+}
+
+void VehicleControlClient::uploadMapTimeout(void)
+{
+    if(isNeedMap == false)
+    {
+        std::string reply = uploadMap();
+        std::cout<< reply <<std::endl;
+        if(isNeedMap == true)
+        {
+            updateMapPOIData();
+        }
+    }
+}
+
+std::string VehicleControlClient::get_patrolPathID(void)
+{
+    return patrolPathID;
+}
+
+bool VehicleControlClient::get_isNeedMap(void)
+{
+    return isNeedMap;
+}
+
+void VehicleControlClient::set_isNeedMap(bool needMapStatus)
+{
+    isNeedMap = needMapStatus;
+}

src/driver/driver_cloud_grpc_client_BS/vehicle_control.h

@@ -0,0 +1,67 @@
+#ifndef VEHICLE_CONTROL_H
+#define VEHICLE_CONTROL_H
+
+#include <QObject>
+#include <QTimer>
+#include <QVector>
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <grpcpp/grpcpp.h>
+
+#include "VehicleControl_service.grpc.pb.h"
+#include "VehicleControl.grpc.pb.h"
+
+using grpc::Channel;
+using grpc::ClientContext;
+using grpc::Status;
+
+using org::jeecg::defsControl::grpc::VehicleControl; ///< service name
+
+using org::jeecg::defsControl::grpc::ControlReply; ///< rpc fuction parameter and return
+using org::jeecg::defsControl::grpc::UploadMapReply;
+using org::jeecg::defsControl::grpc::CtrlModeReply;
+
+class VehicleControlClient : public QObject{
+    Q_OBJECT
+
+public:
+    VehicleControlClient(std::shared_ptr<Channel> channel);
+
+    ~VehicleControlClient(void);
+
+    std::string vehicleControl(void);
+    std::string uploadMap(void);
+    std::string changeCtrlMode(void);
+    void updateControlData(void);
+    void updateMapPOIData(void);
+    void updateCtrolMode(void);
+    std::string get_patrolPathID(void);
+    bool get_isNeedMap(void);
+    void set_isNeedMap(bool needMapStatus);
+
+private:
+    std::unique_ptr<VehicleControl::Stub> stub_;
+
+    org::jeecg::defsControl::grpc::ShiftStatus shiftCMD;
+    double steeringWheelAngleCMD;
+    double throttleCMD;
+    double brakeCMD;
+
+    bool isNeedMap = false;
+    std::string patrolPathID;
+    QVector<org::jeecg::defsControl::grpc::MapPoint> POIPoints;
+
+    org::jeecg::defsControl::grpc::CtrlMode modeCMD;
+
+    QTimer *controlTimer;
+    QTimer *uploadMapTimer;
+
+private slots:
+    void controlTimeout(void);
+    void uploadMapTimeout(void);
+};
+
+#endif // VEHICLE_CONTROL_H

src/driver/driver_cloud_grpc_client_BS/vehicle_patrol.cpp

@@ -0,0 +1,131 @@
+#include "vehicle_patrol.h"
+#include <QDateTime>
+#include <QFile>
+
+extern std::string gstrserverip;
+extern std::string gstrpatrolPort;
+extern std::string gstrpatrolInterval;
+extern std::string gstrid;
+extern std::string gstrplateNumber;
+
+using org::jeecg::defsPatrol::grpc::Empty;
+using org::jeecg::defsPatrol::grpc::GPSPoint;
+
+VehiclePatrolExceptionClient::VehiclePatrolExceptionClient(std::shared_ptr<Channel> channel)
+{
+    stub_ = VehiclePatrolException::NewStub(channel);
+
+    patrolTimer = new QTimer();
+    connect(patrolTimer,SIGNAL(timeout()),this,SLOT(patrolTimeout()));
+//    patrolTimer->start(std::atoi(gstrpatrolInterval.c_str()));
+}
+
+VehiclePatrolExceptionClient::~VehiclePatrolExceptionClient(void)
+{
+    delete patrolTimer;
+}
+
+std::string VehiclePatrolExceptionClient::uploadVehiclePatrolInfo(void)
+{
+    // Data we are sending to the server.
+    PatrolRequest request;
+    request.set_id(id);
+    request.set_istvr(isTVR);
+    request.set_violationstatus(violationStatus);
+    request.set_vehiclelicensenumber(vehicleLicenseNumber);
+    request.set_violationimage(violationImage.data(),violationImage.size());
+    request.mutable_violationposition()->CopyFrom(violationPosition);
+
+    request.set_isfsm(isFSM);
+    request.set_firestatus(fireStatus);
+    request.set_fireimage(fireImage.data(),fireImage.size());
+    request.set_firetime(fireTime);
+    request.mutable_fireposition()->CopyFrom(firePosition);
+
+    request.set_istsgm(isTSGM);
+    request.set_gatestatus(gateStatus);
+    request.set_gateimage(gateImage.data(),gateImage.size());
+    request.set_gatetime(gateTime);
+    request.mutable_gateposition()->CopyFrom(gatePosition);
+
+    request.set_platenumber(plateNumber);
+
+    // Container for the data we expect from the server.
+    Empty reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweak certain RPC behaviors.
+    ClientContext context;
+
+    // The actual RPC.
+    Status status = stub_ -> uploadVehiclePatrolInfo(&context,request,&reply);
+
+    // Act upon its status.
+    if (status.ok()) {
+
+        return "uploadVehiclePatrolInfo RPC successed";
+    } else {
+        std::cout << status.error_code() << ": " << status.error_message()
+                  << std::endl;
+        return "uploadVehiclePatrolInfo RPC failed";
+    }
+}
+
+void VehiclePatrolExceptionClient::updatePatrolData(void)
+{
+    id = gstrid;
+    isTVR = true;
+    violationStatus = 2;
+    vehicleLicenseNumber = "津B654321";
+
+//    QFile xFile;
+//    xFile.setFileName("/home/samuel/Pictures/123.jpg");
+//    if(xFile.open(QIODevice::ReadOnly))
+//    {
+//        violationImage = xFile.readAll();
+//    }
+//    xFile.close();
+
+    violationTime = QDateTime::currentMSecsSinceEpoch();
+    violationPosition.set_height(0.1);
+    violationPosition.set_latitude(39.0666552);
+    violationPosition.set_longitude(117.3542963);
+
+    isFSM = true;
+    fireStatus = 1;
+
+//    xFile.setFileName("/home/samuel/Pictures/123.jpg");
+//    if(xFile.open(QIODevice::ReadOnly))
+//    {
+//        fireImage = xFile.readAll();
+//    }
+//    xFile.close();
+
+    fireTime = QDateTime::currentMSecsSinceEpoch();
+    firePosition.set_height(0.1);
+    firePosition.set_latitude(39.0667552);
+    firePosition.set_longitude(117.3542963);
+
+    isTSGM = true;
+    gateStatus = 2;
+
+//    xFile.setFileName("/home/samuel/Pictures/123.jpg");
+//    if(xFile.open(QIODevice::ReadOnly))
+//    {
+//        gateImage = xFile.readAll();
+//    }
+//    xFile.close();
+
+    gateTime = QDateTime::currentMSecsSinceEpoch();
+    gatePosition.set_height(0.1);
+    gatePosition.set_latitude(39.0665552);
+    gatePosition.set_longitude(117.3542963);
+
+    plateNumber = gstrplateNumber;
+}
+
+void VehiclePatrolExceptionClient::patrolTimeout(void)
+{
+    updatePatrolData();
+    uploadVehiclePatrolInfo();
+}

src/driver/driver_cloud_grpc_client_BS/vehicle_patrol.h

@@ -0,0 +1,68 @@
+#ifndef VEHICLE_PATROL_H
+#define VEHICLE_PATROL_H
+
+#include <QObject>
+#include <QTimer>
+#include <QVector>
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <grpcpp/grpcpp.h>
+
+#include "VehiclePatrol_service.grpc.pb.h"
+#include "VehiclePatrol.grpc.pb.h"
+
+using grpc::Channel;
+using grpc::ClientContext;
+using grpc::Status;
+
+using org::jeecg::defsPatrol::grpc::VehiclePatrolException; ///< service name
+
+using org::jeecg::defsPatrol::grpc::PatrolRequest;
+
+class VehiclePatrolExceptionClient : public QObject{
+    Q_OBJECT
+
+public:
+    VehiclePatrolExceptionClient(std::shared_ptr<Channel> channel);
+
+    ~VehiclePatrolExceptionClient(void);
+
+    std::string uploadVehiclePatrolInfo(void);
+    void updatePatrolData(void);
+
+private:
+    std::unique_ptr<VehiclePatrolException::Stub> stub_;
+
+    std::string id;
+
+    bool isTVR; //Traffic Violation Recognition
+    int32_t violationStatus; //0 no violation 1 overspeed 2 illegal parking 3 direction wrong 4 run the red light
+    std::string vehicleLicenseNumber;
+    QByteArray violationImage;
+    uint64_t violationTime; //time when get violationImage
+    org::jeecg::defsPatrol::grpc::GPSPoint violationPosition; //positon when get violationImage
+
+    bool isFSM; //Fire and Smoke Monitor
+    int32_t fireStatus; //0 no fire 1 has fire
+    QByteArray fireImage;
+    uint64_t fireTime; //time when get fireImage
+    org::jeecg::defsPatrol::grpc::GPSPoint firePosition; //positon when get fireImage
+
+    bool isTSGM; //Turn Stile Gate Monitor
+    int32_t gateStatus; //0 no gate 1 gate close 2 gate open
+    QByteArray gateImage;
+    uint64_t gateTime; //time when get gateImage
+    org::jeecg::defsPatrol::grpc::GPSPoint gatePosition; //positon when get gateImage
+
+    std::string plateNumber;
+
+    QTimer *patrolTimer;
+
+private slots:
+    void patrolTimeout(void);
+};
+
+#endif // VEHICLE_PATROL_H

src/driver/driver_cloud_grpc_client_BS/vehicle_upload.cpp

@@ -0,0 +1,207 @@
+#include "vehicle_upload.h"
+#include <QDateTime>
+#include <QFile>
+
+extern std::string gstrserverip;
+extern std::string gstruploadPort;
+extern std::string gstruploadInterval;
+extern std::string gstrid;
+extern std::string gstrplateNumber;
+
+
+using org::jeecg::defsDetails::grpc::Empty; ///< other message
+using org::jeecg::defsDetails::grpc::GPSPoint;
+using org::jeecg::defsDetails::grpc::MapPoint;
+
+using org::jeecg::defsDetails::grpc::ShiftStatus; ///< other enum
+using org::jeecg::defsDetails::grpc::CtrlMode;
+
+DataExchangeClient::DataExchangeClient(std::shared_ptr<Channel> channel)
+{
+    stub_ = DataExchange::NewStub(channel);
+
+    uploadTimer = new QTimer();
+    connect(uploadTimer,SIGNAL(timeout()),this,SLOT(uploadTimeout()));
+    uploadTimer->start(std::atoi(gstruploadInterval.c_str()));
+}
+
+DataExchangeClient::~DataExchangeClient(void)
+{
+    delete uploadTimer;
+}
+
+std::string DataExchangeClient::uploadVehicleInfo(void)
+{
+
+    // Data we are sending to the server.
+    UplinkRequest request;
+    request.set_id(id);
+    request.set_timestamp(timeStamp);
+    request.set_soc(SOC);
+    request.set_statusfeedback(statusFeedback);
+    request.set_mileage(mileage);
+    request.set_speed(speed);
+    request.set_shiftfeedback(shiftFeedback);
+    request.set_steeringwheelanglefeedback(steeringWheelAngleFeedback);
+    request.set_throttlefeedback(throttleFeedback);
+    request.set_brakefeedback(brakeFeedback);
+    request.set_gpsrtkstatus(GPSRTKStatus);
+    request.mutable_positionfeedback()->CopyFrom(positionFeedback);
+    request.set_pitch(pitch);
+    request.set_roll(roll);
+    request.set_heading(heading);
+    request.set_cameraimagefront(cameraImageFront.data(),cameraImageFront.size());
+    request.set_cameraimagerear(cameraImageRear.data(),cameraImageRear.size());
+    request.set_cameraimageleft(cameraImageLeft.data(),cameraImageLeft.size());
+    request.set_cameraimageright(cameraImageRight.data(),cameraImageRight.size());
+    request.set_sensorstatusgpsimu(sensorStatusGPSIMU);
+    request.set_sensorstatuslidar(sensorStatusLidar);
+    request.set_sensorstatusradar(sensorStatusRadar);
+    request.set_sensorstatuscamfront(sensorStatusCamFront);
+    request.set_sensorstatuscamrear(sensorStatusCamRear);
+    request.set_sensorstatuscamleft(sensorStatusCamLeft);
+    request.set_sensorstatuscamright(sensorStatusCamRight);
+    request.set_isarrived(isArrived);
+    request.set_platenumber(plateNumber);
+    request.set_modefeedback(modeFeedback);
+
+    // Container for the data we expect from the server.
+    ResponseMessage reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweak certain RPC behaviors.
+    ClientContext context;
+
+    // The actual RPC.
+    Status status = stub_ -> uploadVehicleInfo(&context, request, &reply);
+
+    // Act upon its status.
+    if (status.ok()) {
+        destinationPosition.CopyFrom(reply.destinationposition());
+//        std::cout<<"lat:"<<destinationPosition.latitude()<<"lon:"<<destinationPosition.longitude()<<"height:"<<destinationPosition.height()<<std::endl;
+        return "uploadVehicleInfo RPC successed";
+    } else {
+        std::cout << status.error_code() << ": " << status.error_message()
+                  << std::endl;
+        return "uploadVehicleInfo RPC failed";
+    }
+}
+
+std::string DataExchangeClient::uploadPath(void)
+{
+    // Data we are sending to the server.
+    UploadPathRequest request;
+    request.set_id(id);
+    request.set_patrolpathid(patrolPathID);
+    for(int i = 0;i < pathPoints.size();i++)
+    {
+        request.add_pathpoints();
+        request.mutable_pathpoints(i)->operator =(pathPoints.at(i));
+    }
+
+    // Container for the data we expect from the server.
+    Empty reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweak certain RPC behaviors.
+    ClientContext context;
+
+    // The actual RPC.
+    Status status = stub_ -> uploadPath(&context,request,&reply);
+
+    // Act upon its status.
+    if (status.ok()) {
+        if(reply.id() == gstrid)
+        {
+            std::cout<<"Path uploaded by car id:"<<reply.id()<<std::endl;
+        }
+        return "uploadPath RPC successed";
+    } else {
+        std::cout << status.error_code() << ": " << status.error_message()
+                  << std::endl;
+        return "uploadPath RPC failed";
+    }
+}
+
+void DataExchangeClient::updateData(void)
+{
+    id = gstrid;
+    timeStamp = QDateTime::currentMSecsSinceEpoch();
+    SOC = 86.5;
+    statusFeedback = VehicleStatus::STATUS_REMOTE;
+    mileage = 123.45; // kilometer
+    speed = 0.1; // m/s
+    shiftFeedback = ShiftStatus::SHIFT_DRIVE;
+    steeringWheelAngleFeedback = 1.23; //+/-540 degree
+    throttleFeedback = 0.12;
+    brakeFeedback = 0.34;
+    GPSRTKStatus = 6; //GPS-RTK status 0-6 6 is best
+    positionFeedback.set_latitude(39.0666552);
+    positionFeedback.set_longitude(117.3540963);
+    positionFeedback.set_height(0.84);
+    pitch = 0.03;
+    roll = 0.02;
+    heading = 198.4;
+
+//    QFile xFile;
+//    xFile.setFileName("/home/samuel/Pictures/123.jpg");
+//    if(xFile.open(QIODevice::ReadOnly))
+//    {
+//        cameraImageFront = xFile.readAll();
+//    }
+//    xFile.close();
+
+//    xFile.setFileName("/home/samuel/Pictures/123.jpg");
+//    if(xFile.open(QIODevice::ReadOnly))
+//    {
+//        cameraImageRear = xFile.readAll();
+//    }
+//    xFile.close();
+
+//    xFile.setFileName("/home/samuel/Pictures/123.jpg");
+//    if(xFile.open(QIODevice::ReadOnly))
+//    {
+//        cameraImageLeft = xFile.readAll();
+//    }
+//    xFile.close();
+
+//    xFile.setFileName("/home/samuel/Pictures/123.jpg");
+//    if(xFile.open(QIODevice::ReadOnly))
+//    {
+//        cameraImageRight = xFile.readAll();
+//    }
+//    xFile.close();
+
+    sensorStatusGPSIMU = false; //0 GPS-IMU ok 1 GPS-IMU error
+    sensorStatusLidar = false;
+    sensorStatusRadar = false;
+    sensorStatusCamFront = false;
+    sensorStatusCamRear = false;
+    sensorStatusCamLeft = false;
+    sensorStatusCamRight = false;
+
+    isArrived = 0; //0 no destination 1 not arrived 2 arrived
+
+    plateNumber = gstrplateNumber;
+
+    modeFeedback = CtrlMode::CMD_REMOTE; //mode Feedback
+}
+
+void DataExchangeClient::updatePath(std::string pathID, QVector<MapPoint> points)
+{
+    id = gstrid;
+    patrolPathID = pathID;
+    pathPoints.clear();
+    for(int i = 0;i < points.size();i++)
+    {
+        pathPoints.append(points.value(i));
+//        std::cout<<pathPoints.at(i).index()<<std::endl;
+    }
+}
+
+void DataExchangeClient::uploadTimeout(void)
+{
+    updateData();
+    std::string reply = uploadVehicleInfo();
+    std::cout<< reply <<std::endl;
+}

src/driver/driver_cloud_grpc_client_BS/vehicle_upload.h

@@ -0,0 +1,91 @@
+#ifndef VEHICLE_UPLOAD_H
+#define VEHICLE_UPLOAD_H
+
+#include <QObject>
+#include <QTimer>
+#include <QVector>
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <grpcpp/grpcpp.h>
+
+#include "VehicleUpload_service.grpc.pb.h"
+#include "VehicleUpload.grpc.pb.h"
+
+using grpc::Channel;
+using grpc::ClientContext;
+using grpc::Status;
+
+using org::jeecg::defsDetails::grpc::DataExchange; ///< service name
+
+using org::jeecg::defsDetails::grpc::UplinkRequest; ///< rpc fuction parameter and return
+using org::jeecg::defsDetails::grpc::ResponseMessage;
+using org::jeecg::defsDetails::grpc::UploadPathRequest;
+
+using org::jeecg::defsDetails::grpc::VehicleStatus; ///< other enum
+
+class DataExchangeClient : public QObject{
+    Q_OBJECT
+
+public:
+    DataExchangeClient(std::shared_ptr<Channel> channel);
+
+    ~DataExchangeClient(void);
+
+    std::string uploadVehicleInfo(void);
+    std::string uploadPath(void);
+    void updateData(void);
+    void updatePath(std::string pathID,QVector<org::jeecg::defsDetails::grpc::MapPoint> points);
+
+private:
+    std::unique_ptr<DataExchange::Stub> stub_;
+
+    std::string id;
+    uint64_t timeStamp;
+    double SOC; //0.0-100.0%
+    VehicleStatus statusFeedback = VehicleStatus::STATUS_EMERGENCY_STOP;
+    double mileage; // kilometer
+    double speed; // m/s
+    org::jeecg::defsDetails::grpc::ShiftStatus shiftFeedback;
+    double steeringWheelAngleFeedback; //+/-540 degree
+    double throttleFeedback;
+    double brakeFeedback;
+    int32_t GPSRTKStatus; //GPS-RTK status 0-6 6 is best
+    org::jeecg::defsDetails::grpc::GPSPoint positionFeedback;
+    double pitch;
+    double roll;
+    double heading;
+
+    QByteArray cameraImageFront;
+    QByteArray cameraImageRear;
+    QByteArray cameraImageLeft;
+    QByteArray cameraImageRight;
+
+    bool sensorStatusGPSIMU; //0 GPS-IMU ok 1 GPS-IMU error
+    bool sensorStatusLidar;
+    bool sensorStatusRadar;
+    bool sensorStatusCamFront;
+    bool sensorStatusCamRear;
+    bool sensorStatusCamLeft;
+    bool sensorStatusCamRight;
+
+    int32_t isArrived; //0 no destination 1 not arrived 2 arrived
+
+    std::string plateNumber;
+
+    org::jeecg::defsDetails::grpc::CtrlMode modeFeedback = org::jeecg::defsDetails::grpc::CtrlMode::CMD_EMERGENCY_STOP; //mode Feedback
+
+    org::jeecg::defsDetails::grpc::GPSPoint destinationPosition;
+
+    std::string patrolPathID;
+    QVector<org::jeecg::defsDetails::grpc::MapPoint> pathPoints;
+
+    QTimer *uploadTimer;
+
+private slots:
+    void uploadTimeout(void);
+};
+
+#endif // VEHICLE_UPLOAD_H