Changeset 9025 in ntrip


Ignore:
Timestamp:
Aug 25, 2020, 11:02:49 PM (4 weeks ago)
Author:
stuerze
Message:

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

Location:
trunk/BNC/src
Files:
3 added
2 deleted
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/BNC/src/RTCM3/RTCM3Decoder.cpp

    r9011 r9025  
    16311631       * else. */
    16321632      if ((id >= 1057 && id <= 1068) ||
    1633           (id >= 1240 && id <= 1270) ||
    1634                   (id == 4076)) {
     1633            (id >= 1240 && id <= 1270) ||
     1634                      (id == 4076)) {
     1635        RTCM3coDecoder::e_type type = RTCM3coDecoder::e_type::RTCMssr;
     1636        if (id == 4076) {
     1637          type = RTCM3coDecoder::e_type::IGSssr;
     1638        }
    16351639        if (!_coDecoders.contains(_staID.toLatin1()))
    1636           _coDecoders[_staID.toLatin1()] = new RTCM3coDecoder(_staID);
     1640          _coDecoders[_staID.toLatin1()] = new RTCM3coDecoder(_staID, type);
    16371641        RTCM3coDecoder* coDecoder = _coDecoders[_staID.toLatin1()];
    16381642        if (coDecoder->Decode(reinterpret_cast<char *>(_Message), _BlockSize,
     
    17191723uint32_t RTCM3Decoder::CRC24(long size, const unsigned char *buf) {
    17201724  uint32_t crc = 0;
    1721   int i;
    1722 
     1725  int ii;
    17231726  while (size--) {
    17241727    crc ^= (*buf++) << (16);
    1725     for (i = 0; i < 8; i++)
    1726         {
     1728    for (ii = 0; ii < 8; ii++) {
    17271729      crc <<= 1;
    17281730      if (crc & 0x1000000)
  • trunk/BNC/src/RTCM3/RTCM3coDecoder.cpp

    r8981 r9025  
    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._yawRate = _phaseBias.Sat[ii].YawRate;
    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 };
  • trunk/BNC/src/RTCM3/RTCM3coDecoder.h

    r8969 r9025  
    3333
    3434#include "GPSDecoder.h"
     35#include "../RTCM3/clock_and_orbit/clock_orbit_igs.h"
     36#include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h"
    3537
    36 extern "C" {
    37 #ifdef USE_SSR_RTCM
    38 #include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h"
    39 #elif  USE_SSR_IGS
    40 #include "../RTCM3/clock_and_orbit/clock_orbit_igs.h"
    41 #endif
    42 }
     38//class SsrCorr;
    4339
    44 class RTCM3coDecoder : public QObject, public GPSDecoder {
     40  class RTCM3coDecoder : public QObject, public GPSDecoder{
    4541Q_OBJECT
    4642 public:
    47   RTCM3coDecoder(const QString& staID);
     43  enum e_type {RTCMssr, IGSssr};
     44  RTCM3coDecoder(const QString& staID, const e_type type);
    4845  virtual ~RTCM3coDecoder();
    4946  virtual t_irc Decode(char* buffer, int bufLen, std::vector<std::string>& errmsg);
     
    6562  void reopen();
    6663  void checkProviderID();
    67   std::string codeTypeToRnxType(char system, CodeType type) const;
    6864
    6965  std::ofstream*                        _out;
     
    7268  QString                               _fileName;
    7369  QByteArray                            _buffer;
    74   ClockOrbit                            _clkOrb;
    75   CodeBias                              _codeBias;
    76   PhaseBias                             _phaseBias;
    77   VTEC                                  _vTEC;
     70  SsrCorr::ClockOrbit                   _clkOrb;
     71  SsrCorr::CodeBias                     _codeBias;
     72  SsrCorr::PhaseBias                    _phaseBias;
     73  SsrCorr::VTEC                         _vTEC;
    7874  int                                   _providerID[3];
     75  e_type                                _type;
    7976  bncTime                               _lastTime;
     77  SsrCorr*                              _ssrCorr;
    8078  QMap<t_prn, unsigned int>             _IODs;
    8179  QMap<bncTime, QList<t_orbCorr> >      _orbCorrections;
  • trunk/BNC/src/RTCM3/bits.h

    r6812 r9025  
    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) { \
     93int 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; \
  • trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.h

    r8984 r9025  
    44/* Programheader
    55
    6         Name:           clock_orbit_igs.h
    7         Project:        RTCM3
    8         Version:        $Id: clock_orbit_igs.h 8966 2020-07-01 07:48:35Z stuerze $
    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: clock_orbit_igs.h 8966 2020-07-01 07:48:35Z stuerze $
     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 */
  • trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h

    r8982 r9025  
    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: RTCM
    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 */
  • trunk/BNC/src/bncwindow.cpp

    r8936 r9025  
    515515  // Upload Results
    516516  // -------------
    517   _uploadTable = new QTableWidget(0,14);
    518   _uploadTable->setHorizontalHeaderLabels(QString("Host, Port, Mount, Ntrip, User, Password, System, CoM, SP3 File, RNX File, PID, SID, IOD, bytes").split(","));
     517  _uploadTable = new QTableWidget(0,15);
     518  _uploadTable->setHorizontalHeaderLabels(QString("Host, Port, Mount, Ntrip, User, Password, System, Format, CoM, SP3 File, RNX File, PID, SID, IOD, bytes").split(","));
    519519  _uploadTable->setSelectionMode(QAbstractItemView::ExtendedSelection);
    520520  _uploadTable->setSelectionBehavior(QAbstractItemView::SelectRows);
     
    526526  _uploadTable->horizontalHeader()->resizeSection( 5, 8*ww);
    527527  _uploadTable->horizontalHeader()->resizeSection( 6,11*ww);
    528   _uploadTable->horizontalHeader()->resizeSection( 7, 4*ww);
    529   _uploadTable->horizontalHeader()->resizeSection( 8,15*ww);
     528  _uploadTable->horizontalHeader()->resizeSection( 7,11*ww);
     529  _uploadTable->horizontalHeader()->resizeSection( 8, 4*ww);
    530530  _uploadTable->horizontalHeader()->resizeSection( 9,15*ww);
    531   _uploadTable->horizontalHeader()->resizeSection(10, 4*ww);
     531  _uploadTable->horizontalHeader()->resizeSection(10,15*ww);
    532532  _uploadTable->horizontalHeader()->resizeSection(11, 4*ww);
    533533  _uploadTable->horizontalHeader()->resizeSection(12, 4*ww);
    534   _uploadTable->horizontalHeader()->resizeSection(13,12*ww);
     534  _uploadTable->horizontalHeader()->resizeSection(13, 4*ww);
     535  _uploadTable->horizontalHeader()->resizeSection(14,12*ww);
    535536#if QT_VERSION < 0x050000
    536537  _uploadTable->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
     
    18781879    for (int iCol = 0; iCol < _uploadTable->columnCount(); iCol++) {
    18791880      if (_uploadTable->cellWidget(iRow, iCol) &&
    1880           (iCol == 3 || iCol == 4 || iCol == 5 || iCol == 6 || iCol == 7)) {
     1881          (iCol == 3 || iCol == 4 || iCol == 5 || iCol == 6 || iCol == 7 || iCol == 8)) {
    18811882        if       (iCol == 3) {
    18821883          QComboBox* ntripversion = (QComboBox*)(_uploadTable->cellWidget(iRow, iCol));
     
    18961897        }
    18971898        else if (iCol == 7) {
     1899          QComboBox* system = (QComboBox*)(_uploadTable->cellWidget(iRow, iCol));
     1900          hlp += system->currentText() + ",";
     1901        }
     1902        else if (iCol == 8) {
    18981903          QCheckBox* com    = (QCheckBox*)(_uploadTable->cellWidget(iRow, iCol));
    18991904          QString state; state.setNum(com->checkState());
     
    27092714    }
    27102715    else if (iCol == 7) {
     2716      QComboBox* format = new QComboBox();
     2717      format->setEditable(false);
     2718      format->addItems(QString("IGS-SSR,RTCM-SSR").split(","));
     2719      format->setFrame(false);
     2720      _uploadTable->setCellWidget(iRow, iCol, format);
     2721    }
     2722    else if (iCol == 8) {
    27112723      QCheckBox* com = new QCheckBox();
    27122724      _uploadTable->setCellWidget(iRow, iCol, com);
    27132725    }
    2714     else if (iCol == 13) {
     2726    else if (iCol == 14) {
    27152727      bncTableItem* bncIt = new bncTableItem();
    27162728      bncIt->setFlags(bncIt->flags() & ~Qt::ItemIsEditable);
     
    27452757  for (int iRow = 0; iRow < _uploadTable->rowCount(); iRow++) {
    27462758    BNC_CORE->_uploadTableItems[iRow] =
    2747                                 (bncTableItem*) _uploadTable->item(iRow, 13);
     2759                                (bncTableItem*) _uploadTable->item(iRow, 14);
    27482760  }
    27492761  nRows = _uploadTable->rowCount();
     
    28062818      }
    28072819      else if (iCol == 7) {
     2820        QComboBox* format = new QComboBox();
     2821        format->setEditable(false);
     2822        format->addItems(QString("IGS-SSR,RTCM-SSR").split(","));
     2823        format->setFrame(false);
     2824        format->setCurrentIndex(format->findText(hlp[iCol]));
     2825        _uploadTable->setCellWidget(iRow, iCol, format);
     2826      }
     2827      else if (iCol == 8) {
    28082828        QCheckBox* com = new QCheckBox();
    28092829        if (hlp[iCol].toInt() == Qt::Checked) {
     
    28122832        _uploadTable->setCellWidget(iRow, iCol, com);
    28132833      }
    2814       else if (iCol == 13) {
     2834      else if (iCol == 14) {
    28152835        bncTableItem* bncIt = new bncTableItem();
    28162836        bncIt->setFlags(bncIt->flags() & ~Qt::ItemIsEditable);
  • trunk/BNC/src/combination/bnccomb.cpp

    r8901 r9025  
    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
     180
    164181  _rtnetDecoder = 0;
    165182
     
    266283  }
    267284  delete _rtnetDecoder;
     285  if (_ssrCorr) {
     286    delete _ssrCorr;
     287  }
    268288  delete _antex;
    269289  for (int iPar = 1; iPar <= _params.size(); iPar++) {
     
    714734
    715735  QString     outLines;
    716   QStringList corrLines;
     736  //QStringList corrLines;
    717737
    718738  unsigned year, month, day, hour, minute;
     
    770790
    771791    QString line;
    772     int messageType   = COTYPE_GPSCOMBINED;
     792    int messageType   = _ssrCorr->COTYPE_GPSCOMBINED;
    773793    int updateInt     = 0;
    774794    line.sprintf("%d %d %d %.1f %s"
     
    789809                 corr->_orbCorr._dotXr[2],
    790810                 0.0);
    791     corrLines << line;
     811    //corrLines << line;
    792812
    793813    delete corr;
  • trunk/BNC/src/combination/bnccomb.h

    r7299 r9025  
    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
  • trunk/BNC/src/src.pri

    r8969 r9025  
    6363          RTCM3/RTCM3Decoder.h RTCM3/bits.h RTCM3/gnss.h              \
    6464          RTCM3/RTCM3coDecoder.h RTCM3/ephEncoder.h                   \
     65          RTCM3/clock_and_orbit/clock_orbit.h                         \
     66          RTCM3/clock_and_orbit/clock_orbit_igs.h                     \
     67          RTCM3/clock_and_orbit/clock_orbit_rtcm.h                    \
    6568          rinex/rnxobsfile.h                                          \
    6669          rinex/rnxnavfile.h       rinex/corrfile.h                   \
     
    99102          RTCM3/RTCM3Decoder.cpp                                      \
    100103          RTCM3/RTCM3coDecoder.cpp RTCM3/ephEncoder.cpp               \
     104          RTCM3/clock_and_orbit/clock_orbit_igs.cpp                   \
     105          RTCM3/clock_and_orbit/clock_orbit_rtcm.cpp                  \
    101106          rinex/rnxobsfile.cpp                                        \
    102107          rinex/rnxnavfile.cpp     rinex/corrfile.cpp                 \
     
    114119
    115120QT += network
    116 
    117 
    118 # Format of SSR corrections
    119 # -------------------------
    120 DEFINES += USE_SSR_RTCM
    121 #DEFINES += USE_SSR_IGS
    122 contains(DEFINES, USE_SSR_IGS) {
    123   HEADERS += RTCM3/clock_and_orbit/clock_orbit_igs.h
    124   SOURCES += RTCM3/clock_and_orbit/clock_orbit_igs.c
    125 }
    126 else {
    127   HEADERS += RTCM3/clock_and_orbit/clock_orbit_rtcm.h
    128   SOURCES += RTCM3/clock_and_orbit/clock_orbit_rtcm.c
    129 }
    130121
    131122exists(PPP) {
  • trunk/BNC/src/upload/bncrtnetdecoder.cpp

    r8275 r9025  
    5656  while (it.hasNext()) {
    5757    QStringList hlp = it.next().split(",");
    58     if (hlp.size() > 6) {
     58    if (hlp.size() > 8) {
    5959      ++iRow;
    6060      int  outPort = hlp[1].toInt();
    61       bool CoM     = (hlp[7].toInt() == Qt::Checked);
     61      bool CoM     = (hlp[8].toInt() == Qt::Checked);
    6262      int PID = 0;
    63       if (hlp.size() > 10) {
    64         PID = hlp[10].toInt();
     63      if (hlp.size() > 11) {
     64        PID = hlp[11].toInt();
    6565      }
    6666      int SID = 0;
    67       if (hlp.size() > 11) {
    68         SID = hlp[11].toInt();
     67      if (hlp.size() > 12) {
     68        SID = hlp[12].toInt();
    6969      }
    7070      int IOD = 0;
    71       if (hlp.size() > 12) {
    72         IOD = hlp[12].toInt();
     71      if (hlp.size() > 13) {
     72        IOD = hlp[13].toInt();
    7373      }
    7474      bncRtnetUploadCaster* newCaster = new bncRtnetUploadCaster(
    7575                                                       hlp[2], hlp[0], outPort,
    7676                                                       hlp[3], hlp[4],
    77                                                        hlp[5], hlp[6], CoM,
    78                                                        hlp[8], hlp[9],
     77                                                       hlp[5], hlp[6], hlp[7], CoM,
     78                                                       hlp[9], hlp[10],
    7979                                                       PID, SID, IOD, iRow);
    8080      newCaster->start();
  • trunk/BNC/src/upload/bncrtnetuploadcaster.cpp

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

    r8969 r9025  
    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;
     
    1813class bncClockRinex;
    1914class bncSP3;
     15class SsrCorr;
    2016
    2117class bncRtnetUploadCaster : public bncUploadCaster {
     
    2622                  const QString& ntripVersion,
    2723                  const QString& userName,const QString& password,
    28                   const QString& crdTrafo, bool  CoM,
    29                   const QString& sp3FileName,
     24                  const QString& crdTrafo, const QString& ssrFormat,
     25                  bool  CoM, const QString& sp3FileName,
    3026                  const QString& rnxFileName,
    3127                  int PID, int SID, int IOD, int iRow);
     
    4238                        const ColumnVector& rtnCoM,
    4339                        const ColumnVector& rtnClkSig,
    44                         struct ClockOrbit::SatData* sd,
     40                        struct SsrCorr::ClockOrbit::SatData* sd,
    4541                        QString& outLine);
    4642  void crdTrafo(int GPSWeek, ColumnVector& xyz, double& dc);
     
    5248  QString        _rtnetStreamBuffer;
    5349  QString        _crdTrafo;
     50  SsrCorr*       _ssrCorr;
     51  QString        _ssrFormat;
    5452  bool           _CoM;
    5553  int            _PID;
Note: See TracChangeset for help on using the changeset viewer.