Changeset 9355 in ntrip


Ignore:
Timestamp:
Feb 23, 2021, 10:57:39 PM (3 months ago)
Author:
stuerze
Message:

revert last changes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/BNC_2.12/src/upload/bncrtnetuploadcaster.cpp

    r9351 r9355  
    470470        }
    471471      }
    472 
    473       if (!outDatedBcep(eph)                    &&  // detected from storage because of no update
    474           eph->checkState() != t_eph::bad       &&
    475           eph->checkState() != t_eph::unhealthy &&
    476           eph->checkState() != t_eph::outdated) {  // detected during reception (bncephuser)
    477         QMap<QString, double> codeBiases;
    478         QList<phaseBiasSignal> phaseBiasList;
    479         phaseBiasesSat pbSat;
    480         _phaseBiasInformationDecoded = false;
    481 
    482         while (true) {
    483           QString key;
    484           int numVal = 0;
    485           in >> key;
    486           if (in.status() != QTextStream::Ok) {
     472    }
     473
     474    if (eph                                   &&
     475       !outDatedBcep(eph)                     &&  // detected from storage because of no update
     476        eph->checkState() != t_eph::bad       &&
     477        eph->checkState() != t_eph::unhealthy &&
     478        eph->checkState() != t_eph::outdated) {  // detected during reception (bncephuser)
     479      QMap<QString, double> codeBiases;
     480      QList<phaseBiasSignal> phaseBiasList;
     481      phaseBiasesSat pbSat;
     482      _phaseBiasInformationDecoded = false;
     483
     484      while (true) {
     485        QString key;
     486        int numVal = 0;
     487        in >> key;
     488        if (in.status() != QTextStream::Ok) {
     489          break;
     490        }
     491        if (key == "APC") {
     492          in >> numVal;
     493          rtnAPC.ReSize(3); rtnAPC = 0.0;
     494          for (int ii = 0; ii < numVal; ii++) {
     495            in >> rtnAPC[ii];
     496          }
     497        }
     498        else if (key == "Ura") {
     499          in >> numVal;
     500          if (numVal == 1)
     501            in >> rtnUra;
     502        }
     503        else if (key == "Clk") {
     504          in >> numVal;
     505          rtnClk.ReSize(3); rtnClk = 0.0;
     506          for (int ii = 0; ii < numVal; ii++) {
     507            in >> rtnClk[ii];
     508          }
     509        }
     510        else if (key == "ClkSig") {
     511          in >> numVal;
     512          rtnClkSig.ReSize(3); rtnClkSig = 0.0;
     513          for (int ii = 0; ii < numVal; ii++) {
     514            in >> rtnClkSig[ii];
     515          }
     516        }
     517        else if (key == "Vel") {
     518          in >> numVal;
     519          rtnVel.ReSize(3); rtnVel = 0.0;
     520          for (int ii = 0; ii < numVal; ii++) {
     521            in >> rtnVel[ii];
     522          }
     523        }
     524        else if (key == "CoM") {
     525          in >> numVal;
     526          rtnCoM.ReSize(3); rtnCoM = 0.0;
     527          for (int ii = 0; ii < numVal; ii++) {
     528            in >> rtnCoM[ii];
     529          }
     530        }
     531        else if (key == "CodeBias") {
     532          in >> numVal;
     533          for (int ii = 0; ii < numVal; ii++) {
     534            QString type;
     535            double value;
     536            in >> type >> value;
     537            codeBiases[type] = value;
     538          }
     539        }
     540        else if (key == "YawAngle") {
     541          _phaseBiasInformationDecoded = true;
     542          in >> numVal >> pbSat.yawAngle;
     543          if      (pbSat.yawAngle < 0.0) {
     544            pbSat.yawAngle += (2*M_PI);
     545          }
     546          else if (pbSat.yawAngle > 2*M_PI) {
     547            pbSat.yawAngle -= (2*M_PI);
     548          }
     549        }
     550        else if (key == "YawRate") {
     551          _phaseBiasInformationDecoded = true;
     552          in >> numVal >> pbSat.yawRate;
     553        }
     554        else if (key == "PhaseBias") {
     555          _phaseBiasInformationDecoded = true;
     556          in >> numVal;
     557          for (int ii = 0; ii < numVal; ii++) {
     558            phaseBiasSignal pb;
     559            in >> pb.type >> pb.bias >> pb.integerIndicator
     560              >> pb.wlIndicator >> pb.discontinuityCounter;
     561            phaseBiasList.append(pb);
     562          }
     563        }
     564        else {
     565          in >> numVal;
     566          for (int ii = 0; ii < numVal; ii++) {
     567            double dummy;
     568            in >> dummy;
     569          }
     570          emit(newMessage("                      RTNET format error: "
     571                          +  lines[ii].toAscii(), false));
     572        }
     573      }
     574
     575      struct SsrCorr::ClockOrbit::SatData* sd = 0;
     576      if (prn.system() == 'G') {
     577        sd = co.Sat + co.NumberOfSat[CLOCKORBIT_SATGPS];
     578        ++co.NumberOfSat[CLOCKORBIT_SATGPS];
     579      }
     580      else if (prn.system() == 'R') {
     581        sd = co.Sat + CLOCKORBIT_NUMGPS + co.NumberOfSat[CLOCKORBIT_SATGLONASS];
     582        ++co.NumberOfSat[CLOCKORBIT_SATGLONASS];
     583      }
     584      else if (prn.system() == 'E') {
     585        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     586           + co.NumberOfSat[CLOCKORBIT_SATGALILEO];
     587        ++co.NumberOfSat[CLOCKORBIT_SATGALILEO];
     588      }
     589      else if (prn.system() == 'J') {
     590        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     591           + CLOCKORBIT_NUMGALILEO
     592           + co.NumberOfSat[CLOCKORBIT_SATQZSS];
     593        ++co.NumberOfSat[CLOCKORBIT_SATQZSS];
     594      }
     595      else if (prn.system() == 'S') {
     596        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     597            + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     598            + co.NumberOfSat[CLOCKORBIT_SATSBAS];
     599        ++co.NumberOfSat[CLOCKORBIT_SATSBAS];
     600      }
     601      else if (prn.system() == 'C') {
     602        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     603            + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     604            + CLOCKORBIT_NUMSBAS
     605            + co.NumberOfSat[CLOCKORBIT_SATBDS];
     606        ++co.NumberOfSat[CLOCKORBIT_SATBDS];
     607      }
     608      if (sd) {
     609        QString outLine;
     610        t_irc irc = processSatellite(eph, epoTime.gpsw(), epoTime.gpssec(), prnStr, rtnAPC,
     611                                     rtnUra, rtnClk, rtnVel, rtnCoM, rtnClkSig, sd, outLine);
     612        if (irc != success) {/*
     613          // very few cases: check states bad and unhealthy are excluded earlier
     614          sd->ID = prnStr.mid(1).toInt(); // to prevent G00, R00 entries
     615          sd->IOD = eph->IOD();
     616          */
     617          continue;
     618        }
     619      }
     620
     621      // Code Biases
     622      // -----------
     623      struct SsrCorr::CodeBias::BiasSat* biasSat = 0;
     624      if (!codeBiases.isEmpty()) {
     625        if (prn.system() == 'G') {
     626          biasSat = bias.Sat + bias.NumberOfSat[CLOCKORBIT_SATGPS];
     627          ++bias.NumberOfSat[CLOCKORBIT_SATGPS];
     628        }
     629        else if (prn.system() == 'R') {
     630          biasSat = bias.Sat + CLOCKORBIT_NUMGPS
     631                  + bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     632          ++bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     633        }
     634        else if (prn.system() == 'E') {
     635          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     636                  + bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     637          ++bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     638        }
     639        else if (prn.system() == 'J') {
     640          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     641                  + CLOCKORBIT_NUMGALILEO
     642                  + bias.NumberOfSat[CLOCKORBIT_SATQZSS];
     643          ++bias.NumberOfSat[CLOCKORBIT_SATQZSS];
     644        }
     645        else if (prn.system() == 'S') {
     646          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     647                  + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     648                  + bias.NumberOfSat[CLOCKORBIT_SATSBAS];
     649          ++bias.NumberOfSat[CLOCKORBIT_SATSBAS];
     650        }
     651        else if (prn.system() == 'C') {
     652          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     653                  + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     654                  + CLOCKORBIT_NUMSBAS
     655                  + bias.NumberOfSat[CLOCKORBIT_SATBDS];
     656          ++bias.NumberOfSat[CLOCKORBIT_SATBDS];
     657        }
     658      }
     659
     660      if (biasSat) {
     661        biasSat->ID = prn.number();
     662        biasSat->NumberOfCodeBiases = 0;
     663        QMapIterator<QString, double> it(codeBiases);
     664        while (it.hasNext()) {
     665          it.next();
     666          int ii = biasSat->NumberOfCodeBiases;
     667          if (ii >= CLOCKORBIT_NUMBIAS)
    487668            break;
    488           }
    489           if (key == "APC") {
    490             in >> numVal;
    491             rtnAPC.ReSize(3); rtnAPC = 0.0;
    492             for (int ii = 0; ii < numVal; ii++) {
    493               in >> rtnAPC[ii];
    494             }
    495           }
    496           else if (key == "Ura") {
    497             in >> numVal;
    498             if (numVal == 1)
    499               in >> rtnUra;
    500           }
    501           else if (key == "Clk") {
    502             in >> numVal;
    503             rtnClk.ReSize(3); rtnClk = 0.0;
    504             for (int ii = 0; ii < numVal; ii++) {
    505               in >> rtnClk[ii];
    506             }
    507           }
    508           else if (key == "ClkSig") {
    509             in >> numVal;
    510             rtnClkSig.ReSize(3); rtnClkSig = 0.0;
    511             for (int ii = 0; ii < numVal; ii++) {
    512               in >> rtnClkSig[ii];
    513             }
    514           }
    515           else if (key == "Vel") {
    516             in >> numVal;
    517             rtnVel.ReSize(3); rtnVel = 0.0;
    518             for (int ii = 0; ii < numVal; ii++) {
    519               in >> rtnVel[ii];
    520             }
    521           }
    522           else if (key == "CoM") {
    523             in >> numVal;
    524             rtnCoM.ReSize(3); rtnCoM = 0.0;
    525             for (int ii = 0; ii < numVal; ii++) {
    526               in >> rtnCoM[ii];
    527             }
    528           }
    529           else if (key == "CodeBias") {
    530             in >> numVal;
    531             for (int ii = 0; ii < numVal; ii++) {
    532               QString type;
    533               double value;
    534               in >> type >> value;
    535               codeBiases[type] = value;
    536             }
    537           }
    538           else if (key == "YawAngle") {
    539             _phaseBiasInformationDecoded = true;
    540             in >> numVal >> pbSat.yawAngle;
    541             if      (pbSat.yawAngle < 0.0) {
    542               pbSat.yawAngle += (2*M_PI);
    543             }
    544             else if (pbSat.yawAngle > 2*M_PI) {
    545               pbSat.yawAngle -= (2*M_PI);
    546             }
    547           }
    548           else if (key == "YawRate") {
    549             _phaseBiasInformationDecoded = true;
    550             in >> numVal >> pbSat.yawRate;
    551           }
    552           else if (key == "PhaseBias") {
    553             _phaseBiasInformationDecoded = true;
    554             in >> numVal;
    555             for (int ii = 0; ii < numVal; ii++) {
    556               phaseBiasSignal pb;
    557               in >> pb.type >> pb.bias >> pb.integerIndicator
    558                 >> pb.wlIndicator >> pb.discontinuityCounter;
    559               phaseBiasList.append(pb);
    560             }
    561           }
    562           else {
    563             in >> numVal;
    564             for (int ii = 0; ii < numVal; ii++) {
    565               double dummy;
    566               in >> dummy;
    567             }
    568             emit(newMessage("                      RTNET format error: "
    569                             +  lines[ii].toAscii(), false));
    570           }
    571         }
    572 
    573         struct SsrCorr::ClockOrbit::SatData* sd = 0;
    574         if (prn.system() == 'G') {
    575           sd = co.Sat + co.NumberOfSat[CLOCKORBIT_SATGPS];
    576           ++co.NumberOfSat[CLOCKORBIT_SATGPS];
    577         }
    578         else if (prn.system() == 'R') {
    579           sd = co.Sat + CLOCKORBIT_NUMGPS + co.NumberOfSat[CLOCKORBIT_SATGLONASS];
    580           ++co.NumberOfSat[CLOCKORBIT_SATGLONASS];
    581         }
    582         else if (prn.system() == 'E') {
    583           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    584              + co.NumberOfSat[CLOCKORBIT_SATGALILEO];
    585           ++co.NumberOfSat[CLOCKORBIT_SATGALILEO];
    586         }
    587         else if (prn.system() == 'J') {
    588           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    589              + CLOCKORBIT_NUMGALILEO
    590              + co.NumberOfSat[CLOCKORBIT_SATQZSS];
    591           ++co.NumberOfSat[CLOCKORBIT_SATQZSS];
    592         }
    593         else if (prn.system() == 'S') {
    594           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    595               + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    596               + co.NumberOfSat[CLOCKORBIT_SATSBAS];
    597           ++co.NumberOfSat[CLOCKORBIT_SATSBAS];
    598         }
    599         else if (prn.system() == 'C') {
    600           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    601               + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    602               + CLOCKORBIT_NUMSBAS
    603               + co.NumberOfSat[CLOCKORBIT_SATBDS];
    604           ++co.NumberOfSat[CLOCKORBIT_SATBDS];
    605         }
    606         if (sd) {
    607           QString outLine;
    608           t_irc irc = processSatellite(eph, epoTime.gpsw(), epoTime.gpssec(), prnStr, rtnAPC,
    609                                        rtnUra, rtnClk, rtnVel, rtnCoM, rtnClkSig, sd, outLine);
    610           if (irc != success) {/*
    611             // very few cases: check states bad and unhealthy are excluded earlier
    612             sd->ID = prnStr.mid(1).toInt(); // to prevent G00, R00 entries
    613             sd->IOD = eph->IOD();
    614             */
    615             continue;
    616           }
    617         }
    618 
    619         // Code Biases
    620         // -----------
    621         struct SsrCorr::CodeBias::BiasSat* biasSat = 0;
    622         if (!codeBiases.isEmpty()) {
    623           if (prn.system() == 'G') {
    624             biasSat = bias.Sat + bias.NumberOfSat[CLOCKORBIT_SATGPS];
    625             ++bias.NumberOfSat[CLOCKORBIT_SATGPS];
    626           }
    627           else if (prn.system() == 'R') {
    628             biasSat = bias.Sat + CLOCKORBIT_NUMGPS
    629                     + bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    630             ++bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    631           }
    632           else if (prn.system() == 'E') {
    633             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    634                     + bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    635             ++bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    636           }
    637           else if (prn.system() == 'J') {
    638             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    639                     + CLOCKORBIT_NUMGALILEO
    640                     + bias.NumberOfSat[CLOCKORBIT_SATQZSS];
    641             ++bias.NumberOfSat[CLOCKORBIT_SATQZSS];
    642           }
    643           else if (prn.system() == 'S') {
    644             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    645                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    646                     + bias.NumberOfSat[CLOCKORBIT_SATSBAS];
    647             ++bias.NumberOfSat[CLOCKORBIT_SATSBAS];
    648           }
    649           else if (prn.system() == 'C') {
    650             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    651                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    652                     + CLOCKORBIT_NUMSBAS
    653                     + bias.NumberOfSat[CLOCKORBIT_SATBDS];
    654             ++bias.NumberOfSat[CLOCKORBIT_SATBDS];
    655           }
    656         }
    657 
    658         if (biasSat) {
    659           biasSat->ID = prn.number();
    660           biasSat->NumberOfCodeBiases = 0;
    661           QMapIterator<QString, double> it(codeBiases);
    662           while (it.hasNext()) {
    663             it.next();
    664             int ii = biasSat->NumberOfCodeBiases;
    665             if (ii >= CLOCKORBIT_NUMBIAS)
    666               break;
    667             SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), it.key().toStdString());
    668             if (type != _ssrCorr->RESERVED) {
    669               biasSat->NumberOfCodeBiases += 1;
    670               biasSat->Biases[ii].Type = type;
    671               biasSat->Biases[ii].Bias = it.value();
    672             }
    673           }
    674         }
    675 
    676         // Phase Biases
    677         // ------------
    678         struct SsrCorr::PhaseBias::PhaseBiasSat* phasebiasSat = 0;
    679         if (prn.system()      == 'G') {
    680           phasebiasSat = phasebias.Sat
    681                        + phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
    682           ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
    683         }
    684         else if (prn.system() == 'R') {
    685           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
    686                        + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    687           ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    688         }
    689         else if (prn.system() == 'E') {
    690           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    691                        + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    692           ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    693         }
    694         else if (prn.system() == 'J') {
    695           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    696                        + CLOCKORBIT_NUMGALILEO
    697                        + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
    698           ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
    699         }
    700         else if (prn.system() == 'S') {
    701           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    702                        + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    703                        + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
    704           ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
    705         }
    706         else if (prn.system() == 'C') {
    707           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    708                        + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    709                        + CLOCKORBIT_NUMSBAS
    710                        + phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
    711           ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
    712         }
    713 
    714         if (phasebiasSat && _phaseBiasInformationDecoded) {
    715           phasebias.DispersiveBiasConsistencyIndicator = dispersiveBiasConsistenyIndicator;
    716           phasebias.MWConsistencyIndicator = mwConsistencyIndicator;
    717           phasebiasSat->ID = prn.number();
    718           phasebiasSat->NumberOfPhaseBiases = 0;
    719           phasebiasSat->YawAngle = pbSat.yawAngle;
    720           phasebiasSat->YawRate = pbSat.yawRate;
    721           QListIterator<phaseBiasSignal> it(phaseBiasList);
    722           while (it.hasNext()) {
    723             const phaseBiasSignal &pbSig = it.next();
    724             int ii = phasebiasSat->NumberOfPhaseBiases;
    725             if (ii >= CLOCKORBIT_NUMBIAS)
    726               break;
    727             SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), pbSig.type.toStdString());
    728             if (type != _ssrCorr->RESERVED) {
    729               phasebiasSat->NumberOfPhaseBiases += 1;
    730               phasebiasSat->Biases[ii].Type = type;
    731               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    732               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    733               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    734               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    735             }
     669          SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), it.key().toStdString());
     670          if (type != _ssrCorr->RESERVED) {
     671            biasSat->NumberOfCodeBiases += 1;
     672            biasSat->Biases[ii].Type = type;
     673            biasSat->Biases[ii].Bias = it.value();
     674          }
     675        }
     676      }
     677
     678      // Phase Biases
     679      // ------------
     680      struct SsrCorr::PhaseBias::PhaseBiasSat* phasebiasSat = 0;
     681      if (prn.system()      == 'G') {
     682        phasebiasSat = phasebias.Sat
     683                     + phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
     684        ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
     685      }
     686      else if (prn.system() == 'R') {
     687        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
     688                     + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     689        ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     690      }
     691      else if (prn.system() == 'E') {
     692        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     693                     + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     694        ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     695      }
     696      else if (prn.system() == 'J') {
     697        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     698                     + CLOCKORBIT_NUMGALILEO
     699                     + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
     700        ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
     701      }
     702      else if (prn.system() == 'S') {
     703        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     704                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     705                     + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
     706        ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
     707      }
     708      else if (prn.system() == 'C') {
     709        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     710                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     711                     + CLOCKORBIT_NUMSBAS
     712                     + phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
     713        ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
     714      }
     715
     716      if (phasebiasSat && _phaseBiasInformationDecoded) {
     717        phasebias.DispersiveBiasConsistencyIndicator = dispersiveBiasConsistenyIndicator;
     718        phasebias.MWConsistencyIndicator = mwConsistencyIndicator;
     719        phasebiasSat->ID = prn.number();
     720        phasebiasSat->NumberOfPhaseBiases = 0;
     721        phasebiasSat->YawAngle = pbSat.yawAngle;
     722        phasebiasSat->YawRate = pbSat.yawRate;
     723        QListIterator<phaseBiasSignal> it(phaseBiasList);
     724        while (it.hasNext()) {
     725          const phaseBiasSignal &pbSig = it.next();
     726          int ii = phasebiasSat->NumberOfPhaseBiases;
     727          if (ii >= CLOCKORBIT_NUMBIAS)
     728            break;
     729          SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), pbSig.type.toStdString());
     730          if (type != _ssrCorr->RESERVED) {
     731            phasebiasSat->NumberOfPhaseBiases += 1;
     732            phasebiasSat->Biases[ii].Type = type;
     733            phasebiasSat->Biases[ii].Bias = pbSig.bias;
     734            phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
     735            phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
     736            phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    736737          }
    737738        }
Note: See TracChangeset for help on using the changeset viewer.