change RemoteCtrl_stream. add server latency calculate and state show.

src/driver/driver_cloud_grpc_pc_stream/grpcpc.cpp

@@ -31,7 +31,8 @@ void grpcpc::setframerate(float framerate)
     mframerate = framerate;
 }
 
-void grpcpc::threadsend(std::shared_ptr<::grpc::ClientReaderWriter<iv::queryReqStream, iv::queryReplyStream> > writer, bool *pbrun)
+void grpcpc::threadsend(std::shared_ptr<::grpc::ClientReaderWriter<iv::queryReqStream, iv::queryReplyStream> > writer, bool *pbrun,
+                        int * pnsendid,qint64 * pnreplysendtime,qint64 * pnreceivetime,QMutex * pmutexrecive)
 {
     int nctrlsize = mvectorctrlmsgunit.size();
     int i;
@@ -97,6 +98,10 @@ void grpcpc::threadsend(std::shared_ptr<::grpc::ClientReaderWriter<iv::queryReqS
 //            request.set_ntime(QDateTime::currentMSecsSinceEpoch());
             request.set_ntype(0);
 
+            request.set_nreplyid(0);
+            request.set_nreplysendtime(0);
+            request.set_npausetime(0);
+
             if(xmsg.xclouddata_size()>0)
             {
                 int nbytesize = xmsg.ByteSize();
@@ -104,6 +109,11 @@ void grpcpc::threadsend(std::shared_ptr<::grpc::ClientReaderWriter<iv::queryReqS
                 pvectordata.resize(nbytesize);
                 if(xmsg.SerializeToArray(pvectordata.data(),nbytesize))
                 {
+                    pmutexrecive->lock();
+                    request.set_nreplyid(*pnsendid);
+                    request.set_nreplysendtime(*pnreplysendtime);
+                    request.set_npausetime(QDateTime::currentMSecsSinceEpoch() - *pnreceivetime);
+                    pmutexrecive->unlock();
 
 //                    request.set_id(nctrlid);nctrlid++;
                     request.set_strctrlmd5(gstrctrlMD5);
@@ -152,6 +162,11 @@ void grpcpc::run()
 
     int nfail = 0;
 
+    int nreplyid;
+    qint64 nreplysendtime;
+    qint64 nreceivetime;
+    QMutex mutexlatency;
+
     while(!QThread::isInterruptionRequested())
     {
         ClientContext context ;
@@ -159,7 +174,8 @@ void grpcpc::run()
         std::shared_ptr<::grpc::ClientReaderWriter<iv::queryReqStream, iv::queryReplyStream> > writerRead(stub_->queryctrl(&context));
 
         bool bRun = true;
-        std::thread * pthread = new std::thread(&grpcpc::threadsend,this,writerRead,&bRun);
+        std::thread * pthread = new std::thread(&grpcpc::threadsend,this,writerRead,&bRun,
+                                                &nreplyid,&nreplysendtime,&nreceivetime,&mutexlatency);
         (void )pthread;
         iv::queryReplyStream reply;
         while (writerRead->Read(&reply)) {
@@ -167,6 +183,14 @@ void grpcpc::run()
     //        std::cout << "接收到回复：" << reply.remsg()<<"--\n" << std::endl;
             if(reply.nres() == 1)
             {
+                mnstate = 1;
+                mnlastpack = QDateTime::currentMSecsSinceEpoch();
+                mutexlatency.lock();
+                nreplyid = reply.id();
+                nreplysendtime = reply.nsendtime();
+                nreceivetime = QDateTime::currentMSecsSinceEpoch();
+                mutexlatency.unlock();
+                mnserverlatency = reply.nserverlatency();
                 mnculatency = reply.nculatency();
                 std::cout<<"data size is "<<reply.xdata().size()<<"time is"<<QDateTime::currentMSecsSinceEpoch()<<std::endl;
                 iv::cloud::cloudmsg xmsg;
@@ -175,11 +199,17 @@ void grpcpc::run()
                     sharequerymsg(&xmsg);
                 }
             }
+            else
+            {
+                if(mnlastpack == 0)
+                    mnstate = reply.nres();
+            }
             std::cout<<"read data from server. nres :"<< reply.nres()<<std::endl;
         }
         bRun = false;
         pthread->join();
         nfail++;
+        mnstate = -100;
         if(nfail > 100)std::this_thread::sleep_for(std::chrono::milliseconds(3000));
         else std::this_thread::sleep_for(std::chrono::milliseconds(100));
         std::cout<<"reconnnect to server. nfail is "<<nfail<<std::endl;
@@ -370,3 +400,17 @@ qint64 grpcpc::getculatency()
 {
     return mnculatency;
 }
+
+qint64 grpcpc::getserverlatency()
+{
+    return mnserverlatency;
+}
+
+int grpcpc::getstate()
+{
+    if(mnstate == 1)
+    {
+        if((QDateTime::currentMSecsSinceEpoch() - mnlastpack) > 3000)mnstate = 0;
+    }
+    return mnstate;
+}

src/driver/driver_cloud_grpc_pc_stream/grpcpc.h

@@ -77,9 +77,13 @@ private:
     int mninterval = 100;
 
     qint64 mnculatency = 0;
+    qint64 mnserverlatency = 0;
 
     int gindex = 0;
 
+    int mnstate = -100;  // -1 no this vin -2 pass error   0 offline 1 online
+    qint64 mnlastpack = 0;
+
 
 private:
     void dec_yaml(const char * stryamlpath);
@@ -88,13 +92,16 @@ private:
 public:
     void UpdateData(const char * strdata,const unsigned int nSize,const char * strmemname);
     std::string GetVIN();
-    void threadsend(std::shared_ptr<::grpc::ClientReaderWriter<iv::queryReqStream, iv::queryReplyStream> > writer,bool * pbrun);
+    void threadsend(std::shared_ptr<::grpc::ClientReaderWriter<iv::queryReqStream, iv::queryReplyStream> > writer,bool * pbrun,
+                    int * pnsendid,qint64 * pnreplysendtime,qint64 * pnreceivetime,QMutex * pmutexrecive);
 
     void setframerate(float framerate);
     float getframerate();
     void setctrlfps(float framerate);
     float getctrlfps();
     qint64 getculatency();
+    qint64 getserverlatency();
+    int getstate();
 
 
 };

src/driver/driver_cloud_grpc_server_stream/main.cpp

@@ -98,8 +98,21 @@ void uploadsend(::grpc::ServerReaderWriter<iv::UploadReplyStream, iv::UploadRequ
     }
 }
 
+
+qint64 calcserverlatency(std::vector<qint64> & xvectorserverlatency,qint64 nlatency)
+{
+    xvectorserverlatency.push_back(nlatency);
+    while(xvectorserverlatency.size()>5)xvectorserverlatency.erase(xvectorserverlatency.begin());
+    if(xvectorserverlatency.size()<1)return 0;
+    int nsize = xvectorserverlatency.size();
+    int i;
+    qint64 nrtn = 0;
+    for(i=0;i<nsize;i++)nrtn = nrtn +  xvectorserverlatency.at(i);
+    return nrtn/nsize;
+}
+
 void queryctrlsend(::grpc::ServerReaderWriter<iv::queryReplyStream, iv::queryReqStream>* stream,bool * pbrun,
-                std::string * pstrvin,std::string * pstrmd5,bool *pbUpdatemd4orvin,QMutex * pmutex)
+                std::string * pstrvin,std::string * pstrmd5,bool *pbUpdatemd4orvin,QMutex * pmutex,qint64 * pnserverlatency)
 {
     std::string strvin;
     std::string strmd5;
@@ -113,6 +126,9 @@ void queryctrlsend(::grpc::ServerReaderWriter<iv::queryReplyStream, iv::queryReq
     int nlastsend = xTime.elapsed();
     qint64 nlastdatatime = 0;
     qint64 nculatency;
+
+
+
     while(*pbrun)
     {
         if(*pbUpdatemd4orvin)
@@ -141,6 +157,8 @@ void queryctrlsend(::grpc::ServerReaderWriter<iv::queryReplyStream, iv::queryReq
             reply.set_id(id);
             reply.set_ntime(ntime);
             reply.set_nculatency(nculatency);
+            reply.set_nserverlatency(*pnserverlatency);
+            reply.set_nsendtime(QDateTime::currentMSecsSinceEpoch());
             stream->Write(reply);
             nlastsend = xTime.elapsed();
         }
@@ -227,7 +245,11 @@ class UploadServiceImpl final : public iv::UploadStream::Service {
       std::string strvin = "aaa";
       bool bUpdatemd4orvin = false;
       QMutex uploadmutex;
-      std::thread * pthread = new std::thread(queryctrlsend,stream,&brun,&strvin,&strquerymd5,&bUpdatemd4orvin,&uploadmutex);
+      qint64 nreplysendtime;
+      qint64 npausetime;
+      std::vector<qint64> xvectorserverlatency;
+      qint64 nserverlatency = 0;
+      std::thread * pthread = new std::thread(queryctrlsend,stream,&brun,&strvin,&strquerymd5,&bUpdatemd4orvin,&uploadmutex,&nserverlatency);
       std::cout<<"new connect."<<std::endl;
       while (stream->Read(&request))
       {
@@ -248,6 +270,12 @@ class UploadServiceImpl final : public iv::UploadStream::Service {
               xvectordata.resize(request.xdata().size());
               memcpy(xvectordata.data(),request.xdata().data(),request.xdata().size());
           }
+          nreplysendtime = request.nreplysendtime();
+          npausetime = request.npausetime();
+          if(nreplysendtime > 0)
+          {
+              nserverlatency =  calcserverlatency(xvectorserverlatency,QDateTime::currentMSecsSinceEpoch() - nreplysendtime - npausetime);
+          }
           static int tempid = 0;
           tempid++;
           int nid = gpcmsgbuf.addmsg(tempid,request.ntime(),request.strvin(),request.strctrlmd5(),&xvectordata,

src/tool/RemoteCtrl_Stream/mainwindow.cpp

@@ -201,13 +201,40 @@ MainWindow::MainWindow(QWidget *parent)
     pLabel->setText("Latency");
     mpLabelLatency = pLabel;
     ui->statusbar->addPermanentWidget(pLabel);
-    mpProgLatency->setRange(0,100);
+    mpProgLatency->setRange(0,500);
     mpProgLatency->setValue(0);
     mpProgLatency->setTextVisible(false);
-    mpProgLatency->setFixedWidth(300);
+    mpProgLatency->setFixedWidth(200);
     mpProgLatency->setStyleSheet("QProgressBar{background:white} QProgressBar:chunk{background:green}");
+
+
+    mpProgServerLatency = new QProgressBar();
+    ui->statusbar->addPermanentWidget(mpProgServerLatency);
+    pLabel = new QLabel();
+    pLabel->setFixedWidth(150);
+    pLabel->setText("Server Latency");
+    mpLabelServerLatency = pLabel;
+    ui->statusbar->addPermanentWidget(pLabel);
+    mpProgServerLatency->setRange(0,500);
+    mpProgServerLatency->setValue(0);
+    mpProgServerLatency->setTextVisible(false);
+    mpProgServerLatency->setFixedWidth(200);
+    mpProgServerLatency->setStyleSheet("QProgressBar{background:white} QProgressBar:chunk{background:green}");
  //   mpProgLatency->setGeometry(0,0,300,30);
 
+
+    pLabel = new QLabel();
+    pLabel->setText(" ");
+    pLabel->setFixedWidth(50);
+    ui->statusbar->addPermanentWidget(pLabel);
+
+    pLabel = new QLabel();
+    pLabel->setText("Connecting to server....");
+    pLabel->setFixedWidth(200);
+    ui->statusbar->addPermanentWidget(pLabel);
+    mpLabelState = pLabel;
+    mpLabelState->setStyleSheet("QLabel{color: red}");
+
     setWindowTitle(mstrProgName +mstrVIN+  mstrGPSTime + mstrPicTime);
 
 }
@@ -654,9 +681,9 @@ void MainWindow::onTimerUpdateView()
     {
         mncurculatency = nculatency;
         int nsheet = 0;
-        if(mncurculatency >= 200)
+        if(mncurculatency >= 50)
         {
-            if(mncurculatency >= 500)nsheet = 2;
+            if(mncurculatency >= 200)nsheet = 2;
             else nsheet = 1;
         }
         bool bNeedChangeSheet = false;
@@ -665,7 +692,7 @@ void MainWindow::onTimerUpdateView()
             mnProgLatencySheet = nsheet;
             bNeedChangeSheet = true;
         }
-        mpLabelLatency->setText(QString::number(mncurculatency)+"ms");
+        mpLabelLatency->setText("IV Latency: "+QString::number(mncurculatency)+"ms");
         int nprog = mncurculatency;
         if(nprog>500)nprog = 500;
         mpProgLatency->setValue(nprog);
@@ -687,6 +714,74 @@ void MainWindow::onTimerUpdateView()
 
     }
 
+    int nstate = mgrpcpc->getstate();
+    if(nstate != mnstate)
+    {
+        mnstate = nstate;
+        switch (mnstate) {
+        case -100:
+            mpLabelState->setText("Connecting to Server...");
+            mpLabelState->setStyleSheet("QLabel{color: red}");
+            break;
+        case -2:
+            mpLabelState->setText("Password Error...");
+            mpLabelState->setStyleSheet("QLabel{color: red}");
+            break;
+        case -1:
+            mpLabelState->setText("IV not login...");
+            mpLabelState->setStyleSheet("QLabel{color: red}");
+            break;
+        case 0:
+            mpLabelState->setText("IV OffLine.");
+            mpLabelState->setStyleSheet("QLabel{color: red}");
+            break;
+        case 1:
+            mpLabelState->setText("IV OK...");
+            mpLabelState->setStyleSheet("QLabel{color: green}");
+            break;
+        default:
+            break;
+        }
+    }
+
+    qint64 nServerlatency = mgrpcpc->getserverlatency();
+    if(nServerlatency != mncurServerlatency)
+    {
+        mncurServerlatency = nServerlatency;
+        int nsheet = 0;
+        if(mncurServerlatency >= 50)
+        {
+            if(mncurServerlatency >= 200)nsheet = 2;
+            else nsheet = 1;
+        }
+        bool bNeedChangeSheet = false;
+        if(nsheet != mnProgServerLatencySheet)
+        {
+            mnProgServerLatencySheet = nsheet;
+            bNeedChangeSheet = true;
+        }
+        mpLabelServerLatency->setText("Server Latency: "+QString::number(mncurServerlatency)+"ms");
+        int nprog = mncurServerlatency;
+        if(nprog>500)nprog = 500;
+        mpProgServerLatency->setValue(nprog);
+        if(bNeedChangeSheet)
+        {
+            switch(mnProgServerLatencySheet)
+            {
+            case 0:
+                mpProgServerLatency->setStyleSheet("QProgressBar{background:white} QProgressBar:chunk{background:green}");
+                break;
+            case 1:
+                mpProgServerLatency->setStyleSheet("QProgressBar{background:white} QProgressBar:chunk{background:blue}");
+                break;
+            case 2:
+                mpProgServerLatency->setStyleSheet("QProgressBar{background:white} QProgressBar:chunk{background:red}");
+                break;
+            }
+        }
+
+    }
+
     if(gTimeGPSIMUUpdate != time_gps)
     {
         time_gps = gTimeGPSIMUUpdate;

src/tool/RemoteCtrl_Stream/mainwindow.h

@@ -182,6 +182,15 @@ private:
      qint64 mncurculatency = 0;
      int mnProgLatencySheet = 0; //0 green 1 blue 2 red
 
+     QProgressBar * mpProgServerLatency;
+     QLabel * mpLabelServerLatency;
+
+     qint64 mncurServerlatency = 0;
+     int mnProgServerLatencySheet = 0; //0 green 1 blue 2 red
+
+     int mnstate = -100;
+     QLabel * mpLabelState;
+
 
      bool mbSavePic = false;