Changeset 9036 in ntrip


Ignore:
Timestamp:
Aug 27, 2020, 9:36:18 AM (3 weeks ago)
Author:
stuerze
Message:

some modification to allow encoding and decoding of SSR corrections in RTCM-SSR and IGS-SSR formats

Location:
branches/BNC_2.12/src
Files:
3 added
2 deleted
13 edited

Legend:

Unmodified
Added
Removed
  • branches/BNC_2.12/src/RTCM3/RTCM3Decoder.cpp

    r9008 r9036  
    489489
    490490  bncTime CurrentObsTime;
    491   if (sys == 'C') /* BDS */ {
     491  if      (sys == 'C') /* BDS */ {
    492492    GETBITS(i, 30)
    493493    CurrentObsTime.setBDS(i);
     
    793793                  frqObs->_codeValid = true;
    794794                }
    795 
    796795                if (cp[count] > -1.0 / (1 << 8)) {
    797796                  frqObs->_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl
     
    802801                  frqObs->_slipCounter = ll[count];
    803802                }
    804 
    805803                frqObs->_snr = cnr[count];
    806804                frqObs->_snrValid = true;
     
    812810                  frqObs->_codeValid = true;
    813811                }
    814 
    815812                if (cp[count] > -1.0 / (1 << 8)) {
    816813                  frqObs->_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl
     
    821818                  frqObs->_slipCounter = ll[count];
    822819                }
    823 
    824820                frqObs->_snr = cnr[count];
    825821                frqObs->_snrValid = true;
    826 
    827822                if (dop[count] > -1.6384) {
    828823                  frqObs->_doppler = -(dop[count] + rdop[numsat]) / cd.wl;
     
    836831                  frqObs->_codeValid = true;
    837832                }
    838 
    839833                if (cp[count] > -1.0 / (1 << 8)) {
    840834                  frqObs->_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl
     
    855849                  frqObs->_codeValid = true;
    856850                }
    857 
    858851                if (cp[count] > -1.0 / (1 << 8)) {
    859852                  frqObs->_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl
     
    16241617       * else. */
    16251618      if ((id >= 1057 && id <= 1068) ||
    1626           (id >= 1240 && id <= 1270) ||
    1627           (id == 4076)) {
    1628         if (!_coDecoders.contains(_staID.toAscii()))
    1629           _coDecoders[_staID.toAscii()] = new RTCM3coDecoder(_staID);
    1630         RTCM3coDecoder* coDecoder = _coDecoders[_staID.toAscii()];
     1619          (id >= 1240 && id <= 1270) ||
     1620                  (id == 4076)) {
     1621        RTCM3coDecoder::e_type type = RTCM3coDecoder::e_type::RTCMssr;
     1622        if (id == 4076) {
     1623          type = RTCM3coDecoder::e_type::IGSssr;
     1624        }
     1625        if (!_coDecoders.contains(_staID.toLatin1()))
     1626          _coDecoders[_staID.toLatin1()] = new RTCM3coDecoder(_staID, type);
     1627        RTCM3coDecoder* coDecoder = _coDecoders[_staID.toLatin1()];
    16311628        if (coDecoder->Decode(reinterpret_cast<char *>(_Message), _BlockSize,
    16321629            errmsg) == success) {
     
    17161713  while (size--) {
    17171714    crc ^= (*buf++) << (16);
    1718     for (i = 0; i < 8; i++)
    1719         {
     1715    for (i = 0; i < 8; i++) {
    17201716      crc <<= 1;
    17211717      if (crc & 0x1000000)
  • branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.cpp

    r8987 r9036  
    5353// Constructor
    5454////////////////////////////////////////////////////////////////////////////
    55 RTCM3coDecoder::RTCM3coDecoder(const QString& staID) {
     55RTCM3coDecoder::RTCM3coDecoder(const QString& staID, const e_type type) {
    5656
    5757  _staID = staID;
     
    9696  _providerID[1] = -1;
    9797  _providerID[2] = -1;
     98
     99  _type = type;
     100  _ssrCorr = 0;
    98101}
    99102
     
    102105RTCM3coDecoder::~RTCM3coDecoder() {
    103106  delete _out;
     107  delete _ssrCorr;
    104108  _IODs.clear();
    105109  _orbCorrections.clear();
     
    166170  while(_buffer.size()) {
    167171
    168     struct ClockOrbit clkOrbSav;
    169     struct CodeBias   codeBiasSav;
    170     struct PhaseBias  phaseBiasSav;
    171     struct VTEC       vTECSav;
     172    struct SsrCorr::ClockOrbit clkOrbSav;
     173    struct SsrCorr::CodeBias   codeBiasSav;
     174    struct SsrCorr::PhaseBias  phaseBiasSav;
     175    struct SsrCorr::VTEC       vTECSav;
    172176    memcpy(&clkOrbSav,    &_clkOrb,    sizeof(clkOrbSav)); // save state
    173177    memcpy(&codeBiasSav,  &_codeBias,  sizeof(codeBiasSav));
     
    176180
    177181    int bytesused = 0;
    178     GCOB_RETURN irc = GetSSR(&_clkOrb, &_codeBias, &_vTEC, &_phaseBias,
     182    if (_type == e_type::RTCMssr) {
     183      _ssrCorr = new SsrCorrRtcm();
     184    }
     185    else {
     186      _ssrCorr = new SsrCorrIgs();
     187    }
     188    GCOB_RETURN irc = _ssrCorr->GetSSR(&_clkOrb, &_codeBias, &_vTEC, &_phaseBias,
    179189                             _buffer.data(), _buffer.size(), &bytesused);
    180190
     
    259269      continue;
    260270    }
     271
    261272    // Orbit correction
    262273    // ----------------
    263     if ( _clkOrb.messageType == COTYPE_GPSCOMBINED     ||
    264          _clkOrb.messageType == COTYPE_GLONASSCOMBINED ||
    265          _clkOrb.messageType == COTYPE_GALILEOCOMBINED ||
    266          _clkOrb.messageType == COTYPE_QZSSCOMBINED ||
    267          _clkOrb.messageType == COTYPE_SBASCOMBINED ||
    268          _clkOrb.messageType == COTYPE_BDSCOMBINED ||
    269          _clkOrb.messageType == COTYPE_GPSORBIT ||
    270          _clkOrb.messageType == COTYPE_GLONASSORBIT ||
    271          _clkOrb.messageType == COTYPE_GALILEOORBIT ||
    272          _clkOrb.messageType == COTYPE_QZSSORBIT ||
    273          _clkOrb.messageType == COTYPE_SBASORBIT ||
    274          _clkOrb.messageType == COTYPE_BDSORBIT ) {
     274    if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED     ||
     275         _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
     276         _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
     277         _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
     278         _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
     279         _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
     280         _clkOrb.messageType == _ssrCorr->COTYPE_GPSORBIT ||
     281         _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSORBIT ||
     282         _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOORBIT ||
     283         _clkOrb.messageType == _ssrCorr->COTYPE_QZSSORBIT ||
     284         _clkOrb.messageType == _ssrCorr->COTYPE_SBASORBIT ||
     285         _clkOrb.messageType == _ssrCorr->COTYPE_BDSORBIT ) {
    275286
    276287      t_orbCorr orbCorr;
     
    295306    // Clock Corrections
    296307    // -----------------
    297     if ( _clkOrb.messageType == COTYPE_GPSCOMBINED     ||
    298          _clkOrb.messageType == COTYPE_GLONASSCOMBINED ||
    299          _clkOrb.messageType == COTYPE_GALILEOCOMBINED ||
    300          _clkOrb.messageType == COTYPE_QZSSCOMBINED ||
    301          _clkOrb.messageType == COTYPE_SBASCOMBINED ||
    302          _clkOrb.messageType == COTYPE_BDSCOMBINED ||
    303          _clkOrb.messageType == COTYPE_GPSCLOCK ||
    304          _clkOrb.messageType == COTYPE_GLONASSCLOCK ||
    305          _clkOrb.messageType == COTYPE_GALILEOCLOCK ||
    306          _clkOrb.messageType == COTYPE_QZSSCLOCK ||
    307          _clkOrb.messageType == COTYPE_SBASCLOCK ||
    308          _clkOrb.messageType == COTYPE_BDSCLOCK) {
     308    if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED     ||
     309         _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
     310         _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
     311         _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
     312         _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
     313         _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
     314         _clkOrb.messageType == _ssrCorr->COTYPE_GPSCLOCK ||
     315         _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCLOCK ||
     316         _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCLOCK ||
     317         _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCLOCK ||
     318         _clkOrb.messageType == _ssrCorr->COTYPE_SBASCLOCK ||
     319         _clkOrb.messageType == _ssrCorr->COTYPE_BDSCLOCK) {
    309320
    310321      t_clkCorr clkCorr;
     
    327338    // High-Resolution Clocks
    328339    // ----------------------
    329     if ( _clkOrb.messageType == COTYPE_GPSHR     ||
    330          _clkOrb.messageType == COTYPE_GLONASSHR ||
    331          _clkOrb.messageType == COTYPE_GALILEOHR ||
    332          _clkOrb.messageType == COTYPE_QZSSHR ||
    333          _clkOrb.messageType == COTYPE_SBASHR ||
    334          _clkOrb.messageType == COTYPE_BDSHR) {
     340    if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSHR     ||
     341         _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSHR ||
     342         _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOHR ||
     343         _clkOrb.messageType == _ssrCorr->COTYPE_QZSSHR ||
     344         _clkOrb.messageType == _ssrCorr->COTYPE_SBASHR ||
     345         _clkOrb.messageType == _ssrCorr->COTYPE_BDSHR) {
    335346      t_prn prn(sysCh, _clkOrb.Sat[ii].ID, flag);
    336347      if (_lastClkCorrections.contains(prn)) {
     
    390401    satCodeBias._updateInt = _codeBias.UpdateInterval;
    391402    for (unsigned jj = 0; jj < _codeBias.Sat[ii].NumberOfCodeBiases; jj++) {
    392       const CodeBias::BiasSat::CodeBiasEntry& biasEntry = _codeBias.Sat[ii].Biases[jj];
     403      const SsrCorr::CodeBias::BiasSat::CodeBiasEntry& biasEntry = _codeBias.Sat[ii].Biases[jj];
    393404      t_frqCodeBias frqCodeBias;
    394       frqCodeBias._rnxType2ch.assign(codeTypeToRnxType(sysCh, biasEntry.Type));
     405      frqCodeBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sysCh, biasEntry.Type));
    395406      frqCodeBias._value      = biasEntry.Bias;
    396407      if (!frqCodeBias._rnxType2ch.empty()) {
     
    447458    satPhaseBias._yawDegRate = _phaseBias.Sat[ii].YawRate * 180.0 / M_PI;
    448459    for (unsigned jj = 0; jj < _phaseBias.Sat[ii].NumberOfPhaseBiases; jj++) {
    449       const PhaseBias::PhaseBiasSat::PhaseBiasEntry& biasEntry = _phaseBias.Sat[ii].Biases[jj];
     460      const SsrCorr::PhaseBias::PhaseBiasSat::PhaseBiasEntry& biasEntry = _phaseBias.Sat[ii].Biases[jj];
    450461      t_frqPhaseBias frqPhaseBias;
    451       frqPhaseBias._rnxType2ch.assign(codeTypeToRnxType(sysCh, biasEntry.Type));
     462      frqPhaseBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sysCh, biasEntry.Type));
    452463      frqPhaseBias._value                = biasEntry.Bias;
    453464      frqPhaseBias._fixIndicator         = biasEntry.SignalIntegerIndicator;
     
    468479    _vTecMap[_lastTime]._staID = _staID.toStdString();
    469480    for (unsigned ii = 0; ii < _vTEC.NumLayers; ii++) {
    470       const VTEC::IonoLayers& ionoLayer = _vTEC.Layers[ii];
     481      const SsrCorr::VTEC::IonoLayers& ionoLayer = _vTEC.Layers[ii];
    471482      t_vTecLayer layer;
    472483      layer._height = ionoLayer.Height;
     
    647658  }
    648659  else if (epoSecGlo != -1) {
    649 #ifdef USE_SSR_RTCM
    650     QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
    651     epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
    652 #endif
     660    if (_type == e_type::RTCMssr) {
     661      QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
     662      epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
     663    }
    653664    _lastTime.set(currentWeek, epoSecGlo);
    654665  }
     
    663674  }
    664675  else if (epoSecBds != -1) {
    665 #ifdef USE_SSR_RTCM
    666     epoSecBds += 14.0;
    667     if (epoSecBds > 604800.0) {
    668       epoSecBds -= 7.0*24.0*60.0*60.0;
    669     }
    670 #endif
     676    if (_type == e_type::RTCMssr) {
     677      epoSecBds += 14.0;
     678      if (epoSecBds > 604800.0) {
     679        epoSecBds -= 7.0*24.0*60.0*60.0;
     680      }
     681    }
    671682    _lastTime.set(currentWeek, epoSecBds);
    672683  }
     
    682693  }
    683694}
    684 
    685 //
    686 ////////////////////////////////////////////////////////////////////////////
    687 string RTCM3coDecoder::codeTypeToRnxType(char system, CodeType type) const {
    688   if      (system == 'G') {
    689     switch (type) {
    690       case CODETYPEGPS_L1_CA:         return "1C";
    691       case CODETYPEGPS_L1_P:          return "1P";
    692       case CODETYPEGPS_L1_Z:          return "1W";
    693 
    694       case CODETYPEGPS_SEMI_CODELESS: return "2D";
    695       case CODETYPEGPS_L2_CA:         return "2C";
    696       case CODETYPEGPS_L2_P:          return "2P";
    697       case CODETYPEGPS_L2_Z:          return "2W";
    698 
    699       case CODETYPEGPS_L2C_M:         return "2S";
    700       case CODETYPEGPS_L2C_L:         return "2L";
    701 #ifdef USE_SSR_RTCM
    702       case CODETYPEGPS_L2C_ML:        return "2X";
    703 #endif
    704 
    705       case CODETYPEGPS_L5_I:          return "5I";
    706       case CODETYPEGPS_L5_Q:          return "5Q";
    707 #ifdef USE_SSR_RTCM
    708       case CODETYPEGPS_L5_IQ:         return "5X";
    709 #endif
    710       case CODETYPEGPS_L1C_D:         return "1S";
    711       case CODETYPEGPS_L1C_P:         return "1L";
    712 #ifdef USE_SSR_RTCM
    713       case CODETYPEGPS_L1C_DP:        return "1X";
    714 #endif
    715       default: return "";
    716     }
    717   }
    718   else if (system == 'R') {
    719     switch (type) {
    720       case CODETYPEGLONASS_L1_CA:     return "1C";
    721       case CODETYPEGLONASS_L1_P:      return "1P";
    722       case CODETYPEGLONASS_L2_CA:     return "2C";
    723       case CODETYPEGLONASS_L2_P:      return "2P";
    724       case CODETYPEGLONASS_L1a_OCd:   return "4A";
    725       case CODETYPEGLONASS_L1a_OCp:   return "4B";
    726 #ifdef USE_SSR_RTCM
    727       case CODETYPEGLONASS_L1a_OCdp:  return "4X";
    728 #endif
    729       case CODETYPEGLONASS_L2a_CSI:   return "6A";
    730       case CODETYPEGLONASS_L2a_OCp:   return "6B";
    731 #ifdef USE_SSR_RTCM
    732       case CODETYPEGLONASS_L2a_CSIOCp:return "6X";
    733 #endif
    734       case CODETYPEGLONASS_L3_I:      return "3I";
    735       case CODETYPEGLONASS_L3_Q:      return "3Q";
    736 #ifdef USE_SSR_RTCM
    737       case CODETYPEGLONASS_L3_IQ:     return "3X";
    738 #endif
    739       default: return "";
    740     }
    741   }
    742   else if (system == 'E') {
    743     switch (type) {
    744       case CODETYPEGALILEO_E1_A:       return "1A";
    745       case CODETYPEGALILEO_E1_B:       return "1B";
    746       case CODETYPEGALILEO_E1_C:       return "1C";
    747 #ifdef USE_SSR_RTCM
    748       case CODETYPEGALILEO_E1_BC:      return "1X";
    749       case CODETYPEGALILEO_E1_ABC:     return "1Z";
    750 #endif
    751       case CODETYPEGALILEO_E5A_I:      return "5I";
    752       case CODETYPEGALILEO_E5A_Q:      return "5Q";
    753 #ifdef USE_SSR_RTCM
    754       case CODETYPEGALILEO_E5A_IQ:     return "5X";
    755 #endif
    756       case CODETYPEGALILEO_E5B_I:      return "7I";
    757       case CODETYPEGALILEO_E5B_Q:      return "7Q";
    758 #ifdef USE_SSR_RTCM
    759       case CODETYPEGALILEO_E5B_IQ:     return "7X";
    760 
    761       case CODETYPEGALILEO_E5_I:       return "8I";
    762       case CODETYPEGALILEO_E5_Q:       return "8Q";
    763       case CODETYPEGALILEO_E5_IQ:      return "8X";
    764 #endif
    765       case CODETYPEGALILEO_E6_A:       return "6A";
    766       case CODETYPEGALILEO_E6_B:       return "6B";
    767       case CODETYPEGALILEO_E6_C:       return "6C";
    768 #ifdef USE_SSR_RTCM
    769       case CODETYPEGALILEO_E6_BC:      return "6X";
    770       case CODETYPEGALILEO_E6_ABC:     return "6Z";
    771 #endif
    772       default: return "";
    773     }
    774   }
    775    else if (system == 'J') {
    776     switch (type) {
    777       case CODETYPEQZSS_L1_CA:         return "1C";
    778       case CODETYPEQZSS_L1C_D:         return "1S";
    779       case CODETYPEQZSS_L1C_P:         return "1L";
    780 
    781       case CODETYPEQZSS_L2C_M:         return "2S";
    782       case CODETYPEQZSS_L2C_L:         return "2L";
    783 #ifdef USE_SSR_RTCM
    784       case CODETYPEQZSS_L2C_ML:        return "2X";
    785 #endif
    786       case CODETYPEQZSS_L5_I:          return "5I";
    787       case CODETYPEQZSS_L5_Q:          return "5Q";
    788 #ifdef USE_SSR_RTCM
    789       case CODETYPEQZSS_L5_IQ:         return "5X";
    790 #endif
    791       case CODETYPEQZSS_L6_D:          return "6S";
    792       case CODETYPEQZSS_L6_P:          return "6L";
    793 #ifdef USE_SSR_RTCM
    794       case CODETYPEQZSS_L6_DP:         return "6X";
    795 
    796       case CODETYPEQZSS_L1C_DP:        return "1X";
    797       case CODETYPEQZSS_L1_S:          return "1Z";
    798 
    799       case CODETYPEQZSS_L5_D:          return "5D";
    800       case CODETYPEQZSS_L5_P:          return "5P";
    801       case CODETYPEQZSS_L5_DP:         return "5Z";
    802 #endif
    803 
    804       case CODETYPEQZSS_L6_E:          return "6E";
    805 #ifdef USE_SSR_RTCM
    806       case CODETYPEQZSS_L6_DE:         return "6Z";
    807 #endif
    808       default: return "";
    809     }
    810   }
    811   else if (system == 'C') {
    812     switch (type) {
    813       case CODETYPE_BDS_B1_I:         return "2I";
    814       case CODETYPE_BDS_B1_Q:         return "2Q";
    815 #ifdef USE_SSR_RTCM
    816       case CODETYPE_BDS_B1_IQ:        return "2X";
    817 #endif
    818       case CODETYPE_BDS_B3_I:         return "6I";
    819       case CODETYPE_BDS_B3_Q:         return "6Q";
    820 #ifdef USE_SSR_RTCM
    821       case CODETYPE_BDS_B3_IQ:        return "6X";
    822 #endif
    823       case CODETYPE_BDS_B2_I:         return "7I";
    824       case CODETYPE_BDS_B2_Q:         return "7Q";
    825 #ifdef USE_SSR_RTCM
    826       case CODETYPE_BDS_B2_IQ:        return "7X";
    827 #endif
    828       case CODETYPE_BDS_B1a_D:        return "1D";
    829       case CODETYPE_BDS_B1a_P:        return "1P";
    830 #ifdef USE_SSR_RTCM
    831       case CODETYPE_BDS_B1a_DP:       return "1X";
    832 #endif
    833       case CODETYPE_BDS_B2a_D:        return "5D";
    834       case CODETYPE_BDS_B2a_P:        return "5P";
    835 #ifdef USE_SSR_RTCM
    836       case CODETYPE_BDS_B2a_DP:       return "5X";
    837 #elif USE_SSR_IGS
    838       case CODETYPE_BDS_B1_A:         return "1A";
    839       case CODETYPE_BDS_B3_A:         return "6A";
    840 #endif
    841       default: return "";
    842     }
    843   }
    844   else if (system == 'S') {
    845     switch (type) {
    846       case CODETYPE_SBAS_L1_CA:       return "1C";
    847 
    848       case CODETYPE_SBAS_L5_I:        return "5I";
    849       case CODETYPE_SBAS_L5_Q:        return "5Q";
    850 #ifdef USE_SSR_RTCM
    851       case CODETYPE_SBAS_L5_IQ:       return "5X";
    852 #endif
    853       default: return "";
    854     }
    855   }
    856   return "";
    857 };
  • branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.h

    r8987 r9036  
    3030#include <QtNetwork>
    3131#include "GPSDecoder.h"
     32#include "../RTCM3/clock_and_orbit/clock_orbit_igs.h"
     33#include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h"
    3234
    33 extern "C" {
    34 #ifdef USE_SSR_RTCM
    35 #include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h"
    36 #elif  USE_SSR_IGS
    37 #include "../RTCM3/clock_and_orbit/clock_orbit_igs.h"
    38 #endif
    39 }
    40 
    41 class RTCM3coDecoder : public QObject, public GPSDecoder {
     35  class RTCM3coDecoder : public QObject, public GPSDecoder {
    4236Q_OBJECT
    4337 public:
    44   RTCM3coDecoder(const QString& staID);
     38  enum e_type {RTCMssr, IGSssr};
     39  RTCM3coDecoder(const QString& staID, const e_type type);
    4540  virtual ~RTCM3coDecoder();
    4641  virtual t_irc Decode(char* buffer, int bufLen, std::vector<std::string>& errmsg);
     
    6964  QString                               _fileName;
    7065  QByteArray                            _buffer;
    71   ClockOrbit                            _clkOrb;
    72   CodeBias                              _codeBias;
    73   PhaseBias                             _phaseBias;
    74   VTEC                                  _vTEC;
     66  SsrCorr::ClockOrbit                   _clkOrb;
     67  SsrCorr::CodeBias                     _codeBias;
     68  SsrCorr::PhaseBias                    _phaseBias;
     69  SsrCorr::VTEC                         _vTEC;
    7570  int                                   _providerID[3];
     71  e_type                                _type;
    7672  bncTime                               _lastTime;
     73  SsrCorr*                              _ssrCorr;
    7774  QMap<t_prn, unsigned int>             _IODs;
    7875  QMap<bncTime, QList<t_orbCorr> >      _orbCorrections;
  • branches/BNC_2.12/src/RTCM3/bits.h

    r6812 r9036  
    2626#define BITS_H
    2727
    28 #define LOADBITS(a) \
    29 { \
    30   while((a) > numbits) \
    31   { \
     28#define LOADBITS(a) { \
     29  while((a) > numbits) { \
    3230    if(!size--) return false; \
    3331    bitfield = (bitfield<<8)|*(data++); \
     
    3836/* extract bits from data stream
    3937   b = variable to store result, a = number of bits */
    40 #define GETBITS64(b, a) \
    41 { \
    42   if(((a) > 56) && ((a)-56) > numbits) \
    43   { \
     38#define GETBITS64(b, a) { \
     39  if(((a) > 56) && ((a)-56) > numbits) { \
    4440    uint64_t x; \
    4541    GETBITS(x, 56) \
     
    4945    numbits -= ((a)-56); \
    5046  } \
    51   else \
    52   { \
     47  else { \
    5348    GETBITS(b, a) \
    5449  } \
     
    5752/* extract bits from data stream
    5853   b = variable to store result, a = number of bits */
    59 #define GETBITS(b, a) \
    60 { \
     54#define GETBITS(b, a) { \
    6155  LOADBITS(a) \
    6256  b = (bitfield<<(64-numbits))>>(64-(a)); \
     
    6660/* extract bits from data stream
    6761   b = variable to store result, a = number of bits */
    68 #define GETBITSFACTOR(b, a, c) \
    69 { \
     62#define GETBITSFACTOR(b, a, c) { \
    7063  LOADBITS(a) \
    7164  b = ((bitfield<<(sizeof(bitfield)*8-numbits))>>(sizeof(bitfield)*8-(a)))*(c); \
     
    7568/* extract floating value from data stream
    7669   b = variable to store result, a = number of bits */
    77 #define GETFLOAT(b, a, c) \
    78 { \
     70#define GETFLOAT(b, a, c) { \
    7971  LOADBITS(a) \
    8072  b = ((double)((bitfield<<(64-numbits))>>(64-(a))))*(c); \
     
    8476/* extract signed floating value from data stream
    8577   b = variable to store result, a = number of bits */
    86 #define GETFLOATSIGN(b, a, c) \
    87 { \
     78#define GETFLOATSIGN(b, a, c) { \
    8879  LOADBITS(a) \
    8980  b = ((double)(((int64_t)(bitfield<<(64-numbits)))>>(64-(a))))*(c); \
     
    9384/* extract bits from data stream
    9485   b = variable to store result, a = number of bits */
    95 #define GETBITSSIGN(b, a) \
    96 { \
     86#define GETBITSSIGN(b, a) { \
    9787  LOADBITS(a) \
    9888  b = ((int64_t)(bitfield<<(64-numbits)))>>(64-(a)); \
     
    10090}
    10191
    102 #define GETFLOATSIGNM(b, a, c) \
    103 { int l; \
     92#define GETFLOATSIGNM(b, a, c) { \
     93  int l; \
    10494  LOADBITS(a) \
    10595  l = (bitfield<<(64-numbits))>>(64-1); \
     
    113103/* extract byte-aligned byte from data stream,
    114104   b = variable to store size, s = variable to store string pointer */
    115 #define GETSTRING(b, s) \
    116 { \
     105#define GETSTRING(b, s) { \
    117106  b = *(data++); \
    118107  s = (char *) data; \
  • branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.h

    r8987 r9036  
    44/* Programheader
    55
    6         Name:           clock_orbit_igs.h
    7         Project:        RTCM3
    8         Version:        $Id$
    9         Authors:        Dirk Stöcker, Andrea Stürze
    10         Description:    state space approach: IGS
    11 */
    12 
     6 Name:           clock_orbit_igs.h
     7 Project:        RTCM3
     8 Version:        $Id$
     9 Authors:        Dirk Stöcker, Andrea Stürze
     10 Description:    state space approach: IGS
     11 */
     12#include <QDebug>
    1313#include <string.h>
    14 
    15 enum IGS_NUMBERS {
    16  RTCM_MESSAGE_NUMBER_IGS = 4076,
    17  IGS_SSR_VERSION         = 3
    18 };
    19 
    20 enum SatelliteReferenceDatum {
    21   DATUM_ITRF  = 0,
    22   DATUM_LOCAL = 1
    23 };
    24 
    25 enum COR_BASE {
    26   COBBASE_GPS     =  21,
    27   COBBASE_GLONASS =  41,
    28   COBBASE_GALILEO =  61,
    29   COBBASE_QZSS    =  81,
    30   COBBASE_BDS     = 101,
    31   COBBASE_SBAS    = 121,
    32   COBBASE_NUM
    33 };
    34 
    35 enum COR_OFFSET {   // sub-type message, for example:
    36   COBOFS_ORBIT = 0, // GPS: IM21
    37   COBOFS_CLOCK,     // GPS: IM22
    38   COBOFS_COMBINED,  // GPS: IM23
    39   COBOFS_HR,        // GPS: IM24
    40   COBOFS_CBIAS,     // GPS: IM25
    41   COBOFS_PBIAS,     // GPS: IM26
    42   COBOFS_URA,       // GPS: IM27
    43   COBOFS_NUM
    44 };
    45 
    46 enum ClockOrbitType {
    47   COTYPE_GPSORBIT        = COBBASE_GPS     + COBOFS_ORBIT,
    48   COTYPE_GPSCLOCK,
    49   COTYPE_GPSCOMBINED     = COBBASE_GPS     + COBOFS_COMBINED,
    50   COTYPE_GPSHR,
    51   COTYPE_GPSURA          = COBBASE_GPS     + COBOFS_URA,
    52 
    53   COTYPE_GLONASSORBIT    = COBBASE_GLONASS + COBOFS_ORBIT,
    54   COTYPE_GLONASSCLOCK,
    55   COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED,
    56   COTYPE_GLONASSHR,
    57   COTYPE_GLONASSURA      = COBBASE_GLONASS + COBOFS_URA,
    58 
    59   COTYPE_GALILEOORBIT    = COBBASE_GALILEO + COBOFS_ORBIT,
    60   COTYPE_GALILEOCLOCK,
    61   COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED,
    62   COTYPE_GALILEOHR,
    63   COTYPE_GALILEOURA      = COBBASE_GALILEO + COBOFS_URA,
    64 
    65   COTYPE_QZSSORBIT       = COBBASE_QZSS    + COBOFS_ORBIT,
    66   COTYPE_QZSSCLOCK,
    67   COTYPE_QZSSCOMBINED    = COBBASE_QZSS    + COBOFS_COMBINED,
    68   COTYPE_QZSSHR,
    69   COTYPE_QZSSURA         = COBBASE_QZSS    + COBOFS_URA,
    70 
    71   COTYPE_SBASORBIT       = COBBASE_SBAS    + COBOFS_ORBIT,
    72   COTYPE_SBASCLOCK,
    73   COTYPE_SBASCOMBINED    = COBBASE_SBAS    + COBOFS_COMBINED,
    74   COTYPE_SBASHR,
    75   COTYPE_SBASURA         = COBBASE_SBAS    + COBOFS_URA,
    76 
    77   COTYPE_BDSORBIT        = COBBASE_BDS     + COBOFS_ORBIT,
    78   COTYPE_BDSCLOCK,
    79   COTYPE_BDSCOMBINED     = COBBASE_BDS     + COBOFS_COMBINED,
    80   COTYPE_BDSHR,
    81   COTYPE_BDSURA          = COBBASE_BDS     + COBOFS_URA,
    82 
    83   COTYPE_AUTO = 0,
    84 };
    85 
    86 enum CodeBiasType {
    87   CBTYPE_GPS     = COBBASE_GPS     + COBOFS_CBIAS,
    88   CBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_CBIAS,
    89   CBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_CBIAS,
    90   CBTYPE_QZSS    = COBBASE_QZSS    + COBOFS_CBIAS,
    91   CBTYPE_SBAS    = COBBASE_SBAS    + COBOFS_CBIAS,
    92   CBTYPE_BDS     = COBBASE_BDS     + COBOFS_CBIAS,
    93   CBTYPE_AUTO    = 0
    94 };
    95 
    96 enum PhaseBiasType {
    97   PBTYPE_GPS     = COBBASE_GPS     + COBOFS_PBIAS,
    98   PBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_PBIAS,
    99   PBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_PBIAS,
    100   PBTYPE_QZSS    = COBBASE_QZSS    + COBOFS_PBIAS,
    101   PBTYPE_SBAS    = COBBASE_SBAS    + COBOFS_PBIAS,
    102   PBTYPE_BDS     = COBBASE_BDS     + COBOFS_PBIAS,
    103   PBTYPE_AUTO    = 0
    104 };
    105 
    106 enum VTECType {
    107   VTEC_BASE = 201
    108 };
    109 
    110 /* if some systems aren't supported at all, change the following numbers to zero
    111 for these systems to save space */
    112 enum COR_CONSTANTS {
    113   CLOCKORBIT_BUFFERSIZE    = 8192,
    114   CLOCKORBIT_NUMGPS        =   32,
    115   CLOCKORBIT_NUMGLONASS    =   26,
    116   CLOCKORBIT_NUMGALILEO    =   36,
    117   CLOCKORBIT_NUMQZSS       =   10,
    118   CLOCKORBIT_NUMSBAS       =   38,
    119   CLOCKORBIT_NUMBDS        =   65,
    120   CLOCKORBIT_NUMBIAS       =  100,
    121   CLOCKORBIT_NUMIONOLAYERS =    4,
    122   CLOCKORBIT_MAXIONOORDER  =   16,
    123   CLOCKORBIT_MAXIONODEGREE =   16
    124 };
    125 
    126 enum COR_SATSYSTEM {
    127   CLOCKORBIT_SATGPS=0,
    128   CLOCKORBIT_SATGLONASS,
    129   CLOCKORBIT_SATGALILEO,
    130   CLOCKORBIT_SATQZSS,
    131   CLOCKORBIT_SATSBAS,
    132   CLOCKORBIT_SATBDS,
    133   CLOCKORBIT_SATNUM
    134 };
    135 
    136 enum COR_OFFSETS {
    137   CLOCKORBIT_OFFSETGPS     = 0,
    138   CLOCKORBIT_OFFSETGLONASS = CLOCKORBIT_NUMGPS,
    139   CLOCKORBIT_OFFSETGALILEO = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS,
    140   CLOCKORBIT_OFFSETQZSS    = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO,
    141   CLOCKORBIT_OFFSETSBAS    = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    142                            + CLOCKORBIT_NUMQZSS,
    143   CLOCKORBIT_OFFSETBDS     = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    144                            + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS,
    145   CLOCKORBIT_COUNTSAT      = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    146                            + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS    + CLOCKORBIT_NUMBDS
    147 };
    148 
    149 enum CodeType {
    150   CODETYPEGPS_L1_CA          = 0,
    151   CODETYPEGPS_L1_P           = 1,
    152   CODETYPEGPS_L1_Z           = 2,
    153   CODETYPEGPS_L1C_D          = 3,
    154   CODETYPEGPS_L1C_P          = 4,
    155   CODETYPEGPS_L2_CA          = 5,
    156   CODETYPEGPS_SEMI_CODELESS  = 6,
    157   CODETYPEGPS_L2C_M          = 7,
    158   CODETYPEGPS_L2C_L          = 8,
    159   //RESERVED                 = 9,
    160   CODETYPEGPS_L2_P           = 10,
    161   CODETYPEGPS_L2_Z           = 11,
    162   //RESERVED                 = 12,
    163   //RESERVED                 = 13,
    164   CODETYPEGPS_L5_I           = 14,
    165   CODETYPEGPS_L5_Q           = 15,
    166 
    167   CODETYPEGLONASS_L1_CA      = 0,
    168   CODETYPEGLONASS_L1_P       = 1,
    169   CODETYPEGLONASS_L2_CA      = 2,
    170   CODETYPEGLONASS_L2_P       = 3,
    171   CODETYPEGLONASS_L1a_OCd    = 4,
    172   CODETYPEGLONASS_L1a_OCp    = 5,
    173   CODETYPEGLONASS_L2a_CSI    = 6,
    174   CODETYPEGLONASS_L2a_OCp    = 7,
    175   CODETYPEGLONASS_L3_I       = 8,
    176   CODETYPEGLONASS_L3_Q       = 9,
    177 
    178   CODETYPEGALILEO_E1_A       = 0,
    179   CODETYPEGALILEO_E1_B       = 1,
    180   CODETYPEGALILEO_E1_C       = 2,
    181   //RESERVED_E1_BC           = 3,
    182   //RESERVED_E1_ABC          = 4,
    183   CODETYPEGALILEO_E5A_I      = 5,
    184   CODETYPEGALILEO_E5A_Q      = 6,
    185   //RESERVED_E5A_IQ          = 7,
    186   CODETYPEGALILEO_E5B_I      = 8,
    187   CODETYPEGALILEO_E5B_Q      = 9,
    188   //RESERVED_E5B_IQ          = 10,
    189   //RESERVED_E5_I            = 11,
    190   //RESERVED_E5_Q            = 12,
    191   //RESERVED_E5_IQ           = 13,
    192   CODETYPEGALILEO_E6_A       = 14,
    193   CODETYPEGALILEO_E6_B       = 15,
    194   CODETYPEGALILEO_E6_C       = 16,
    195   //RESERVED_E6_BC           = 17,
    196   //RESERVED_E6_ABC          = 18,
    197 
    198   CODETYPEQZSS_L1_CA         = 0,
    199   CODETYPEQZSS_L1C_D         = 1,
    200   CODETYPEQZSS_L1C_P         = 2,
    201   CODETYPEQZSS_L2C_M         = 3,
    202   CODETYPEQZSS_L2C_L         = 4,
    203   //RESEVED_L2C_ML           = 5,
    204   CODETYPEQZSS_L5_I          = 6,
    205   CODETYPEQZSS_L5_Q          = 7,
    206   //RESERVED_L5_IQ           = 8,
    207   CODETYPEQZSS_L6_D          = 9,
    208   CODETYPEQZSS_L6_P          = 10,
    209   //RESERVED_L6_DP           = 11,
    210   //RESERVED_L1C_DP          = 12,
    211   //RESERVED_L1_S            = 13,
    212   //RESERVED_L5_D            = 14,
    213   //RESERVED_L5_P            = 15,
    214   //RESERVED_L5_DP           = 16,
    215   CODETYPEQZSS_L6_E          = 17,
    216   //RESERVED_L6_DE           = 18,
    217 
    218   CODETYPE_SBAS_L1_CA        = 0,
    219   CODETYPE_SBAS_L5_I         = 1,
    220   CODETYPE_SBAS_L5_Q         = 2,
    221   //RESERVED_SBAS_L5_IQ      = 3,
    222 
    223   CODETYPE_BDS_B1_I          = 0,
    224   CODETYPE_BDS_B1_Q          = 1,
    225   //RESERVED_BDS_B1_IQ       = 2,
    226   CODETYPE_BDS_B3_I          = 3,
    227   CODETYPE_BDS_B3_Q          = 4,
    228   //RESERVED_BDS_B3_IQ       = 5,
    229   CODETYPE_BDS_B2_I          = 6,
    230   CODETYPE_BDS_B2_Q          = 7,
    231   //RESERVED_BDS_B2_IQ       = 8,
    232   CODETYPE_BDS_B1a_D         = 9,
    233   CODETYPE_BDS_B1a_P         = 10,
    234   //RESERVED_BDS_B1a_DP      = 11,
    235   CODETYPE_BDS_B2a_D         = 12,
    236   CODETYPE_BDS_B2a_P         = 13,
    237   //RESEVED_BDS_B2a_DP       = 14,
    238   CODETYPE_BDS_B1_A          = 15, //NEW 1A
    239   //RESERVED                 = 16,
    240   //RESERVED                 = 17,
    241   CODETYPE_BDS_B3_A          = 18  //NEW 6A
    242 };
    243 
    244 #define SSR_MAXURA 5.5 /* > 5466.5mm in meter */
    245 
    246 /* satellite system data is stored with offset CLOCKORBIT_OFFSET...
    247 in the data structures. So first GLONASS satellite is at
    248 xxx->Sat[CLOCKORBIT_OFFSETGLONASS], first GPS satellite is
    249 xxx->Sat[CLOCKORBIT_OFFSETGPS]. */
    250 
    251 struct ClockOrbit {
    252   enum ClockOrbitType messageType;
    253   unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
    254   unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */
    255   unsigned int Supplied[COBOFS_NUM];           /* boolean */
    256   unsigned int SSRIOD;
    257   unsigned int SSRProviderID;
    258   unsigned int SSRSolutionID;
    259   unsigned int UpdateInterval;
    260   enum SatelliteReferenceDatum SatRefDatum;
    261   struct SatData {
    262     unsigned int ID; /* all */
    263     unsigned int IOD; /* all */
    264     unsigned int toe; /* SBAS, BDS */
    265     double UserRangeAccuracy; /* accuracy values in [m] */
    266     double hrclock;
    267     struct OrbitPart {
    268       double DeltaRadial;           /* m */
    269       double DeltaAlongTrack;       /* m */
    270       double DeltaCrossTrack;       /* m */
    271       double DotDeltaRadial;        /* m/s */
    272       double DotDeltaAlongTrack;    /* m/s */
    273       double DotDeltaCrossTrack;    /* m/s */
    274     } Orbit;
    275     struct ClockPart {
    276       double DeltaA0;               /* m */
    277       double DeltaA1;               /* m/s */
    278       double DeltaA2;               /* m/ss */
    279     } Clock;
    280   } Sat[CLOCKORBIT_COUNTSAT];
    281 };
    282 
    283 struct CodeBias {
    284   enum CodeBiasType messageType;
    285   unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
    286   unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */
    287   unsigned int UpdateInterval;
    288   unsigned int SSRIOD;
    289   unsigned int SSRProviderID;
    290   unsigned int SSRSolutionID;
    291   struct BiasSat {
    292     unsigned int ID; /* all */
    293     unsigned int NumberOfCodeBiases;
    294     struct CodeBiasEntry {
    295       enum CodeType Type;
    296       float         Bias;           /* m */
    297     } Biases[CLOCKORBIT_NUMBIAS];
    298   } Sat[CLOCKORBIT_COUNTSAT];
    299 };
    300 
    301 struct PhaseBias {
    302   enum PhaseBiasType messageType;
    303   unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
    304   unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */
    305   unsigned int UpdateInterval;
    306   unsigned int SSRIOD;
    307   unsigned int SSRProviderID;
    308   unsigned int SSRSolutionID;
    309   unsigned int DispersiveBiasConsistencyIndicator;
    310   unsigned int MWConsistencyIndicator;
    311   struct PhaseBiasSat {
    312     unsigned int ID; /* all */
    313     unsigned int NumberOfPhaseBiases;
    314     double YawAngle; /* radiant */
    315     double YawRate;  /* radiant/s */
    316     struct PhaseBiasEntry {
    317       enum CodeType Type;
    318       unsigned int  SignalIntegerIndicator;
    319       unsigned int  SignalsWideLaneIntegerIndicator;
    320       unsigned int  SignalDiscontinuityCounter;
    321       float         Bias;           /* m */
    322     } Biases[CLOCKORBIT_NUMBIAS];
    323   } Sat[CLOCKORBIT_COUNTSAT];
    324 };
    325 
    326 struct VTEC {
    327   unsigned int EpochTime; /* GPS */
    328   unsigned int UpdateInterval;
    329   unsigned int SSRIOD;
    330   unsigned int SSRProviderID;
    331   unsigned int SSRSolutionID;
    332   unsigned int NumLayers; /* 1-4 */
    333   double Quality;
    334   struct IonoLayers {
    335     double       Height; /* m */
    336     unsigned int Degree; /* 1-16 */
    337     unsigned int Order; /* 1-16 */
    338     double       Sinus[CLOCKORBIT_MAXIONODEGREE][CLOCKORBIT_MAXIONOORDER];
    339     double       Cosinus[CLOCKORBIT_MAXIONODEGREE][CLOCKORBIT_MAXIONOORDER];
    340   } Layers[CLOCKORBIT_NUMIONOLAYERS];
    341 };
    342 
    343 /* return size of resulting data or 0 in case of an error */
    344 size_t MakeClockOrbit(const struct ClockOrbit *co, enum ClockOrbitType type,
     14#include "clock_orbit.h"
     15
     16class SsrCorrIgs: public SsrCorr {
     17  //Q_OBJECT
     18
     19public:
     20  SsrCorrIgs() {qDebug() << "SsrCorrIgs()";
     21    setCorBase();
     22    setCorOffset();
     23    setCoType();
     24    setCbType();
     25    setPbType();
     26    setVtecType();
     27    setCodeType();
     28
     29    satoffset << CLOCKORBIT_OFFSETGPS
     30        << CLOCKORBIT_OFFSETGLONASS
     31        << CLOCKORBIT_OFFSETGALILEO
     32        << CLOCKORBIT_OFFSETQZSS
     33        << CLOCKORBIT_OFFSETSBAS
     34        << CLOCKORBIT_OFFSETBDS
     35        << CLOCKORBIT_COUNTSAT;
     36  };
     37
     38  ~SsrCorrIgs() {};
     39
     40  void setCorBase() {
     41    COBBASE_GPS     =  21;
     42    COBBASE_GLONASS =  41;
     43    COBBASE_GALILEO =  61;
     44    COBBASE_QZSS    =  81;
     45    COBBASE_BDS     = 101;
     46    COBBASE_SBAS    = 121;
     47    COBBASE_NUM     =   6;
     48
     49    corbase << COBBASE_GPS
     50            << COBBASE_GLONASS
     51            << COBBASE_GALILEO
     52            << COBBASE_QZSS
     53            << COBBASE_SBAS
     54            << COBBASE_BDS;
     55  }
     56
     57  void setCorOffset() {
     58    COBOFS_ORBIT    = 0; // GPS: IM21
     59    COBOFS_CLOCK    = 1; // GPS: IM22
     60    COBOFS_COMBINED = 2; // GPS: IM23
     61    COBOFS_HR       = 3; // GPS: IM24
     62    COBOFS_CBIAS    = 4; // GPS: IM25
     63    COBOFS_PBIAS    = 5; // GPS: IM26
     64    COBOFS_URA      = 6; // GPS: IM27
     65    COBOFS_NUM      = 7;
     66  };
     67
     68  void setCoType() {
     69    COTYPE_GPSORBIT        = COBBASE_GPS + COBOFS_ORBIT;
     70    COTYPE_GPSCLOCK        = COTYPE_GPSORBIT + 1;
     71    COTYPE_GPSCOMBINED     = COBBASE_GPS + COBOFS_COMBINED;
     72    COTYPE_GPSHR           = COTYPE_GPSCOMBINED + 1;
     73    COTYPE_GPSURA          = COBBASE_GPS + COBOFS_URA;
     74
     75    COTYPE_GLONASSORBIT    = COBBASE_GLONASS + COBOFS_ORBIT;
     76    COTYPE_GLONASSCLOCK    = COTYPE_GLONASSORBIT + 1;
     77    COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED,
     78    COTYPE_GLONASSHR       = COTYPE_GLONASSCOMBINED + 1;
     79    COTYPE_GLONASSURA      = COBBASE_GLONASS + COBOFS_URA,
     80
     81    COTYPE_GALILEOORBIT    = COBBASE_GALILEO + COBOFS_ORBIT;
     82    COTYPE_GALILEOCLOCK    = COTYPE_GALILEOORBIT + 1;
     83    COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED,
     84    COTYPE_GALILEOHR       = COTYPE_GALILEOCOMBINED + 1;
     85    COTYPE_GALILEOURA      = COBBASE_GALILEO + COBOFS_URA;
     86
     87    COTYPE_QZSSORBIT       = COBBASE_QZSS + COBOFS_ORBIT;
     88    COTYPE_QZSSCLOCK       = COTYPE_QZSSORBIT + 1;
     89    COTYPE_QZSSCOMBINED    = COBBASE_QZSS + COBOFS_COMBINED;
     90    COTYPE_QZSSHR          = COTYPE_QZSSCOMBINED + 1;
     91    COTYPE_QZSSURA         = COBBASE_QZSS + COBOFS_URA;
     92
     93    COTYPE_SBASORBIT       = COBBASE_SBAS + COBOFS_ORBIT;
     94    COTYPE_SBASCLOCK       = COTYPE_SBASORBIT + 1;
     95    COTYPE_SBASCOMBINED    = COBBASE_SBAS + COBOFS_COMBINED;
     96    COTYPE_SBASHR          = COTYPE_SBASCOMBINED + 1;
     97    COTYPE_SBASURA         = COBBASE_SBAS + COBOFS_URA;
     98
     99    COTYPE_BDSORBIT        = COBBASE_BDS + COBOFS_ORBIT;
     100    COTYPE_BDSCLOCK        = COTYPE_BDSORBIT + 1;
     101    COTYPE_BDSCOMBINED     = COBBASE_BDS + COBOFS_COMBINED;
     102    COTYPE_BDSHR           = COTYPE_BDSCOMBINED + 1;
     103    COTYPE_BDSURA          = COBBASE_BDS + COBOFS_URA;
     104
     105    COTYPE_AUTO = 0;
     106  };
     107
     108  void setCbType() {
     109    CBTYPE_GPS     = COBBASE_GPS     + COBOFS_CBIAS;
     110    CBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_CBIAS;
     111    CBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_CBIAS;
     112    CBTYPE_QZSS    = COBBASE_QZSS    + COBOFS_CBIAS;
     113    CBTYPE_SBAS    = COBBASE_SBAS    + COBOFS_CBIAS;
     114    CBTYPE_BDS     = COBBASE_BDS     + COBOFS_CBIAS;
     115    CBTYPE_AUTO = 0;
     116  };
     117
     118  void setPbType() {
     119    PBTYPE_GPS     = COBBASE_GPS     + COBOFS_PBIAS;
     120    PBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_PBIAS;
     121    PBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_PBIAS;
     122    PBTYPE_QZSS    = COBBASE_QZSS    + COBOFS_PBIAS;
     123    PBTYPE_SBAS    = COBBASE_SBAS    + COBOFS_PBIAS;
     124    PBTYPE_BDS     = COBBASE_BDS     + COBOFS_PBIAS;
     125    PBTYPE_AUTO = 0;
     126  };
     127
     128  void setVtecType() {
     129      VTEC_BASE   = 201;
     130  };
     131
     132  void setCodeType() {
     133    CODETYPE_GPS_L1_CA          =  0;
     134    CODETYPE_GPS_L1_P           =  1;
     135    CODETYPE_GPS_L1_Z           =  2;
     136    CODETYPE_GPS_L1C_D          =  3;
     137    CODETYPE_GPS_L1C_P          =  4;
     138    CODETYPE_GPS_L2_CA          =  5;
     139    CODETYPE_GPS_SEMI_CODELESS  =  6;
     140    CODETYPE_GPS_L2C_M          =  7;
     141    CODETYPE_GPS_L2C_L          =  8;
     142    //RESERVED                  =  9;
     143    CODETYPE_GPS_L2_P           = 10;
     144    CODETYPE_GPS_L2_Z           = 11;
     145    //RESERVED                  = 12;
     146    //RESERVED                  = 13;
     147    CODETYPE_GPS_L5_I           = 14;
     148    CODETYPE_GPS_L5_Q           = 15;
     149
     150
     151
     152
     153
     154    CODETYPE_GLONASS_L1_CA      =  0;
     155    CODETYPE_GLONASS_L1_P       =  1;
     156    CODETYPE_GLONASS_L2_CA      =  2;
     157    CODETYPE_GLONASS_L2_P       =  3;
     158    CODETYPE_GLONASS_L1a_OCd    =  4;
     159    CODETYPE_GLONASS_L1a_OCp    =  5;
     160    CODETYPE_GLONASS_L2a_CSI    =  6;
     161    CODETYPE_GLONASS_L2a_OCp    =  7;
     162    CODETYPE_GLONASS_L3_I       =  8;
     163    CODETYPE_GLONASS_L3_Q       =  9;
     164
     165
     166
     167
     168    CODETYPE_GALILEO_E1_A       =  0;
     169    CODETYPE_GALILEO_E1_B       =  1;
     170    CODETYPE_GALILEO_E1_C       =  2;
     171    //RESERVED_E1_BC            =  3;
     172    //RESERVED_E1_ABC           =  4;
     173    CODETYPE_GALILEO_E5A_I      =  5;
     174    CODETYPE_GALILEO_E5A_Q      =  6;
     175    //RESERVED_E5A_IQ           =  7;
     176    CODETYPE_GALILEO_E5B_I      =  8;
     177    CODETYPE_GALILEO_E5B_Q      =  9;
     178    //RESERVED_E5B_IQ           = 10;
     179    //RESERVED_E5_I             = 11;
     180    //RESERVED_E5_Q             = 12;
     181    //RESERVED_E5_IQ            = 13;
     182    CODETYPE_GALILEO_E6_A       = 14;
     183    CODETYPE_GALILEO_E6_B       = 15;
     184    CODETYPE_GALILEO_E6_C       = 16;
     185    //RESERVED_E6_BC            = 17;
     186    //RESERVED_E6_ABC           = 18;
     187
     188    CODETYPE_QZSS_L1_CA         = 0;
     189    CODETYPE_QZSS_L1C_D         = 1;
     190    CODETYPE_QZSS_L1C_P         = 2;
     191    CODETYPE_QZSS_L2C_M         = 3;
     192    CODETYPE_QZSS_L2C_L         = 4;
     193    //RESEVED_L2C_ML            = 5;
     194    CODETYPE_QZSS_L5_I          = 6;
     195    CODETYPE_QZSS_L5_Q          = 7;
     196    //RESERVED_L5_IQ            = 8;
     197    CODETYPE_QZSS_L6_D          = 9;
     198    CODETYPE_QZSS_L6_P          = 10;
     199    //RESERVED_L6_DP            = 11;
     200    //RESERVED_L1C_DP           = 12;
     201    //RESERVED_L1_S             = 13;
     202    //RESERVED_L5_D             = 14;
     203    //RESERVED_L5_P             = 15;
     204    //RESERVED_L5_DP            = 16;
     205    CODETYPE_QZSS_L6_E          = 17;
     206    //RESERVED_L6_DE            = 18;
     207
     208    CODETYPE_SBAS_L1_CA        =  0;
     209    CODETYPE_SBAS_L5_I         =  1;
     210    CODETYPE_SBAS_L5_Q         =  2;
     211    //RESERVED_CODETYPE_SBAS_L5_IQ      = 3;
     212
     213    CODETYPE_BDS_B1_I          =  0;
     214    CODETYPE_BDS_B1_Q          =  1;
     215    //RESERVED_CODETYPE_BDS_B1_IQ       = 2;
     216    CODETYPE_BDS_B3_I          =  3;
     217    CODETYPE_BDS_B3_Q          =  4;
     218    //RESERVED_CODETYPE_BDS_B3_IQ       = 5;
     219    CODETYPE_BDS_B2_I          =  6;
     220    CODETYPE_BDS_B2_Q          =  7;
     221    //RESERVED_CODETYPE_BDS_B2_IQ       = 8;
     222    CODETYPE_BDS_B1a_D         =  9;
     223    CODETYPE_BDS_B1a_P         = 10;
     224    //RESERVED_CODETYPE_BDS_B1a_DP      = 11;
     225    CODETYPE_BDS_B2a_D         = 12;
     226    CODETYPE_BDS_B2a_P         = 13;
     227    //RESEVED_CODETYPE_BDS_B2a_DP       = 14;
     228    CODETYPE_BDS_B1_A          = 15; //NEW 1A
     229    //RESERVED                 = 16;
     230    //RESERVED                 = 17;
     231    CODETYPE_BDS_B3_A          = 18;  //NEW 6A
     232   };
     233
     234   std::string       codeTypeToRnxType(char system, CodeType type);
     235   SsrCorr::CodeType rnxTypeToCodeType(char system, std::string type);
     236
     237   size_t MakeClockOrbit(const struct ClockOrbit *co, ClockOrbitType type,
    345238       int moremessagesfollow, char *buffer, size_t size);
    346 size_t MakeCodeBias(const struct CodeBias *b, enum CodeBiasType type,
     239   size_t MakeCodeBias(const struct CodeBias *b, CodeBiasType type,
    347240       int moremessagesfollow, char *buffer, size_t size);
    348 size_t MakePhaseBias(const struct PhaseBias *b, enum PhaseBiasType type,
     241   size_t MakePhaseBias(const struct PhaseBias *b, PhaseBiasType type,
    349242       int moremessagesfollow, char *buffer, size_t size);
    350 size_t MakeVTEC(const struct VTEC *b, int moremessagesfollow, char *buffer,
     243   size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer,
    351244       size_t size);
    352 
    353 enum GCOB_RETURN {
    354   /* all well */
    355   GCOBR_MESSAGEFOLLOWS        =  1,
    356   GCOBR_OK                    =  0,
    357   /* unknown data, a warning */
    358   GCOBR_UNKNOWNTYPE           = -1,
    359   GCOBR_UNKNOWNDATA           = -2,
    360   GCOBR_CRCMISMATCH           = -3,
    361   GCOBR_SHORTMESSAGE          = -4,
    362   /* failed to do the work */
    363   GCOBR_NOCLOCKORBITPARAMETER = -10,
    364   GCOBR_NOCODEBIASPARAMETER   = -11,
    365   GCOBR_NOPHASEBIASPARAMETER  = -12,
    366   GCOBR_NOVTECPARAMETER       = -13,
    367   /* data mismatch - data in storage does not match new data */
    368   GCOBR_TIMEMISMATCH          = -20,
    369   GCOBR_DATAMISMATCH          = -21,
    370   /* not enough data - can decode the block completely */
    371   GCOBR_SHORTBUFFER           = -30,
    372   GCOBR_MESSAGEEXCEEDSBUFFER  = -31};
    373 
    374 /* NOTE: When an error message has been emitted, the output structures may have been modified. Make a copy of the previous variant before calling the
    375 function to have a clean state. */
    376 
    377 /* buffer should point to a RTCM3 block */
    378 enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b, struct VTEC *v,
    379        struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused);
     245   enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b,
     246       struct VTEC *v, struct PhaseBias *pb, const char *buffer, size_t size,
     247       int *bytesused);
     248  };
    380249
    381250#endif /* RTCM3_CLOCK_ORBIT_IGS_H */
  • branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h

    r8987 r9036  
    44/* Programheader
    55
    6         Name:           clock_orbit_rtcm.h
    7         Project:        RTCM3
    8         Version:        $Id$
    9         Authors:        Dirk Stöcker
    10         Description:    state space approach for RTCM3
    11 */
     6 Name:           clock_orbit_rtcm.h
     7 Project:        RTCM3
     8 Version:        $Id$
     9 Authors:        Dirk Stöcker, Andrea Stürze
     10 Description:    state space approach: RTCM
     11 */
    1212
    1313#include <string.h>
    14 
    15 
    16 
    17 
    18 
    19 
    20 enum SatelliteReferenceDatum {
    21   DATUM_ITRF  = 0,
    22   DATUM_LOCAL = 1
    23 };
    24 
    25 enum COR_BASE {
    26   COBBASE_GPS     = 1057,
    27   COBBASE_GLONASS = 1063,
    28   COBBASE_GALILEO = 1240,
    29   COBBASE_QZSS    = 1246,
    30   COBBASE_SBAS    = 1252,
    31   COBBASE_BDS     = 1258,
    32   COBBASE_NUM
    33 };
    34 
    35 enum COR_OFFSET {
    36   COBOFS_ORBIT = 0,
    37   COBOFS_CLOCK,
    38   COBOFS_CBIAS,
    39   COBOFS_COMBINED,
    40   COBOFS_URA,
    41   COBOFS_HR,
    42   COBOFS_NUM
    43 };
    44 
    45 enum ClockOrbitType {
    46   COTYPE_GPSORBIT        = COBBASE_GPS     + COBOFS_ORBIT,
    47   COTYPE_GPSCLOCK,
    48   COTYPE_GPSCOMBINED     = COBBASE_GPS     + COBOFS_COMBINED,
    49   COTYPE_GPSURA,
    50   COTYPE_GPSHR,
    51 
    52   COTYPE_GLONASSORBIT    = COBBASE_GLONASS + COBOFS_ORBIT,
    53   COTYPE_GLONASSCLOCK,
    54   COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED,
    55   COTYPE_GLONASSURA,
    56   COTYPE_GLONASSHR,
    57 
    58   COTYPE_GALILEOORBIT    = COBBASE_GALILEO + COBOFS_ORBIT,
    59   COTYPE_GALILEOCLOCK,
    60   COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED,
    61   COTYPE_GALILEOURA,
    62   COTYPE_GALILEOHR,
    63 
    64   COTYPE_QZSSORBIT       = COBBASE_QZSS    + COBOFS_ORBIT,
    65   COTYPE_QZSSCLOCK,
    66   COTYPE_QZSSCOMBINED    = COBBASE_QZSS    + COBOFS_COMBINED,
    67   COTYPE_QZSSURA,
    68   COTYPE_QZSSHR,
    69 
    70   COTYPE_SBASORBIT       = COBBASE_SBAS    + COBOFS_ORBIT,
    71   COTYPE_SBASCLOCK,
    72   COTYPE_SBASCOMBINED    = COBBASE_SBAS    + COBOFS_COMBINED,
    73   COTYPE_SBASURA,
    74   COTYPE_SBASHR,
    75 
    76   COTYPE_BDSORBIT        = COBBASE_BDS     + COBOFS_ORBIT,
    77   COTYPE_BDSCLOCK,
    78   COTYPE_BDSCOMBINED     = COBBASE_BDS + COBOFS_COMBINED,
    79   COTYPE_BDSURA,
    80   COTYPE_BDSHR,
    81 
    82   COTYPE_AUTO = 0,
    83 };
    84 
    85 enum CodeBiasType {
    86   CBTYPE_GPS     = COBBASE_GPS     + COBOFS_CBIAS,
    87   CBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_CBIAS,
    88   CBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_CBIAS,
    89   CBTYPE_QZSS    = COBBASE_QZSS    + COBOFS_CBIAS,
    90   CBTYPE_SBAS    = COBBASE_SBAS    + COBOFS_CBIAS,
    91   CBTYPE_BDS     = COBBASE_BDS     + COBOFS_CBIAS,
    92   CBTYPE_AUTO    = 0
    93 };
    94 
    95 enum PhaseBiasType{
    96   PBTYPE_BASE    = 1265,
    97   PBTYPE_GPS     = PBTYPE_BASE,
    98   PBTYPE_GLONASS,
    99   PBTYPE_GALILEO,
    100   PBTYPE_QZSS,
    101   PBTYPE_SBAS,
    102   PBTYPE_BDS,
    103   PBTYPE_AUTO    = 0
    104 };
    105 
    106 enum VTECType {
    107   VTEC_BASE = 1264
    108 };
    109 
    110 /* if some systems aren't supported at all, change the following numbers to zero
    111 for these systems to save space */
    112 enum COR_CONSTANTS {
    113   CLOCKORBIT_BUFFERSIZE    = 8192,
    114   CLOCKORBIT_NUMGPS        =   32,
    115   CLOCKORBIT_NUMGLONASS    =   26,
    116   CLOCKORBIT_NUMGALILEO    =   36,
    117   CLOCKORBIT_NUMQZSS       =   10,
    118   CLOCKORBIT_NUMSBAS       =   38,
    119   CLOCKORBIT_NUMBDS        =   65,
    120   CLOCKORBIT_NUMBIAS       =  100,
    121   CLOCKORBIT_NUMIONOLAYERS =    4,
    122   CLOCKORBIT_MAXIONOORDER  =   16,
    123   CLOCKORBIT_MAXIONODEGREE =   16
    124 };
    125 
    126 enum COR_SATSYSTEM {
    127   CLOCKORBIT_SATGPS=0,
    128   CLOCKORBIT_SATGLONASS,
    129   CLOCKORBIT_SATGALILEO,
    130   CLOCKORBIT_SATQZSS,
    131   CLOCKORBIT_SATSBAS,
    132   CLOCKORBIT_SATBDS,
    133   CLOCKORBIT_SATNUM
    134 };
    135 
    136 enum COR_OFFSETS {
    137   CLOCKORBIT_OFFSETGPS     = 0,
    138   CLOCKORBIT_OFFSETGLONASS = CLOCKORBIT_NUMGPS,
    139   CLOCKORBIT_OFFSETGALILEO = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS,
    140   CLOCKORBIT_OFFSETQZSS    = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO,
    141   CLOCKORBIT_OFFSETSBAS    = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    142                            + CLOCKORBIT_NUMQZSS,
    143   CLOCKORBIT_OFFSETBDS     = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    144                            + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS,
    145   CLOCKORBIT_COUNTSAT      = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    146                            + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS    + CLOCKORBIT_NUMBDS
    147 };
    148 
    149 enum CodeType {
    150   CODETYPEGPS_L1_CA          = 0,
    151   CODETYPEGPS_L1_P           = 1,
    152   CODETYPEGPS_L1_Z           = 2,
    153   //CODETYPEGPS_L1_Y           = 3,
    154   //CODETYPEGPS_L1_M           = 4,
    155   CODETYPEGPS_L2_CA          = 5,
    156   CODETYPEGPS_SEMI_CODELESS  = 6,
    157   CODETYPEGPS_L2C_M          = 7,
    158   CODETYPEGPS_L2C_L          = 8,
    159   CODETYPEGPS_L2C_ML         = 9,
    160   CODETYPEGPS_L2_P           = 10,
    161   CODETYPEGPS_L2_Z           = 11,
    162   //CODETYPEGPS_L2_Y           = 12,
    163   //CODETYPEGPS_L2_M           = 13,
    164   CODETYPEGPS_L5_I           = 14,
    165   CODETYPEGPS_L5_Q           = 15,
    166   CODETYPEGPS_L5_IQ          = 16,
    167   CODETYPEGPS_L1C_D          = 17,
    168   CODETYPEGPS_L1C_P          = 18,
    169   CODETYPEGPS_L1C_DP         = 19,
    170 
    171   CODETYPEGLONASS_L1_CA      = 0,
    172   CODETYPEGLONASS_L1_P       = 1,
    173   CODETYPEGLONASS_L2_CA      = 2,
    174   CODETYPEGLONASS_L2_P       = 3,
    175   CODETYPEGLONASS_L1a_OCd    = 4,
    176   CODETYPEGLONASS_L1a_OCp    = 5,
    177   CODETYPEGLONASS_L1a_OCdp   = 6,
    178   CODETYPEGLONASS_L2a_CSI    = 7,
    179   CODETYPEGLONASS_L2a_OCp    = 8,
    180   CODETYPEGLONASS_L2a_CSIOCp = 9,
    181   CODETYPEGLONASS_L3_I       = 10,
    182   CODETYPEGLONASS_L3_Q       = 11,
    183   CODETYPEGLONASS_L3_IQ      = 12,
    184 
    185   CODETYPEGALILEO_E1_A       = 0,
    186   CODETYPEGALILEO_E1_B       = 1,
    187   CODETYPEGALILEO_E1_C       = 2,
    188   CODETYPEGALILEO_E1_BC      = 3,
    189   CODETYPEGALILEO_E1_ABC     = 4,
    190   CODETYPEGALILEO_E5A_I      = 5,
    191   CODETYPEGALILEO_E5A_Q      = 6,
    192   CODETYPEGALILEO_E5A_IQ     = 7,
    193   CODETYPEGALILEO_E5B_I      = 8,
    194   CODETYPEGALILEO_E5B_Q      = 9,
    195   CODETYPEGALILEO_E5B_IQ     = 10,
    196   CODETYPEGALILEO_E5_I       = 11,
    197   CODETYPEGALILEO_E5_Q       = 12,
    198   CODETYPEGALILEO_E5_IQ      = 13,
    199   CODETYPEGALILEO_E6_A       = 14,
    200   CODETYPEGALILEO_E6_B       = 15,
    201   CODETYPEGALILEO_E6_C       = 16,
    202   CODETYPEGALILEO_E6_BC      = 17,
    203   CODETYPEGALILEO_E6_ABC     = 18,
    204 
    205   CODETYPEQZSS_L1_CA         = 0,
    206   CODETYPEQZSS_L1C_D         = 1,
    207   CODETYPEQZSS_L1C_P         = 2,
    208   CODETYPEQZSS_L2C_M         = 3,
    209   CODETYPEQZSS_L2C_L         = 4,
    210   CODETYPEQZSS_L2C_ML        = 5,
    211   CODETYPEQZSS_L5_I          = 6,
    212   CODETYPEQZSS_L5_Q          = 7,
    213   CODETYPEQZSS_L5_IQ         = 8,
    214   CODETYPEQZSS_L6_D          = 9,
    215   CODETYPEQZSS_L6_P          = 10,
    216   CODETYPEQZSS_L6_DP         = 11,
    217   CODETYPEQZSS_L1C_DP        = 12,
    218   CODETYPEQZSS_L1_S          = 13,
    219   CODETYPEQZSS_L5_D          = 14,
    220   CODETYPEQZSS_L5_P          = 15,
    221   CODETYPEQZSS_L5_DP         = 16,
    222   CODETYPEQZSS_L6_E          = 17,
    223   CODETYPEQZSS_L6_DE         = 18,
    224 
    225   CODETYPE_SBAS_L1_CA        = 0,
    226   CODETYPE_SBAS_L5_I         = 1,
    227   CODETYPE_SBAS_L5_Q         = 2,
    228   CODETYPE_SBAS_L5_IQ        = 3,
    229 
    230   CODETYPE_BDS_B1_I          = 0,
    231   CODETYPE_BDS_B1_Q          = 1,
    232   CODETYPE_BDS_B1_IQ         = 2,
    233   CODETYPE_BDS_B3_I          = 3,
    234   CODETYPE_BDS_B3_Q          = 4,
    235   CODETYPE_BDS_B3_IQ         = 5,
    236   CODETYPE_BDS_B2_I          = 6,
    237   CODETYPE_BDS_B2_Q          = 7,
    238   CODETYPE_BDS_B2_IQ         = 8,
    239   CODETYPE_BDS_B1a_D         = 9,
    240   CODETYPE_BDS_B1a_P         = 10,
    241   CODETYPE_BDS_B1a_DP        = 11,
    242   CODETYPE_BDS_B2a_D         = 12,
    243   CODETYPE_BDS_B2a_P         = 13,
    244   CODETYPE_BDS_B2a_DP        = 14
    245 };
    246 
    247 #define SSR_MAXURA 5.5 /* > 5466.5mm in meter */
    248 
    249 /* satellite system data is stored with offset CLOCKORBIT_OFFSET...
    250 in the data structures. So first GLONASS satellite is at
    251 xxx->Sat[CLOCKORBIT_OFFSETGLONASS], first GPS satellite is
    252 xxx->Sat[CLOCKORBIT_OFFSETGPS]. */
    253 
    254 struct ClockOrbit {
    255   enum ClockOrbitType messageType;
    256   unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
    257   unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */
    258   unsigned int Supplied[COBOFS_NUM];           /* boolean */
    259   unsigned int SSRIOD;
    260   unsigned int SSRProviderID;
    261   unsigned int SSRSolutionID;
    262   unsigned int UpdateInterval;
    263   enum SatelliteReferenceDatum SatRefDatum;
    264   struct SatData {
    265     unsigned int ID; /* all */
    266     unsigned int IOD; /* all */
    267     unsigned int toe; /* SBAS, BDS */
    268     double UserRangeAccuracy; /* accuracy values in [m] */
    269     double hrclock;
    270     struct OrbitPart {
    271       double DeltaRadial;           /* m */
    272       double DeltaAlongTrack;       /* m */
    273       double DeltaCrossTrack;       /* m */
    274       double DotDeltaRadial;        /* m/s */
    275       double DotDeltaAlongTrack;    /* m/s */
    276       double DotDeltaCrossTrack;    /* m/s */
    277     } Orbit;
    278     struct ClockPart {
    279       double DeltaA0;               /* m */
    280       double DeltaA1;               /* m/s */
    281       double DeltaA2;               /* m/ss */
    282     } Clock;
    283   } Sat[CLOCKORBIT_COUNTSAT];
    284 };
    285 
    286 struct CodeBias {
    287   enum CodeBiasType messageType;
    288   unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
    289   unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */
    290   unsigned int UpdateInterval;
    291   unsigned int SSRIOD;
    292   unsigned int SSRProviderID;
    293   unsigned int SSRSolutionID;
    294   struct BiasSat {
    295     unsigned int ID; /* all */
    296     unsigned int NumberOfCodeBiases;
    297     struct CodeBiasEntry {
    298       enum CodeType Type;
    299       float         Bias;           /* m */
    300     } Biases[CLOCKORBIT_NUMBIAS];
    301   } Sat[CLOCKORBIT_COUNTSAT];
    302 };
    303 
    304 struct PhaseBias {
    305   enum PhaseBiasType messageType;
    306   unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
    307   unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */
    308   unsigned int UpdateInterval;
    309   unsigned int SSRIOD;
    310   unsigned int SSRProviderID;
    311   unsigned int SSRSolutionID;
    312   unsigned int DispersiveBiasConsistencyIndicator;
    313   unsigned int MWConsistencyIndicator;
    314   struct PhaseBiasSat {
    315     unsigned int ID; /* all */
    316     unsigned int NumberOfPhaseBiases;
    317     double YawAngle; /* radiant */
    318     double YawRate;  /* radiant/s */
    319     struct PhaseBiasEntry {
    320       enum CodeType Type;
    321       unsigned int  SignalIntegerIndicator;
    322       unsigned int  SignalsWideLaneIntegerIndicator;
    323       unsigned int  SignalDiscontinuityCounter;
    324       float         Bias;           /* m */
    325     } Biases[CLOCKORBIT_NUMBIAS];
    326   } Sat[CLOCKORBIT_COUNTSAT];
    327 };
    328 
    329 struct VTEC {
    330   unsigned int EpochTime; /* GPS */
    331   unsigned int UpdateInterval;
    332   unsigned int SSRIOD;
    333   unsigned int SSRProviderID;
    334   unsigned int SSRSolutionID;
    335   unsigned int NumLayers; /* 1-4 */
    336   double Quality;
    337   struct IonoLayers {
    338     double       Height; /* m */
    339     unsigned int Degree; /* 1-16 */
    340     unsigned int Order; /* 1-16 */
    341     double       Sinus[CLOCKORBIT_MAXIONODEGREE][CLOCKORBIT_MAXIONOORDER];
    342     double       Cosinus[CLOCKORBIT_MAXIONODEGREE][CLOCKORBIT_MAXIONOORDER];
    343   } Layers[CLOCKORBIT_NUMIONOLAYERS];
    344 };
    345 
    346 /* return size of resulting data or 0 in case of an error */
    347 size_t MakeClockOrbit(const struct ClockOrbit *co, enum ClockOrbitType type,
    348        int moremessagesfollow, char *buffer, size_t size);
    349 size_t MakeCodeBias(const struct CodeBias *b, enum CodeBiasType type,
    350        int moremessagesfollow, char *buffer, size_t size);
    351 size_t MakePhaseBias(const struct PhaseBias *b, enum PhaseBiasType type,
    352        int moremessagesfollow, char *buffer, size_t size);
    353 size_t MakeVTEC(const struct VTEC *b, int moremessagesfollow, char *buffer,
    354        size_t size);
    355 
    356 enum GCOB_RETURN {
    357   /* all well */
    358   GCOBR_MESSAGEFOLLOWS        =  1,
    359   GCOBR_OK                    =  0,
    360   /* unknown data, a warning */
    361   GCOBR_UNKNOWNTYPE           = -1,
    362   GCOBR_UNKNOWNDATA           = -2,
    363   GCOBR_CRCMISMATCH           = -3,
    364   GCOBR_SHORTMESSAGE          = -4,
    365   /* failed to do the work */
    366   GCOBR_NOCLOCKORBITPARAMETER = -10,
    367   GCOBR_NOCODEBIASPARAMETER   = -11,
    368   GCOBR_NOPHASEBIASPARAMETER  = -12,
    369   GCOBR_NOVTECPARAMETER       = -13,
    370   /* data mismatch - data in storage does not match new data */
    371   GCOBR_TIMEMISMATCH          = -20,
    372   GCOBR_DATAMISMATCH          = -21,
    373   /* not enough data - can decode the block completely */
    374   GCOBR_SHORTBUFFER           = -30,
    375   GCOBR_MESSAGEEXCEEDSBUFFER  = -31};
    376 
    377 /* NOTE: When an error message has been emitted, the output structures may have been modified. Make a copy of the previous variant before calling the
    378 function to have a clean state. */
    379 
    380 /* buffer should point to a RTCM3 block */
    381 enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b, struct VTEC *v,
    382        struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused);
     14#include "clock_orbit.h"
     15
     16class SsrCorrRtcm: public SsrCorr {
     17  //Q_OBJECT
     18
     19public:
     20  SsrCorrRtcm() {
     21    setCorBase();
     22    setCorOffset();
     23    setCoType();
     24    setCbType();
     25    setPbType();
     26    setVtecType();
     27    setCodeType();
     28
     29    satoffset << CLOCKORBIT_OFFSETGPS
     30        << CLOCKORBIT_OFFSETGLONASS
     31        << CLOCKORBIT_OFFSETGALILEO
     32        << CLOCKORBIT_OFFSETQZSS
     33        << CLOCKORBIT_OFFSETSBAS
     34        << CLOCKORBIT_OFFSETBDS
     35        << CLOCKORBIT_COUNTSAT;
     36  };
     37
     38  ~SsrCorrRtcm() {};
     39
     40  void setCorBase() {
     41    COBBASE_GPS     = 1057;
     42    COBBASE_GLONASS = 1063;
     43    COBBASE_GALILEO = 1240;
     44    COBBASE_QZSS    = 1246;
     45    COBBASE_SBAS    = 1252;
     46    COBBASE_BDS     = 1258;
     47    COBBASE_NUM     =    6;
     48    corbase << COBBASE_GPS
     49        << COBBASE_GLONASS
     50        << COBBASE_GALILEO
     51        << COBBASE_QZSS
     52        << COBBASE_SBAS
     53        << COBBASE_BDS;
     54  };
     55
     56  void setCorOffset() {
     57    COBOFS_ORBIT     = 0;
     58    COBOFS_CLOCK     = 1;
     59    COBOFS_CBIAS     = 2;
     60    COBOFS_COMBINED  = 3;
     61    COBOFS_URA       = 4;
     62    COBOFS_HR        = 5;
     63    COBOFS_NUM       = 6;
     64  };
     65
     66  void setCoType() {
     67    COTYPE_GPSORBIT        = COBBASE_GPS + COBOFS_ORBIT;
     68    COTYPE_GPSCLOCK        = COTYPE_GPSORBIT + 1;
     69    COTYPE_GPSCOMBINED     = COBBASE_GPS + COBOFS_COMBINED;
     70    COTYPE_GPSURA          = COTYPE_GPSCOMBINED + 1;
     71    COTYPE_GPSHR           = COTYPE_GPSURA + 1;
     72
     73    COTYPE_GLONASSORBIT    = COBBASE_GLONASS + COBOFS_ORBIT;
     74    COTYPE_GLONASSCLOCK    = COTYPE_GLONASSORBIT + 1;
     75    COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED;
     76    COTYPE_GLONASSURA      = COTYPE_GLONASSCOMBINED + 1;
     77    COTYPE_GLONASSHR       = COTYPE_GLONASSURA + 1;
     78
     79    COTYPE_GALILEOORBIT    = COBBASE_GALILEO + COBOFS_ORBIT,
     80    COTYPE_GALILEOCLOCK    = COTYPE_GALILEOORBIT + 1;
     81    COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED;
     82    COTYPE_GALILEOURA      = COTYPE_GALILEOCOMBINED + 1;
     83    COTYPE_GALILEOHR       = COTYPE_GALILEOURA + 1;
     84
     85    COTYPE_QZSSORBIT       = COBBASE_QZSS + COBOFS_ORBIT;
     86    COTYPE_QZSSCLOCK       = COTYPE_QZSSORBIT + 1;
     87    COTYPE_QZSSCOMBINED    = COBBASE_QZSS + COBOFS_COMBINED,
     88    COTYPE_QZSSURA         = COTYPE_QZSSCOMBINED + 1;
     89    COTYPE_QZSSHR          = COTYPE_QZSSURA + 1;
     90
     91    COTYPE_SBASORBIT       = COBBASE_SBAS + COBOFS_ORBIT;
     92    COTYPE_SBASCLOCK       = COTYPE_SBASORBIT + 1;
     93    COTYPE_SBASCOMBINED    = COBBASE_SBAS + COBOFS_COMBINED;
     94    COTYPE_SBASURA         = COTYPE_SBASCOMBINED + 1;
     95    COTYPE_SBASHR          = COTYPE_SBASURA + 1;
     96
     97    COTYPE_BDSORBIT        = COBBASE_BDS + COBOFS_ORBIT;
     98    COTYPE_BDSCLOCK        = COTYPE_BDSORBIT + 1;
     99    COTYPE_BDSCOMBINED     = COBBASE_BDS + COBOFS_COMBINED,
     100    COTYPE_BDSURA          = COTYPE_BDSCOMBINED + 1;
     101    COTYPE_BDSHR           = COTYPE_BDSURA + 1;
     102
     103    COTYPE_AUTO = 0;
     104  };
     105
     106  void setCbType() {
     107    CBTYPE_GPS     = COBBASE_GPS     + COBOFS_CBIAS;
     108    CBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_CBIAS;
     109    CBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_CBIAS;
     110    CBTYPE_QZSS    = COBBASE_QZSS    + COBOFS_CBIAS;
     111    CBTYPE_SBAS    = COBBASE_SBAS    + COBOFS_CBIAS;
     112    CBTYPE_BDS     = COBBASE_BDS     + COBOFS_CBIAS;
     113    CBTYPE_AUTO = 0;
     114  };
     115
     116  void setPbType() {
     117    PBTYPE_BASE    = 1265;
     118    PBTYPE_GPS     = PBTYPE_BASE;
     119    PBTYPE_GLONASS = PBTYPE_GPS++;
     120    PBTYPE_GALILEO = PBTYPE_GLONASS++;
     121    PBTYPE_QZSS    = PBTYPE_GALILEO++;
     122    PBTYPE_SBAS    = PBTYPE_QZSS++;
     123    PBTYPE_BDS     = PBTYPE_SBAS++;
     124    PBTYPE_AUTO = 0;
     125  };
     126
     127  void setVtecType() {
     128      VTEC_BASE   = 1264;
     129  };
     130
     131  void setCodeType() {
     132    CODETYPE_GPS_L1_CA          =  0;
     133    CODETYPE_GPS_L1_P           =  1;
     134    CODETYPE_GPS_L1_Z           =  2;
     135
     136
     137    CODETYPE_GPS_L2_CA          =  5;
     138    CODETYPE_GPS_SEMI_CODELESS  =  6;
     139    CODETYPE_GPS_L2C_M          =  7;
     140    CODETYPE_GPS_L2C_L          =  8;
     141    CODETYPE_GPS_L2C_ML         =  9;
     142    CODETYPE_GPS_L2_P           = 10;
     143    CODETYPE_GPS_L2_Z           = 11;
     144
     145
     146    CODETYPE_GPS_L5_I           = 14;
     147    CODETYPE_GPS_L5_Q           = 15;
     148    CODETYPE_GPS_L5_IQ          = 16;
     149    CODETYPE_GPS_L1C_D          = 17;
     150    CODETYPE_GPS_L1C_P          = 18;
     151    CODETYPE_GPS_L1C_DP         = 19;
     152
     153    CODETYPE_GLONASS_L1_CA      =  0;
     154    CODETYPE_GLONASS_L1_P       =  1;
     155    CODETYPE_GLONASS_L2_CA      =  2;
     156    CODETYPE_GLONASS_L2_P       =  3;
     157    CODETYPE_GLONASS_L1a_OCd    =  4;
     158    CODETYPE_GLONASS_L1a_OCp    =  5;
     159    CODETYPE_GLONASS_L1a_OCdp   =  6;
     160    CODETYPE_GLONASS_L2a_CSI    =  7;
     161    CODETYPE_GLONASS_L2a_OCp    =  8;
     162    CODETYPE_GLONASS_L2a_CSIOCp =  9;
     163    CODETYPE_GLONASS_L3_I       = 10;
     164    CODETYPE_GLONASS_L3_Q       = 11;
     165    CODETYPE_GLONASS_L3_IQ      = 12;
     166
     167    CODETYPE_GALILEO_E1_A       =  0;
     168    CODETYPE_GALILEO_E1_B       =  1;
     169    CODETYPE_GALILEO_E1_C       =  2;
     170    CODETYPE_GALILEO_E1_BC      =  3;
     171    CODETYPE_GALILEO_E1_ABC     =  4;
     172    CODETYPE_GALILEO_E5A_I      =  5;
     173    CODETYPE_GALILEO_E5A_Q      =  6;
     174    CODETYPE_GALILEO_E5A_IQ     =  7;
     175    CODETYPE_GALILEO_E5B_I      =  8;
     176    CODETYPE_GALILEO_E5B_Q      =  9;
     177    CODETYPE_GALILEO_E5B_IQ     = 10;
     178    CODETYPE_GALILEO_E5_I       = 11;
     179    CODETYPE_GALILEO_E5_Q       = 12;
     180    CODETYPE_GALILEO_E5_IQ      = 13;
     181    CODETYPE_GALILEO_E6_A       = 14;
     182    CODETYPE_GALILEO_E6_B       = 15;
     183    CODETYPE_GALILEO_E6_C       = 16;
     184    CODETYPE_GALILEO_E6_BC      = 17;
     185    CODETYPE_GALILEO_E6_ABC     = 18;
     186
     187    CODETYPE_QZSS_L1_CA         =  0;
     188    CODETYPE_QZSS_L1C_D         =  1;
     189    CODETYPE_QZSS_L1C_P         =  2;
     190    CODETYPE_QZSS_L2C_M         =  3;
     191    CODETYPE_QZSS_L2C_L         =  4;
     192    CODETYPE_QZSS_L2C_ML        =  5;
     193    CODETYPE_QZSS_L5_I          =  6;
     194    CODETYPE_QZSS_L5_Q          =  7;
     195    CODETYPE_QZSS_L5_IQ         =  8;
     196    CODETYPE_QZSS_L6_D          =  9;
     197    CODETYPE_QZSS_L6_P          = 10;
     198    CODETYPE_QZSS_L6_DP         = 11;
     199    CODETYPE_QZSS_L1C_DP        = 12;
     200    CODETYPE_QZSS_L1_S          = 13;
     201    CODETYPE_QZSS_L5_D          = 14;
     202    CODETYPE_QZSS_L5_P          = 15;
     203    CODETYPE_QZSS_L5_DP         = 16;
     204    CODETYPE_QZSS_L6_E          = 17;
     205    CODETYPE_QZSS_L6_DE         = 18;
     206
     207    CODETYPE_SBAS_L1_CA         =  0;
     208    CODETYPE_SBAS_L5_I          =  1;
     209    CODETYPE_SBAS_L5_Q          =  2;
     210    CODETYPE_SBAS_L5_IQ         =  3;
     211
     212    CODETYPE_BDS_B1_I           =  0;
     213    CODETYPE_BDS_B1_Q           =  1;
     214    CODETYPE_BDS_B1_IQ          =  2;
     215    CODETYPE_BDS_B3_I           =  3;
     216    CODETYPE_BDS_B3_Q           =  4;
     217    CODETYPE_BDS_B3_IQ          =  5;
     218    CODETYPE_BDS_B2_I           =  6;
     219    CODETYPE_BDS_B2_Q           =  7;
     220    CODETYPE_BDS_B2_IQ          =  8;
     221    CODETYPE_BDS_B1a_D          =  9;
     222    CODETYPE_BDS_B1a_P          = 10;
     223    CODETYPE_BDS_B1a_DP         = 11;
     224    CODETYPE_BDS_B2a_D          = 12;
     225    CODETYPE_BDS_B2a_P          = 13;
     226    CODETYPE_BDS_B2a_DP         = 14;
     227
     228
     229
     230
     231  }
     232
     233  std::string       codeTypeToRnxType(char system, CodeType type);
     234  SsrCorr::CodeType rnxTypeToCodeType(char system, std::string type);
     235
     236  size_t MakeClockOrbit(const struct ClockOrbit *co, ClockOrbitType type,
     237      int moremessagesfollow, char *buffer, size_t size);
     238  size_t MakeCodeBias(const struct CodeBias *b, CodeBiasType type,
     239      int moremessagesfollow, char *buffer, size_t size);
     240  size_t MakePhaseBias(const struct PhaseBias *b, PhaseBiasType type,
     241      int moremessagesfollow, char *buffer, size_t size);
     242  size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer,
     243      size_t size);
     244  enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b,
     245      struct VTEC *v, struct PhaseBias *pb, const char *buffer, size_t size,
     246      int *bytesused);
     247 };
    383248
    384249#endif /* RTCM3_CLOCK_ORBIT_RTCM_H */
  • branches/BNC_2.12/src/bncwindow.cpp

    r8663 r9036  
    486486  // Upload Results
    487487  // -------------
    488   _uploadTable = new QTableWidget(0,12);
    489   _uploadTable->setHorizontalHeaderLabels(QString("Host, Port, Mount, Password, System, CoM, SP3 File, RNX File, PID, SID, IOD, bytes").split(","));
     488  _uploadTable = new QTableWidget(0,13);
     489  _uploadTable->setHorizontalHeaderLabels(QString("Host, Port, Mount, Password, System, Format, CoM, SP3 File, RNX File, PID, SID, IOD, bytes").split(","));
    490490  _uploadTable->setSelectionMode(QAbstractItemView::ExtendedSelection);
    491491  _uploadTable->setSelectionBehavior(QAbstractItemView::SelectRows);
     
    495495  _uploadTable->horizontalHeader()->resizeSection( 3, 8*ww);
    496496  _uploadTable->horizontalHeader()->resizeSection( 4,11*ww);
    497   _uploadTable->horizontalHeader()->resizeSection( 5, 4*ww);
    498   _uploadTable->horizontalHeader()->resizeSection( 6,15*ww);
     497  _uploadTable->horizontalHeader()->resizeSection( 5,11*ww);
     498  _uploadTable->horizontalHeader()->resizeSection( 6, 4*ww);
    499499  _uploadTable->horizontalHeader()->resizeSection( 7,15*ww);
    500   _uploadTable->horizontalHeader()->resizeSection( 8, 4*ww);
     500  _uploadTable->horizontalHeader()->resizeSection( 8,15*ww);
    501501  _uploadTable->horizontalHeader()->resizeSection( 9, 4*ww);
    502502  _uploadTable->horizontalHeader()->resizeSection(10, 4*ww);
    503   _uploadTable->horizontalHeader()->resizeSection(11,12*ww);
     503  _uploadTable->horizontalHeader()->resizeSection(11, 4*ww);
     504  _uploadTable->horizontalHeader()->resizeSection(12,12*ww);
    504505  _uploadTable->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
    505506  _uploadTable->horizontalHeader()->setStretchLastSection(true);
     
    18201821    for (int iCol = 0; iCol < _uploadTable->columnCount(); iCol++) {
    18211822      if (_uploadTable->cellWidget(iRow, iCol) &&
    1822           (iCol == 3 || iCol == 4 || iCol == 5)) {
     1823          (iCol == 3 || iCol == 4 || iCol == 5 || iCol == 6)) {
    18231824        if      (iCol == 3) {
    18241825          QLineEdit* passwd = (QLineEdit*)(_uploadTable->cellWidget(iRow, iCol));
     
    18301831        }
    18311832        else if (iCol == 5) {
     1833          QComboBox* format = (QComboBox*)(_uploadTable->cellWidget(iRow, iCol));
     1834          hlp += format->currentText() + ",";
     1835        }
     1836        else if (iCol == 6) {
    18321837          QCheckBox* com    = (QCheckBox*)(_uploadTable->cellWidget(iRow, iCol));
    18331838          QString state; state.setNum(com->checkState());
     
    25992604    }
    26002605    else if (iCol == 5) {
     2606      QComboBox* format = new QComboBox();
     2607      format->setEditable(false);
     2608      format->addItems(QString("IGS-SSR,RTCM-SSR").split(","));
     2609      format->setFrame(false);
     2610      _uploadTable->setCellWidget(iRow, iCol, format);
     2611    }
     2612    else if (iCol == 6) {
    26012613      QCheckBox* com = new QCheckBox();
    26022614      _uploadTable->setCellWidget(iRow, iCol, com);
    26032615    }
    2604     else if (iCol == 11) {
     2616    else if (iCol == 12) {
    26052617      bncTableItem* bncIt = new bncTableItem();
    26062618      bncIt->setFlags(bncIt->flags() & ~Qt::ItemIsEditable);
     
    26352647  for (int iRow = 0; iRow < _uploadTable->rowCount(); iRow++) {
    26362648    BNC_CORE->_uploadTableItems[iRow] =
    2637                                 (bncTableItem*) _uploadTable->item(iRow, 11);
     2649                                (bncTableItem*) _uploadTable->item(iRow, 12);
    26382650  }
    26392651  nRows = _uploadTable->rowCount();
     
    26812693      }
    26822694      else if (iCol == 5) {
     2695        QComboBox* format = new QComboBox();
     2696        format->setEditable(false);
     2697        format->addItems(QString("IGS-SSR,RTCM-SSR").split(","));
     2698        format->setFrame(false);
     2699        format->setCurrentIndex(format->findText(hlp[iCol]));
     2700        _uploadTable->setCellWidget(iRow, iCol, format);
     2701      }
     2702      else if (iCol == 6) {
    26832703        QCheckBox* com = new QCheckBox();
    26842704        if (hlp[iCol].toInt() == Qt::Checked) {
     
    26872707        _uploadTable->setCellWidget(iRow, iCol, com);
    26882708      }
    2689       else if (iCol == 11) {
     2709      else if (iCol == 12) {
    26902710        bncTableItem* bncIt = new bncTableItem();
    26912711        bncIt->setFlags(bncIt->flags() & ~Qt::ItemIsEditable);
  • branches/BNC_2.12/src/combination/bnccomb.cpp

    r8696 r9036  
    162162  }
    163163
     164  QString ssrFormat;
     165  QListIterator<QString> it(settings.value("uploadMountpointsOut").toStringList());
     166  while (it.hasNext()) {
     167    QStringList hlp = it.next().split(",");
     168    if (hlp.size() > 7) {
     169      ssrFormat = hlp[7];
     170    }
     171  }
     172  _ssrCorr = 0;
     173  if      (ssrFormat == "IGS-SSR") {
     174    _ssrCorr = new SsrCorrIgs();
     175  }
     176  else if (ssrFormat == "RTCM-SSR") {
     177    _ssrCorr = new SsrCorrRtcm();
     178  }
     179
    164180  _rtnetDecoder = 0;
    165181
     
    266282  }
    267283  delete _rtnetDecoder;
     284  if (_ssrCorr) {
     285    delete _ssrCorr;
     286  }
    268287  delete _antex;
    269288  for (int iPar = 1; iPar <= _params.size(); iPar++) {
     
    714733
    715734  QString     outLines;
    716   QStringList corrLines;
     735  //QStringList corrLines;
    717736
    718737  unsigned year, month, day, hour, minute;
     
    770789
    771790    QString line;
    772     int messageType   = COTYPE_GPSCOMBINED;
     791    int messageType   = _ssrCorr->COTYPE_GPSCOMBINED;
    773792    int updateInt     = 0;
    774793    line.sprintf("%d %d %d %.1f %s"
     
    789808                 corr->_orbCorr._dotXr[2],
    790809                 0.0);
    791     corrLines << line;
     810    //corrLines << line;
    792811
    793812    delete corr;
     
    883902    }
    884903//    if (_useGlonass) {
    885 //      for (int iGlo = 1; iGlo <= t_prn::MAXPRN_GLONASS; iGlo++) {
     904//      for (unsigned iGlo = 1; iGlo <= t_prn::MAXPRN_GLONASS; iGlo++) {
    886905//        QString prn = QString("R%1_0").arg(iGlo, 2, 10, QChar('0'));
    887906//        ++iCond;
  • branches/BNC_2.12/src/combination/bnccomb.h

    r7299 r9036  
    77#include "bncephuser.h"
    88#include "satObs.h"
     9#include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h"
     10#include "../RTCM3/clock_and_orbit/clock_orbit_igs.h"
    911
    1012class bncRtnetDecoder;
     
    126128  QMap<QString, QMap<t_prn, t_orbCorr> > _orbCorrections;
    127129  bncEphUser                             _ephUser;
     130  SsrCorr*                               _ssrCorr;
    128131};
    129132
  • branches/BNC_2.12/src/src.pri

    r8987 r9036  
    6060          RTCM3/RTCM3Decoder.h RTCM3/bits.h RTCM3/gnss.h              \
    6161          RTCM3/RTCM3coDecoder.h RTCM3/ephEncoder.h                   \
     62          RTCM3/clock_and_orbit/clock_orbit.h                         \
     63          RTCM3/clock_and_orbit/clock_orbit_igs.h                     \
     64          RTCM3/clock_and_orbit/clock_orbit_rtcm.h                    \
    6265          rinex/rnxobsfile.h                                          \
    6366          rinex/rnxnavfile.h       rinex/corrfile.h                   \
     
    9699          RTCM3/RTCM3Decoder.cpp                                      \
    97100          RTCM3/RTCM3coDecoder.cpp RTCM3/ephEncoder.cpp               \
     101          RTCM3/clock_and_orbit/clock_orbit_igs.cpp                   \
     102          RTCM3/clock_and_orbit/clock_orbit_rtcm.cpp                  \
    98103          rinex/rnxobsfile.cpp                                        \
    99104          rinex/rnxnavfile.cpp     rinex/corrfile.cpp                 \
     
    111116
    112117QT += network
    113 
    114 # Format of SSR corrections
    115 # -------------------------
    116 DEFINES += USE_SSR_RTCM
    117 #DEFINES += USE_SSR_IGS
    118 contains(DEFINES, USE_SSR_IGS) {
    119   HEADERS += RTCM3/clock_and_orbit/clock_orbit_igs.h
    120   SOURCES += RTCM3/clock_and_orbit/clock_orbit_igs.c
    121 }
    122 else {
    123   HEADERS += RTCM3/clock_and_orbit/clock_orbit_rtcm.h
    124   SOURCES += RTCM3/clock_and_orbit/clock_orbit_rtcm.c
    125 }
    126118
    127119exists(PPP) {
  • branches/BNC_2.12/src/upload/bncrtnetdecoder.cpp

    r4176 r9036  
    5959      ++iRow;
    6060      int  outPort = hlp[1].toInt();
    61       bool CoM     = (hlp[5].toInt() == Qt::Checked);
     61      bool CoM     = (hlp[6].toInt() == Qt::Checked);
    6262      int PID = 0;
    63       if (hlp.size() > 8) {
    64         PID = hlp[8].toInt();
     63      if (hlp.size() > 9) {
     64        PID = hlp[9].toInt();
    6565      }
    6666      int SID = 0;
    67       if (hlp.size() > 9) {
    68         SID = hlp[9].toInt();
     67      if (hlp.size() > 10) {
     68        SID = hlp[10].toInt();
    6969      }
    7070      int IOD = 0;
    71       if (hlp.size() > 10) {
    72         IOD = hlp[10].toInt();
     71      if (hlp.size() > 11) {
     72        IOD = hlp[11].toInt();
    7373      }
    7474      bncRtnetUploadCaster* newCaster = new bncRtnetUploadCaster(
    75                                                        hlp[2], hlp[0], outPort,
    76                                                        hlp[3], hlp[4], CoM,
    77                                                        hlp[6], hlp[7],
     75                                                       hlp[2], hlp[0], outPort,
     76                                                       hlp[3], hlp[4], hlp[5],
     77                                                       CoM,
     78                                                       hlp[7], hlp[8],
    7879                                                       PID, SID, IOD, iRow);
    7980      newCaster->start();
  • branches/BNC_2.12/src/upload/bncrtnetuploadcaster.cpp

    r8992 r9036  
    2828////////////////////////////////////////////////////////////////////////////
    2929bncRtnetUploadCaster::bncRtnetUploadCaster(const QString& mountpoint,
    30     const QString& outHost, int outPort, const QString& password,
    31     const QString& crdTrafo, bool CoM, const QString& sp3FileName,
     30    const QString& outHost, int outPort,
     31    const QString& password,
     32    const QString& crdTrafo, const QString& ssrFormat, bool CoM, const QString& sp3FileName,
    3233    const QString& rnxFileName, int PID, int SID, int IOD, int iRow) :
    3334    bncUploadCaster(mountpoint, outHost, outPort, password, iRow, 0) {
     
    5354
    5455  _crdTrafo = crdTrafo;
     56
     57  _ssrFormat = ssrFormat;
     58  _ssrCorr = 0;
     59  if      (_ssrFormat == "IGS-SSR") {qDebug() << "bin hier IGS";
     60    _ssrCorr = new SsrCorrIgs();
     61  }
     62  else if (_ssrFormat == "RTCM-SSR") {qDebug() << "bin hier RTCM";
     63    _ssrCorr = new SsrCorrRtcm();
     64  }
     65
    5566  _CoM = CoM;
    5667  _PID = PID;
     
    225236  delete _ephUser;
    226237  delete _usedEph;
     238  delete _ssrCorr;
    227239}
    228240
     
    291303          + _casterID.toAscii(), false));
    292304
    293   struct ClockOrbit co;
     305  struct SsrCorr::ClockOrbit co;
    294306  memset(&co, 0, sizeof(co));
    295307  co.EpochTime[CLOCKORBIT_SATGPS] = static_cast<int>(epoTime.gpssec());
    296 #ifdef USE_SSR_RTCM
    297   double gt = epoTime.gpssec() + 3 * 3600 - gnumleap(year, month, day);
    298   co.EpochTime[CLOCKORBIT_SATGLONASS] = static_cast<int>(fmod(gt, 86400.0));
    299 #elif  USE_SSR_IGS
    300   co.EpochTime[CLOCKORBIT_SATGLONASS] = static_cast<int>(epoTime.gpssec());
    301 #endif
     308  if      (_ssrFormat == "RTCM-SSR") {
     309    double gt = epoTime.gpssec() + 3 * 3600 - gnumleap(year, month, day);
     310    co.EpochTime[CLOCKORBIT_SATGLONASS] = static_cast<int>(fmod(gt, 86400.0));
     311  }
     312  else if (_ssrFormat == "IGS-SSR") {
     313    co.EpochTime[CLOCKORBIT_SATGLONASS] = static_cast<int>(epoTime.gpssec());
     314  }
    302315  co.EpochTime[CLOCKORBIT_SATGALILEO] = static_cast<int>(epoTime.gpssec());
    303   co.EpochTime[CLOCKORBIT_SATQZSS] = static_cast<int>(epoTime.gpssec());
    304   co.EpochTime[CLOCKORBIT_SATSBAS] = static_cast<int>(epoTime.gpssec());
    305 #ifdef USE_SSR_RTCM
    306   co.EpochTime[CLOCKORBIT_SATBDS] = static_cast<int>(epoTime.bdssec());
    307 #elif  USE_SSR_IGS
    308   co.EpochTime[CLOCKORBIT_SATBDS] = static_cast<int>(epoTime.gpssec());
    309 #endif
    310   co.Supplied[COBOFS_CLOCK] = 1;
    311   co.Supplied[COBOFS_ORBIT] = 1;
    312   co.SatRefDatum = DATUM_ITRF;
    313   co.SSRIOD = _IOD;
     316  co.EpochTime[CLOCKORBIT_SATQZSS]    = static_cast<int>(epoTime.gpssec());
     317  co.EpochTime[CLOCKORBIT_SATSBAS]    = static_cast<int>(epoTime.gpssec());
     318  if      (_ssrFormat == "RTCM-SSR") {
     319    co.EpochTime[CLOCKORBIT_SATBDS] = static_cast<int>(epoTime.bdssec());
     320  }
     321  else if (_ssrFormat == "IGS-SSR") {
     322    co.EpochTime[CLOCKORBIT_SATBDS] = static_cast<int>(epoTime.gpssec());
     323  }
     324  co.Supplied[_ssrCorr->COBOFS_CLOCK] = 1;
     325  co.Supplied[_ssrCorr->COBOFS_ORBIT] = 1;
     326  co.SatRefDatum = _ssrCorr->DATUM_ITRF;
     327  co.SSRIOD        = _IOD;
    314328  co.SSRProviderID = _PID; // 256 .. BKG,  257 ... EUREF
    315329  co.SSRSolutionID = _SID;
    316330
    317   struct CodeBias bias;
     331  struct SsrCorr::CodeBias bias;
    318332  memset(&bias, 0, sizeof(bias));
    319   bias.EpochTime[CLOCKORBIT_SATGPS] = co.EpochTime[CLOCKORBIT_SATGPS];
     333  bias.EpochTime[CLOCKORBIT_SATGPS]     = co.EpochTime[CLOCKORBIT_SATGPS];
    320334  bias.EpochTime[CLOCKORBIT_SATGLONASS] = co.EpochTime[CLOCKORBIT_SATGLONASS];
    321335  bias.EpochTime[CLOCKORBIT_SATGALILEO] = co.EpochTime[CLOCKORBIT_SATGALILEO];
    322   bias.EpochTime[CLOCKORBIT_SATQZSS] = co.EpochTime[CLOCKORBIT_SATQZSS];
    323   bias.EpochTime[CLOCKORBIT_SATSBAS] = co.EpochTime[CLOCKORBIT_SATSBAS];
    324   bias.EpochTime[CLOCKORBIT_SATBDS] = co.EpochTime[CLOCKORBIT_SATBDS];
    325   bias.SSRIOD = _IOD;
     336  bias.EpochTime[CLOCKORBIT_SATQZSS]    = co.EpochTime[CLOCKORBIT_SATQZSS];
     337  bias.EpochTime[CLOCKORBIT_SATSBAS]    = co.EpochTime[CLOCKORBIT_SATSBAS];
     338  bias.EpochTime[CLOCKORBIT_SATBDS]     = co.EpochTime[CLOCKORBIT_SATBDS];
     339  bias.SSRIOD        = _IOD;
    326340  bias.SSRProviderID = _PID;
    327341  bias.SSRSolutionID = _SID;
    328342
    329   struct PhaseBias phasebias;
     343  struct SsrCorr::PhaseBias phasebias;
    330344  memset(&phasebias, 0, sizeof(phasebias));
    331345  unsigned int dispersiveBiasConsistenyIndicator = 0;
    332346  unsigned int mwConsistencyIndicator = 0;
    333   phasebias.EpochTime[CLOCKORBIT_SATGPS] = co.EpochTime[CLOCKORBIT_SATGPS];
     347  phasebias.EpochTime[CLOCKORBIT_SATGPS]     = co.EpochTime[CLOCKORBIT_SATGPS];
    334348  phasebias.EpochTime[CLOCKORBIT_SATGLONASS] = co.EpochTime[CLOCKORBIT_SATGLONASS];
    335349  phasebias.EpochTime[CLOCKORBIT_SATGALILEO] = co.EpochTime[CLOCKORBIT_SATGALILEO];
    336   phasebias.EpochTime[CLOCKORBIT_SATQZSS] = co.EpochTime[CLOCKORBIT_SATQZSS];
    337   phasebias.EpochTime[CLOCKORBIT_SATSBAS] = co.EpochTime[CLOCKORBIT_SATSBAS];
    338   phasebias.EpochTime[CLOCKORBIT_SATBDS] = co.EpochTime[CLOCKORBIT_SATBDS];
    339   phasebias.SSRIOD = _IOD;
     350  phasebias.EpochTime[CLOCKORBIT_SATQZSS]    = co.EpochTime[CLOCKORBIT_SATQZSS];
     351  phasebias.EpochTime[CLOCKORBIT_SATSBAS]    = co.EpochTime[CLOCKORBIT_SATSBAS];
     352  phasebias.EpochTime[CLOCKORBIT_SATBDS]     = co.EpochTime[CLOCKORBIT_SATBDS];
     353  phasebias.SSRIOD        = _IOD;
    340354  phasebias.SSRProviderID = _PID;
    341355  phasebias.SSRSolutionID = _SID;
    342356
    343   struct VTEC vtec;
     357  struct SsrCorr::VTEC vtec;
    344358  memset(&vtec, 0, sizeof(vtec));
    345359  vtec.EpochTime = static_cast<int>(epoTime.gpssec());
    346   vtec.SSRIOD = _IOD;
     360  vtec.SSRIOD        = _IOD;
    347361  vtec.SSRProviderID = _PID;
    348362  vtec.SSRSolutionID = _SID;
     
    385399      continue;
    386400    }
    387 
    388401    // non-satellite specific parameters
    389402    if (key.contains("VTEC", Qt::CaseSensitive)) {
     
    408421      continue;
    409422    }
    410 
    411423    // satellite specific parameters
    412424    char sys = key.mid(0, 1).at(0).toAscii();
     
    423435    const t_eph* ephPrev = _ephUser->ephPrev(prnInternalStr);
    424436    const t_eph* eph = ephLast;
    425 
    426437    if (eph) {
    427438
     
    551562      }
    552563
    553       struct ClockOrbit::SatData* sd = 0;
     564      struct SsrCorr::ClockOrbit::SatData* sd = 0;
    554565      if (prn.system() == 'G') {
    555566        sd = co.Sat + co.NumberOfSat[CLOCKORBIT_SATGPS];
     
    597608      // Code Biases
    598609      // -----------
    599       struct CodeBias::BiasSat* biasSat = 0;
     610      struct SsrCorr::CodeBias::BiasSat* biasSat = 0;
    600611      if (!codeBiases.isEmpty()) {
    601612        if (prn.system() == 'G') {
     
    637648        biasSat->ID = prn.number();
    638649        biasSat->NumberOfCodeBiases = 0;
    639         if (prn.system() == 'G') {
    640           QMapIterator<QString, double> it(codeBiases);
    641           while (it.hasNext()) {
    642             it.next();
    643             if (it.key() == "1C") {
    644               int ii = biasSat->NumberOfCodeBiases;
    645               if (ii >= CLOCKORBIT_NUMBIAS)
    646                 break;
    647               biasSat->NumberOfCodeBiases += 1;
    648               biasSat->Biases[ii].Type = CODETYPEGPS_L1_CA;
    649               biasSat->Biases[ii].Bias = it.value();
    650             }
    651             else if (it.key() == "1S") {
    652               int ii = biasSat->NumberOfCodeBiases;
    653               if (ii >= CLOCKORBIT_NUMBIAS)
    654                 break;
    655               biasSat->NumberOfCodeBiases += 1;
    656               biasSat->Biases[ii].Type = CODETYPEGPS_L1C_D;
    657               biasSat->Biases[ii].Bias = it.value();
    658             }
    659             else if (it.key() == "1L") {
    660               int ii = biasSat->NumberOfCodeBiases;
    661               if (ii >= CLOCKORBIT_NUMBIAS)
    662                 break;
    663               biasSat->NumberOfCodeBiases += 1;
    664               biasSat->Biases[ii].Type = CODETYPEGPS_L1C_P;
    665               biasSat->Biases[ii].Bias = it.value();
    666             }
    667 #ifdef USE_SSR_RTCM
    668             else if (it.key() == "1X") {
    669               int ii = biasSat->NumberOfCodeBiases;
    670               if (ii >= CLOCKORBIT_NUMBIAS)
    671                 break;
    672               biasSat->NumberOfCodeBiases += 1;
    673               biasSat->Biases[ii].Type = CODETYPEGPS_L1C_DP;
    674               biasSat->Biases[ii].Bias = it.value();
    675             }
    676 #endif
    677             else if (it.key() == "1P") {
    678               int ii = biasSat->NumberOfCodeBiases;
    679               if (ii >= CLOCKORBIT_NUMBIAS)
    680                 break;
    681               biasSat->NumberOfCodeBiases += 1;
    682               biasSat->Biases[ii].Type = CODETYPEGPS_L1_P;
    683               biasSat->Biases[ii].Bias = it.value();
    684             }
    685             else if (it.key() == "1W") {
    686               int ii = biasSat->NumberOfCodeBiases;
    687               if (ii >= CLOCKORBIT_NUMBIAS)
    688                 break;
    689               biasSat->NumberOfCodeBiases += 1;
    690               biasSat->Biases[ii].Type = CODETYPEGPS_L1_Z;
    691               biasSat->Biases[ii].Bias = it.value();
    692             }
    693             else if (it.key() == "2C") {
    694               int ii = biasSat->NumberOfCodeBiases;
    695               if (ii >= CLOCKORBIT_NUMBIAS)
    696                 break;
    697               biasSat->NumberOfCodeBiases += 1;
    698               biasSat->Biases[ii].Type = CODETYPEGPS_L2_CA;
    699               biasSat->Biases[ii].Bias = it.value();
    700             }
    701             else if (it.key() == "2D") {
    702               int ii = biasSat->NumberOfCodeBiases;
    703               if (ii >= CLOCKORBIT_NUMBIAS)
    704                 break;
    705               biasSat->NumberOfCodeBiases += 1;
    706               biasSat->Biases[ii].Type = CODETYPEGPS_SEMI_CODELESS;
    707               biasSat->Biases[ii].Bias = it.value();
    708             }
    709             else if (it.key() == "2S") {
    710               int ii = biasSat->NumberOfCodeBiases;
    711               if (ii >= CLOCKORBIT_NUMBIAS)
    712                 break;
    713               biasSat->NumberOfCodeBiases += 1;
    714               biasSat->Biases[ii].Type = CODETYPEGPS_L2C_M;
    715               biasSat->Biases[ii].Bias = it.value();
    716             }
    717             else if (it.key() == "2L") {
    718               int ii = biasSat->NumberOfCodeBiases;
    719               if (ii >= CLOCKORBIT_NUMBIAS)
    720                 break;
    721               biasSat->NumberOfCodeBiases += 1;
    722               biasSat->Biases[ii].Type = CODETYPEGPS_L2C_L;
    723               biasSat->Biases[ii].Bias = it.value();
    724             }
    725 #ifdef USE_SSR_RTCM
    726             else if (it.key() == "2X") {
    727               int ii = biasSat->NumberOfCodeBiases;
    728               if (ii >= CLOCKORBIT_NUMBIAS)
    729                 break;
    730               biasSat->NumberOfCodeBiases += 1;
    731               biasSat->Biases[ii].Type = CODETYPEGPS_L2C_ML;
    732               biasSat->Biases[ii].Bias = it.value();
    733             }
    734 #endif
    735             else if (it.key() == "2P") {
    736               int ii = biasSat->NumberOfCodeBiases;
    737               if (ii >= CLOCKORBIT_NUMBIAS)
    738                 break;
    739               biasSat->NumberOfCodeBiases += 1;
    740               biasSat->Biases[ii].Type = CODETYPEGPS_L2_P;
    741               biasSat->Biases[ii].Bias = it.value();
    742             }
    743             else if (it.key() == "2W") {
    744               int ii = biasSat->NumberOfCodeBiases;
    745               if (ii >= CLOCKORBIT_NUMBIAS)
    746                 break;
    747               biasSat->NumberOfCodeBiases += 1;
    748               biasSat->Biases[ii].Type = CODETYPEGPS_L2_Z;
    749               biasSat->Biases[ii].Bias = it.value();
    750             }
    751             else if (it.key() == "5I") {
    752               int ii = biasSat->NumberOfCodeBiases;
    753               if (ii >= CLOCKORBIT_NUMBIAS)
    754                 break;
    755               biasSat->NumberOfCodeBiases += 1;
    756               biasSat->Biases[ii].Type = CODETYPEGPS_L5_I;
    757               biasSat->Biases[ii].Bias = it.value();
    758             }
    759             else if (it.key() == "5Q") {
    760               int ii = biasSat->NumberOfCodeBiases;
    761               if (ii >= CLOCKORBIT_NUMBIAS)
    762                 break;
    763               biasSat->NumberOfCodeBiases += 1;
    764               biasSat->Biases[ii].Type = CODETYPEGPS_L5_Q;
    765               biasSat->Biases[ii].Bias = it.value();
    766             }
    767 #ifdef USE_SSR_RTCM
    768             else if (it.key() == "5X") {
    769               int ii = biasSat->NumberOfCodeBiases;
    770               if (ii >= CLOCKORBIT_NUMBIAS)
    771                 break;
    772               biasSat->NumberOfCodeBiases += 1;
    773               biasSat->Biases[ii].Type = CODETYPEGPS_L5_IQ;
    774               biasSat->Biases[ii].Bias = it.value();
    775             }
    776 #endif
    777           }
    778         }
    779         else if (prn.system() == 'R') {
    780           QMapIterator<QString, double> it(codeBiases);
    781           while (it.hasNext()) {
    782             it.next();
    783             if (it.key() == "1C") {
    784               int ii = biasSat->NumberOfCodeBiases;
    785               if (ii >= CLOCKORBIT_NUMBIAS)
    786                 break;
    787               biasSat->NumberOfCodeBiases += 1;
    788               biasSat->Biases[ii].Type = CODETYPEGLONASS_L1_CA;
    789               biasSat->Biases[ii].Bias = it.value();
    790             }
    791             else if (it.key() == "1P") {
    792               int ii = biasSat->NumberOfCodeBiases;
    793               if (ii >= CLOCKORBIT_NUMBIAS)
    794                 break;
    795               biasSat->NumberOfCodeBiases += 1;
    796               biasSat->Biases[ii].Type = CODETYPEGLONASS_L1_P;
    797               biasSat->Biases[ii].Bias = it.value();
    798             }
    799             else if (it.key() == "2C") {
    800               int ii = biasSat->NumberOfCodeBiases;
    801               if (ii >= CLOCKORBIT_NUMBIAS)
    802                 break;
    803               biasSat->NumberOfCodeBiases += 1;
    804               biasSat->Biases[ii].Type = CODETYPEGLONASS_L2_CA;
    805               biasSat->Biases[ii].Bias = it.value();
    806             }
    807             else if (it.key() == "2P") {
    808               int ii = biasSat->NumberOfCodeBiases;
    809               if (ii >= CLOCKORBIT_NUMBIAS)
    810                 break;
    811               biasSat->NumberOfCodeBiases += 1;
    812               biasSat->Biases[ii].Type = CODETYPEGLONASS_L2_P;
    813               biasSat->Biases[ii].Bias = it.value();
    814             }
    815             else if (it.key() == "4A") {
    816               int ii = biasSat->NumberOfCodeBiases;
    817               if (ii >= CLOCKORBIT_NUMBIAS)
    818                 break;
    819               biasSat->NumberOfCodeBiases += 1;
    820               biasSat->Biases[ii].Type = CODETYPEGLONASS_L1a_OCd;
    821               biasSat->Biases[ii].Bias = it.value();
    822             }
    823             else if (it.key() == "4B") {
    824               int ii = biasSat->NumberOfCodeBiases;
    825               if (ii >= CLOCKORBIT_NUMBIAS)
    826                 break;
    827               biasSat->NumberOfCodeBiases += 1;
    828               biasSat->Biases[ii].Type = CODETYPEGLONASS_L1a_OCp;
    829               biasSat->Biases[ii].Bias = it.value();
    830             }
    831 #ifdef USE_SSR_RTCM
    832             else if (it.key() == "4X") {
    833               int ii = biasSat->NumberOfCodeBiases;
    834               if (ii >= CLOCKORBIT_NUMBIAS)
    835                 break;
    836               biasSat->NumberOfCodeBiases += 1;
    837               biasSat->Biases[ii].Type = CODETYPEGLONASS_L1a_OCdp;
    838               biasSat->Biases[ii].Bias = it.value();
    839             }
    840 #endif
    841             else if (it.key() == "6A") {
    842               int ii = biasSat->NumberOfCodeBiases;
    843               if (ii >= CLOCKORBIT_NUMBIAS)
    844                 break;
    845               biasSat->NumberOfCodeBiases += 1;
    846               biasSat->Biases[ii].Type = CODETYPEGLONASS_L2a_CSI;
    847               biasSat->Biases[ii].Bias = it.value();
    848             }
    849             else if (it.key() == "6B") {
    850               int ii = biasSat->NumberOfCodeBiases;
    851               if (ii >= CLOCKORBIT_NUMBIAS)
    852                 break;
    853               biasSat->NumberOfCodeBiases += 1;
    854               biasSat->Biases[ii].Type = CODETYPEGLONASS_L2a_OCp;
    855               biasSat->Biases[ii].Bias = it.value();
    856             }
    857 #ifdef USE_SSR_RTCM
    858             else if (it.key() == "6X") {
    859               int ii = biasSat->NumberOfCodeBiases;
    860               if (ii >= CLOCKORBIT_NUMBIAS)
    861                 break;
    862               biasSat->NumberOfCodeBiases += 1;
    863               biasSat->Biases[ii].Type = CODETYPEGLONASS_L2a_CSIOCp;
    864               biasSat->Biases[ii].Bias = it.value();
    865             }
    866 #endif
    867             else if (it.key() == "3I") {
    868               int ii = biasSat->NumberOfCodeBiases;
    869               if (ii >= CLOCKORBIT_NUMBIAS)
    870                 break;
    871               biasSat->NumberOfCodeBiases += 1;
    872               biasSat->Biases[ii].Type = CODETYPEGLONASS_L3_I;
    873               biasSat->Biases[ii].Bias = it.value();
    874             }
    875             else if (it.key() == "3Q") {
    876               int ii = biasSat->NumberOfCodeBiases;
    877               if (ii >= CLOCKORBIT_NUMBIAS)
    878                 break;
    879               biasSat->NumberOfCodeBiases += 1;
    880               biasSat->Biases[ii].Type = CODETYPEGLONASS_L3_Q;
    881               biasSat->Biases[ii].Bias = it.value();
    882             }
    883 #ifdef USE_SSR_RTCM
    884             else if (it.key() == "3X") {
    885               int ii = biasSat->NumberOfCodeBiases;
    886               if (ii >= CLOCKORBIT_NUMBIAS)
    887                 break;
    888               biasSat->NumberOfCodeBiases += 1;
    889               biasSat->Biases[ii].Type = CODETYPEGLONASS_L3_IQ;
    890               biasSat->Biases[ii].Bias = it.value();
    891             }
    892 #endif
    893           }
    894         }
    895         else if (prn.system() == 'E') {
    896           QMapIterator<QString, double> it(codeBiases);
    897           while (it.hasNext()) {
    898             it.next();
    899             if (it.key() == "1A") {
    900               int ii = biasSat->NumberOfCodeBiases;
    901               if (ii >= CLOCKORBIT_NUMBIAS)
    902                 break;
    903               biasSat->NumberOfCodeBiases += 1;
    904               biasSat->Biases[ii].Type = CODETYPEGALILEO_E1_A;
    905               biasSat->Biases[ii].Bias = it.value();
    906             }
    907             else if (it.key() == "1B") {
    908               int ii = biasSat->NumberOfCodeBiases;
    909               if (ii >= CLOCKORBIT_NUMBIAS)
    910                 break;
    911               biasSat->NumberOfCodeBiases += 1;
    912               biasSat->Biases[ii].Type = CODETYPEGALILEO_E1_B;
    913               biasSat->Biases[ii].Bias = it.value();
    914             }
    915             else if (it.key() == "1C") {
    916               int ii = biasSat->NumberOfCodeBiases;
    917               if (ii >= CLOCKORBIT_NUMBIAS)
    918                 break;
    919               biasSat->NumberOfCodeBiases += 1;
    920               biasSat->Biases[ii].Type = CODETYPEGALILEO_E1_C;
    921               biasSat->Biases[ii].Bias = it.value();
    922             }
    923 #ifdef USE_SSR_RTCM
    924             else if (it.key() == "1X") {
    925               int ii = biasSat->NumberOfCodeBiases;
    926               if (ii >= CLOCKORBIT_NUMBIAS)
    927                 break;
    928               biasSat->NumberOfCodeBiases += 1;
    929               biasSat->Biases[ii].Type = CODETYPEGALILEO_E1_BC;
    930               biasSat->Biases[ii].Bias = it.value();
    931             }
    932             else if (it.key() == "1Z") {
    933               int ii = biasSat->NumberOfCodeBiases;
    934               if (ii >= CLOCKORBIT_NUMBIAS)
    935                 break;
    936               biasSat->NumberOfCodeBiases += 1;
    937               biasSat->Biases[ii].Type = CODETYPEGALILEO_E1_ABC;
    938               biasSat->Biases[ii].Bias = it.value();
    939             }
    940 #endif
    941             else if (it.key() == "5I") {
    942               int ii = biasSat->NumberOfCodeBiases;
    943               if (ii >= CLOCKORBIT_NUMBIAS)
    944                 break;
    945               biasSat->NumberOfCodeBiases += 1;
    946               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5A_I;
    947               biasSat->Biases[ii].Bias = it.value();
    948             }
    949             else if (it.key() == "5Q") {
    950               int ii = biasSat->NumberOfCodeBiases;
    951               if (ii >= CLOCKORBIT_NUMBIAS)
    952                 break;
    953               biasSat->NumberOfCodeBiases += 1;
    954               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5A_Q;
    955               biasSat->Biases[ii].Bias = it.value();
    956             }
    957 #ifdef USE_SSR_RTCM
    958             else if (it.key() == "5X") {
    959               int ii = biasSat->NumberOfCodeBiases;
    960               if (ii >= CLOCKORBIT_NUMBIAS)
    961                 break;
    962               biasSat->NumberOfCodeBiases += 1;
    963               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5A_IQ;
    964               biasSat->Biases[ii].Bias = it.value();
    965             }
    966 #endif
    967             else if (it.key() == "7I") {
    968               int ii = biasSat->NumberOfCodeBiases;
    969               if (ii >= CLOCKORBIT_NUMBIAS)
    970                 break;
    971               biasSat->NumberOfCodeBiases += 1;
    972               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5B_I;
    973               biasSat->Biases[ii].Bias = it.value();
    974             }
    975             else if (it.key() == "7Q") {
    976               int ii = biasSat->NumberOfCodeBiases;
    977               if (ii >= CLOCKORBIT_NUMBIAS)
    978                 break;
    979               biasSat->NumberOfCodeBiases += 1;
    980               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5B_Q;
    981               biasSat->Biases[ii].Bias = it.value();
    982             }
    983 #ifdef USE_SSR_RTCM
    984             else if (it.key() == "7X") {
    985               int ii = biasSat->NumberOfCodeBiases;
    986               if (ii >= CLOCKORBIT_NUMBIAS)
    987                 break;
    988               biasSat->NumberOfCodeBiases += 1;
    989               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5B_IQ;
    990               biasSat->Biases[ii].Bias = it.value();
    991             }
    992             else if (it.key() == "8I") {
    993               int ii = biasSat->NumberOfCodeBiases;
    994               if (ii >= CLOCKORBIT_NUMBIAS)
    995                 break;
    996               biasSat->NumberOfCodeBiases += 1;
    997               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5_I;
    998               biasSat->Biases[ii].Bias = it.value();
    999             }
    1000             else if (it.key() == "8Q") {
    1001               int ii = biasSat->NumberOfCodeBiases;
    1002               if (ii >= CLOCKORBIT_NUMBIAS)
    1003                 break;
    1004               biasSat->NumberOfCodeBiases += 1;
    1005               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5_Q;
    1006               biasSat->Biases[ii].Bias = it.value();
    1007             }
    1008             else if (it.key() == "8X") {
    1009               int ii = biasSat->NumberOfCodeBiases;
    1010               if (ii >= CLOCKORBIT_NUMBIAS)
    1011                 break;
    1012               biasSat->NumberOfCodeBiases += 1;
    1013               biasSat->Biases[ii].Type = CODETYPEGALILEO_E5_IQ;
    1014               biasSat->Biases[ii].Bias = it.value();
    1015             }
    1016 #endif
    1017             else if (it.key() == "6A") {
    1018               int ii = biasSat->NumberOfCodeBiases;
    1019               if (ii >= CLOCKORBIT_NUMBIAS)
    1020                 break;
    1021               biasSat->NumberOfCodeBiases += 1;
    1022               biasSat->Biases[ii].Type = CODETYPEGALILEO_E6_A;
    1023               biasSat->Biases[ii].Bias = it.value();
    1024             }
    1025             else if (it.key() == "6B") {
    1026               int ii = biasSat->NumberOfCodeBiases;
    1027               if (ii >= CLOCKORBIT_NUMBIAS)
    1028                 break;
    1029               biasSat->NumberOfCodeBiases += 1;
    1030               biasSat->Biases[ii].Type = CODETYPEGALILEO_E6_B;
    1031               biasSat->Biases[ii].Bias = it.value();
    1032             }
    1033             else if (it.key() == "6C") {
    1034               int ii = biasSat->NumberOfCodeBiases;
    1035               if (ii >= CLOCKORBIT_NUMBIAS)
    1036                 break;
    1037               biasSat->NumberOfCodeBiases += 1;
    1038               biasSat->Biases[ii].Type = CODETYPEGALILEO_E6_C;
    1039               biasSat->Biases[ii].Bias = it.value();
    1040             }
    1041 #ifdef USE_SSR_RTCM
    1042             else if (it.key() == "6X") {
    1043               int ii = biasSat->NumberOfCodeBiases;
    1044               if (ii >= CLOCKORBIT_NUMBIAS)
    1045                 break;
    1046               biasSat->NumberOfCodeBiases += 1;
    1047               biasSat->Biases[ii].Type = CODETYPEGALILEO_E6_BC;
    1048               biasSat->Biases[ii].Bias = it.value();
    1049             }
    1050             else if (it.key() == "6Z") {
    1051               int ii = biasSat->NumberOfCodeBiases;
    1052               if (ii >= CLOCKORBIT_NUMBIAS)
    1053                 break;
    1054               biasSat->NumberOfCodeBiases += 1;
    1055               biasSat->Biases[ii].Type = CODETYPEGALILEO_E6_ABC;
    1056               biasSat->Biases[ii].Bias = it.value();
    1057             }
    1058 #endif
    1059           }
    1060         }
    1061         else if (prn.system() == 'J') {
    1062           QMapIterator<QString, double> it(codeBiases);
    1063           while (it.hasNext()) {
    1064             it.next();
    1065             if (it.key() == "1C") {
    1066               int ii = biasSat->NumberOfCodeBiases;
    1067               if (ii >= CLOCKORBIT_NUMBIAS)
    1068                 break;
    1069               biasSat->NumberOfCodeBiases += 1;
    1070               biasSat->Biases[ii].Type = CODETYPEQZSS_L1_CA;
    1071               biasSat->Biases[ii].Bias = it.value();
    1072             }
    1073             else if (it.key() == "1S") {
    1074               int ii = biasSat->NumberOfCodeBiases;
    1075               if (ii >= CLOCKORBIT_NUMBIAS)
    1076                 break;
    1077               biasSat->NumberOfCodeBiases += 1;
    1078               biasSat->Biases[ii].Type = CODETYPEQZSS_L1C_D;
    1079               biasSat->Biases[ii].Bias = it.value();
    1080             }
    1081             else if (it.key() == "1L") {
    1082               int ii = biasSat->NumberOfCodeBiases;
    1083               if (ii >= CLOCKORBIT_NUMBIAS)
    1084                 break;
    1085               biasSat->NumberOfCodeBiases += 1;
    1086               biasSat->Biases[ii].Type = CODETYPEQZSS_L1C_P;
    1087               biasSat->Biases[ii].Bias = it.value();
    1088             }
    1089             else if (it.key() == "2S") {
    1090               int ii = biasSat->NumberOfCodeBiases;
    1091               if (ii >= CLOCKORBIT_NUMBIAS)
    1092                 break;
    1093               biasSat->NumberOfCodeBiases += 1;
    1094               biasSat->Biases[ii].Type = CODETYPEQZSS_L2C_M;
    1095               biasSat->Biases[ii].Bias = it.value();
    1096             }
    1097             else if (it.key() == "2L") {
    1098               int ii = biasSat->NumberOfCodeBiases;
    1099               if (ii >= CLOCKORBIT_NUMBIAS)
    1100                 break;
    1101               biasSat->NumberOfCodeBiases += 1;
    1102               biasSat->Biases[ii].Type = CODETYPEQZSS_L2C_L;
    1103               biasSat->Biases[ii].Bias = it.value();
    1104             }
    1105 #ifdef USE_SSR_RTCM
    1106             else if (it.key() == "2X") {
    1107               int ii = biasSat->NumberOfCodeBiases;
    1108               if (ii >= CLOCKORBIT_NUMBIAS)
    1109                 break;
    1110               biasSat->NumberOfCodeBiases += 1;
    1111               biasSat->Biases[ii].Type = CODETYPEQZSS_L2C_ML;
    1112               biasSat->Biases[ii].Bias = it.value();
    1113             }
    1114 #endif
    1115             else if (it.key() == "5I") {
    1116               int ii = biasSat->NumberOfCodeBiases;
    1117               if (ii >= CLOCKORBIT_NUMBIAS)
    1118                 break;
    1119               biasSat->NumberOfCodeBiases += 1;
    1120               biasSat->Biases[ii].Type = CODETYPEQZSS_L5_I;
    1121               biasSat->Biases[ii].Bias = it.value();
    1122             }
    1123             else if (it.key() == "5Q") {
    1124               int ii = biasSat->NumberOfCodeBiases;
    1125               if (ii >= CLOCKORBIT_NUMBIAS)
    1126                 break;
    1127               biasSat->NumberOfCodeBiases += 1;
    1128               biasSat->Biases[ii].Type = CODETYPEQZSS_L5_Q;
    1129               biasSat->Biases[ii].Bias = it.value();
    1130             }
    1131 #ifdef USE_SSR_RTCM
    1132             else if (it.key() == "5X") {
    1133               int ii = biasSat->NumberOfCodeBiases;
    1134               if (ii >= CLOCKORBIT_NUMBIAS)
    1135                 break;
    1136               biasSat->NumberOfCodeBiases += 1;
    1137               biasSat->Biases[ii].Type = CODETYPEQZSS_L5_IQ;
    1138               biasSat->Biases[ii].Bias = it.value();
    1139             }
    1140 #endif
    1141             else if (it.key() == "6S") {
    1142               int ii = biasSat->NumberOfCodeBiases;
    1143               if (ii >= CLOCKORBIT_NUMBIAS)
    1144                 break;
    1145               biasSat->NumberOfCodeBiases += 1;
    1146               biasSat->Biases[ii].Type = CODETYPEQZSS_L6_D;
    1147               biasSat->Biases[ii].Bias = it.value();
    1148             }
    1149             else if (it.key() == "6L") {
    1150               int ii = biasSat->NumberOfCodeBiases;
    1151               if (ii >= CLOCKORBIT_NUMBIAS)
    1152                 break;
    1153               biasSat->NumberOfCodeBiases += 1;
    1154               biasSat->Biases[ii].Type = CODETYPEQZSS_L6_P;
    1155               biasSat->Biases[ii].Bias = it.value();
    1156             }
    1157 #ifdef USE_SSR_RTCM
    1158             else if (it.key() == "6X") {
    1159               int ii = biasSat->NumberOfCodeBiases;
    1160               if (ii >= CLOCKORBIT_NUMBIAS)
    1161                 break;
    1162               biasSat->NumberOfCodeBiases += 1;
    1163               biasSat->Biases[ii].Type = CODETYPEQZSS_L6_DP;
    1164               biasSat->Biases[ii].Bias = it.value();
    1165             }
    1166             else if (it.key() == "1X") {
    1167               int ii = biasSat->NumberOfCodeBiases;
    1168               if (ii >= CLOCKORBIT_NUMBIAS)
    1169                 break;
    1170               biasSat->NumberOfCodeBiases += 1;
    1171               biasSat->Biases[ii].Type = CODETYPEQZSS_L1C_DP;
    1172               biasSat->Biases[ii].Bias = it.value();
    1173             }
    1174             else if (it.key() == "1Z") {
    1175               int ii = biasSat->NumberOfCodeBiases;
    1176               if (ii >= CLOCKORBIT_NUMBIAS)
    1177                 break;
    1178               biasSat->NumberOfCodeBiases += 1;
    1179               biasSat->Biases[ii].Type = CODETYPEQZSS_L1_S;
    1180               biasSat->Biases[ii].Bias = it.value();
    1181             }
    1182             else if (it.key() == "5D") {
    1183               int ii = biasSat->NumberOfCodeBiases;
    1184               if (ii >= CLOCKORBIT_NUMBIAS)
    1185                 break;
    1186               biasSat->NumberOfCodeBiases += 1;
    1187               biasSat->Biases[ii].Type = CODETYPEQZSS_L5_D;
    1188               biasSat->Biases[ii].Bias = it.value();
    1189             }
    1190             else if (it.key() == "5P") {
    1191               int ii = biasSat->NumberOfCodeBiases;
    1192               if (ii >= CLOCKORBIT_NUMBIAS)
    1193                 break;
    1194               biasSat->NumberOfCodeBiases += 1;
    1195               biasSat->Biases[ii].Type = CODETYPEQZSS_L5_P;
    1196               biasSat->Biases[ii].Bias = it.value();
    1197             }
    1198             else if (it.key() == "5Z") {
    1199               int ii = biasSat->NumberOfCodeBiases;
    1200               if (ii >= CLOCKORBIT_NUMBIAS)
    1201                 break;
    1202               biasSat->NumberOfCodeBiases += 1;
    1203               biasSat->Biases[ii].Type = CODETYPEQZSS_L5_DP;
    1204               biasSat->Biases[ii].Bias = it.value();
    1205             }
    1206 #endif
    1207             else if (it.key() == "6E") {
    1208               int ii = biasSat->NumberOfCodeBiases;
    1209               if (ii >= CLOCKORBIT_NUMBIAS)
    1210                 break;
    1211               biasSat->NumberOfCodeBiases += 1;
    1212               biasSat->Biases[ii].Type = CODETYPEQZSS_L6_E;
    1213               biasSat->Biases[ii].Bias = it.value();
    1214             }
    1215 #ifdef USE_SSR_RTCM
    1216             else if (it.key() == "6Z") {
    1217               int ii = biasSat->NumberOfCodeBiases;
    1218               if (ii >= CLOCKORBIT_NUMBIAS)
    1219                 break;
    1220               biasSat->NumberOfCodeBiases += 1;
    1221               biasSat->Biases[ii].Type = CODETYPEQZSS_L6_DE;
    1222               biasSat->Biases[ii].Bias = it.value();
    1223             }
    1224 #endif
    1225           }
    1226         }
    1227         else if (prn.system() == 'S') {
    1228           QMapIterator<QString, double> it(codeBiases);
    1229           while (it.hasNext()) {
    1230             it.next();
    1231             if (it.key() == "1C") {
    1232               int ii = biasSat->NumberOfCodeBiases;
    1233               if (ii >= CLOCKORBIT_NUMBIAS)
    1234                 break;
    1235               biasSat->NumberOfCodeBiases += 1;
    1236               biasSat->Biases[ii].Type = CODETYPE_SBAS_L1_CA;
    1237               biasSat->Biases[ii].Bias = it.value();
    1238             }
    1239             else if (it.key() == "5I") {
    1240               int ii = biasSat->NumberOfCodeBiases;
    1241               if (ii >= CLOCKORBIT_NUMBIAS)
    1242                 break;
    1243               biasSat->NumberOfCodeBiases += 1;
    1244               biasSat->Biases[ii].Type = CODETYPE_SBAS_L5_I;
    1245               biasSat->Biases[ii].Bias = it.value();
    1246             }
    1247             else if (it.key() == "5Q") {
    1248               int ii = biasSat->NumberOfCodeBiases;
    1249               if (ii >= CLOCKORBIT_NUMBIAS)
    1250                 break;
    1251               biasSat->NumberOfCodeBiases += 1;
    1252               biasSat->Biases[ii].Type = CODETYPE_SBAS_L5_Q;
    1253               biasSat->Biases[ii].Bias = it.value();
    1254             }
    1255 #ifdef USE_SSR_RTCM
    1256             else if (it.key() == "5X") {
    1257               int ii = biasSat->NumberOfCodeBiases;
    1258               if (ii >= CLOCKORBIT_NUMBIAS)
    1259                 break;
    1260               biasSat->NumberOfCodeBiases += 1;
    1261               biasSat->Biases[ii].Type = CODETYPE_SBAS_L5_IQ;
    1262               biasSat->Biases[ii].Bias = it.value();
    1263             }
    1264 #endif
    1265           }
    1266         }
    1267         else if (prn.system() == 'C') {
    1268           QMapIterator<QString, double> it(codeBiases);
    1269           while (it.hasNext()) {
    1270             it.next();
    1271             if (it.key() == "2I") {
    1272               int ii = biasSat->NumberOfCodeBiases;
    1273               if (ii >= CLOCKORBIT_NUMBIAS)
    1274                 break;
    1275               biasSat->NumberOfCodeBiases += 1;
    1276               biasSat->Biases[ii].Type = CODETYPE_BDS_B1_I;
    1277               biasSat->Biases[ii].Bias = it.value();
    1278             }
    1279             else if (it.key() == "2Q") {
    1280               int ii = biasSat->NumberOfCodeBiases;
    1281               if (ii >= CLOCKORBIT_NUMBIAS)
    1282                 break;
    1283               biasSat->NumberOfCodeBiases += 1;
    1284               biasSat->Biases[ii].Type = CODETYPE_BDS_B1_Q;
    1285               biasSat->Biases[ii].Bias = it.value();
    1286             }
    1287 #ifdef USE_SSR_RTCM
    1288             else if (it.key() == "2X") {
    1289               int ii = biasSat->NumberOfCodeBiases;
    1290               if (ii >= CLOCKORBIT_NUMBIAS)
    1291                 break;
    1292               biasSat->NumberOfCodeBiases += 1;
    1293               biasSat->Biases[ii].Type = CODETYPE_BDS_B1_IQ;
    1294               biasSat->Biases[ii].Bias = it.value();
    1295             }
    1296 #endif
    1297             else if (it.key() == "6I") {
    1298               int ii = biasSat->NumberOfCodeBiases;
    1299               if (ii >= CLOCKORBIT_NUMBIAS)
    1300                 break;
    1301               biasSat->NumberOfCodeBiases += 1;
    1302               biasSat->Biases[ii].Type = CODETYPE_BDS_B3_I;
    1303               biasSat->Biases[ii].Bias = it.value();
    1304             }
    1305             else if (it.key() == "6Q") {
    1306               int ii = biasSat->NumberOfCodeBiases;
    1307               if (ii >= CLOCKORBIT_NUMBIAS)
    1308                 break;
    1309               biasSat->NumberOfCodeBiases += 1;
    1310               biasSat->Biases[ii].Type = CODETYPE_BDS_B3_Q;
    1311               biasSat->Biases[ii].Bias = it.value();
    1312             }
    1313 #ifdef USE_SSR_RTCM
    1314             else if (it.key() == "6X") {
    1315               int ii = biasSat->NumberOfCodeBiases;
    1316               if (ii >= CLOCKORBIT_NUMBIAS)
    1317                 break;
    1318               biasSat->NumberOfCodeBiases += 1;
    1319               biasSat->Biases[ii].Type = CODETYPE_BDS_B3_IQ;
    1320               biasSat->Biases[ii].Bias = it.value();
    1321             }
    1322 #endif
    1323             else if (it.key() == "7I") {
    1324               int ii = biasSat->NumberOfCodeBiases;
    1325               if (ii >= CLOCKORBIT_NUMBIAS)
    1326                 break;
    1327               biasSat->NumberOfCodeBiases += 1;
    1328               biasSat->Biases[ii].Type = CODETYPE_BDS_B2_I;
    1329               biasSat->Biases[ii].Bias = it.value();
    1330             }
    1331             else if (it.key() == "7Q") {
    1332               int ii = biasSat->NumberOfCodeBiases;
    1333               if (ii >= CLOCKORBIT_NUMBIAS)
    1334                 break;
    1335               biasSat->NumberOfCodeBiases += 1;
    1336               biasSat->Biases[ii].Type = CODETYPE_BDS_B2_Q;
    1337               biasSat->Biases[ii].Bias = it.value();
    1338             }
    1339 #ifdef USE_SSR_RTCM
    1340             else if (it.key() == "7X") {
    1341               int ii = biasSat->NumberOfCodeBiases;
    1342               if (ii >= CLOCKORBIT_NUMBIAS)
    1343                 break;
    1344               biasSat->NumberOfCodeBiases += 1;
    1345               biasSat->Biases[ii].Type = CODETYPE_BDS_B2_IQ;
    1346               biasSat->Biases[ii].Bias = it.value();
    1347             }
    1348 #endif
    1349             else if (it.key() == "1D") {
    1350               int ii = biasSat->NumberOfCodeBiases;
    1351               if (ii >= CLOCKORBIT_NUMBIAS)
    1352                 break;
    1353               biasSat->NumberOfCodeBiases += 1;
    1354               biasSat->Biases[ii].Type = CODETYPE_BDS_B1a_D;
    1355               biasSat->Biases[ii].Bias = it.value();
    1356             }
    1357             else if (it.key() == "1P") {
    1358               int ii = biasSat->NumberOfCodeBiases;
    1359               if (ii >= CLOCKORBIT_NUMBIAS)
    1360                 break;
    1361               biasSat->NumberOfCodeBiases += 1;
    1362               biasSat->Biases[ii].Type = CODETYPE_BDS_B1a_P;
    1363               biasSat->Biases[ii].Bias = it.value();
    1364             }
    1365 #ifdef USE_SSR_RTCM
    1366             else if (it.key() == "1X") {
    1367               int ii = biasSat->NumberOfCodeBiases;
    1368               if (ii >= CLOCKORBIT_NUMBIAS)
    1369                 break;
    1370               biasSat->NumberOfCodeBiases += 1;
    1371               biasSat->Biases[ii].Type = CODETYPE_BDS_B1a_DP;
    1372               biasSat->Biases[ii].Bias = it.value();
    1373             }
    1374 #endif
    1375             else if (it.key() == "5D") {
    1376               int ii = biasSat->NumberOfCodeBiases;
    1377               if (ii >= CLOCKORBIT_NUMBIAS)
    1378                 break;
    1379               biasSat->NumberOfCodeBiases += 1;
    1380               biasSat->Biases[ii].Type = CODETYPE_BDS_B2a_D;
    1381               biasSat->Biases[ii].Bias = it.value();
    1382             }
    1383             else if (it.key() == "5P") {
    1384               int ii = biasSat->NumberOfCodeBiases;
    1385               if (ii >= CLOCKORBIT_NUMBIAS)
    1386                 break;
    1387               biasSat->NumberOfCodeBiases += 1;
    1388               biasSat->Biases[ii].Type = CODETYPE_BDS_B2a_P;
    1389               biasSat->Biases[ii].Bias = it.value();
    1390             }
    1391 #ifdef USE_SSR_RTCM
    1392             else if (it.key() == "5X") {
    1393               int ii = biasSat->NumberOfCodeBiases;
    1394               if (ii >= CLOCKORBIT_NUMBIAS)
    1395                 break;
    1396               biasSat->NumberOfCodeBiases += 1;
    1397               biasSat->Biases[ii].Type = CODETYPE_BDS_B2a_DP;
    1398               biasSat->Biases[ii].Bias = it.value();
    1399             }
    1400 #elif USE_SSR_IGS
    1401             else if (it.key() == "1A") {
    1402               int ii = biasSat->NumberOfCodeBiases;
    1403               if (ii >= CLOCKORBIT_NUMBIAS)
    1404                 break;
    1405               biasSat->NumberOfCodeBiases += 1;
    1406               biasSat->Biases[ii].Type = CODETYPE_BDS_B1_A;
    1407               biasSat->Biases[ii].Bias = it.value();
    1408           }
    1409             else if (it.key() == "6A") {
    1410               int ii = biasSat->NumberOfCodeBiases;
    1411               if (ii >= CLOCKORBIT_NUMBIAS)
    1412                 break;
    1413               biasSat->NumberOfCodeBiases += 1;
    1414               biasSat->Biases[ii].Type = CODETYPE_BDS_B3_A;
    1415               biasSat->Biases[ii].Bias = it.value();
    1416             }
    1417 #endif
    1418           }
    1419         }
    1420       }
    1421      
     650        QMapIterator<QString, double> it(codeBiases);
     651        while (it.hasNext()) {
     652          it.next();
     653          int ii = biasSat->NumberOfCodeBiases;
     654          if (ii >= CLOCKORBIT_NUMBIAS)
     655            break;
     656          SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), it.key().toStdString());
     657          if (type != _ssrCorr->RESERVED) {
     658            biasSat->NumberOfCodeBiases += 1;
     659            biasSat->Biases[ii].Type = type;
     660            biasSat->Biases[ii].Bias = it.value();
     661          }
     662        }
     663      }
     664
    1422665      // Phase Biases
    1423666      // ------------
    1424       struct PhaseBias::PhaseBiasSat* phasebiasSat = 0;
     667      struct SsrCorr::PhaseBias::PhaseBiasSat* phasebiasSat = 0;
    1425668      if (prn.system()      == 'G') {
    1426669        phasebiasSat = phasebias.Sat
     
    1465708        phasebiasSat->YawAngle = pbSat.yawAngle;
    1466709        phasebiasSat->YawRate = pbSat.yawRate;
    1467         if (prn.system() == 'G') {
    1468           QListIterator<phaseBiasSignal> it(phaseBiasList);
    1469           while (it.hasNext()) {
    1470             const phaseBiasSignal &pbSig = it.next();
    1471             if (pbSig.type == "1C") {
    1472               int ii = phasebiasSat->NumberOfPhaseBiases;
    1473               if (ii >= CLOCKORBIT_NUMBIAS)
    1474                 break;
    1475               phasebiasSat->NumberOfPhaseBiases += 1;
    1476               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L1_CA;
    1477               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1478               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1479               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1480               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1481             }
    1482             else if (pbSig.type == "1P") {
    1483               int ii = phasebiasSat->NumberOfPhaseBiases;
    1484               if (ii >= CLOCKORBIT_NUMBIAS)
    1485                 break;
    1486               phasebiasSat->NumberOfPhaseBiases += 1;
    1487               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L1_P;
    1488               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1489               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1490               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1491               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1492             }
    1493             else if (pbSig.type == "1W") {
    1494               int ii = phasebiasSat->NumberOfPhaseBiases;
    1495               if (ii >= CLOCKORBIT_NUMBIAS)
    1496                 break;
    1497               phasebiasSat->NumberOfPhaseBiases += 1;
    1498               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L1_Z;
    1499               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1500               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1501               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1502               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1503             }
    1504             else if (pbSig.type == "2C") {
    1505               int ii = phasebiasSat->NumberOfPhaseBiases;
    1506               if (ii >= CLOCKORBIT_NUMBIAS)
    1507                 break;
    1508               phasebiasSat->NumberOfPhaseBiases += 1;
    1509               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L2_CA;
    1510               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1511               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1512               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1513               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1514             }
    1515             else if (pbSig.type == "2D") {
    1516               int ii = phasebiasSat->NumberOfPhaseBiases;
    1517               if (ii >= CLOCKORBIT_NUMBIAS)
    1518                 break;
    1519               phasebiasSat->NumberOfPhaseBiases += 1;
    1520               phasebiasSat->Biases[ii].Type = CODETYPEGPS_SEMI_CODELESS;
    1521               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1522               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1523               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1524               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1525             }
    1526             else if (pbSig.type == "2S") {
    1527               int ii = phasebiasSat->NumberOfPhaseBiases;
    1528               if (ii >= CLOCKORBIT_NUMBIAS)
    1529                 break;
    1530               phasebiasSat->NumberOfPhaseBiases += 1;
    1531               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L2C_M;
    1532               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1533               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1534               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1535               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1536             }
    1537             else if (pbSig.type == "2L") {
    1538               int ii = phasebiasSat->NumberOfPhaseBiases;
    1539               if (ii >= CLOCKORBIT_NUMBIAS)
    1540                 break;
    1541               phasebiasSat->NumberOfPhaseBiases += 1;
    1542               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L2C_L;
    1543               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1544               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1545               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1546               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1547             }
    1548 #ifdef USE_SSR_RTCM
    1549             else if (pbSig.type == "2X") {
    1550               int ii = phasebiasSat->NumberOfPhaseBiases;
    1551               if (ii >= CLOCKORBIT_NUMBIAS)
    1552                 break;
    1553               phasebiasSat->NumberOfPhaseBiases += 1;
    1554               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L2C_ML;
    1555               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1556               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1557               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1558               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1559             }
    1560 #endif
    1561             else if (pbSig.type == "2P") {
    1562               int ii = phasebiasSat->NumberOfPhaseBiases;
    1563               if (ii >= CLOCKORBIT_NUMBIAS)
    1564                 break;
    1565               phasebiasSat->NumberOfPhaseBiases += 1;
    1566               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L2_P;
    1567               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1568               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1569               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1570               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1571             }
    1572             else if (pbSig.type == "2W") {
    1573               int ii = phasebiasSat->NumberOfPhaseBiases;
    1574               if (ii >= CLOCKORBIT_NUMBIAS)
    1575                 break;
    1576               phasebiasSat->NumberOfPhaseBiases += 1;
    1577               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L2_Z;
    1578               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1579               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1580               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1581               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1582             }
    1583             else if (pbSig.type == "5I") {
    1584               int ii = phasebiasSat->NumberOfPhaseBiases;
    1585               if (ii >= CLOCKORBIT_NUMBIAS)
    1586                 break;
    1587               phasebiasSat->NumberOfPhaseBiases += 1;
    1588               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L5_I;
    1589               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1590               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1591               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1592               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1593             }
    1594             else if (pbSig.type == "5Q") {
    1595               int ii = phasebiasSat->NumberOfPhaseBiases;
    1596               if (ii >= CLOCKORBIT_NUMBIAS)
    1597                 break;
    1598               phasebiasSat->NumberOfPhaseBiases += 1;
    1599               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L5_Q;
    1600               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1601               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1602               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1603               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1604             }
    1605 #ifdef USE_SSR_RTCM
    1606             else if (pbSig.type == "5X") {
    1607               int ii = phasebiasSat->NumberOfPhaseBiases;
    1608               if (ii >= CLOCKORBIT_NUMBIAS)
    1609                 break;
    1610               phasebiasSat->NumberOfPhaseBiases += 1;
    1611               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L5_IQ;
    1612               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1613               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1614               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1615               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1616             }
    1617 #endif
    1618             else if (pbSig.type == "1S") {
    1619               int ii = phasebiasSat->NumberOfPhaseBiases;
    1620               if (ii >= CLOCKORBIT_NUMBIAS)
    1621                 break;
    1622               phasebiasSat->NumberOfPhaseBiases += 1;
    1623               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L1C_D;
    1624               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1625               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1626               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1627               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1628             }
    1629             else if (pbSig.type == "1L") {
    1630               int ii = phasebiasSat->NumberOfPhaseBiases;
    1631               if (ii >= CLOCKORBIT_NUMBIAS)
    1632                 break;
    1633               phasebiasSat->NumberOfPhaseBiases += 1;
    1634               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L1C_P;
    1635               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1636               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1637               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1638               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1639             }
    1640 #ifdef USE_SSR_RTCM
    1641             else if (pbSig.type == "1X") {
    1642               int ii = phasebiasSat->NumberOfPhaseBiases;
    1643               if (ii >= CLOCKORBIT_NUMBIAS)
    1644                 break;
    1645               phasebiasSat->NumberOfPhaseBiases += 1;
    1646               phasebiasSat->Biases[ii].Type = CODETYPEGPS_L1C_DP;
    1647               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1648               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1649               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1650               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1651             }
    1652 #endif
    1653           }
    1654         }
    1655         if (prn.system() == 'R') {
    1656           QListIterator<phaseBiasSignal> it(phaseBiasList);
    1657           while (it.hasNext()) {
    1658             const phaseBiasSignal &pbSig = it.next();
    1659             if (pbSig.type == "1C") {
    1660               int ii = phasebiasSat->NumberOfPhaseBiases;
    1661               if (ii >= CLOCKORBIT_NUMBIAS)
    1662                 break;
    1663               phasebiasSat->NumberOfPhaseBiases += 1;
    1664               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L1_CA;
    1665               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1666               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1667               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1668               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1669             }
    1670             else if (pbSig.type == "1P") {
    1671               int ii = phasebiasSat->NumberOfPhaseBiases;
    1672               if (ii >= CLOCKORBIT_NUMBIAS)
    1673                 break;
    1674               phasebiasSat->NumberOfPhaseBiases += 1;
    1675               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L1_P;
    1676               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1677               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1678               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1679               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1680             }
    1681             else if (pbSig.type == "2C") {
    1682               int ii = phasebiasSat->NumberOfPhaseBiases;
    1683               if (ii >= CLOCKORBIT_NUMBIAS)
    1684                 break;
    1685               phasebiasSat->NumberOfPhaseBiases += 1;
    1686               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L2_CA;
    1687               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1688               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1689               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1690               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1691             }
    1692             else if (pbSig.type == "2P") {
    1693               int ii = phasebiasSat->NumberOfPhaseBiases;
    1694               if (ii >= CLOCKORBIT_NUMBIAS)
    1695                 break;
    1696               phasebiasSat->NumberOfPhaseBiases += 1;
    1697               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L2_P;
    1698               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1699               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1700               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1701               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1702             }
    1703             else if (pbSig.type == "4A") {
    1704               int ii = phasebiasSat->NumberOfPhaseBiases;
    1705               if (ii >= CLOCKORBIT_NUMBIAS)
    1706                 break;
    1707               phasebiasSat->NumberOfPhaseBiases += 1;
    1708               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L1a_OCd;
    1709               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1710               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1711               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1712               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1713             }
    1714             else if (pbSig.type == "4B") {
    1715               int ii = phasebiasSat->NumberOfPhaseBiases;
    1716               if (ii >= CLOCKORBIT_NUMBIAS)
    1717                 break;
    1718               phasebiasSat->NumberOfPhaseBiases += 1;
    1719               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L1a_OCp;
    1720               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1721               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1722               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1723               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1724             }
    1725 #ifdef USE_SSR_RTCM
    1726             else if (pbSig.type == "4X") {
    1727               int ii = phasebiasSat->NumberOfPhaseBiases;
    1728               if (ii >= CLOCKORBIT_NUMBIAS)
    1729                 break;
    1730               phasebiasSat->NumberOfPhaseBiases += 1;
    1731               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L1a_OCdp;
    1732               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1733               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1734               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1735               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1736             }
    1737 #endif
    1738             else if (pbSig.type == "6A") {
    1739               int ii = phasebiasSat->NumberOfPhaseBiases;
    1740               if (ii >= CLOCKORBIT_NUMBIAS)
    1741                 break;
    1742               phasebiasSat->NumberOfPhaseBiases += 1;
    1743               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L2a_CSI;
    1744               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1745               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1746               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1747               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1748             }
    1749             else if (pbSig.type == "6B") {
    1750               int ii = phasebiasSat->NumberOfPhaseBiases;
    1751               if (ii >= CLOCKORBIT_NUMBIAS)
    1752                 break;
    1753               phasebiasSat->NumberOfPhaseBiases += 1;
    1754               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L2a_OCp;
    1755               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1756               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1757               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1758               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1759             }
    1760 #ifdef USE_SSR_RTCM
    1761             else if (pbSig.type == "6X") {
    1762               int ii = phasebiasSat->NumberOfPhaseBiases;
    1763               if (ii >= CLOCKORBIT_NUMBIAS)
    1764                 break;
    1765               phasebiasSat->NumberOfPhaseBiases += 1;
    1766               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L2a_CSIOCp;
    1767               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1768               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1769               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1770               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1771             }
    1772 #endif
    1773             else if (pbSig.type == "3I") {
    1774               int ii = phasebiasSat->NumberOfPhaseBiases;
    1775               if (ii >= CLOCKORBIT_NUMBIAS)
    1776                 break;
    1777               phasebiasSat->NumberOfPhaseBiases += 1;
    1778               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L3_I;
    1779               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1780               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1781               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1782               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1783             }
    1784             else if (pbSig.type == "3Q") {
    1785               int ii = phasebiasSat->NumberOfPhaseBiases;
    1786               if (ii >= CLOCKORBIT_NUMBIAS)
    1787                 break;
    1788               phasebiasSat->NumberOfPhaseBiases += 1;
    1789               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L3_Q;
    1790               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1791               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1792               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1793               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1794             }
    1795 #ifdef USE_SSR_RTCM
    1796             else if (pbSig.type == "3X") {
    1797               int ii = phasebiasSat->NumberOfPhaseBiases;
    1798               if (ii >= CLOCKORBIT_NUMBIAS)
    1799                 break;
    1800               phasebiasSat->NumberOfPhaseBiases += 1;
    1801               phasebiasSat->Biases[ii].Type = CODETYPEGLONASS_L3_IQ;
    1802               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1803               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1804               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1805               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1806             }
    1807 #endif
    1808           }
    1809         }
    1810         if (prn.system() == 'E') {
    1811           QListIterator<phaseBiasSignal> it(phaseBiasList);
    1812           while (it.hasNext()) {
    1813             const phaseBiasSignal &pbSig = it.next();
    1814             if (pbSig.type == "1A") {
    1815               int ii = phasebiasSat->NumberOfPhaseBiases;
    1816               if (ii >= CLOCKORBIT_NUMBIAS)
    1817                 break;
    1818               phasebiasSat->NumberOfPhaseBiases += 1;
    1819               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E1_A;
    1820               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1821               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1822               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1823               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1824             }
    1825             else if (pbSig.type == "1B") {
    1826               int ii = phasebiasSat->NumberOfPhaseBiases;
    1827               if (ii >= CLOCKORBIT_NUMBIAS)
    1828                 break;
    1829               phasebiasSat->NumberOfPhaseBiases += 1;
    1830               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E1_B;
    1831               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1832               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1833               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1834               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1835             }
    1836             else if (pbSig.type == "1C") {
    1837               int ii = phasebiasSat->NumberOfPhaseBiases;
    1838               if (ii >= CLOCKORBIT_NUMBIAS)
    1839                 break;
    1840               phasebiasSat->NumberOfPhaseBiases += 1;
    1841               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E1_C;
    1842               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1843               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1844               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1845               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1846             }
    1847 #ifdef USE_SSR_RTCM
    1848             else if (pbSig.type == "1X") {
    1849               int ii = phasebiasSat->NumberOfPhaseBiases;
    1850               if (ii >= CLOCKORBIT_NUMBIAS)
    1851                 break;
    1852               phasebiasSat->NumberOfPhaseBiases += 1;
    1853               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E1_BC;
    1854               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1855               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1856               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1857               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1858             }
    1859             else if (pbSig.type == "1Z") {
    1860               int ii = phasebiasSat->NumberOfPhaseBiases;
    1861               if (ii >= CLOCKORBIT_NUMBIAS)
    1862                 break;
    1863               phasebiasSat->NumberOfPhaseBiases += 1;
    1864               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E1_ABC;
    1865               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1866               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1867               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1868               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1869             }
    1870 #endif
    1871             else if (pbSig.type == "5I") {
    1872               int ii = phasebiasSat->NumberOfPhaseBiases;
    1873               if (ii >= CLOCKORBIT_NUMBIAS)
    1874                 break;
    1875               phasebiasSat->NumberOfPhaseBiases += 1;
    1876               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5A_I;
    1877               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1878               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1879               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1880               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1881             }
    1882             else if (pbSig.type == "5Q") {
    1883               int ii = phasebiasSat->NumberOfPhaseBiases;
    1884               if (ii >= CLOCKORBIT_NUMBIAS)
    1885                 break;
    1886               phasebiasSat->NumberOfPhaseBiases += 1;
    1887               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5A_Q;
    1888               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1889               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1890               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1891               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1892             }
    1893 #ifdef USE_SSR_RTCM
    1894             else if (pbSig.type == "5X") {
    1895               int ii = phasebiasSat->NumberOfPhaseBiases;
    1896               if (ii >= CLOCKORBIT_NUMBIAS)
    1897                 break;
    1898               phasebiasSat->NumberOfPhaseBiases += 1;
    1899               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5A_IQ;
    1900               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1901               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1902               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1903               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1904             }
    1905 #endif
    1906             else if (pbSig.type == "7I") {
    1907               int ii = phasebiasSat->NumberOfPhaseBiases;
    1908               if (ii >= CLOCKORBIT_NUMBIAS)
    1909                 break;
    1910               phasebiasSat->NumberOfPhaseBiases += 1;
    1911               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5B_I;
    1912               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1913               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1914               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1915               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1916             }
    1917             else if (pbSig.type == "7Q") {
    1918               int ii = phasebiasSat->NumberOfPhaseBiases;
    1919               if (ii >= CLOCKORBIT_NUMBIAS)
    1920                 break;
    1921               phasebiasSat->NumberOfPhaseBiases += 1;
    1922               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5B_Q;
    1923               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1924               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1925               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1926               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1927             }
    1928 #ifdef USE_SSR_RTCM
    1929             else if (pbSig.type == "7X") {
    1930               int ii = phasebiasSat->NumberOfPhaseBiases;
    1931               if (ii >= CLOCKORBIT_NUMBIAS)
    1932                 break;
    1933               phasebiasSat->NumberOfPhaseBiases += 1;
    1934               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5B_IQ;
    1935               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1936               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1937               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1938               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1939             }
    1940             else if (pbSig.type == "8I") {
    1941               int ii = phasebiasSat->NumberOfPhaseBiases;
    1942               if (ii >= CLOCKORBIT_NUMBIAS)
    1943                 break;
    1944               phasebiasSat->NumberOfPhaseBiases += 1;
    1945               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5_I;
    1946               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1947               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1948               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1949               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1950             }
    1951             else if (pbSig.type == "8Q") {
    1952               int ii = phasebiasSat->NumberOfPhaseBiases;
    1953               if (ii >= CLOCKORBIT_NUMBIAS)
    1954                 break;
    1955               phasebiasSat->NumberOfPhaseBiases += 1;
    1956               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5_Q;
    1957               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1958               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1959               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1960               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1961             }
    1962             else if (pbSig.type == "8X") {
    1963               int ii = phasebiasSat->NumberOfPhaseBiases;
    1964               if (ii >= CLOCKORBIT_NUMBIAS)
    1965                 break;
    1966               phasebiasSat->NumberOfPhaseBiases += 1;
    1967               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E5_IQ;
    1968               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1969               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1970               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1971               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1972             }
    1973 #endif
    1974             else if (pbSig.type == "6A") {
    1975               int ii = phasebiasSat->NumberOfPhaseBiases;
    1976               if (ii >= CLOCKORBIT_NUMBIAS)
    1977                 break;
    1978               phasebiasSat->NumberOfPhaseBiases += 1;
    1979               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E6_A;
    1980               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1981               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1982               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1983               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1984             }
    1985             else if (pbSig.type == "6B") {
    1986               int ii = phasebiasSat->NumberOfPhaseBiases;
    1987               if (ii >= CLOCKORBIT_NUMBIAS)
    1988                 break;
    1989               phasebiasSat->NumberOfPhaseBiases += 1;
    1990               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E6_B;
    1991               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    1992               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    1993               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    1994               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    1995             }
    1996             else if (pbSig.type == "6C") {
    1997               int ii = phasebiasSat->NumberOfPhaseBiases;
    1998               if (ii >= CLOCKORBIT_NUMBIAS)
    1999                 break;
    2000               phasebiasSat->NumberOfPhaseBiases += 1;
    2001               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E6_C;
    2002               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2003               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2004               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2005               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2006             }
    2007 #ifdef USE_SSR_RTCM
    2008             else if (pbSig.type == "6X") {
    2009               int ii = phasebiasSat->NumberOfPhaseBiases;
    2010               if (ii >= CLOCKORBIT_NUMBIAS)
    2011                 break;
    2012               phasebiasSat->NumberOfPhaseBiases += 1;
    2013               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E6_BC;
    2014               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2015               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2016               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2017               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2018             }
    2019             else if (pbSig.type == "6Z") {
    2020               int ii = phasebiasSat->NumberOfPhaseBiases;
    2021               if (ii >= CLOCKORBIT_NUMBIAS)
    2022                 break;
    2023               phasebiasSat->NumberOfPhaseBiases += 1;
    2024               phasebiasSat->Biases[ii].Type = CODETYPEGALILEO_E6_ABC;
    2025               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2026               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2027               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2028               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2029             }
    2030 #endif
    2031           }
    2032         }
    2033         if (prn.system() == 'J') {
    2034           QListIterator<phaseBiasSignal> it(phaseBiasList);
    2035           while (it.hasNext()) {
    2036             const phaseBiasSignal &pbSig = it.next();
    2037             if (pbSig.type == "1C") {
    2038               int ii = phasebiasSat->NumberOfPhaseBiases;
    2039               if (ii >= CLOCKORBIT_NUMBIAS)
    2040                 break;
    2041               phasebiasSat->NumberOfPhaseBiases += 1;
    2042               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L1_CA;
    2043               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2044               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2045               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2046               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2047             }
    2048             else if (pbSig.type == "1S") {
    2049               int ii = phasebiasSat->NumberOfPhaseBiases;
    2050               if (ii >= CLOCKORBIT_NUMBIAS)
    2051                 break;
    2052               phasebiasSat->NumberOfPhaseBiases += 1;
    2053               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L1C_D;
    2054               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2055               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2056               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2057             }
    2058             else if (pbSig.type == "1L") {
    2059               int ii = phasebiasSat->NumberOfPhaseBiases;
    2060               if (ii >= CLOCKORBIT_NUMBIAS)
    2061                 break;
    2062               phasebiasSat->NumberOfPhaseBiases += 1;
    2063               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L1C_P;
    2064               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2065               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2066               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2067               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2068             }
    2069             else if (pbSig.type == "2S") {
    2070               int ii = phasebiasSat->NumberOfPhaseBiases;
    2071               if (ii >= CLOCKORBIT_NUMBIAS)
    2072                 break;
    2073               phasebiasSat->NumberOfPhaseBiases += 1;
    2074               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L2C_M;
    2075               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2076               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2077               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2078               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2079             }
    2080             else if (pbSig.type == "2L") {
    2081               int ii = phasebiasSat->NumberOfPhaseBiases;
    2082               if (ii >= CLOCKORBIT_NUMBIAS)
    2083                 break;
    2084               phasebiasSat->NumberOfPhaseBiases += 1;
    2085               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L2C_L;
    2086               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2087               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2088               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2089               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2090             }
    2091 #ifdef USE_SSR_RTCM
    2092             else if (pbSig.type == "2X") {
    2093               int ii = phasebiasSat->NumberOfPhaseBiases;
    2094               if (ii >= CLOCKORBIT_NUMBIAS)
    2095                 break;
    2096               phasebiasSat->NumberOfPhaseBiases += 1;
    2097               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L2C_ML;
    2098               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2099               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2100               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2101             }
    2102 #endif
    2103             else if (pbSig.type == "5I") {
    2104               int ii = phasebiasSat->NumberOfPhaseBiases;
    2105               if (ii >= CLOCKORBIT_NUMBIAS)
    2106                 break;
    2107               phasebiasSat->NumberOfPhaseBiases += 1;
    2108               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L5_I;
    2109               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2110               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2111               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2112               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2113             }
    2114             else if (pbSig.type == "5Q") {
    2115               int ii = phasebiasSat->NumberOfPhaseBiases;
    2116               if (ii >= CLOCKORBIT_NUMBIAS)
    2117                 break;
    2118               phasebiasSat->NumberOfPhaseBiases += 1;
    2119               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L5_Q;
    2120               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2121               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2122               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2123               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2124             }
    2125 #ifdef USE_SSR_RTCM
    2126             else if (pbSig.type == "5X") {
    2127               int ii = phasebiasSat->NumberOfPhaseBiases;
    2128               if (ii >= CLOCKORBIT_NUMBIAS)
    2129                 break;
    2130               phasebiasSat->NumberOfPhaseBiases += 1;
    2131               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L5_IQ;
    2132               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2133               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2134               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2135               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2136             }
    2137 #endif
    2138             else if (pbSig.type == "6S") {
    2139               int ii = phasebiasSat->NumberOfPhaseBiases;
    2140               if (ii >= CLOCKORBIT_NUMBIAS)
    2141                 break;
    2142               phasebiasSat->NumberOfPhaseBiases += 1;
    2143               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L6_D;
    2144               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2145               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2146               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2147               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2148             }
    2149             else if (pbSig.type == "6L") {
    2150               int ii = phasebiasSat->NumberOfPhaseBiases;
    2151               if (ii >= CLOCKORBIT_NUMBIAS)
    2152                 break;
    2153               phasebiasSat->NumberOfPhaseBiases += 1;
    2154               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L6_P;
    2155               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2156               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2157               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2158               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2159             }
    2160 #ifdef USE_SSR_RTCM
    2161             else if (pbSig.type == "6X") {
    2162               int ii = phasebiasSat->NumberOfPhaseBiases;
    2163               if (ii >= CLOCKORBIT_NUMBIAS)
    2164                 break;
    2165               phasebiasSat->NumberOfPhaseBiases += 1;
    2166               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L6_DP;
    2167               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2168               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2169               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2170               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2171             }
    2172                         else if (pbSig.type == "1X") {
    2173               int ii = phasebiasSat->NumberOfPhaseBiases;
    2174               if (ii >= CLOCKORBIT_NUMBIAS)
    2175                 break;
    2176               phasebiasSat->NumberOfPhaseBiases += 1;
    2177               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L1C_DP;
    2178               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2179               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2180               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2181               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2182             }
    2183             else if (pbSig.type == "1Z") {
    2184               int ii = phasebiasSat->NumberOfPhaseBiases;
    2185               if (ii >= CLOCKORBIT_NUMBIAS)
    2186                 break;
    2187               phasebiasSat->NumberOfPhaseBiases += 1;
    2188               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L1_S;
    2189               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2190               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2191               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2192               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2193             }
    2194             else if (pbSig.type == "5D") {
    2195               int ii = phasebiasSat->NumberOfPhaseBiases;
    2196               if (ii >= CLOCKORBIT_NUMBIAS)
    2197                 break;
    2198               phasebiasSat->NumberOfPhaseBiases += 1;
    2199               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L5_D;
    2200               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2201               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2202               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2203               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2204             }
    2205             else if (pbSig.type == "5P") {
    2206               int ii = phasebiasSat->NumberOfPhaseBiases;
    2207               if (ii >= CLOCKORBIT_NUMBIAS)
    2208                 break;
    2209               phasebiasSat->NumberOfPhaseBiases += 1;
    2210               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L5_P;
    2211               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2212               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2213               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2214               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2215             }
    2216             else if (pbSig.type == "5Z") {
    2217               int ii = phasebiasSat->NumberOfPhaseBiases;
    2218               if (ii >= CLOCKORBIT_NUMBIAS)
    2219                 break;
    2220               phasebiasSat->NumberOfPhaseBiases += 1;
    2221               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L5_DP;
    2222               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2223               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2224               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2225               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2226             }
    2227 #endif
    2228             else if (pbSig.type == "6E") {
    2229               int ii = phasebiasSat->NumberOfPhaseBiases;
    2230               if (ii >= CLOCKORBIT_NUMBIAS)
    2231                 break;
    2232               phasebiasSat->NumberOfPhaseBiases += 1;
    2233               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L6_E;
    2234               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2235               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2236               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2237               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2238             }
    2239 #ifdef USE_SSR_RTCM
    2240             else if (pbSig.type == "6Z") {
    2241               int ii = phasebiasSat->NumberOfPhaseBiases;
    2242               if (ii >= CLOCKORBIT_NUMBIAS)
    2243                 break;
    2244               phasebiasSat->NumberOfPhaseBiases += 1;
    2245               phasebiasSat->Biases[ii].Type = CODETYPEQZSS_L6_DE;
    2246               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2247               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2248               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2249               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2250             }
    2251 #endif
    2252           }
    2253         }
    2254         if (prn.system() == 'S') {
    2255           QListIterator<phaseBiasSignal> it(phaseBiasList);
    2256           while (it.hasNext()) {
    2257             const phaseBiasSignal &pbSig = it.next();
    2258             if (pbSig.type == "1C") {
    2259               int ii = phasebiasSat->NumberOfPhaseBiases;
    2260               if (ii >= CLOCKORBIT_NUMBIAS)
    2261                 break;
    2262               phasebiasSat->NumberOfPhaseBiases += 1;
    2263               phasebiasSat->Biases[ii].Type = CODETYPE_SBAS_L1_CA;
    2264               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2265               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2266               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2267               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2268             }
    2269             else if (pbSig.type == "5I") {
    2270               int ii = phasebiasSat->NumberOfPhaseBiases;
    2271               if (ii >= CLOCKORBIT_NUMBIAS)
    2272                 break;
    2273               phasebiasSat->NumberOfPhaseBiases += 1;
    2274               phasebiasSat->Biases[ii].Type = CODETYPE_SBAS_L5_I;
    2275               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2276               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2277               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2278             }
    2279             else if (pbSig.type == "5Q") {
    2280               int ii = phasebiasSat->NumberOfPhaseBiases;
    2281               if (ii >= CLOCKORBIT_NUMBIAS)
    2282                 break;
    2283               phasebiasSat->NumberOfPhaseBiases += 1;
    2284               phasebiasSat->Biases[ii].Type = CODETYPE_SBAS_L5_Q;
    2285               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2286               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2287               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2288               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2289             }
    2290 #ifdef USE_SSR_RTCM
    2291             else if (pbSig.type == "5X") {
    2292               int ii = phasebiasSat->NumberOfPhaseBiases;
    2293               if (ii >= CLOCKORBIT_NUMBIAS)
    2294                 break;
    2295               phasebiasSat->NumberOfPhaseBiases += 1;
    2296               phasebiasSat->Biases[ii].Type = CODETYPE_SBAS_L5_IQ;
    2297               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2298               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2299               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2300               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2301             }
    2302 #endif
    2303           }
    2304         }
    2305         if (prn.system() == 'C') {
    2306           QListIterator<phaseBiasSignal> it(phaseBiasList);
    2307           while (it.hasNext()) {
    2308             const phaseBiasSignal &pbSig = it.next();
    2309             if (pbSig.type == "2I") {
    2310               int ii = phasebiasSat->NumberOfPhaseBiases;
    2311               if (ii >= CLOCKORBIT_NUMBIAS)
    2312                 break;
    2313               phasebiasSat->NumberOfPhaseBiases += 1;
    2314               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1_I;
    2315               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2316               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2317               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2318               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2319             }
    2320             else if (pbSig.type == "2Q") {
    2321               int ii = phasebiasSat->NumberOfPhaseBiases;
    2322               if (ii >= CLOCKORBIT_NUMBIAS)
    2323                 break;
    2324               phasebiasSat->NumberOfPhaseBiases += 1;
    2325               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1_Q;
    2326               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2327               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2328               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2329               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2330             }
    2331 #ifdef USE_SSR_RTCM
    2332             else if (pbSig.type == "2X") {
    2333               int ii = phasebiasSat->NumberOfPhaseBiases;
    2334               if (ii >= CLOCKORBIT_NUMBIAS)
    2335                 break;
    2336               phasebiasSat->NumberOfPhaseBiases += 1;
    2337               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1_IQ;
    2338               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2339               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2340               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2341               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2342             }
    2343 #endif
    2344             else if (pbSig.type == "6I") {
    2345               int ii = phasebiasSat->NumberOfPhaseBiases;
    2346               if (ii >= CLOCKORBIT_NUMBIAS)
    2347                 break;
    2348               phasebiasSat->NumberOfPhaseBiases += 1;
    2349               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B3_I;
    2350               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2351               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2352               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2353               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2354             }
    2355             else if (pbSig.type == "6Q") {
    2356               int ii = phasebiasSat->NumberOfPhaseBiases;
    2357               if (ii >= CLOCKORBIT_NUMBIAS)
    2358                 break;
    2359               phasebiasSat->NumberOfPhaseBiases += 1;
    2360               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B3_Q;
    2361               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2362               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2363               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2364               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2365             }
    2366 #ifdef USE_SSR_RTCM
    2367             else if (pbSig.type == "6X") {
    2368               int ii = phasebiasSat->NumberOfPhaseBiases;
    2369               if (ii >= CLOCKORBIT_NUMBIAS)
    2370                 break;
    2371               phasebiasSat->NumberOfPhaseBiases += 1;
    2372               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B3_IQ;
    2373               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2374               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2375               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2376               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2377             }
    2378 #endif
    2379             else if (pbSig.type == "7I") {
    2380               int ii = phasebiasSat->NumberOfPhaseBiases;
    2381               if (ii >= CLOCKORBIT_NUMBIAS)
    2382                 break;
    2383               phasebiasSat->NumberOfPhaseBiases += 1;
    2384               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B2_I;
    2385               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2386               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2387               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2388               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2389             }
    2390             else if (pbSig.type == "7Q") {
    2391               int ii = phasebiasSat->NumberOfPhaseBiases;
    2392               if (ii >= CLOCKORBIT_NUMBIAS)
    2393                 break;
    2394               phasebiasSat->NumberOfPhaseBiases += 1;
    2395               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B2_Q;
    2396               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2397               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    2398               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2399               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2400             }
    2401 #ifdef USE_SSR_RTCM
    2402             else if (pbSig.type == "7X") {
    2403               int ii = phasebiasSat->NumberOfPhaseBiases;
    2404               if (ii >= CLOCKORBIT_NUMBIAS)
    2405                 break;
    2406               phasebiasSat->NumberOfPhaseBiases += 1;
    2407               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B2_IQ;
    2408               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2409               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2410               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2411             }
    2412 #endif
    2413             else if (pbSig.type == "1D") {
    2414               int ii = phasebiasSat->NumberOfPhaseBiases;
    2415               if (ii >= CLOCKORBIT_NUMBIAS)
    2416                 break;
    2417               phasebiasSat->NumberOfPhaseBiases += 1;
    2418               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1a_D;
    2419               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2420               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2421               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2422             }
    2423             else if (pbSig.type == "1P") {
    2424               int ii = phasebiasSat->NumberOfPhaseBiases;
    2425               if (ii >= CLOCKORBIT_NUMBIAS)
    2426                 break;
    2427               phasebiasSat->NumberOfPhaseBiases += 1;
    2428               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1a_P;
    2429               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2430               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2431               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2432             }
    2433 #ifdef USE_SSR_RTCM
    2434             else if (pbSig.type == "1X") {
    2435               int ii = phasebiasSat->NumberOfPhaseBiases;
    2436               if (ii >= CLOCKORBIT_NUMBIAS)
    2437                 break;
    2438               phasebiasSat->NumberOfPhaseBiases += 1;
    2439               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1a_DP;
    2440               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2441               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2442               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2443             }
    2444 #endif
    2445             else if (pbSig.type == "5D") {
    2446               int ii = phasebiasSat->NumberOfPhaseBiases;
    2447               if (ii >= CLOCKORBIT_NUMBIAS)
    2448                 break;
    2449               phasebiasSat->NumberOfPhaseBiases += 1;
    2450               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B2a_D;
    2451               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2452               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2453               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2454             }
    2455             else if (pbSig.type == "5P") {
    2456               int ii = phasebiasSat->NumberOfPhaseBiases;
    2457               if (ii >= CLOCKORBIT_NUMBIAS)
    2458                 break;
    2459               phasebiasSat->NumberOfPhaseBiases += 1;
    2460               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B2a_P;
    2461               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2462               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2463               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2464             }
    2465 #ifdef USE_SSR_RTCM
    2466             else if (pbSig.type == "5X") {
    2467               int ii = phasebiasSat->NumberOfPhaseBiases;
    2468               if (ii >= CLOCKORBIT_NUMBIAS)
    2469                 break;
    2470               phasebiasSat->NumberOfPhaseBiases += 1;
    2471               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B2a_DP;
    2472               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2473               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2474               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2475             }
    2476 #elif USE_SSR_IGS
    2477             else if (pbSig.type == "1A") {
    2478               int ii = phasebiasSat->NumberOfPhaseBiases;
    2479               if (ii >= CLOCKORBIT_NUMBIAS)
    2480                 break;
    2481               phasebiasSat->NumberOfPhaseBiases += 1;
    2482               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1_A;
    2483               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2484               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2485               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2486             }
    2487             else if (pbSig.type == "6A") {
    2488               int ii = phasebiasSat->NumberOfPhaseBiases;
    2489               if (ii >= CLOCKORBIT_NUMBIAS)
    2490                 break;
    2491               phasebiasSat->NumberOfPhaseBiases += 1;
    2492               phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B3_A;
    2493               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    2494               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    2495               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    2496             }
    2497 #endif
    2498           }
    2499         }
    2500       }
    2501     }
    2502   }
    2503 
     710        QListIterator<phaseBiasSignal> it(phaseBiasList);
     711        while (it.hasNext()) {
     712          const phaseBiasSignal &pbSig = it.next();
     713          int ii = phasebiasSat->NumberOfPhaseBiases;
     714          if (ii >= CLOCKORBIT_NUMBIAS)
     715            break;
     716          SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), pbSig.type.toStdString());
     717          if (type != _ssrCorr->RESERVED) {
     718            phasebiasSat->NumberOfPhaseBiases += 1;
     719            phasebiasSat->Biases[ii].Type = type;
     720            phasebiasSat->Biases[ii].Bias = pbSig.bias;
     721            phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
     722            phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
     723            phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
     724          }
     725        }
     726      }
     727    }
     728  }
    2504729
    2505730  QByteArray hlpBufferCo;
     
    2515740        || co.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
    2516741      char obuffer[CLOCKORBIT_BUFFERSIZE];
    2517       int len = MakeClockOrbit(&co, COTYPE_AUTO, 0, obuffer, sizeof(obuffer));
     742      int len = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_AUTO, 0, obuffer, sizeof(obuffer));
    2518743      if (len > 0) {
    2519744        hlpBufferCo = QByteArray(obuffer, len);
     
    2529754      if (fmod(epoTime.gpssec(), _samplRtcmEphCorr) == 0.0) {
    2530755        co.UpdateInterval = ephUpdInd;
    2531         int len1 = MakeClockOrbit(&co, COTYPE_GPSORBIT, 1, obuffer,
     756        int len1 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_GPSORBIT, 1, obuffer,
    2532757            sizeof(obuffer));
    2533758        co.UpdateInterval = clkUpdInd;
     
    2541766                  co.NumberOfSat[CLOCKORBIT_SATSBAS]    > 0 ||
    2542767                  co.NumberOfSat[CLOCKORBIT_SATBDS]     > 0   ) ? 1 : 0;
    2543       int len2 = MakeClockOrbit(&co, COTYPE_GPSCLOCK, mmsg, obuffer,
     768      int len2 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_GPSCLOCK, mmsg, obuffer,
    2544769          sizeof(obuffer));
    2545770      if (len2 > 0) {
     
    2551776      if (fmod(epoTime.gpssec(), _samplRtcmEphCorr) == 0.0) {
    2552777        co.UpdateInterval = ephUpdInd;
    2553         int len1 = MakeClockOrbit(&co, COTYPE_GLONASSORBIT, 1, obuffer,
     778        int len1 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_GLONASSORBIT, 1, obuffer,
    2554779            sizeof(obuffer));
    2555780        co.UpdateInterval = clkUpdInd;
     
    2562787                  co.NumberOfSat[CLOCKORBIT_SATSBAS]    > 0 ||
    2563788                  co.NumberOfSat[CLOCKORBIT_SATBDS]     > 0   ) ? 1 : 0;
    2564       int len2 = MakeClockOrbit(&co, COTYPE_GLONASSCLOCK, mmsg, obuffer,
     789      int len2 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_GLONASSCLOCK, mmsg, obuffer,
    2565790          sizeof(obuffer));
    2566791      if (len2 > 0) {
     
    2572797      if (fmod(epoTime.gpssec(), _samplRtcmEphCorr) == 0.0) {
    2573798        co.UpdateInterval = ephUpdInd;
    2574         int len1 = MakeClockOrbit(&co, COTYPE_GALILEOORBIT, 1, obuffer,
     799        int len1 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_GALILEOORBIT, 1, obuffer,
    2575800            sizeof(obuffer));
    2576801        co.UpdateInterval = clkUpdInd;
     
    2582807                  co.NumberOfSat[CLOCKORBIT_SATSBAS]    > 0 ||
    2583808                  co.NumberOfSat[CLOCKORBIT_SATBDS]     > 0   ) ? 1 : 0;
    2584       int len2 = MakeClockOrbit(&co, COTYPE_GALILEOCLOCK, mmsg, obuffer,
     809      int len2 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_GALILEOCLOCK, mmsg, obuffer,
    2585810          sizeof(obuffer));
    2586811      if (len2 > 0) {
     
    2592817      if (fmod(epoTime.gpssec(), _samplRtcmEphCorr) == 0.0) {
    2593818        co.UpdateInterval = ephUpdInd;
    2594         int len1 = MakeClockOrbit(&co, COTYPE_QZSSORBIT, 1, obuffer,
     819        int len1 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_QZSSORBIT, 1, obuffer,
    2595820            sizeof(obuffer));
    2596821        co.UpdateInterval = clkUpdInd;
     
    2601826      int mmsg = (co.NumberOfSat[CLOCKORBIT_SATSBAS]    > 0 ||
    2602827                  co.NumberOfSat[CLOCKORBIT_SATBDS]     > 0   ) ? 1 : 0;
    2603       int len2 = MakeClockOrbit(&co, COTYPE_QZSSCLOCK, mmsg, obuffer,
     828      int len2 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_QZSSCLOCK, mmsg, obuffer,
    2604829          sizeof(obuffer));
    2605830      if (len2 > 0) {
     
    2611836      if (fmod(epoTime.gpssec(), _samplRtcmEphCorr) == 0.0) {
    2612837        co.UpdateInterval = ephUpdInd;
    2613         int len1 = MakeClockOrbit(&co, COTYPE_SBASORBIT, 1, obuffer,
     838        int len1 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_SBASORBIT, 1, obuffer,
    2614839            sizeof(obuffer));
    2615840        co.UpdateInterval = clkUpdInd;
     
    2619844      }
    2620845      int mmsg = (co.NumberOfSat[CLOCKORBIT_SATBDS] > 0) ? 1 : 0;
    2621       int len2 = MakeClockOrbit(&co, COTYPE_SBASCLOCK, mmsg, obuffer,
     846      int len2 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_SBASCLOCK, mmsg, obuffer,
    2622847          sizeof(obuffer));
    2623848      if (len2 > 0) {
     
    2629854      if (fmod(epoTime.gpssec(), _samplRtcmEphCorr) == 0.0) {
    2630855        co.UpdateInterval = ephUpdInd;
    2631         int len1 = MakeClockOrbit(&co, COTYPE_BDSORBIT, 1, obuffer,
     856        int len1 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_BDSORBIT, 1, obuffer,
    2632857            sizeof(obuffer));
    2633858        co.UpdateInterval = clkUpdInd;
     
    2637862      }
    2638863      int mmsg = 0;
    2639       int len2 = MakeClockOrbit(&co, COTYPE_BDSCLOCK, mmsg, obuffer,
     864      int len2 = _ssrCorr->MakeClockOrbit(&co, _ssrCorr->COTYPE_BDSCLOCK, mmsg, obuffer,
    2640865          sizeof(obuffer));
    2641866      if (len2 > 0) {
     
    2655880      || bias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
    2656881    char obuffer[CLOCKORBIT_BUFFERSIZE];
    2657     int len = MakeCodeBias(&bias, CBTYPE_AUTO, 0, obuffer, sizeof(obuffer));
     882    int len = _ssrCorr->MakeCodeBias(&bias, _ssrCorr->CBTYPE_AUTO, 0, obuffer, sizeof(obuffer));
    2658883    if (len > 0) {
    2659884      hlpBufferBias = QByteArray(obuffer, len);
     
    2671896      || phasebias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
    2672897    char obuffer[CLOCKORBIT_BUFFERSIZE];
    2673     int len = MakePhaseBias(&phasebias, PBTYPE_AUTO, 0, obuffer,
     898    int len = _ssrCorr->MakePhaseBias(&phasebias, _ssrCorr->PBTYPE_AUTO, 0, obuffer,
    2674899        sizeof(obuffer));
    2675900    if (len > 0) {
     
    2683908  if (vtec.NumLayers > 0) {
    2684909    char obuffer[CLOCKORBIT_BUFFERSIZE];
    2685     int len = MakeVTEC(&vtec, 0, obuffer, sizeof(obuffer));
     910    int len = _ssrCorr->MakeVTEC(&vtec, 0, obuffer, sizeof(obuffer));
    2686911    if (len > 0) {
    2687912      hlpBufferVtec = QByteArray(obuffer, len);
     
    2699924    double rtnUra, const ColumnVector& rtnClk, const ColumnVector& rtnVel,
    2700925    const ColumnVector& rtnCoM, const ColumnVector& rtnClkSig,
    2701     struct ClockOrbit::SatData* sd, QString& outLine) {
     926    struct SsrCorr::ClockOrbit::SatData* sd, QString& outLine) {
    2702927
    2703928  // Broadcast Position and Velocity
  • branches/BNC_2.12/src/upload/bncrtnetuploadcaster.h

    r8989 r9036  
    66#include "bnctime.h"
    77#include "ephemeris.h"
    8 extern "C" {
    9 #ifdef USE_SSR_RTCM
    108#include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h"
    11 #elif  USE_SSR_IGS
    129#include "../RTCM3/clock_and_orbit/clock_orbit_igs.h"
    13 #endif
    14 }
    1510
    1611class bncEphUser;
     
    2520                  const QString& outHost, int outPort,
    2621                  const QString& password,
    27                   const QString& crdTrafo, bool  CoM,
     22                  const QString& crdTrafo, const QString& ssrFormat,
     23                  bool  CoM,
    2824                  const QString& sp3FileName,
    2925                  const QString& rnxFileName,
     
    4137                        const ColumnVector& rtnCoM,
    4238                        const ColumnVector& rtnClkSig,
    43                         struct ClockOrbit::SatData* sd,
     39                        struct SsrCorr::ClockOrbit::SatData* sd,
    4440                        QString& outLine);
    4541  void crdTrafo(int GPSWeek, ColumnVector& xyz, double& dc);
     
    5147  QString        _rtnetStreamBuffer;
    5248  QString        _crdTrafo;
     49  SsrCorr*       _ssrCorr;
     50  QString        _ssrFormat;
    5351  bool           _CoM;
    5452  int            _PID;
Note: See TracChangeset for help on using the changeset viewer.