Changeset 9036 in ntrip for branches/BNC_2.12/src/RTCM3


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

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

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

Legend:

Unmodified
Added
Removed

  • branches/BNC_2.12/src/RTCM3/RTCM3Decoder.cpp

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

  • branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.cpp

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

  • branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.h

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

  • branches/BNC_2.12/src/RTCM3/bits.h

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

  • branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.h

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

  • branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h

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