Changeset 11008 in ntrip for trunk


Ignore:
Timestamp:
Sep 9, 2026, 11:11:03 AM (5 days ago)
Author:
stuerze
Message:

updates regarding RTCM-SSR

Location:
trunk/BNC/src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/BNC/src/RTCM3/RTCM3coDecoder.cpp

    r11004 r11008  
    8585          BNC_CORE, SLOT(slotNewTec(t_vTec)));
    8686
     87  connect(this, SIGNAL(newMetaData(t_metaData)),
     88          BNC_CORE, SLOT(slotNewMetaData(t_metaData)));
     89
    8790  connect(this, SIGNAL(providerIDChanged(QString)),
    8891          BNC_CORE, SIGNAL(providerIDChanged(QString)));
    … …  
    113116  _phaseBiases.clear();
    114117  _vTecMap.clear();
     118  _metaDataMap.clear();
    115119}
    116120
    … …  
    583587  }
    584588
     589  // Metadata (model correction information)
     590  // ----------------------------------------
     591  if (_metaData.NumEntries > 0) {
     592    // Metadata carries no epoch field of its own (it is keyed here by
     593    // _lastTime, inherited from whichever other message last set it), so a
     594    // fresh, complete message must replace rather than accumulate onto
     595    // whatever a previous message at the same _lastTime already stored.
     596    _metaDataMap[_lastTime] = t_metaData();
     597    _metaDataMap[_lastTime]._time       = _lastTime;
     598    _metaDataMap[_lastTime]._staID      = _staID.toStdString();
     599    _metaDataMap[_lastTime]._ssrIOD     = _metaData.SSRIOD;
     600    _metaDataMap[_lastTime]._providerID = _metaData.SSRProviderID;
     601    _metaDataMap[_lastTime]._solutionID = _metaData.SSRSolutionID;
     602    for (unsigned ii = 0; ii < _metaData.NumEntries; ii++) {
     603      const SsrCorr::MetaData::ModelPart& part = _metaData.Entries[ii];
     604      t_metaDataEntry entry;
     605      entry._typeIndicator        = part.TypeIndicator;
     606      entry._applicationIndicator = part.ApplicationIndicator;
     607      entry._nonDefaultIndicator  = part.nonDefaultIndicator;
     608      entry._nonDefaultIdentifier = part.nonDefaultIdentifier;
     609      entry._dataIODIndicator     = part.DataIODIndicator;
     610      entry._dataIOD              = part.DataIOD;
     611      _metaDataMap[_lastTime]._entries.push_back(entry);
     612    }
     613  }
     614
    585615  // Dump all older epochs
    586616  // ---------------------
    … …  
    628658      t_vTec::write(_out, itTec.value());
    629659      itTec.remove();
     660    }
     661  }
     662  QMutableMapIterator<bncTime, t_metaData> itMD(_metaDataMap);
     663  while (itMD.hasNext()) {
     664    itMD.next();
     665    if (itMD.key() < _lastTime) {
     666      emit newMetaData(itMD.value());
     667      t_metaData::write(_out, itMD.value());
     668      itMD.remove();
    630669    }
    631670  }

  • trunk/BNC/src/RTCM3/RTCM3coDecoder.h

    r11004 r11008  
    6363  void newPhaseBiases(QList<t_satPhaseBias>);
    6464  void newTec(t_vTec);
     65  void newMetaData(t_metaData);
    6566  void newMessage(QByteArray msg, bool showOnScreen);
    6667  void providerIDChanged(QString staID);
    … …  
    9596  QMap<bncTime, QList<t_satPhaseBias> > _phaseBiases;
    9697  QMap<bncTime, t_vTec>                 _vTecMap;
     98  QMap<bncTime, t_metaData>             _metaDataMap;
    9799};
    98100

  • trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit.h

    r11004 r11008  
    2121enum IGS_NUMBERS {
    2222  RTCM_MESSAGE_NUMBER_IGS = 4076,
    23   IGS_SSR_VERSION         = 3
     23  IGS_SSR_VERSION = 3
    2424};
    2525
    … …  
    2727 for these systems to save space */
    2828enum COR_CONSTANTS {
    29   COBOFS_MAXNUM          =  10,
    30   CLOCKORBIT_BUFFERSIZE  = 8192,
    31   CLOCKORBIT_NUMGPS      = t_prn::MAXPRN_GPS,
    32   CLOCKORBIT_NUMGLONASS  = t_prn::MAXPRN_GLONASS,
    33   CLOCKORBIT_NUMGALILEO  = t_prn::MAXPRN_GALILEO,
    34   CLOCKORBIT_NUMQZSS     = t_prn::MAXPRN_QZSS,
    35   CLOCKORBIT_NUMSBAS     = t_prn::MAXPRN_SBAS,
    36   CLOCKORBIT_NUMBDS      = t_prn::MAXPRN_BDS,
    37   CLOCKORBIT_NUMBIAS     = 150,
    38   VTEC_NUMIONOLAYERS     =    4,
    39   VTEC_MAXIONOORDER      =  16,
    40   VTEC_MAXIONODEGREE     =  16,
    41   META_MAXNUMENTRIES     =    7
     29  COBOFS_MAXNUM = 10,
     30  CLOCKORBIT_BUFFERSIZE = 8192,
     31  CLOCKORBIT_NUMGPS = t_prn::MAXPRN_GPS,
     32  CLOCKORBIT_NUMGLONASS = t_prn::MAXPRN_GLONASS,
     33  CLOCKORBIT_NUMGALILEO = t_prn::MAXPRN_GALILEO,
     34  CLOCKORBIT_NUMQZSS = t_prn::MAXPRN_QZSS,
     35  CLOCKORBIT_NUMSBAS = t_prn::MAXPRN_SBAS,
     36  CLOCKORBIT_NUMBDS = t_prn::MAXPRN_BDS,
     37  CLOCKORBIT_NUMBIAS = 150,
     38  VTEC_NUMIONOLAYERS = 4,
     39  VTEC_MAXIONOORDER = 16,
     40  VTEC_MAXIONODEGREE = 16,
     41  META_MAXNUMENTRIES = 7
    4242};
    4343
    … …  
    5353
    5454enum COR_OFFSETS {
    55   CLOCKORBIT_OFFSETGPS     = 0,
     55  CLOCKORBIT_OFFSETGPS = 0,
    5656  CLOCKORBIT_OFFSETGLONASS = CLOCKORBIT_NUMGPS,
    5757  CLOCKORBIT_OFFSETGALILEO = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS,
    58   CLOCKORBIT_OFFSETQZSS    = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO, 
    59   CLOCKORBIT_OFFSETSBAS    = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS,
    60   CLOCKORBIT_OFFSETBDS     = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS,
    61   CLOCKORBIT_COUNTSAT      = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS + CLOCKORBIT_NUMBDS
     58  CLOCKORBIT_OFFSETQZSS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO,
     59  CLOCKORBIT_OFFSETSBAS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS,
     60  CLOCKORBIT_OFFSETBDS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS,
     61  CLOCKORBIT_COUNTSAT = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS + CLOCKORBIT_NUMBDS
    6262};
    6363
    … …  
    6767  GCOBR_OK = 0,
    6868  /* unknown data, a warning */
    69   GCOBR_UNKNOWNTYPE           = -1,
    70   GCOBR_UNKNOWNDATA           = -2,
    71   GCOBR_CRCMISMATCH           = -3,
    72   GCOBR_SHORTMESSAGE          = -4,
     69  GCOBR_UNKNOWNTYPE = -1,
     70  GCOBR_UNKNOWNDATA = -2,
     71  GCOBR_CRCMISMATCH = -3,
     72  GCOBR_SHORTMESSAGE = -4,
    7373  /* failed to do the work */
    7474  GCOBR_NOCLOCKORBITPARAMETER = -10,
    75   GCOBR_NOCODEBIASPARAMETER   = -11,
    76   GCOBR_NOPHASEBIASPARAMETER  = -12,
    77   GCOBR_NOVTECPARAMETER       = -13,
     75  GCOBR_NOCODEBIASPARAMETER = -11,
     76  GCOBR_NOPHASEBIASPARAMETER = -12,
     77  GCOBR_NOVTECPARAMETER = -13,
    7878  /* data mismatch - data in storage does not match new data */
    79   GCOBR_TIMEMISMATCH          = -20,
    80   GCOBR_DATAMISMATCH          = -21,
     79  GCOBR_TIMEMISMATCH = -20,
     80  GCOBR_DATAMISMATCH = -21,
    8181  /* not enough data - can decode the block completely */
    82   GCOBR_SHORTBUFFER           = -30,
    83   GCOBR_MESSAGEEXCEEDSBUFFER  = -31
    84 /* NOTE: When an error message has been emitted, the output structures may have been modified.
    85  * Make a copy of the previous variant before calling the
    86  function to have a clean state. */
     82  GCOBR_SHORTBUFFER = -30,
     83  GCOBR_MESSAGEEXCEEDSBUFFER = -31
     84  /* NOTE: When an error message has been emitted, the output structures may have been modified.
     85   * Make a copy of the previous variant before calling the
     86   function to have a clean state. */
    8787};
    8888
    … …  
    337337  QList<QList<unsigned int> > corType;
    338338
    339   bool lookupCorType(unsigned int msgNumber, unsigned int &sys, unsigned int &kind) const {
     339  bool lookupCorType(unsigned int msgNumber, unsigned int& sys, unsigned int& kind) const {
    340340    for (int s = 0; s < corType.size(); ++s) {
    341341      for (int k = 0; k < corType[s].size(); ++k) {
    … …  
    419419    unsigned int SSRSolutionID;
    420420    /* IGS-SSR and old RTCM-SSR only*/
    421     unsigned int DispersiveBiasConsistencyIndicator; 
     421    unsigned int DispersiveBiasConsistencyIndicator;
    422422    unsigned int MWConsistencyIndicator;
    423      /* new RTCM-SSR only*/
     423    /* new RTCM-SSR only*/
    424424    unsigned int SatelliteYawInformationIndicator;
    425425    unsigned int ExtendedPhaseBiasPropertyID;
    … …  
    456456  };
    457457
    458     struct MetaData {
     458  struct MetaData {
    459459    unsigned int EpochTime; /* GPS */
    460460    unsigned int SSRIOD;
    … …  
    476476
    477477  /* return size of resulting data or 0 in case of an error */
    478   virtual size_t MakeClockOrbit(const struct ClockOrbit *co, CodeType type, int moremessagesfollow, char *buffer, size_t size) = 0;
    479   virtual size_t MakeCodeBias(const struct CodeBias *b, CodeBiasType type,  int moremessagesfollow, char *buffer, size_t size) = 0;
    480   virtual size_t MakePhaseBias(const struct PhaseBias *b, CodeBiasType type, int moremessagesfollow, char *buffer, size_t size) = 0;
    481   virtual size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, size_t size) = 0;
     478  virtual size_t MakeClockOrbit(const struct ClockOrbit* co, CodeType type, int moremessagesfollow, char* buffer, size_t size) = 0;
     479  virtual size_t MakeCodeBias(const struct CodeBias* b, CodeBiasType type, int moremessagesfollow, char* buffer, size_t size) = 0;
     480  virtual size_t MakePhaseBias(const struct PhaseBias* b, CodeBiasType type, int moremessagesfollow, char* buffer, size_t size) = 0;
     481  virtual size_t MakeVTEC(const struct VTEC* v, int moremessagesfollow, char* buffer, size_t size) = 0;
    482482  /* buffer should point to a RTCM3 block */
    483   virtual enum GCOB_RETURN GetSSR(struct ClockOrbit *co,
    484                                   struct CodeBias *b, struct VTEC *v,
    485                                   struct PhaseBias *pb,
    486                                   struct MetaData *md, 
    487                                   const char *buffer, size_t size, int *bytesused) = 0;
     483  virtual enum GCOB_RETURN GetSSR(struct ClockOrbit* co,
     484    struct CodeBias* b, struct VTEC* v,
     485    struct PhaseBias* pb,
     486    struct MetaData* md,
     487    const char* buffer, size_t size, int* bytesused) = 0;
    488488
    489489  virtual std::string metaTypeToStr(unsigned int ind) = 0;
    … …  
    520520#define E_BDS_TOEMOD(a)                                  ADDBITS(10, (a/8))                 /* DF470  */
    521521#define E_BDS_IOD(a)                                     ADDBITS( 8, a)                     /* DF471  */
    522  
     522
    523523/* Orbit Corrections */
    524524#define E_DELTA_RADIAL(a)                                SCALEADDBITS(22,    10000.0, a)    /* DF365, IDF013 */
    … …  
    658658
    659659
    660 static double URAToValue(int ura) {
    661   int urac, urav;
    662   urac = ura >> 3;
    663   urav = ura & 7;
    664   if (!ura)
    665     return 0;
    666   else if (ura == 63)
    667     return SSR_MAXURA;
    668   return (pow(3, urac) * (1.0 + urav / 4.0) - 1.0) / 1000.0;
    669 }
    670 
    671 static int ValueToURA(double val) {
    672   int ura;
    673   if (!val)
    674     return 0;
    675   else if (val > 5.4665)
    676     return 63;
    677   for (ura = 1; ura < 63 && val > URAToValue(ura); ++ura)
    678     ;
    679   return ura;
    680 }
     660  static double URAToValue(int ura) {
     661    int urac, urav;
     662    urac = ura >> 3;
     663    urav = ura & 7;
     664    if (!ura)
     665      return 0;
     666    else if (ura == 63)
     667      return SSR_MAXURA;
     668    return (pow(3, urac) * (1.0 + urav / 4.0) - 1.0) / 1000.0;
     669  }
     670
     671  static int ValueToURA(double val) {
     672    int ura;
     673    if (!val)
     674      return 0;
     675    else if (val > 5.4665)
     676      return 63;
     677    for (ura = 1; ura < 63 && val > URAToValue(ura); ++ura)
     678      ;
     679    return ura;
     680  }
    681681
    682682#define DECODESTART \
    … …  
    692692}
    693693
    694 /* extract bits from data stream
    695  b = variable to store result, a = number of bits */
     694  /* extract bits from data stream
     695   b = variable to store result, a = number of bits */
    696696#define GETSSRBITS(b, a) { \
    697697  LOADSSRBITS(a) \
    … …  
    700700}
    701701
    702 /* extract bits from data stream
    703    b = variable to store result, a = number of bits */
     702   /* extract bits from data stream
     703      b = variable to store result, a = number of bits */
    704704#define GETSSRBITSSIGN(b, a) { \
    705705  LOADBITS(a) \
    … …  
    708708}
    709709
    710 /* extract bits from data stream
    711  b = variable to store result, a = number of bits */
     710      /* extract bits from data stream
     711       b = variable to store result, a = number of bits */
    712712#define GETSSRBITSFACTOR(b, a, c) { \
    713713  LOADSSRBITS(a) \
    … …  
    716716}
    717717
    718 /* extract signed floating value from data stream
    719  b = variable to store result, a = number of bits */
     718       /* extract signed floating value from data stream
     719        b = variable to store result, a = number of bits */
    720720#define GETSSRFLOATSIGN(b, a, c) { \
    721721  LOADSSRBITS(a) \
    … …  
    724724}
    725725
    726 /* extract floating value from data stream
    727  b = variable to store result, a = number of bits, c = scale factor */
     726        /* extract floating value from data stream
     727         b = variable to store result, a = number of bits, c = scale factor */
    728728#define GETSSRFLOAT(b, a, c) { \
    729729  LOADSSRBITS(a) \
    … …  
    734734#define SKIPSSRBITS(b) { LOADSSRBITS(b) numbits -= (b); }
    735735
    736 /* GPS macros also used for other systems when matching! */
     736         /* GPS macros also used for other systems when matching! */
    737737
    738738#define D_HEADER(a)                                      GETSSRBITS(a,  8)
    … …  
    830830#define D_NADIR_ANGLE_DEPENDENT_CORRECTION(a, nbits)    GETSSRFLOATSIGN(a,  3 + nbits, 1/1000.0) /* DF+021 (new RTCM) in [m]; can be extended up to 15/18 Bits from DF+015*/
    831831/*
    832 //Decoding 
     832//Decoding
    833833#define D_NEW_PAR(a, nbits)        GETSSRBITS(a, nbits)            //called as D_NEW_PAR(co->NewPar, co->NewParNumBits)
    834834#define D_NEW_PAR_SCALE(a, nbits)  GETSSRFLOAT(a, nbits, 10000.0)  //called as D_NEW_PAR(co->NewPar, co->NewParNumBits)

  • trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm_new.cpp

    r11006 r11008  
    3434
    3535  satoffset << CLOCKORBIT_OFFSETGPS
    36       << CLOCKORBIT_OFFSETGLONASS
    37       << CLOCKORBIT_OFFSETGALILEO
    38       << CLOCKORBIT_OFFSETQZSS
    39       << CLOCKORBIT_OFFSETSBAS
    40       << CLOCKORBIT_OFFSETBDS
    41       << CLOCKORBIT_COUNTSAT;
     36    << CLOCKORBIT_OFFSETGLONASS
     37    << CLOCKORBIT_OFFSETGALILEO
     38    << CLOCKORBIT_OFFSETQZSS
     39    << CLOCKORBIT_OFFSETSBAS
     40    << CLOCKORBIT_OFFSETBDS
     41    << CLOCKORBIT_COUNTSAT;
    4242}
    4343SsrCorrRtcmNew::~SsrCorrRtcmNew() {};
    4444
    45 size_t SsrCorrRtcmNew::MakeClockOrbit(const struct ClockOrbit *co, ClockOrbitType type,
    46     int moremessagesfollow, char *buffer, size_t size) {
     45size_t SsrCorrRtcmNew::MakeClockOrbit(const struct ClockOrbit* co, ClockOrbitType type,
     46  int moremessagesfollow, char* buffer, size_t size) {
    4747  std::vector< std::vector<unsigned int> > status(CLOCKORBIT_SATNUM, std::vector<unsigned int>(COBOFS_MAXNUM));
    4848  unsigned int i, s;
    … …  
    5252  STARTDATA
    5353
    54   for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
    55     for (i = 0; i < COBOFS_MAXNUM; ++i) {
    56       if (co->NumberOfSat[s] && (type == COTYPE_AUTO || type == corType[s][i]) && (co->Supplied[i] ||
    57         (i <= COBOFS_CLOCK &&  co->Supplied[COBOFS_COMBINED]) ||
    58            (i == COBOFS_COMBINED && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK]))) {
    59         status[s][i] = 1;
    60         if (i == COBOFS_COMBINED) {
    61           status[s][COBOFS_ORBIT] = status[s][COBOFS_CLOCK] = 0;
    62         } /* disable single blocks for combined type */
    63       } /* check for data */
    64     } /* iterate over RTCM data types */
    65   } /* iterate over satellite systems */
     54    for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
     55      for (i = 0; i < COBOFS_MAXNUM; ++i) {
     56        if (co->NumberOfSat[s] && (type == COTYPE_AUTO || type == corType[s][i]) && (co->Supplied[i] ||
     57          (i <= COBOFS_CLOCK && co->Supplied[COBOFS_COMBINED]) ||
     58          (i == COBOFS_COMBINED && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK]))) {
     59          status[s][i] = 1;
     60          if (i == COBOFS_COMBINED) {
     61            status[s][COBOFS_ORBIT] = status[s][COBOFS_CLOCK] = 0;
     62          } /* disable single blocks for combined type */
     63        } /* check for data */
     64      } /* iterate over RTCM data types */
     65    } /* iterate over satellite systems */
    6666
    6767  for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
    6868    if (status[s][COBOFS_ORBIT]) {
    6969      INITBLOCK
    70       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_ORBIT])
    71       switch (s) {
     70        E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_ORBIT])
     71        switch (s) {
    7272        case CLOCKORBIT_SATGPS:
    7373        case CLOCKORBIT_SATGALILEO:
    … …  
    7676        case CLOCKORBIT_SATBDS:
    7777          E_GPS_EPOCH_TIME(co->EpochTime[s])
    78           break;
     78            break;
    7979        case CLOCKORBIT_SATGLONASS:
    8080          E_GLONASS_EPOCH_TIME(co->EpochTime[s])
    81           break;
    82       }
     81            break;
     82        }
    8383      E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    84       E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    85       E_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
    86       E_SSR_IOD(co->SSRIOD)
    87       E_SSR_PROVIDER_ID(co->SSRProviderID)
    88       E_SSR_SOLUTION_ID(co->SSRSolutionID)
    89       E_NO_OF_SATELLITES(co->NumberOfSat[s])
    90       for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
    91         switch (s)        {
     84        E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     85        E_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
     86        E_SSR_IOD(co->SSRIOD)
     87        E_SSR_PROVIDER_ID(co->SSRProviderID)
     88        E_SSR_SOLUTION_ID(co->SSRSolutionID)
     89        E_NO_OF_SATELLITES(co->NumberOfSat[s])
     90        for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     91          switch (s) {
    9292          case CLOCKORBIT_SATGPS:
    9393            E_GPS_SATELLITE_ID(co->Sat[i].ID)
    94             E_GPS_IODE(co->Sat[i].IOD)
    95             break;
     94              E_GPS_IODE(co->Sat[i].IOD)
     95              break;
    9696          case CLOCKORBIT_SATGLONASS:
    9797            E_GLONASS_SATELLITE_ID(co->Sat[i].ID)
    98             E_GLONASS_IOD(co->Sat[i].IOD)
    99             break;
     98              E_GLONASS_IOD(co->Sat[i].IOD)
     99              break;
    100100          case CLOCKORBIT_SATGALILEO:
    101101            E_GPS_SATELLITE_ID(co->Sat[i].ID)
    102             E_GALILEO_IOD(co->Sat[i].IOD)
    103             break;
     102              E_GALILEO_IOD(co->Sat[i].IOD)
     103              break;
    104104          case CLOCKORBIT_SATQZSS:
    105105            E_QZSS_SATELLITE_ID(co->Sat[i].ID)
    106             E_GPS_IODE(co->Sat[i].IOD)
    107             break;
     106              E_GPS_IODE(co->Sat[i].IOD)
     107              break;
    108108          case CLOCKORBIT_SATSBAS:
    109109            E_GPS_SATELLITE_ID(co->Sat[i].ID)
    110             E_SBAS_T0MOD(co->Sat[i].toe)
    111             E_SBAS_IODCRC(co->Sat[i].IOD)
    112             break;
     110              E_SBAS_T0MOD(co->Sat[i].toe)
     111              E_SBAS_IODCRC(co->Sat[i].IOD)
     112              break;
    113113          case CLOCKORBIT_SATBDS:
    114114            E_GPS_SATELLITE_ID(co->Sat[i].ID)
    115             E_BDS_IOD(co->Sat[i].IOD)
    116             break;
    117         }
    118         E_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
    119         E_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
    120         E_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
    121         E_DOT_DELTA_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
    122         E_DOT_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
    123         E_DOT_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
    124       }
     115              E_BDS_IOD(co->Sat[i].IOD)
     116              break;
     117          }
     118          E_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
     119            E_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
     120            E_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
     121            E_DOT_DELTA_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
     122            E_DOT_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
     123            E_DOT_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
     124        }
    125125      ENDBLOCK
    126126    }
    127127    if (status[s][COBOFS_CLOCK]) {
    128128      INITBLOCK
    129       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_CLOCK])
    130       switch (s) {
     129        E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_CLOCK])
     130        switch (s) {
    131131        case CLOCKORBIT_SATGPS:
    132132        case CLOCKORBIT_SATGALILEO:
    … …  
    135135        case CLOCKORBIT_SATBDS:
    136136          E_GPS_EPOCH_TIME(co->EpochTime[s])
    137           break;
     137            break;
    138138        case CLOCKORBIT_SATGLONASS:
    139139          E_GLONASS_EPOCH_TIME(co->EpochTime[s])
    140           break;
    141       }
     140            break;
     141        }
    142142      E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    143       E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    144       E_SSR_IOD(co->SSRIOD)
    145       E_SSR_PROVIDER_ID(co->SSRProviderID)
    146       E_SSR_SOLUTION_ID(co->SSRSolutionID)
    147       E_NO_OF_SATELLITES(co->NumberOfSat[s])
    148       for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
    149         E_GPS_SATELLITE_ID(co->Sat[i].ID)
    150         E_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
    151         E_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
    152         E_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
    153       }
     143        E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     144        E_SSR_IOD(co->SSRIOD)
     145        E_SSR_PROVIDER_ID(co->SSRProviderID)
     146        E_SSR_SOLUTION_ID(co->SSRSolutionID)
     147        E_NO_OF_SATELLITES(co->NumberOfSat[s])
     148        for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     149          E_GPS_SATELLITE_ID(co->Sat[i].ID)
     150            E_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
     151            E_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
     152            E_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
     153        }
    154154      ENDBLOCK
    155155    }
    … …  
    158158      unsigned int nums = co->NumberOfSat[s];
    159159      unsigned int left, start = satoffset[s];
    160       if(nums > 28) {/* split block when more than 28 sats */
     160      if (nums > 28) {/* split block when more than 28 sats */
    161161        left = nums - 28;
    162162        nums = 28;
    … …  
    165165        left = 0;
    166166      }
    167       while(nums) {
    168 #endif
     167      while (nums) {
     168#endif
     169        INITBLOCK
     170          E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_COMBINED])
     171          switch (s) {
     172          case CLOCKORBIT_SATGPS:
     173          case CLOCKORBIT_SATGALILEO:
     174          case CLOCKORBIT_SATQZSS:
     175          case CLOCKORBIT_SATSBAS:
     176          case CLOCKORBIT_SATBDS:
     177            E_GPS_EPOCH_TIME(co->EpochTime[s])
     178              break;
     179          case CLOCKORBIT_SATGLONASS:
     180            E_GLONASS_EPOCH_TIME(co->EpochTime[s])
     181              break;
     182          }
     183        E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     184#ifdef SPLITBLOCK
     185          E_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0)
     186#else
     187          E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     188#endif
     189          E_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
     190          E_SSR_IOD(co->SSRIOD)
     191          E_SSR_PROVIDER_ID(co->SSRProviderID)
     192          E_SSR_SOLUTION_ID(co->SSRSolutionID)
     193#ifdef SPLITBLOCK
     194          E_NO_OF_SATELLITES(nums)
     195          for (i = start; i < start + nums; ++i)
     196#else
     197          E_NO_OF_SATELLITES(co->NumberOfSat[s])
     198          for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i)
     199#endif
     200          {
     201            switch (s) {
     202            case CLOCKORBIT_SATGPS:
     203              E_GPS_SATELLITE_ID(co->Sat[i].ID)
     204                E_GPS_IODE(co->Sat[i].IOD)
     205                break;
     206            case CLOCKORBIT_SATGLONASS:
     207              E_GLONASS_SATELLITE_ID(co->Sat[i].ID)
     208                E_GLONASS_IOD(co->Sat[i].IOD)
     209                break;
     210            case CLOCKORBIT_SATGALILEO:
     211              E_GPS_SATELLITE_ID(co->Sat[i].ID)
     212                E_GALILEO_IOD(co->Sat[i].IOD)
     213                break;
     214            case CLOCKORBIT_SATQZSS:
     215              E_QZSS_SATELLITE_ID(co->Sat[i].ID)
     216                E_GPS_IODE(co->Sat[i].IOD)
     217                break;
     218            case CLOCKORBIT_SATSBAS:
     219              E_GPS_SATELLITE_ID(co->Sat[i].ID)
     220                E_SBAS_T0MOD(co->Sat[i].toe)
     221                E_SBAS_IODCRC(co->Sat[i].IOD)
     222                break;
     223            case CLOCKORBIT_SATBDS:
     224              E_GPS_SATELLITE_ID(co->Sat[i].ID)
     225                E_BDS_IOD(co->Sat[i].IOD)
     226                break;
     227            }
     228            E_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
     229              E_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
     230              E_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
     231              E_DOT_DELTA_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
     232              E_DOT_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
     233              E_DOT_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
     234              E_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
     235              E_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
     236              E_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
     237          }
     238        ENDBLOCK
     239#ifdef SPLITBLOCK
     240          start += nums;
     241        nums = left;
     242        left = 0;
     243      }
     244#endif
     245    }
     246    if (status[s][COBOFS_HR]) {
    169247      INITBLOCK
    170       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_COMBINED])
    171       switch (s) {
     248        E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_HR])
     249        switch (s) {
    172250        case CLOCKORBIT_SATGPS:
    173251        case CLOCKORBIT_SATGALILEO:
    … …  
    176254        case CLOCKORBIT_SATBDS:
    177255          E_GPS_EPOCH_TIME(co->EpochTime[s])
    178           break;
     256            break;
    179257        case CLOCKORBIT_SATGLONASS:
    180258          E_GLONASS_EPOCH_TIME(co->EpochTime[s])
    181           break;
    182       }
     259            break;
     260        }
    183261      E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    184 #ifdef SPLITBLOCK
    185       E_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0)
    186 #else
    187       E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    188 #endif
    189       E_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
    190       E_SSR_IOD(co->SSRIOD)
    191       E_SSR_PROVIDER_ID(co->SSRProviderID)
    192       E_SSR_SOLUTION_ID(co->SSRSolutionID)
    193 #ifdef SPLITBLOCK
    194       E_NO_OF_SATELLITES(nums)
    195       for(i = start; i < start+nums; ++i)
    196 #else
    197       E_NO_OF_SATELLITES(co->NumberOfSat[s])
    198       for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i)
    199 #endif
    200       {
     262        E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     263        E_SSR_IOD(co->SSRIOD)
     264        E_SSR_PROVIDER_ID(co->SSRProviderID)
     265        E_SSR_SOLUTION_ID(co->SSRSolutionID)
     266        E_NO_OF_SATELLITES(co->NumberOfSat[s])
     267        for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     268          E_GPS_SATELLITE_ID(co->Sat[i].ID)
     269            E_HR_CLOCK_CORRECTION(co->Sat[i].hrclock)
     270        }
     271      ENDBLOCK
     272    }
     273    if (status[s][COBOFS_URA]) {
     274      INITBLOCK
     275        E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_URA])
    201276        switch (s) {
    202           case CLOCKORBIT_SATGPS:
    203             E_GPS_SATELLITE_ID(co->Sat[i].ID)
    204             E_GPS_IODE(co->Sat[i].IOD)
    205             break;
    206           case CLOCKORBIT_SATGLONASS:
    207             E_GLONASS_SATELLITE_ID(co->Sat[i].ID)
    208             E_GLONASS_IOD(co->Sat[i].IOD)
    209             break;
    210           case CLOCKORBIT_SATGALILEO:
    211             E_GPS_SATELLITE_ID(co->Sat[i].ID)
    212             E_GALILEO_IOD(co->Sat[i].IOD)
    213             break;
    214           case CLOCKORBIT_SATQZSS:
    215             E_QZSS_SATELLITE_ID(co->Sat[i].ID)
    216             E_GPS_IODE(co->Sat[i].IOD)
    217             break;
    218           case CLOCKORBIT_SATSBAS:
    219             E_GPS_SATELLITE_ID(co->Sat[i].ID)
    220             E_SBAS_T0MOD(co->Sat[i].toe)
    221             E_SBAS_IODCRC(co->Sat[i].IOD)
    222             break;
    223           case CLOCKORBIT_SATBDS:
    224             E_GPS_SATELLITE_ID(co->Sat[i].ID)
    225             E_BDS_IOD(co->Sat[i].IOD)
    226             break;
    227         }
    228         E_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
    229         E_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
    230         E_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
    231         E_DOT_DELTA_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
    232         E_DOT_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
    233         E_DOT_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
    234         E_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
    235         E_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
    236         E_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
    237       }
    238       ENDBLOCK
    239 #ifdef SPLITBLOCK
    240       start += nums;
    241       nums = left;
    242       left = 0;
    243     }
    244 #endif
    245     }
    246     if (status[s][COBOFS_HR]) {
    247       INITBLOCK
    248       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_HR])
    249       switch (s) {
    250277        case CLOCKORBIT_SATGPS:
    251278        case CLOCKORBIT_SATGALILEO:
    … …  
    254281        case CLOCKORBIT_SATBDS:
    255282          E_GPS_EPOCH_TIME(co->EpochTime[s])
    256           break;
     283            break;
    257284        case CLOCKORBIT_SATGLONASS:
    258285          E_GLONASS_EPOCH_TIME(co->EpochTime[s])
    259           break;
    260       }
     286            break;
     287        }
    261288      E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    262       E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    263       E_SSR_IOD(co->SSRIOD)
    264       E_SSR_PROVIDER_ID(co->SSRProviderID)
    265       E_SSR_SOLUTION_ID(co->SSRSolutionID)
    266       E_NO_OF_SATELLITES(co->NumberOfSat[s])
    267       for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
    268         E_GPS_SATELLITE_ID(co->Sat[i].ID)
    269         E_HR_CLOCK_CORRECTION(co->Sat[i].hrclock)
    270       }
    271       ENDBLOCK
    272     }
    273     if (status[s][COBOFS_URA]) {
    274       INITBLOCK
    275       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_URA])
    276       switch (s) {
    277         case CLOCKORBIT_SATGPS:
    278         case CLOCKORBIT_SATGALILEO:
    279         case CLOCKORBIT_SATQZSS:
    280         case CLOCKORBIT_SATSBAS:
    281         case CLOCKORBIT_SATBDS:
    282           E_GPS_EPOCH_TIME(co->EpochTime[s])
    283           break;
    284         case CLOCKORBIT_SATGLONASS:
    285           E_GLONASS_EPOCH_TIME(co->EpochTime[s])
    286           break;
    287       }
    288       E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    289       E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    290       E_SSR_IOD(co->SSRIOD)
    291       E_SSR_PROVIDER_ID(co->SSRProviderID)
    292       E_SSR_SOLUTION_ID(co->SSRSolutionID)
    293       E_NO_OF_SATELLITES(co->NumberOfSat[s])
    294       for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
    295         E_GPS_SATELLITE_ID(co->Sat[i].ID)
    296         E_SSR_URA(ValueToURA(co->Sat[i].UserRangeAccuracy))
    297       }
     289        E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     290        E_SSR_IOD(co->SSRIOD)
     291        E_SSR_PROVIDER_ID(co->SSRProviderID)
     292        E_SSR_SOLUTION_ID(co->SSRSolutionID)
     293        E_NO_OF_SATELLITES(co->NumberOfSat[s])
     294        for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     295          E_GPS_SATELLITE_ID(co->Sat[i].ID)
     296            E_SSR_URA(ValueToURA(co->Sat[i].UserRangeAccuracy))
     297        }
    298298      ENDBLOCK
    299299    }
    … …  
    302302}
    303303
    304 size_t SsrCorrRtcmNew::MakeCodeBias(const struct CodeBias *b, CodeBiasType type,
    305     int moremessagesfollow, char *buffer, size_t size) {
     304size_t SsrCorrRtcmNew::MakeCodeBias(const struct CodeBias* b, CodeBiasType type,
     305  int moremessagesfollow, char* buffer, size_t size) {
    306306  unsigned int s, i, j;
    307307
    308308  STARTDATA
    309309
    310   for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
    311     if (b->NumberOfSat[s] && (type == CBTYPE_AUTO || type == corType[s][COBOFS_CBIAS])) {
    312       INITBLOCK
    313       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_CBIAS])
    314       switch (s) {
    315         case CLOCKORBIT_SATGPS:
    316         case CLOCKORBIT_SATGALILEO:
    317         case CLOCKORBIT_SATQZSS:
    318         case CLOCKORBIT_SATSBAS:
    319         case CLOCKORBIT_SATBDS:
    320           E_GPS_EPOCH_TIME(b->EpochTime[s])
    321           break;
    322         case CLOCKORBIT_SATGLONASS:
    323           E_GLONASS_EPOCH_TIME(b->EpochTime[s])
    324           break;
    325       }
    326       E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
    327       E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    328       E_SSR_IOD(b->SSRIOD)
    329       E_SSR_PROVIDER_ID(b->SSRProviderID)
    330       E_SSR_SOLUTION_ID(b->SSRSolutionID)
    331       E_NO_OF_SATELLITES(b->NumberOfSat[s])
    332       for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
    333         E_GPS_SATELLITE_ID(b->Sat[i].ID)
    334         E_NO_OF_BIASES(b->Sat[i].NumberOfCodeBiases)
    335         for (j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j) {
    336           E_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
    337           E_CODE_BIAS(b->Sat[i].Biases[j].Bias)
    338         }
    339       }
    340       ENDBLOCK
    341     }
    342   }
     310    for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
     311      if (b->NumberOfSat[s] && (type == CBTYPE_AUTO || type == corType[s][COBOFS_CBIAS])) {
     312        INITBLOCK
     313          E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_CBIAS])
     314          switch (s) {
     315          case CLOCKORBIT_SATGPS:
     316          case CLOCKORBIT_SATGALILEO:
     317          case CLOCKORBIT_SATQZSS:
     318          case CLOCKORBIT_SATSBAS:
     319          case CLOCKORBIT_SATBDS:
     320            E_GPS_EPOCH_TIME(b->EpochTime[s])
     321              break;
     322          case CLOCKORBIT_SATGLONASS:
     323            E_GLONASS_EPOCH_TIME(b->EpochTime[s])
     324              break;
     325          }
     326        E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
     327          E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     328          E_SSR_IOD(b->SSRIOD)
     329          E_SSR_PROVIDER_ID(b->SSRProviderID)
     330          E_SSR_SOLUTION_ID(b->SSRSolutionID)
     331          E_NO_OF_SATELLITES(b->NumberOfSat[s])
     332          for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
     333            E_GPS_SATELLITE_ID(b->Sat[i].ID)
     334              E_NO_OF_BIASES(b->Sat[i].NumberOfCodeBiases)
     335              for (j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j) {
     336                E_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
     337                  E_CODE_BIAS(b->Sat[i].Biases[j].Bias)
     338              }
     339          }
     340        ENDBLOCK
     341      }
     342    }
    343343  return ressize;
    344344}
    345345
    346 size_t SsrCorrRtcmNew::MakePhaseBias(const struct PhaseBias *b, PhaseBiasType type,
    347     int moremessagesfollow, char *buffer, size_t size) {
     346size_t SsrCorrRtcmNew::MakePhaseBias(const struct PhaseBias* b, PhaseBiasType type,
     347  int moremessagesfollow, char* buffer, size_t size) {
    348348  unsigned int s, i, j;
    349349
    350350  STARTDATA
    351351
    352   for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
    353      /* Satellite Phase Bias Message */
    354     if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == corType[s][COBOFS_PBIAS])) {
    355       INITBLOCK
    356       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_PBIAS])
    357       switch (s) {
    358         case CLOCKORBIT_SATGPS:
    359         case CLOCKORBIT_SATGALILEO:
    360         case CLOCKORBIT_SATQZSS:
    361         case CLOCKORBIT_SATSBAS:
    362         case CLOCKORBIT_SATBDS:
    363           E_GPS_EPOCH_TIME(b->EpochTime[s])
    364           break;
    365         case CLOCKORBIT_SATGLONASS:
    366           E_GLONASS_EPOCH_TIME(b->EpochTime[s])
    367           break;
    368       }
    369       E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
    370       E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    371       E_SSR_IOD(b->SSRIOD)
    372       E_SSR_PROVIDER_ID(b->SSRProviderID)
    373       E_SSR_SOLUTION_ID(b->SSRSolutionID)
    374       E_YAW_INFO_INDICATOR(b->SatelliteYawInformationIndicator)
    375       E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
    376       E_NO_OF_SATELLITES(b->NumberOfSat[s])
    377       for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
    378         E_GPS_SATELLITE_ID(b->Sat[i].ID)
    379         E_NO_OF_BIASES(b->Sat[i].NumberOfPhaseBiases)
    380         if (b->SatelliteYawInformationIndicator) {
    381           E_YAW_ANGLE(b->Sat[i].YawAngle)
    382           E_YAW_RATE(b->Sat[i].YawRate)
    383         }
    384         for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
    385           E_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
    386           E_INTEGER_INDICATOR(b->Sat[i].Biases[j].IntegerIndicator ? 1 : 0)
    387           E_DISCONTINUITY_COUNTER(b->Sat[i].Biases[j].DiscontinuityCounter)
    388           E_PHASE_BIAS_CORRECTION(b->Sat[i].Biases[j].Bias)
    389         }
    390       }
    391       ENDBLOCK
    392     }
    393     /* Extended Satellite Phase Bias Message 
    394        The Widelane Signal Group Indicator shall be releated for every satellite and signal 
    395        included in the corresponding Satellite Phase Bias Message in the same order. The 
    396        Extended Satellite Phase Bias Message shall be sent BEFORE the corresponding 
    397        Satellite Phase Bias Message VICE VERSA??*/
    398     if (b->NumberOfSat[s] && (type == PBEXTTYPE_AUTO || type == corType[s][COBOFS_PBEXT])) {
    399       INITBLOCK
    400       E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_PBEXT])
    401       switch (s) {
    402         case CLOCKORBIT_SATGPS:
    403         case CLOCKORBIT_SATGALILEO:
    404         case CLOCKORBIT_SATQZSS:
    405         case CLOCKORBIT_SATSBAS:
    406         case CLOCKORBIT_SATBDS:
    407           E_GPS_EPOCH_TIME(b->EpochTime[s])
    408           break;
    409         case CLOCKORBIT_SATGLONASS:
    410           E_GLONASS_EPOCH_TIME(b->EpochTime[s])
    411           break;
    412       }
    413       E_SSR_IOD(b->SSRIOD)
    414       E_SSR_PROVIDER_ID(b->SSRProviderID)
    415       E_SSR_SOLUTION_ID(b->SSRSolutionID)
    416       E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
    417       for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
    418         for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
    419           E_WIDE_LANE_INDICATOR(b->Sat[i].Biases[j].WidelaneGroupIndicator)
    420         }
    421       }
    422       ENDBLOCK
    423     }
    424   }
     352    for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
     353      /* Satellite Phase Bias Message */
     354      if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == corType[s][COBOFS_PBIAS])) {
     355        INITBLOCK
     356          E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_PBIAS])
     357          switch (s) {
     358          case CLOCKORBIT_SATGPS:
     359          case CLOCKORBIT_SATGALILEO:
     360          case CLOCKORBIT_SATQZSS:
     361          case CLOCKORBIT_SATSBAS:
     362          case CLOCKORBIT_SATBDS:
     363            E_GPS_EPOCH_TIME(b->EpochTime[s])
     364              break;
     365          case CLOCKORBIT_SATGLONASS:
     366            E_GLONASS_EPOCH_TIME(b->EpochTime[s])
     367              break;
     368          }
     369        E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
     370          E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     371          E_SSR_IOD(b->SSRIOD)
     372          E_SSR_PROVIDER_ID(b->SSRProviderID)
     373          E_SSR_SOLUTION_ID(b->SSRSolutionID)
     374          E_YAW_INFO_INDICATOR(b->SatelliteYawInformationIndicator)
     375          E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
     376          E_NO_OF_SATELLITES(b->NumberOfSat[s])
     377          for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
     378            E_GPS_SATELLITE_ID(b->Sat[i].ID)
     379              E_NO_OF_BIASES(b->Sat[i].NumberOfPhaseBiases)
     380              if (b->SatelliteYawInformationIndicator) {
     381                E_YAW_ANGLE(b->Sat[i].YawAngle)
     382                  E_YAW_RATE(b->Sat[i].YawRate)
     383              }
     384            for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
     385              E_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
     386                E_INTEGER_INDICATOR(b->Sat[i].Biases[j].IntegerIndicator ? 1 : 0)
     387                E_DISCONTINUITY_COUNTER(b->Sat[i].Biases[j].DiscontinuityCounter)
     388                E_PHASE_BIAS_CORRECTION(b->Sat[i].Biases[j].Bias)
     389            }
     390          }
     391        ENDBLOCK
     392      }
     393      /* Extended Satellite Phase Bias Message
     394         The Widelane Signal Group Indicator shall be releated for every satellite and signal
     395         included in the corresponding Satellite Phase Bias Message in the same order. The
     396         Extended Satellite Phase Bias Message shall be sent BEFORE the corresponding
     397         Satellite Phase Bias Message VICE VERSA??*/
     398      if (b->NumberOfSat[s] && (type == PBEXTTYPE_AUTO || type == corType[s][COBOFS_PBEXT])) {
     399        INITBLOCK
     400          E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_PBEXT])
     401          switch (s) {
     402          case CLOCKORBIT_SATGPS:
     403          case CLOCKORBIT_SATGALILEO:
     404          case CLOCKORBIT_SATQZSS:
     405          case CLOCKORBIT_SATSBAS:
     406          case CLOCKORBIT_SATBDS:
     407            E_GPS_EPOCH_TIME(b->EpochTime[s])
     408              break;
     409          case CLOCKORBIT_SATGLONASS:
     410            E_GLONASS_EPOCH_TIME(b->EpochTime[s])
     411              break;
     412          }
     413        E_SSR_IOD(b->SSRIOD)
     414          E_SSR_PROVIDER_ID(b->SSRProviderID)
     415          E_SSR_SOLUTION_ID(b->SSRSolutionID)
     416          E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
     417          for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
     418            for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
     419              E_WIDE_LANE_INDICATOR(b->Sat[i].Biases[j].WidelaneGroupIndicator)
     420            }
     421          }
     422        ENDBLOCK
     423      }
     424    }
    425425  return ressize;
    426426}
    427427
    428 size_t SsrCorrRtcmNew::MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, size_t size) {
     428size_t SsrCorrRtcmNew::MakeVTEC(const struct VTEC* v, int moremessagesfollow, char* buffer, size_t size) {
    429429  unsigned int l, o, d;
    430430
    431431  STARTDATA
    432432    INITBLOCK
    433   E_RTCM_MESSAGE_NUMBER(VTEC_BASE)
    434   E_GPS_EPOCH_TIME(v->EpochTime)
    435   E_SSR_UPDATE_INTERVAL(v->UpdateInterval)
    436   E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    437   E_SSR_IOD(v->SSRIOD)
    438   E_SSR_PROVIDER_ID(v->SSRProviderID)
    439   E_SSR_SOLUTION_ID(v->SSRSolutionID)
    440   E_VTEC_QUALITY_INDICATOR(v->Quality)
    441   E_NO_IONO_LAYERS(v->NumLayers)
    442   for (l = 0; l < v->NumLayers; ++l) {
    443     E_IONO_HEIGHT(v->Layers[l].Height)
    444     E_IONO_DEGREE(v->Layers[l].Degree)
    445     E_IONO_ORDER(v->Layers[l].Order)
    446     for (o = 0; o <= v->Layers[l].Order; ++o) {
    447       for (d = o; d <= v->Layers[l].Degree; ++d) {
    448         E_IONO_COEFF_C(v->Layers[l].Cosinus[d][o])
    449       }
    450     }
    451     for (o = 1; o <= v->Layers[l].Order; ++o) {
    452       for (d = o; d <= v->Layers[l].Degree; ++d) {
    453         E_IONO_COEFF_S(v->Layers[l].Sinus[d][o])
    454       }
    455     }
    456   }
     433    E_RTCM_MESSAGE_NUMBER(VTEC_BASE)
     434    E_GPS_EPOCH_TIME(v->EpochTime)
     435    E_SSR_UPDATE_INTERVAL(v->UpdateInterval)
     436    E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     437    E_SSR_IOD(v->SSRIOD)
     438    E_SSR_PROVIDER_ID(v->SSRProviderID)
     439    E_SSR_SOLUTION_ID(v->SSRSolutionID)
     440    E_VTEC_QUALITY_INDICATOR(v->Quality)
     441    E_NO_IONO_LAYERS(v->NumLayers)
     442    for (l = 0; l < v->NumLayers; ++l) {
     443      E_IONO_HEIGHT(v->Layers[l].Height)
     444        E_IONO_DEGREE(v->Layers[l].Degree)
     445        E_IONO_ORDER(v->Layers[l].Order)
     446        for (o = 0; o <= v->Layers[l].Order; ++o) {
     447          for (d = o; d <= v->Layers[l].Degree; ++d) {
     448            E_IONO_COEFF_C(v->Layers[l].Cosinus[d][o])
     449          }
     450        }
     451      for (o = 1; o <= v->Layers[l].Order; ++o) {
     452        for (d = o; d <= v->Layers[l].Degree; ++d) {
     453          E_IONO_COEFF_S(v->Layers[l].Sinus[d][o])
     454        }
     455      }
     456    }
    457457  ENDBLOCK
    458   return ressize;
     458    return ressize;
    459459}
    460460
    461 enum GCOB_RETURN SsrCorrRtcmNew::GetSSR(struct ClockOrbit *co, struct CodeBias *b, struct VTEC *v,
    462     struct PhaseBias *pb, struct MetaData *md, const char *buffer, size_t size, int *bytesused) {
     461enum GCOB_RETURN SsrCorrRtcmNew::GetSSR(struct ClockOrbit* co, struct CodeBias* b, struct VTEC* v,
     462  struct PhaseBias* pb, struct MetaData* md, const char* buffer, size_t size, int* bytesused) {
    463463  int mmi = 0, h, rs;
    464464  unsigned int type, pos, i, j, s, nums, id;
    465465  size_t sizeofrtcmblock;
    466   const char *blockstart = buffer;
     466  const char* blockstart = buffer;
    467467  DECODESTART
    468468
    469   if (size < 7)
    470     return GCOBR_SHORTBUFFER;
    471 
    472 #ifdef BNC_DEBUG_SSR
    473   fprintf(stderr, "GetSSR-RTCM START: size %d, numbits %d\n",(int)size, numbits);
     469    if (size < 7)
     470      return GCOBR_SHORTBUFFER;
     471
     472#ifdef BNC_DEBUG_SSR
     473  fprintf(stderr, "GetSSR-RTCM START: size %d, numbits %d\n", (int)size, numbits);
    474474#endif
    475475
    476476  D_HEADER(h)
    477   D_RESERVEDH(rs)
    478   D_SIZE(sizeofrtcmblock);
    479 
    480   if ((unsigned char) h != 0xD3 || rs)
     477    D_RESERVEDH(rs)
     478    D_SIZE(sizeofrtcmblock);
     479
     480  if ((unsigned char)h != 0xD3 || rs)
    481481    return GCOBR_UNKNOWNDATA;
    482482
    … …  
    484484    return GCOBR_MESSAGEEXCEEDSBUFFER;
    485485
    486   if (CRC24(sizeofrtcmblock + 3, (const unsigned char *) blockstart) !=
    487       (uint32_t) ((((unsigned char) buffer[sizeofrtcmblock]) << 16) |
    488           (((unsigned char) buffer[sizeofrtcmblock + 1]) << 8) |
    489           (((unsigned char) buffer[sizeofrtcmblock + 2]))))
     486  if (CRC24(sizeofrtcmblock + 3, (const unsigned char*)blockstart) !=
     487    (uint32_t)((((unsigned char)buffer[sizeofrtcmblock]) << 16) |
     488    (((unsigned char)buffer[sizeofrtcmblock + 1]) << 8) |
     489    (((unsigned char)buffer[sizeofrtcmblock + 2]))))
    490490    return GCOBR_CRCMISMATCH;
    491491
    … …  
    495495
    496496#ifdef BNC_DEBUG_SSR
    497   fprintf(stderr, "type %d size %d\n",type,(int)sizeofrtcmblock);
     497    fprintf(stderr, "type %d size %d\n", type, (int)sizeofrtcmblock);
    498498#endif
    499499
    500500  if (bytesused)
    501501    *bytesused = sizeofrtcmblock + 6;
    502    
     502
    503503  if (type == METADATATYPE_BASE) {
    504504    unsigned int i;
    … …  
    511511    D_NUMBER_OF_SSR_MODEL_CORRECTION_ENTRIES(md->NumEntries)
    512512#ifdef BNC_DEBUG_SSR
    513           fprintf(stderr, "ssrIod %d providerId %d solId %d numEntries %d \n",
    514                               md->SSRIOD, md->SSRProviderID, md->SSRSolutionID, md->NumEntries);
     513      fprintf(stderr, "ssrIod %d providerId %d solId %d numEntries %d \n",
     514      md->SSRIOD, md->SSRProviderID, md->SSRSolutionID, md->NumEntries);
    515515#endif
    516516    for (i = 0; i < md->NumEntries; i++) {
    … …  
    519519      D_MODEL_CORRECTION_APPLICATION_INDICATOR(md->Entries[i].ApplicationIndicator)
    520520      D_NON_DEFAULT_MODEL_CORRECTION_INDICATOR(md->Entries[i].nonDefaultIndicator)
    521             fprintf(stderr, "entry #%d \n"
    522               "- model-correction-type               : %d (%s)\n"
    523               "- model-correction-applied            : %d (%s)\n"
    524               "- non-default-model                   : %d (%s)\n",
     521#ifdef BNC_DEBUG_SSR
     522      fprintf(stderr, "entry #%d \n"
     523        "- model-correction-type               : %d (%s)\n"
     524        "- model-correction-applied            : %d (%s)\n"
     525        "- non-default-model                   : %d (%s)\n",
    525526        i, md->Entries[i].TypeIndicator, (metaTypeToStr(md->Entries[i].TypeIndicator)).c_str(),
    526527        md->Entries[i].ApplicationIndicator, md->Entries[i].ApplicationIndicator ? "yes" : "no",
    527528        md->Entries[i].nonDefaultIndicator, md->Entries[i].nonDefaultIndicator ? "non-default-model" : "default-model applied");
    528 
     529#endif
    529530      if (md->Entries[i].nonDefaultIndicator) {
    530531        D_NON_DEFAULT_MODEL_CORRECTION_IDENTIFIER(md->Entries[i].nonDefaultIdentifier)
    531         fprintf(stderr, "- non-default-model-identifier        : %d\n"
    532                         "- additional-model-parameter-indicator: %d\n",
    533           md->Entries[i].nonDefaultIdentifier,
    534           md->Entries[i].additionalParameterIndicator);
    535       }
    536 
     532#ifdef BNC_DEBUG_SSR
     533      fprintf(stderr, "- non-default-model-identifier        : %d\n"
     534        "- additional-model-parameter-indicator: %d\n",
     535        md->Entries[i].nonDefaultIdentifier,
     536        md->Entries[i].additionalParameterIndicator);
     537#endif
     538      }
    537539      D_MODEL_CORRECTION_DATA_IOD_INDICATOR(md->Entries[i].DataIODIndicator)
    538       fprintf(stderr,   "- additional-data-IOD-indicator       : %d (%s) \n", md->Entries[i].DataIODIndicator,
     540#ifdef BNC_DEBUG_SSR
     541      fprintf(stderr, "- additional-data-IOD-indicator       : %d (%s) \n", md->Entries[i].DataIODIndicator,
    539542        (md->Entries[i].DataIODIndicator) ? "additional data, IOD follows" : "no additional data");
    540      
     543#endif     
    541544      if (md->Entries[i].DataIODIndicator) {
    542545        D_MODEL_CORRECTION_DATA_IOD(md->Entries[i].DataIOD)
     546#ifdef BNC_DEBUG_SSR       
    543547        fprintf(stderr, "- additional-data-IOD                 : %d \n", md->Entries[i].DataIOD);
    544       }
    545      
     548#endif     
     549      }
    546550      if (md->Entries[i].nonDefaultIndicator) {
    547551        D_ADDITIONAL_MODEL_PARAMETER_INDICATOR(md->Entries[i].additionalParameterIndicator)
     552#ifdef BNC_DEBUG_SSR
    548553        fprintf(stderr, "- additional-data-parameter-indicator : %d\n", md->Entries[i].additionalParameterIndicator);
    549       }
    550      
     554#endif
     555      }
    551556      if (md->Entries[i].additionalParameterIndicator) {
    552557        D_NUMBER_OF_ADDITIONAL_MODEL_PARAMETER_BITS(additionalBits)
    553558        md->Entries[i].additionalParameterNumBits = additionalBits;
     559#ifdef BNC_DEBUG_SSR         
    554560        fprintf(stderr, "- additional-data-parameter-bits     : %d\n", md->Entries[i].additionalParameterNumBits);
    555       }
    556 
     561#endif       
     562      }
    557563      if (md->Entries[i].nonDefaultIndicator &&
    558           md->Entries[i].additionalParameterIndicator) {
     564        md->Entries[i].additionalParameterIndicator) {
    559565        D_ADDITIONAL_MODEL_PARAMETER_DATA(md->Entries[i].additionalParameterData, additionalBits)
     566#ifdef BNC_DEBUG_SSR
    560567        fprintf(stderr, "- additional-data-parameter-data     : %d\n", md->Entries[i].additionalParameterData);
    561       }
    562      
    563 #ifdef BNC_DEBUG_SSR
    564 /*
    565       fprintf(stderr, "entry #%d \n"
    566               "- model-correction-type               : %d (%s)\n"
    567               "- model-correction-applied            : %d (%s)\n"
    568               "- non-default-model                   : %d (%s)\n",
    569         i, md->Entries[i].TypeIndicator, (metaTypeToStr(md->Entries[i].TypeIndicator)).c_str(),
    570         md->Entries[i].ApplicationIndicator, md->Entries[i].ApplicationIndicator ? "yes" : "no",
    571         md->Entries[i].nonDefaultIndicator, md->Entries[i].nonDefaultIndicator ? "non-default-model" : "default-model applied");
    572 
    573       if (md->Entries[i].nonDefaultIndicator) { // DF+066
    574         fprintf(stderr, "- non-default-model-identifier        : %d\n"
    575                         "- additional-model-parameter-indicator: %d\n",
    576           md->Entries[i].nonDefaultIdentifier,
    577           md->Entries[i].additionalParameterIndicator);
    578       }
    579       fprintf(stderr,   "- additional-data-IOD-indicator       : %d (%s) \n", md->Entries[i].DataIODIndicator,
    580         (md->Entries[i].DataIODIndicator) ? "additional data, IOD follows" : "no additional data");
    581       if (md->Entries[i].DataIODIndicator) { // DF+068
    582         fprintf(stderr, "- additional-data-IOD                 : %d \n", md->Entries[i].DataIOD);
    583       }
    584       if (md->Entries[i].additionalParameterIndicator) {//DF+070
    585         fprintf(stderr, "- additional-parameter-bits           : %d\n", md->Entries[i].additionalParameterNumBits);
    586       }
    587       if (md->Entries[i].nonDefaultIndicator &&          // DF+066 and
    588           md->Entries[i].additionalParameterIndicator) { // DF+070
    589         fprintf(stderr, "- additional-parameter-data           : %d\n", md->Entries[i].additionalParameterData);
    590       }
    591       */
    592 #endif
    593 
    594     }
    595 #ifdef BNC_DEBUG_SSR
    596     for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
    597     numbits += 8;
    598     fprintf(stderr, "numbits left %d\n",numbits);
     568#endif       
     569      }
     570    }
     571#ifdef BNC_DEBUG_SSR
     572    for (type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
     573      numbits += 8;
     574    fprintf(stderr, "numbits left %d\n", numbits);
    599575#endif
    600576    return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
    … …  
    608584    /* COBOFS_* are per-instance (set in setCorType()), not compile-time
    609585       constants, so this has to be an if/else-if chain rather than a switch. */
    610     if      (kind == COBOFS_PBIAS) {
    611           if (!pb)
    612             return GCOBR_NOPHASEBIASPARAMETER;
    613           pb->messageType = type;
    614           /* Header Part*/
    615           /* pb->NumberOfSat[s] is no longer cleared by the caller between
    616            * messages (kept intact so a subsequent Extended Phase Bias message
    617            * can correlate against it), so this decode must start each fresh
    618            * message with an empty satellite list itself rather than relying
    619            * on D_..._EPOCH_TIME_CHECK's stale-data check, which would
    620            * otherwise reject every message but the first with GCOBR_TIMEMISMATCH. */
    621           pb->NumberOfSat[s] = 0;
    622           switch (s) {
    623             case CLOCKORBIT_SATGPS:
    624             case CLOCKORBIT_SATGALILEO:
    625             case CLOCKORBIT_SATQZSS:
    626             case CLOCKORBIT_SATSBAS:
    627             case CLOCKORBIT_SATBDS:
    628               D_GPS_EPOCH_TIME(pb->EpochTime[s])
    629               break;
    630             case CLOCKORBIT_SATGLONASS:
    631               D_GLONASS_EPOCH_TIME(pb->EpochTime[s])
    632               break;
     586    if (kind == COBOFS_PBIAS) {
     587      if (!pb)
     588        return GCOBR_NOPHASEBIASPARAMETER;
     589      pb->messageType = type;
     590      /* Header Part*/
     591      /* pb->NumberOfSat[s] is no longer cleared by the caller between
     592       * messages (kept intact so a subsequent Extended Phase Bias message
     593       * can correlate against it), so this decode must start each fresh
     594       * message with an empty satellite list itself rather than relying
     595       * on D_..._EPOCH_TIME_CHECK's stale-data check, which would
     596       * otherwise reject every message but the first with GCOBR_TIMEMISMATCH. */
     597      pb->NumberOfSat[s] = 0;
     598      switch (s) {
     599      case CLOCKORBIT_SATGPS:
     600      case CLOCKORBIT_SATGALILEO:
     601      case CLOCKORBIT_SATQZSS:
     602      case CLOCKORBIT_SATSBAS:
     603      case CLOCKORBIT_SATBDS:
     604        D_GPS_EPOCH_TIME(pb->EpochTime[s])
     605          break;
     606      case CLOCKORBIT_SATGLONASS:
     607        D_GLONASS_EPOCH_TIME(pb->EpochTime[s])
     608          break;
     609      }
     610      D_SSR_UPDATE_INTERVAL(pb->UpdateInterval)
     611        D_MULTIPLE_MESSAGE_INDICATOR(mmi)
     612        D_SSR_IOD(pb->SSRIOD)
     613        D_SSR_PROVIDER_ID(pb->SSRProviderID)
     614        D_SSR_SOLUTION_ID(pb->SSRSolutionID)
     615        D_YAW_INFO_INDICATOR(pb->SatelliteYawInformationIndicator)
     616        D_EXTENDED_PHASE_BIAS_ID(pb->ExtendedPhaseBiasPropertyID)
     617        D_NO_OF_SATELLITES(nums)
     618#ifdef BNC_DEBUG_SSR
     619        fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d yawInd %d extpbInd %d\n",
     620        pb->EpochTime[s], pb->UpdateInterval, mmi, pb->NumberOfSat[s], nums,
     621        pb->SSRIOD, pb->SSRProviderID, pb->SSRSolutionID,
     622        pb->SatelliteYawInformationIndicator, pb->ExtendedPhaseBiasPropertyID);
     623#endif
     624      /* Satellite Specific Part*/
     625      for (i = 0; i < nums; ++i) {
     626        D_GPS_SATELLITE_ID(id)
     627          for (pos = satoffset[s];
     628          pos < satoffset[s] + pb->NumberOfSat[s] && pb->Sat[pos].ID != id;
     629          ++pos)
     630            ;
     631        if (pos >= satoffset[s + 1])
     632          return GCOBR_DATAMISMATCH;
     633        else if (pos == pb->NumberOfSat[s] + satoffset[s])
     634          ++pb->NumberOfSat[s];
     635        pb->Sat[pos].ID = id;
     636        D_NO_OF_BIASES(pb->Sat[pos].NumberOfPhaseBiases)
     637          if (pb->SatelliteYawInformationIndicator) {
     638            D_YAW_ANGLE(pb->Sat[pos].YawAngle)
     639              D_YAW_RATE(pb->Sat[pos].YawRate)
    633640          }
    634           D_SSR_UPDATE_INTERVAL(pb->UpdateInterval)
    635           D_MULTIPLE_MESSAGE_INDICATOR(mmi)
    636           D_SSR_IOD(pb->SSRIOD)
    637           D_SSR_PROVIDER_ID(pb->SSRProviderID)
    638           D_SSR_SOLUTION_ID(pb->SSRSolutionID)
    639           D_YAW_INFO_INDICATOR(pb->SatelliteYawInformationIndicator)
    640           D_EXTENDED_PHASE_BIAS_ID(pb->ExtendedPhaseBiasPropertyID)
    641           D_NO_OF_SATELLITES(nums)
    642 #ifdef BNC_DEBUG_SSR
    643           fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d yawInd %d extpbInd %d\n",
    644                               pb->EpochTime[s], pb->UpdateInterval,mmi,pb->NumberOfSat[s],nums,
    645                                           pb->SSRIOD, pb->SSRProviderID, pb->SSRSolutionID,
    646                                           pb->SatelliteYawInformationIndicator, pb->ExtendedPhaseBiasPropertyID);
    647 #endif
    648           /* Satellite Specific Part*/
    649           for (i = 0; i < nums; ++i) {
    650             D_GPS_SATELLITE_ID(id)
    651             for (pos = satoffset[s];
    652                 pos < satoffset[s] + pb->NumberOfSat[s] && pb->Sat[pos].ID != id;
    653                 ++pos)
    654               ;
    655             if (pos >= satoffset[s + 1])
    656               return GCOBR_DATAMISMATCH;
    657             else if (pos == pb->NumberOfSat[s] + satoffset[s])
    658               ++pb->NumberOfSat[s];
    659             pb->Sat[pos].ID = id;
    660             D_NO_OF_BIASES(pb->Sat[pos].NumberOfPhaseBiases)
    661             if (pb->SatelliteYawInformationIndicator) {
    662               D_YAW_ANGLE(pb->Sat[pos].YawAngle)
    663               D_YAW_RATE(pb->Sat[pos].YawRate)
    664             }
    665 #ifdef BNC_DEBUG_SSR
    666             fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ",
    667                     pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases,
    668                                                   pb->Sat[pos].YawAngle/MPI, pb->Sat[pos].YawRate/MPI);
    669 #endif
    670             /* Signal Specific Part */
    671             for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
    672               D_GNSS_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type)
    673               D_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].IntegerIndicator)
    674               D_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].DiscontinuityCounter)
    675               D_PHASE_BIAS_CORRECTION(pb->Sat[pos].Biases[j].Bias)
    676 #ifdef BNC_DEBUG_SSR
    677               fprintf(stderr, "t %02d int %02d disc %d b %8.4f ",
    678                       pb->Sat[pos].Biases[j].Type,
    679                                                     pb->Sat[pos].Biases[j].IntegerIndicator,
    680                                                   pb->Sat[pos].Biases[j].DiscontinuityCounter,
    681                                                     pb->Sat[pos].Biases[j].Bias);
    682 #endif
    683             }
    684 #ifdef BNC_DEBUG_SSR
    685             fprintf(stderr, "\n");
    686 #endif
    687           }
     641#ifdef BNC_DEBUG_SSR
     642        fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ",
     643          pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases,
     644          pb->Sat[pos].YawAngle / MPI, pb->Sat[pos].YawRate / MPI);
     645#endif
     646        /* Signal Specific Part */
     647        for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
     648          D_GNSS_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type)
     649            D_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].IntegerIndicator)
     650            D_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].DiscontinuityCounter)
     651            D_PHASE_BIAS_CORRECTION(pb->Sat[pos].Biases[j].Bias)
     652#ifdef BNC_DEBUG_SSR
     653            fprintf(stderr, "t %02d int %02d disc %d b %8.4f ",
     654            pb->Sat[pos].Biases[j].Type,
     655            pb->Sat[pos].Biases[j].IntegerIndicator,
     656            pb->Sat[pos].Biases[j].DiscontinuityCounter,
     657            pb->Sat[pos].Biases[j].Bias);
     658#endif
     659        }
     660#ifdef BNC_DEBUG_SSR
     661        fprintf(stderr, "\n");
     662#endif
     663      }
    688664    }
    689665    else if (kind == COBOFS_PBEXT) {
    690666      unsigned int EpochTime, SSRIOD, SSRProviderID, SSRSolutionID, ExtendedPhaseBiasPropertyID;
    691         if (!pb)
    692           return GCOBR_NOPHASEBIASPARAMETER;
    693         pb->messageExtType = type;
    694         switch (s) {
    695           case CLOCKORBIT_SATGPS:
    696           case CLOCKORBIT_SATGALILEO:
    697           case CLOCKORBIT_SATQZSS:
    698           case CLOCKORBIT_SATSBAS:
    699           case CLOCKORBIT_SATBDS:
    700             D_GPS_EPOCH_TIME(EpochTime)
    701             break;
    702           case CLOCKORBIT_SATGLONASS:
    703             D_GLONASS_EPOCH_TIME(EpochTime)
    704             break;
    705         }
    706         D_SSR_IOD(SSRIOD)
     667      if (!pb)
     668        return GCOBR_NOPHASEBIASPARAMETER;
     669      pb->messageExtType = type;
     670      switch (s) {
     671      case CLOCKORBIT_SATGPS:
     672      case CLOCKORBIT_SATGALILEO:
     673      case CLOCKORBIT_SATQZSS:
     674      case CLOCKORBIT_SATSBAS:
     675      case CLOCKORBIT_SATBDS:
     676        D_GPS_EPOCH_TIME(EpochTime)
     677          break;
     678      case CLOCKORBIT_SATGLONASS:
     679        D_GLONASS_EPOCH_TIME(EpochTime)
     680          break;
     681      }
     682      D_SSR_IOD(SSRIOD)
    707683        D_SSR_PROVIDER_ID(SSRProviderID)
    708684        D_SSR_SOLUTION_ID(SSRSolutionID)
    … …  
    710686#ifdef BNC_DEBUG_SSR
    711687        fprintf(stderr, "epochTime %d/%d ssrIod %d/%d  providerId %d/%d  solId %d/%d  extpbInd %d/%d \n",
    712                       EpochTime, pb->EpochTime[s], 
    713                             SSRIOD, pb->SSRIOD, 
    714                 SSRProviderID, pb->SSRProviderID, 
    715                 SSRSolutionID, pb->SSRSolutionID,
    716                             ExtendedPhaseBiasPropertyID, pb->ExtendedPhaseBiasPropertyID);
    717 #endif
    718         if (EpochTime == pb->EpochTime[s] && 
    719             ExtendedPhaseBiasPropertyID == pb->ExtendedPhaseBiasPropertyID) {
    720           for (i = 0; i < pb->NumberOfSat[s]; ++i) {
    721             /* The wire format does not repeat the satellite ID here: entries
    722              * are implicitly in the same satellite/signal order as the
    723              * correlated Phase Bias message, so the i-th satellite is simply
    724              * the i-th one already recorded for this system. */
    725             pos = satoffset[s] + i;
    726             if (pos >= satoffset[s + 1])
    727               return GCOBR_DATAMISMATCH;
    728 #ifdef BNC_DEBUG_SSR
    729             fprintf(stderr, "id %2d ", pb->Sat[pos].ID);
    730 #endif
    731             for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
    732               D_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].WidelaneGroupIndicator)
     688        EpochTime, pb->EpochTime[s],
     689        SSRIOD, pb->SSRIOD,
     690        SSRProviderID, pb->SSRProviderID,
     691        SSRSolutionID, pb->SSRSolutionID,
     692        ExtendedPhaseBiasPropertyID, pb->ExtendedPhaseBiasPropertyID);
     693#endif
     694      if (EpochTime == pb->EpochTime[s] &&
     695        ExtendedPhaseBiasPropertyID == pb->ExtendedPhaseBiasPropertyID) {
     696        for (i = 0; i < pb->NumberOfSat[s]; ++i) {
     697          /* The wire format does not repeat the satellite ID here: entries
     698           * are implicitly in the same satellite/signal order as the
     699           * correlated Phase Bias message, so the i-th satellite is simply
     700           * the i-th one already recorded for this system. */
     701          pos = satoffset[s] + i;
     702          if (pos >= satoffset[s + 1])
     703            return GCOBR_DATAMISMATCH;
     704#ifdef BNC_DEBUG_SSR
     705          fprintf(stderr, "id %2d ", pb->Sat[pos].ID);
     706#endif
     707          for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
     708            D_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].WidelaneGroupIndicator)
    733709#ifdef BNC_DEBUG_SSR
    734710              fprintf(stderr, "t %02d wl %d ",
    735                       pb->Sat[pos].Biases[j].Type,
    736                                                     pb->Sat[pos].Biases[j].WidelaneGroupIndicator);
    737 #endif
    738             }
    739 #ifdef BNC_DEBUG_SSR
    740             fprintf(stderr, "\n");
     711              pb->Sat[pos].Biases[j].Type,
     712              pb->Sat[pos].Biases[j].WidelaneGroupIndicator);
    741713#endif
    742714          }
    743         }
     715#ifdef BNC_DEBUG_SSR
     716          fprintf(stderr, "\n");
     717#endif
     718        }
     719      }
    744720    }
    745721    else if (kind == COBOFS_ORBIT) {
    746           if (!co)
    747             return GCOBR_NOCLOCKORBITPARAMETER;
    748           co->messageType = type;
    749           switch (s) {
    750             case CLOCKORBIT_SATGPS:
    751             case CLOCKORBIT_SATGALILEO:
    752             case CLOCKORBIT_SATQZSS:
    753             case CLOCKORBIT_SATSBAS:
    754             case CLOCKORBIT_SATBDS:
    755               D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    756               break;
    757             case CLOCKORBIT_SATGLONASS:
    758               D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    759               break;
    760           }
    761           D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    762           D_MULTIPLE_MESSAGE_INDICATOR(mmi)
    763           D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
    764           D_SSR_IOD(co->SSRIOD)
    765           D_SSR_PROVIDER_ID(co->SSRProviderID)
    766           D_SSR_SOLUTION_ID(co->SSRSolutionID)
    767           D_NO_OF_SATELLITES(nums)
    768           co->Supplied[COBOFS_ORBIT] |= 1;
    769 #ifdef BNC_DEBUG_SSR
    770           fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
    771                           co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
    772                                   co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
    773 #endif
    774           for (i = 0; i < nums; ++i) {
    775             D_GPS_SATELLITE_ID(id)
    776             for (pos = satoffset[s];
    777                 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
    778                 ++pos)
    779               ;
    780             if (pos >= satoffset[s + 1])
    781               return GCOBR_DATAMISMATCH;
    782             else if (pos == co->NumberOfSat[s] + satoffset[s])
    783               ++co->NumberOfSat[s];
    784             co->Sat[pos].ID = id;
    785 
    786             switch (s) {
    787               case CLOCKORBIT_SATGPS:
    788               case CLOCKORBIT_SATQZSS:
    789                 D_GPS_IODE(co->Sat[pos].IOD)
    790                 break;
    791               case CLOCKORBIT_SATGLONASS:
    792                 D_GLONASS_IOD(co->Sat[pos].IOD)
    793                 break;
    794               case CLOCKORBIT_SATGALILEO:
    795                 D_GALILEO_IOD(co->Sat[pos].IOD)
    796                 break;
    797               case CLOCKORBIT_SATSBAS:
    798                 D_SBAS_T0MOD(co->Sat[pos].toe)
    799                 D_SBAS_IODCRC(co->Sat[pos].IOD)
    800                 break;
    801               case CLOCKORBIT_SATBDS:
    802                 D_GPS_IODE(co->Sat[pos].IOD)
    803                 break;
    804             }
    805             D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
    806             D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
    807             D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
    808             D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
    809             D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
    810             D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
    811 #ifdef BNC_DEBUG_SSR
    812             fprintf(stderr, "id %2d iod %3d dr %8.4f da %8.4f dc %8.4f dr %8.3f da %8.3f dc %8.3f\n",
    813                 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
    814                 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
    815                 co->Sat[pos].Orbit.DotDeltaRadial,
    816                 co->Sat[pos].Orbit.DotDeltaAlongTrack,
    817                 co->Sat[pos].Orbit.DotDeltaCrossTrack);
    818 #endif
    819           }
     722      if (!co)
     723        return GCOBR_NOCLOCKORBITPARAMETER;
     724      co->messageType = type;
     725      switch (s) {
     726      case CLOCKORBIT_SATGPS:
     727      case CLOCKORBIT_SATGALILEO:
     728      case CLOCKORBIT_SATQZSS:
     729      case CLOCKORBIT_SATSBAS:
     730      case CLOCKORBIT_SATBDS:
     731        D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     732          break;
     733      case CLOCKORBIT_SATGLONASS:
     734        D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     735          break;
     736      }
     737      D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     738        D_MULTIPLE_MESSAGE_INDICATOR(mmi)
     739        D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
     740        D_SSR_IOD(co->SSRIOD)
     741        D_SSR_PROVIDER_ID(co->SSRProviderID)
     742        D_SSR_SOLUTION_ID(co->SSRSolutionID)
     743        D_NO_OF_SATELLITES(nums)
     744        co->Supplied[COBOFS_ORBIT] |= 1;
     745#ifdef BNC_DEBUG_SSR
     746      fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
     747        co->EpochTime[s], co->UpdateInterval, mmi, co->NumberOfSat[s], nums,
     748        co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     749#endif
     750      for (i = 0; i < nums; ++i) {
     751        D_GPS_SATELLITE_ID(id)
     752          for (pos = satoffset[s];
     753          pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     754          ++pos)
     755            ;
     756        if (pos >= satoffset[s + 1])
     757          return GCOBR_DATAMISMATCH;
     758        else if (pos == co->NumberOfSat[s] + satoffset[s])
     759          ++co->NumberOfSat[s];
     760        co->Sat[pos].ID = id;
     761
     762        switch (s) {
     763        case CLOCKORBIT_SATGPS:
     764        case CLOCKORBIT_SATQZSS:
     765          D_GPS_IODE(co->Sat[pos].IOD)
     766            break;
     767        case CLOCKORBIT_SATGLONASS:
     768          D_GLONASS_IOD(co->Sat[pos].IOD)
     769            break;
     770        case CLOCKORBIT_SATGALILEO:
     771          D_GALILEO_IOD(co->Sat[pos].IOD)
     772            break;
     773        case CLOCKORBIT_SATSBAS:
     774          D_SBAS_T0MOD(co->Sat[pos].toe)
     775            D_SBAS_IODCRC(co->Sat[pos].IOD)
     776            break;
     777        case CLOCKORBIT_SATBDS:
     778          D_GPS_IODE(co->Sat[pos].IOD)
     779            break;
     780        }
     781        D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
     782          D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
     783          D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
     784          D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
     785          D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
     786          D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
     787#ifdef BNC_DEBUG_SSR
     788          fprintf(stderr, "id %2d iod %3d dr %8.4f da %8.4f dc %8.4f dr %8.3f da %8.3f dc %8.3f\n",
     789          co->Sat[pos].ID, co->Sat[pos].IOD, co->Sat[pos].Orbit.DeltaRadial,
     790          co->Sat[pos].Orbit.DeltaAlongTrack, co->Sat[pos].Orbit.DeltaCrossTrack,
     791          co->Sat[pos].Orbit.DotDeltaRadial,
     792          co->Sat[pos].Orbit.DotDeltaAlongTrack,
     793          co->Sat[pos].Orbit.DotDeltaCrossTrack);
     794#endif
     795      }
    820796    }
    821797    else if (kind == COBOFS_CLOCK) {
    822           if (!co)
    823             return GCOBR_NOCLOCKORBITPARAMETER;
    824           co->messageType = type;
    825           switch (s) {
    826             case CLOCKORBIT_SATGPS:
    827             case CLOCKORBIT_SATGALILEO:
    828             case CLOCKORBIT_SATQZSS:
    829             case CLOCKORBIT_SATSBAS:
    830             case CLOCKORBIT_SATBDS:
    831               D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    832               break;
    833             case CLOCKORBIT_SATGLONASS:
    834               D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    835               break;
    836           }
    837           D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    838           D_MULTIPLE_MESSAGE_INDICATOR(mmi)
    839           D_SSR_IOD(co->SSRIOD)
    840           D_SSR_PROVIDER_ID(co->SSRProviderID)
    841           D_SSR_SOLUTION_ID(co->SSRSolutionID)
    842           D_NO_OF_SATELLITES(nums)
    843           co->Supplied[COBOFS_CLOCK] |= 1;
    844 #ifdef BNC_DEBUG_SSR
    845           fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
    846                           co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
    847                                   co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
    848 #endif
    849           for (i = 0; i < nums; ++i) {
    850             D_GPS_SATELLITE_ID(id)
    851             for (pos = satoffset[s];
    852                 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
    853                 ++pos)
    854               ;
    855             if (pos >= satoffset[s + 1])
    856               return GCOBR_DATAMISMATCH;
    857             else if (pos == co->NumberOfSat[s] + satoffset[s])
    858               ++co->NumberOfSat[s];
    859             co->Sat[pos].ID = id;
    860 
    861             D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
    862             D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
    863             D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
    864 #ifdef BNC_DEBUG_SSR
    865             fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n",
    866                 co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1,
    867                 co->Sat[pos].Clock.DeltaA2);
    868 #endif
    869           }
     798      if (!co)
     799        return GCOBR_NOCLOCKORBITPARAMETER;
     800      co->messageType = type;
     801      switch (s) {
     802      case CLOCKORBIT_SATGPS:
     803      case CLOCKORBIT_SATGALILEO:
     804      case CLOCKORBIT_SATQZSS:
     805      case CLOCKORBIT_SATSBAS:
     806      case CLOCKORBIT_SATBDS:
     807        D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     808          break;
     809      case CLOCKORBIT_SATGLONASS:
     810        D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     811          break;
     812      }
     813      D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     814        D_MULTIPLE_MESSAGE_INDICATOR(mmi)
     815        D_SSR_IOD(co->SSRIOD)
     816        D_SSR_PROVIDER_ID(co->SSRProviderID)
     817        D_SSR_SOLUTION_ID(co->SSRSolutionID)
     818        D_NO_OF_SATELLITES(nums)
     819        co->Supplied[COBOFS_CLOCK] |= 1;
     820#ifdef BNC_DEBUG_SSR
     821      fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     822        co->EpochTime[s], co->UpdateInterval, mmi, co->NumberOfSat[s], nums,
     823        co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     824#endif
     825      for (i = 0; i < nums; ++i) {
     826        D_GPS_SATELLITE_ID(id)
     827          for (pos = satoffset[s];
     828          pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     829          ++pos)
     830            ;
     831        if (pos >= satoffset[s + 1])
     832          return GCOBR_DATAMISMATCH;
     833        else if (pos == co->NumberOfSat[s] + satoffset[s])
     834          ++co->NumberOfSat[s];
     835        co->Sat[pos].ID = id;
     836
     837        D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
     838          D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
     839          D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
     840#ifdef BNC_DEBUG_SSR
     841          fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n",
     842          co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1,
     843          co->Sat[pos].Clock.DeltaA2);
     844#endif
     845      }
    870846    }
    871847    else if (kind == COBOFS_COMBINED) {
    872           if (!co)
    873             return GCOBR_NOCLOCKORBITPARAMETER;
    874           co->messageType = type;
    875           switch (s) {
    876             case CLOCKORBIT_SATGPS:
    877             case CLOCKORBIT_SATGALILEO:
    878             case CLOCKORBIT_SATQZSS:
    879             case CLOCKORBIT_SATSBAS:
    880             case CLOCKORBIT_SATBDS:
    881               D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    882               break;
    883             case CLOCKORBIT_SATGLONASS:
    884               D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    885               break;
    886           }
    887           D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    888           D_MULTIPLE_MESSAGE_INDICATOR(mmi)
    889           D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
    890           D_SSR_IOD(co->SSRIOD)
    891           D_SSR_PROVIDER_ID(co->SSRProviderID)
    892           D_SSR_SOLUTION_ID(co->SSRSolutionID)
    893           D_NO_OF_SATELLITES(nums)
    894           co->Supplied[COBOFS_ORBIT] |= 1;
    895           co->Supplied[COBOFS_CLOCK] |= 1;
    896 #ifdef BNC_DEBUG_SSR
    897           fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
    898                           co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
    899                                   co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
    900 #endif
    901           for (i = 0; i < nums; ++i) {
    902             D_GPS_SATELLITE_ID(id)
    903             for (pos = satoffset[s];
    904                 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
    905                 ++pos)
    906               ;
    907             if (pos >= satoffset[s + 1])
    908               return GCOBR_DATAMISMATCH;
    909             else if (pos == co->NumberOfSat[s] + satoffset[s])
    910               ++co->NumberOfSat[s];
    911             co->Sat[pos].ID = id;
    912 
    913             switch (s) {
    914               case CLOCKORBIT_SATGPS:
    915               case CLOCKORBIT_SATQZSS:
    916                 D_GPS_IODE(co->Sat[pos].IOD)
    917                 break;
    918               case CLOCKORBIT_SATGLONASS:
    919                 D_GLONASS_IOD(co->Sat[pos].IOD)
    920                 break;
    921               case CLOCKORBIT_SATGALILEO:
    922                 D_GALILEO_IOD(co->Sat[pos].IOD)
    923                 break;
    924               case CLOCKORBIT_SATSBAS:
    925                 D_SBAS_T0MOD(co->Sat[pos].toe)
    926                 D_SBAS_IODCRC(co->Sat[pos].IOD)
    927                 break;
    928               case CLOCKORBIT_SATBDS:
    929                 D_GPS_IODE(co->Sat[pos].IOD)
    930                 break;
    931             }
    932             D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
    933             D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
    934             D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
    935             D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
    936             D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
    937             D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
    938             D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
    939             D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
    940             D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
    941 #ifdef BNC_DEBUG_SSR
    942             fprintf(stderr, "id %2d iod %3d dr %10.6f da %10.6f dc %10.6f dr %10.6f da %10.6f dc %10.6f  c0 %10.6f c1 %10.6f c2 %10.6f\n",
    943                 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
    944                 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
    945                 co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack,
    946                 co->Sat[pos].Orbit.DotDeltaCrossTrack,
    947                                         co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2);
    948 #endif
    949           }
     848      if (!co)
     849        return GCOBR_NOCLOCKORBITPARAMETER;
     850      co->messageType = type;
     851      switch (s) {
     852      case CLOCKORBIT_SATGPS:
     853      case CLOCKORBIT_SATGALILEO:
     854      case CLOCKORBIT_SATQZSS:
     855      case CLOCKORBIT_SATSBAS:
     856      case CLOCKORBIT_SATBDS:
     857        D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     858          break;
     859      case CLOCKORBIT_SATGLONASS:
     860        D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     861          break;
     862      }
     863      D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     864        D_MULTIPLE_MESSAGE_INDICATOR(mmi)
     865        D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
     866        D_SSR_IOD(co->SSRIOD)
     867        D_SSR_PROVIDER_ID(co->SSRProviderID)
     868        D_SSR_SOLUTION_ID(co->SSRSolutionID)
     869        D_NO_OF_SATELLITES(nums)
     870        co->Supplied[COBOFS_ORBIT] |= 1;
     871      co->Supplied[COBOFS_CLOCK] |= 1;
     872#ifdef BNC_DEBUG_SSR
     873      fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
     874        co->EpochTime[s], co->UpdateInterval, mmi, co->NumberOfSat[s], nums,
     875        co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     876#endif
     877      for (i = 0; i < nums; ++i) {
     878        D_GPS_SATELLITE_ID(id)
     879          for (pos = satoffset[s];
     880          pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     881          ++pos)
     882            ;
     883        if (pos >= satoffset[s + 1])
     884          return GCOBR_DATAMISMATCH;
     885        else if (pos == co->NumberOfSat[s] + satoffset[s])
     886          ++co->NumberOfSat[s];
     887        co->Sat[pos].ID = id;
     888
     889        switch (s) {
     890        case CLOCKORBIT_SATGPS:
     891        case CLOCKORBIT_SATQZSS:
     892          D_GPS_IODE(co->Sat[pos].IOD)
     893            break;
     894        case CLOCKORBIT_SATGLONASS:
     895          D_GLONASS_IOD(co->Sat[pos].IOD)
     896            break;
     897        case CLOCKORBIT_SATGALILEO:
     898          D_GALILEO_IOD(co->Sat[pos].IOD)
     899            break;
     900        case CLOCKORBIT_SATSBAS:
     901          D_SBAS_T0MOD(co->Sat[pos].toe)
     902            D_SBAS_IODCRC(co->Sat[pos].IOD)
     903            break;
     904        case CLOCKORBIT_SATBDS:
     905          D_GPS_IODE(co->Sat[pos].IOD)
     906            break;
     907        }
     908        D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
     909          D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
     910          D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
     911          D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
     912          D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
     913          D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
     914          D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
     915          D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
     916          D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
     917#ifdef BNC_DEBUG_SSR
     918          fprintf(stderr, "id %2d iod %3d dr %10.6f da %10.6f dc %10.6f dr %10.6f da %10.6f dc %10.6f  c0 %10.6f c1 %10.6f c2 %10.6f\n",
     919          co->Sat[pos].ID, co->Sat[pos].IOD, co->Sat[pos].Orbit.DeltaRadial,
     920          co->Sat[pos].Orbit.DeltaAlongTrack, co->Sat[pos].Orbit.DeltaCrossTrack,
     921          co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack,
     922          co->Sat[pos].Orbit.DotDeltaCrossTrack,
     923          co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2);
     924#endif
     925      }
    950926    }
    951927    else if (kind == COBOFS_URA) {
    952           if (!co)
    953             return GCOBR_NOCLOCKORBITPARAMETER;
    954           co->messageType = type;
    955           switch (s) {
    956             case CLOCKORBIT_SATGPS:
    957             case CLOCKORBIT_SATGALILEO:
    958             case CLOCKORBIT_SATQZSS:
    959             case CLOCKORBIT_SATSBAS:
    960             case CLOCKORBIT_SATBDS:
    961               D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    962               break;
    963             case CLOCKORBIT_SATGLONASS:
    964               D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    965               break;
    966           }
    967           D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    968           D_MULTIPLE_MESSAGE_INDICATOR(mmi)
    969           D_SSR_IOD(co->SSRIOD)
    970           D_SSR_PROVIDER_ID(co->SSRProviderID)
    971           D_SSR_SOLUTION_ID(co->SSRSolutionID)
    972           D_NO_OF_SATELLITES(nums)
    973           co->Supplied[COBOFS_URA] |= 1;
    974 #ifdef BNC_DEBUG_SSR
    975           fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
    976                           co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
    977                                   co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
    978 #endif
    979           for (i = 0; i < nums; ++i) {
    980             D_GPS_SATELLITE_ID(id)
    981             for (pos = satoffset[s];
    982                 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
    983                 ++pos)
    984               ;
    985             if (pos >= satoffset[s + 1])
    986               return GCOBR_DATAMISMATCH;
    987             else if (pos == co->NumberOfSat[s] + satoffset[s])
    988               ++co->NumberOfSat[s];
    989             co->Sat[pos].ID = id;
    990             D_SSR_URA(co->Sat[pos].UserRangeAccuracy)
    991 #ifdef BNC_DEBUG_SSR
    992             fprintf(stderr, "id %2d ura %8.3f \n",
    993                 co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy);
    994 #endif
    995           }
     928      if (!co)
     929        return GCOBR_NOCLOCKORBITPARAMETER;
     930      co->messageType = type;
     931      switch (s) {
     932      case CLOCKORBIT_SATGPS:
     933      case CLOCKORBIT_SATGALILEO:
     934      case CLOCKORBIT_SATQZSS:
     935      case CLOCKORBIT_SATSBAS:
     936      case CLOCKORBIT_SATBDS:
     937        D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     938          break;
     939      case CLOCKORBIT_SATGLONASS:
     940        D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     941          break;
     942      }
     943      D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     944        D_MULTIPLE_MESSAGE_INDICATOR(mmi)
     945        D_SSR_IOD(co->SSRIOD)
     946        D_SSR_PROVIDER_ID(co->SSRProviderID)
     947        D_SSR_SOLUTION_ID(co->SSRSolutionID)
     948        D_NO_OF_SATELLITES(nums)
     949        co->Supplied[COBOFS_URA] |= 1;
     950#ifdef BNC_DEBUG_SSR
     951      fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     952        co->EpochTime[s], co->UpdateInterval, mmi, co->NumberOfSat[s], nums,
     953        co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     954#endif
     955      for (i = 0; i < nums; ++i) {
     956        D_GPS_SATELLITE_ID(id)
     957          for (pos = satoffset[s];
     958          pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     959          ++pos)
     960            ;
     961        if (pos >= satoffset[s + 1])
     962          return GCOBR_DATAMISMATCH;
     963        else if (pos == co->NumberOfSat[s] + satoffset[s])
     964          ++co->NumberOfSat[s];
     965        co->Sat[pos].ID = id;
     966        D_SSR_URA(co->Sat[pos].UserRangeAccuracy)
     967#ifdef BNC_DEBUG_SSR
     968          fprintf(stderr, "id %2d ura %8.3f \n",
     969          co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy);
     970#endif
     971      }
    996972    }
    997973    else if (kind == COBOFS_HR) {
    998           if (!co)
    999             return GCOBR_NOCLOCKORBITPARAMETER;
    1000           co->messageType = type;
    1001           switch (s) {
    1002             case CLOCKORBIT_SATGPS:/* Phase specific part of GNSS phase bias message */
    1003             case CLOCKORBIT_SATGALILEO:
    1004             case CLOCKORBIT_SATQZSS:
    1005             case CLOCKORBIT_SATSBAS:
    1006             case CLOCKORBIT_SATBDS:
    1007               D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    1008               break;
    1009             case CLOCKORBIT_SATGLONASS:
    1010               D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
    1011               break;
    1012           }
    1013           D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    1014           D_MULTIPLE_MESSAGE_INDICATOR(mmi)
    1015           D_SSR_IOD(co->SSRIOD)
    1016           D_SSR_PROVIDER_ID(co->SSRProviderID)
    1017           D_SSR_SOLUTION_ID(co->SSRSolutionID)
    1018           D_NO_OF_SATELLITES(nums)
    1019           co->Supplied[COBOFS_HR] |= 1;
    1020 #ifdef BNC_DEBUG_SSR
    1021           fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
    1022                           co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
    1023                                   co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
    1024 #endif
    1025           for (i = 0; i < nums; ++i) {
    1026             D_GPS_SATELLITE_ID(id)
    1027             for (pos = satoffset[s];
    1028                 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
    1029                 ++pos)
    1030               ;
    1031             if (pos >= satoffset[s + 1])
    1032               return GCOBR_DATAMISMATCH;
    1033             else if (pos == co->NumberOfSat[s] + satoffset[s])
    1034               ++co->NumberOfSat[s];
    1035             co->Sat[pos].ID = id;
    1036             D_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock)
    1037 #ifdef BNC_DEBUG_SSR
    1038             fprintf(stderr, "id %2d hrClock %8.3f \n",
    1039                     co->Sat[pos].ID, co->Sat[pos].hrclock);
    1040 #endif
    1041           }
     974      if (!co)
     975        return GCOBR_NOCLOCKORBITPARAMETER;
     976      co->messageType = type;
     977      switch (s) {
     978      case CLOCKORBIT_SATGPS:/* Phase specific part of GNSS phase bias message */
     979      case CLOCKORBIT_SATGALILEO:
     980      case CLOCKORBIT_SATQZSS:
     981      case CLOCKORBIT_SATSBAS:
     982      case CLOCKORBIT_SATBDS:
     983        D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     984          break;
     985      case CLOCKORBIT_SATGLONASS:
     986        D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
     987          break;
     988      }
     989      D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     990        D_MULTIPLE_MESSAGE_INDICATOR(mmi)
     991        D_SSR_IOD(co->SSRIOD)
     992        D_SSR_PROVIDER_ID(co->SSRProviderID)
     993        D_SSR_SOLUTION_ID(co->SSRSolutionID)
     994        D_NO_OF_SATELLITES(nums)
     995        co->Supplied[COBOFS_HR] |= 1;
     996#ifdef BNC_DEBUG_SSR
     997      fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     998        co->EpochTime[s], co->UpdateInterval, mmi, co->NumberOfSat[s], nums,
     999        co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     1000#endif
     1001      for (i = 0; i < nums; ++i) {
     1002        D_GPS_SATELLITE_ID(id)
     1003          for (pos = satoffset[s];
     1004          pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     1005          ++pos)
     1006            ;
     1007        if (pos >= satoffset[s + 1])
     1008          return GCOBR_DATAMISMATCH;
     1009        else if (pos == co->NumberOfSat[s] + satoffset[s])
     1010          ++co->NumberOfSat[s];
     1011        co->Sat[pos].ID = id;
     1012        D_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock)
     1013#ifdef BNC_DEBUG_SSR
     1014          fprintf(stderr, "id %2d hrClock %8.3f \n",
     1015          co->Sat[pos].ID, co->Sat[pos].hrclock);
     1016#endif
     1017      }
    10421018    }
    10431019    else if (kind == COBOFS_CBIAS) {
    1044           if (!b)
    1045             return GCOBR_NOCODEBIASPARAMETER;
    1046           b->messageType = type;
    1047           switch (s) {
    1048             case CLOCKORBIT_SATGPS:
    1049             case CLOCKORBIT_SATGALILEO:
    1050             case CLOCKORBIT_SATQZSS:
    1051             case CLOCKORBIT_SATSBAS:
    1052             case CLOCKORBIT_SATBDS:
    1053               D_GPS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
    1054               break;
    1055             case CLOCKORBIT_SATGLONASS:
    1056               D_GLONASS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
    1057               break;
    1058           }
    1059           D_SSR_UPDATE_INTERVAL(b->UpdateInterval)
    1060           D_MULTIPLE_MESSAGE_INDICATOR(mmi)
    1061           D_SSR_IOD(b->SSRIOD)
    1062           D_SSR_PROVIDER_ID(b->SSRProviderID)
    1063           D_SSR_SOLUTION_ID(b->SSRSolutionID)
    1064           D_NO_OF_SATELLITES(nums)
    1065 #ifdef BNC_DEBUG_SSR
    1066           fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
    1067                           b->EpochTime[s], b->UpdateInterval,mmi,b->NumberOfSat[s],nums,
    1068                                           b->SSRIOD, b->SSRProviderID, b->SSRSolutionID);
    1069 #endif
    1070           for (i = 0; i < nums; ++i) {
    1071             D_GPS_SATELLITE_ID(id)
    1072             for (pos = satoffset[s];
    1073                 pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id;
    1074                 ++pos)
    1075               ;
    1076             if (pos >= satoffset[s + 1])
    1077               return GCOBR_DATAMISMATCH;
    1078             else if (pos == b->NumberOfSat[s] + satoffset[s])
    1079               ++b->NumberOfSat[s];
    1080             b->Sat[pos].ID = id;
    1081             D_NO_OF_BIASES(b->Sat[pos].NumberOfCodeBiases)
    1082 #ifdef BNC_DEBUG_SSR
    1083             fprintf(stderr, "id %2d #%d ",
    1084                     b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases);
    1085 #endif
    1086             for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) {
    1087               D_GNSS_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type)
    1088               D_CODE_BIAS(b->Sat[pos].Biases[j].Bias)
     1020      if (!b)
     1021        return GCOBR_NOCODEBIASPARAMETER;
     1022      b->messageType = type;
     1023      switch (s) {
     1024      case CLOCKORBIT_SATGPS:
     1025      case CLOCKORBIT_SATGALILEO:
     1026      case CLOCKORBIT_SATQZSS:
     1027      case CLOCKORBIT_SATSBAS:
     1028      case CLOCKORBIT_SATBDS:
     1029        D_GPS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
     1030          break;
     1031      case CLOCKORBIT_SATGLONASS:
     1032        D_GLONASS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
     1033          break;
     1034      }
     1035      D_SSR_UPDATE_INTERVAL(b->UpdateInterval)
     1036        D_MULTIPLE_MESSAGE_INDICATOR(mmi)
     1037        D_SSR_IOD(b->SSRIOD)
     1038        D_SSR_PROVIDER_ID(b->SSRProviderID)
     1039        D_SSR_SOLUTION_ID(b->SSRSolutionID)
     1040        D_NO_OF_SATELLITES(nums)
     1041#ifdef BNC_DEBUG_SSR
     1042        fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     1043        b->EpochTime[s], b->UpdateInterval, mmi, b->NumberOfSat[s], nums,
     1044        b->SSRIOD, b->SSRProviderID, b->SSRSolutionID);
     1045#endif
     1046      for (i = 0; i < nums; ++i) {
     1047        D_GPS_SATELLITE_ID(id)
     1048          for (pos = satoffset[s];
     1049          pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id;
     1050          ++pos)
     1051            ;
     1052        if (pos >= satoffset[s + 1])
     1053          return GCOBR_DATAMISMATCH;
     1054        else if (pos == b->NumberOfSat[s] + satoffset[s])
     1055          ++b->NumberOfSat[s];
     1056        b->Sat[pos].ID = id;
     1057        D_NO_OF_BIASES(b->Sat[pos].NumberOfCodeBiases)
     1058#ifdef BNC_DEBUG_SSR
     1059          fprintf(stderr, "id %2d #%d ",
     1060          b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases);
     1061#endif
     1062        for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) {
     1063          D_GNSS_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type)
     1064            D_CODE_BIAS(b->Sat[pos].Biases[j].Bias)
    10891065#ifdef BNC_DEBUG_SSR
    10901066            fprintf(stderr, "t %02d b %8.2f ",
    1091                     b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias);
    1092 #endif
    1093             }
    1094 #ifdef BNC_DEBUG_SSR
    1095             fprintf(stderr, "\n");
    1096 #endif
    1097           }
     1067            b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias);
     1068#endif
     1069        }
     1070#ifdef BNC_DEBUG_SSR
     1071        fprintf(stderr, "\n");
     1072#endif
     1073      }
    10981074    }
    10991075    //else if (kind == COBOFS_)
    … …  
    11051081
    11061082#ifdef BNC_DEBUG_SSR
    1107     for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
    1108     numbits += 8;
    1109     fprintf(stderr, "numbits left %d\n",numbits);
     1083    for (type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
     1084      numbits += 8;
     1085    fprintf(stderr, "numbits left %d\n", numbits);
    11101086#endif
    11111087    return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
    … …  
    11161092////////////////////////////////////////////////////////////////////////////
    11171093std::string SsrCorrRtcmNew::codeTypeToRnxType(char system, CodeType type) {
    1118   if      (system == 'G') {
    1119       if (type == CODETYPE_GPS_L1_CA)         return "1C";
    1120       if (type == CODETYPE_GPS_L1_P)          return "1P";
    1121       if (type == CODETYPE_GPS_L1_Z)          return "1W";
    1122       if (type == CODETYPE_GPS_SEMI_CODELESS) return "2D";
    1123       if (type == CODETYPE_GPS_L2_CA)         return "2C";
    1124       if (type == CODETYPE_GPS_L2_P)          return "2P";
    1125       if (type == CODETYPE_GPS_L2_Z)          return "2W";
    1126       if (type == CODETYPE_GPS_L2C_M)         return "2S";
    1127       if (type == CODETYPE_GPS_L2C_L)         return "2L";
    1128       if (type == CODETYPE_GPS_L2C_ML)        return "2X";
    1129       if (type == CODETYPE_GPS_L5_I)          return "5I";
    1130       if (type == CODETYPE_GPS_L5_Q)          return "5Q";
    1131       if (type == CODETYPE_GPS_L5_IQ)         return "5X";
    1132       if (type == CODETYPE_GPS_L1C_D)         return "1S";
    1133       if (type == CODETYPE_GPS_L1C_P)         return "1L";
    1134       if (type == CODETYPE_GPS_L1C_DP)        return "1X";
     1094  if (system == 'G') {
     1095    if (type == CODETYPE_GPS_L1_CA)         return "1C";
     1096    if (type == CODETYPE_GPS_L1_P)          return "1P";
     1097    if (type == CODETYPE_GPS_L1_Z)          return "1W";
     1098    if (type == CODETYPE_GPS_SEMI_CODELESS) return "2D";
     1099    if (type == CODETYPE_GPS_L2_CA)         return "2C";
     1100    if (type == CODETYPE_GPS_L2_P)          return "2P";
     1101    if (type == CODETYPE_GPS_L2_Z)          return "2W";
     1102    if (type == CODETYPE_GPS_L2C_M)         return "2S";
     1103    if (type == CODETYPE_GPS_L2C_L)         return "2L";
     1104    if (type == CODETYPE_GPS_L2C_ML)        return "2X";
     1105    if (type == CODETYPE_GPS_L5_I)          return "5I";
     1106    if (type == CODETYPE_GPS_L5_Q)          return "5Q";
     1107    if (type == CODETYPE_GPS_L5_IQ)         return "5X";
     1108    if (type == CODETYPE_GPS_L1C_D)         return "1S";
     1109    if (type == CODETYPE_GPS_L1C_P)         return "1L";
     1110    if (type == CODETYPE_GPS_L1C_DP)        return "1X";
    11351111  }
    11361112  else if (system == 'R') {
    1137       if (type == CODETYPE_GLONASS_L1_CA)     return "1C";
    1138       if (type == CODETYPE_GLONASS_L1_P)      return "1P";
    1139       if (type == CODETYPE_GLONASS_L2_CA)     return "2C";
    1140       if (type == CODETYPE_GLONASS_L2_P)      return "2P";
     1113    if (type == CODETYPE_GLONASS_L1_CA)     return "1C";
     1114    if (type == CODETYPE_GLONASS_L1_P)      return "1P";
     1115    if (type == CODETYPE_GLONASS_L2_CA)     return "2C";
     1116    if (type == CODETYPE_GLONASS_L2_P)      return "2P";
    11411117  }
    11421118  else if (system == 'E') {
    1143       if (type == CODETYPE_GALILEO_E1_A)       return "1A";
    1144       if (type == CODETYPE_GALILEO_E1_B)       return "1B";
    1145       if (type == CODETYPE_GALILEO_E1_C)       return "1C";
    1146       if (type == CODETYPE_GALILEO_E1_BC)      return "1X";
    1147       if (type == CODETYPE_GALILEO_E1_ABC)     return "1Z";
    1148       if (type == CODETYPE_GALILEO_E5A_I)      return "5I";
    1149       if (type == CODETYPE_GALILEO_E5A_Q)      return "5Q";
    1150       if (type == CODETYPE_GALILEO_E5A_IQ)     return "5X";
    1151       if (type == CODETYPE_GALILEO_E5B_I)      return "7I";
    1152       if (type == CODETYPE_GALILEO_E5B_Q)      return "7Q";
    1153       if (type == CODETYPE_GALILEO_E5B_IQ)     return "7X";
    1154       if (type == CODETYPE_GALILEO_E5_I)       return "8I";
    1155       if (type == CODETYPE_GALILEO_E5_Q)       return "8Q";
    1156       if (type == CODETYPE_GALILEO_E5_IQ)      return "8X";
    1157       if (type == CODETYPE_GALILEO_E6_A)       return "6A";
    1158       if (type == CODETYPE_GALILEO_E6_B)       return "6B";
    1159       if (type == CODETYPE_GALILEO_E6_C)       return "6C";
    1160       if (type == CODETYPE_GALILEO_E6_BC)      return "6X";
    1161       if (type == CODETYPE_GALILEO_E6_ABC)     return "6Z";
     1119    if (type == CODETYPE_GALILEO_E1_A)       return "1A";
     1120    if (type == CODETYPE_GALILEO_E1_B)       return "1B";
     1121    if (type == CODETYPE_GALILEO_E1_C)       return "1C";
     1122    if (type == CODETYPE_GALILEO_E1_BC)      return "1X";
     1123    if (type == CODETYPE_GALILEO_E1_ABC)     return "1Z";
     1124    if (type == CODETYPE_GALILEO_E5A_I)      return "5I";
     1125    if (type == CODETYPE_GALILEO_E5A_Q)      return "5Q";
     1126    if (type == CODETYPE_GALILEO_E5A_IQ)     return "5X";
     1127    if (type == CODETYPE_GALILEO_E5B_I)      return "7I";
     1128    if (type == CODETYPE_GALILEO_E5B_Q)      return "7Q";
     1129    if (type == CODETYPE_GALILEO_E5B_IQ)     return "7X";
     1130    if (type == CODETYPE_GALILEO_E5_I)       return "8I";
     1131    if (type == CODETYPE_GALILEO_E5_Q)       return "8Q";
     1132    if (type == CODETYPE_GALILEO_E5_IQ)      return "8X";
     1133    if (type == CODETYPE_GALILEO_E6_A)       return "6A";
     1134    if (type == CODETYPE_GALILEO_E6_B)       return "6B";
     1135    if (type == CODETYPE_GALILEO_E6_C)       return "6C";
     1136    if (type == CODETYPE_GALILEO_E6_BC)      return "6X";
     1137    if (type == CODETYPE_GALILEO_E6_ABC)     return "6Z";
    11621138  }
    1163    else if (system == 'J') {
    1164       if (type == CODETYPE_QZSS_L1_CA)         return "1C";
    1165       if (type == CODETYPE_QZSS_L1C_D)         return "1S";
    1166       if (type == CODETYPE_QZSS_L1C_P)         return "1L";
    1167       if (type == CODETYPE_QZSS_L2C_M)         return "2S";
    1168       if (type == CODETYPE_QZSS_L2C_L)         return "2L";
    1169       if (type == CODETYPE_QZSS_L2C_ML)        return "2X";
    1170       if (type == CODETYPE_QZSS_L5_I)          return "5I";
    1171       if (type == CODETYPE_QZSS_L5_Q)          return "5Q";
    1172       if (type == CODETYPE_QZSS_L5_IQ)         return "5X";
    1173       if (type == CODETYPE_QZSS_L6_D)          return "6S";
    1174       if (type == CODETYPE_QZSS_L6_P)          return "6L";
    1175       if (type == CODETYPE_QZSS_L6_DP)         return "6X";
    1176       if (type == CODETYPE_QZSS_L1C_DP)        return "1X";
     1139  else if (system == 'J') {
     1140    if (type == CODETYPE_QZSS_L1_CA)         return "1C";
     1141    if (type == CODETYPE_QZSS_L1C_D)         return "1S";
     1142    if (type == CODETYPE_QZSS_L1C_P)         return "1L";
     1143    if (type == CODETYPE_QZSS_L2C_M)         return "2S";
     1144    if (type == CODETYPE_QZSS_L2C_L)         return "2L";
     1145    if (type == CODETYPE_QZSS_L2C_ML)        return "2X";
     1146    if (type == CODETYPE_QZSS_L5_I)          return "5I";
     1147    if (type == CODETYPE_QZSS_L5_Q)          return "5Q";
     1148    if (type == CODETYPE_QZSS_L5_IQ)         return "5X";
     1149    if (type == CODETYPE_QZSS_L6_D)          return "6S";
     1150    if (type == CODETYPE_QZSS_L6_P)          return "6L";
     1151    if (type == CODETYPE_QZSS_L6_DP)         return "6X";
     1152    if (type == CODETYPE_QZSS_L1C_DP)        return "1X";
    11771153  }
    11781154  else if (system == 'C') {
    1179       if (type == CODETYPE_BDS_B1_I)         return "2I";
    1180       if (type == CODETYPE_BDS_B1_Q)         return "2Q";
    1181       if (type == CODETYPE_BDS_B1_IQ)        return "2X";
    1182       if (type == CODETYPE_BDS_B3_I)         return "6I";
    1183       if (type == CODETYPE_BDS_B3_Q)         return "6Q";
    1184       if (type == CODETYPE_BDS_B3_IQ)        return "6X";
    1185       if (type == CODETYPE_BDS_B2_I)         return "7I";
    1186       if (type == CODETYPE_BDS_B2_Q)         return "7Q";
    1187       if (type == CODETYPE_BDS_B2_IQ)        return "7X";
    1188       if (type == CODETYPE_BDS_B1C_D)        return "1D";
    1189       if (type == CODETYPE_BDS_B1C_P)        return "1P";
    1190       if (type == CODETYPE_BDS_B1C_DP)       return "1X";
    1191       if (type == CODETYPE_BDS_B2a_D)        return "5D";
    1192       if (type == CODETYPE_BDS_B2a_P)        return "5P";
    1193       if (type == CODETYPE_BDS_B2a_DP)       return "5X";
    1194       if (type == CODETYPE_BDS_B2b_D)        return "7D";
     1155    if (type == CODETYPE_BDS_B1_I)         return "2I";
     1156    if (type == CODETYPE_BDS_B1_Q)         return "2Q";
     1157    if (type == CODETYPE_BDS_B1_IQ)        return "2X";
     1158    if (type == CODETYPE_BDS_B3_I)         return "6I";
     1159    if (type == CODETYPE_BDS_B3_Q)         return "6Q";
     1160    if (type == CODETYPE_BDS_B3_IQ)        return "6X";
     1161    if (type == CODETYPE_BDS_B2_I)         return "7I";
     1162    if (type == CODETYPE_BDS_B2_Q)         return "7Q";
     1163    if (type == CODETYPE_BDS_B2_IQ)        return "7X";
     1164    if (type == CODETYPE_BDS_B1C_D)        return "1D";
     1165    if (type == CODETYPE_BDS_B1C_P)        return "1P";
     1166    if (type == CODETYPE_BDS_B1C_DP)       return "1X";
     1167    if (type == CODETYPE_BDS_B2a_D)        return "5D";
     1168    if (type == CODETYPE_BDS_B2a_P)        return "5P";
     1169    if (type == CODETYPE_BDS_B2a_DP)       return "5X";
     1170    if (type == CODETYPE_BDS_B2b_D)        return "7D";
    11951171  }
    11961172
    … …  
    12011177////////////////////////////////////////////////////////////////////////////
    12021178SsrCorr::CodeType SsrCorrRtcmNew::rnxTypeToCodeType(char system, std::string type) {
    1203   if      (system == 'G') {
    1204     if (type.compare("1C") == 0) {return CODETYPE_GPS_L1_CA;}
    1205     if (type.compare("1P") == 0) {return CODETYPE_GPS_L1_P;}
    1206     if (type.compare("1W") == 0) {return CODETYPE_GPS_L1_Z;}
    1207     if (type.compare("2D") == 0) {return CODETYPE_GPS_SEMI_CODELESS;}
    1208     if (type.compare("2C") == 0) {return CODETYPE_GPS_L2_CA;}
    1209     if (type.compare("2P") == 0) {return CODETYPE_GPS_L2_P;}
    1210     if (type.compare("2W") == 0) {return CODETYPE_GPS_L2_Z;}
    1211     if (type.compare("2S") == 0) {return CODETYPE_GPS_L2C_M;}
    1212     if (type.compare("2L") == 0) {return CODETYPE_GPS_L2C_L;}
    1213     if (type.compare("2X") == 0) {return CODETYPE_GPS_L2C_ML;}
    1214     if (type.compare("5I") == 0) {return CODETYPE_GPS_L5_I;}
    1215     if (type.compare("5Q") == 0) {return CODETYPE_GPS_L5_Q;}
    1216     if (type.compare("5X") == 0) {return CODETYPE_GPS_L5_IQ;}
    1217     if (type.compare("1S") == 0) {return CODETYPE_GPS_L1C_D;}
    1218     if (type.compare("1L") == 0) {return CODETYPE_GPS_L1C_P;}
    1219     if (type.compare("1X") == 0) {return CODETYPE_GPS_L1C_DP;}
     1179  if (system == 'G') {
     1180    if (type.compare("1C") == 0) { return CODETYPE_GPS_L1_CA; }
     1181    if (type.compare("1P") == 0) { return CODETYPE_GPS_L1_P; }
     1182    if (type.compare("1W") == 0) { return CODETYPE_GPS_L1_Z; }
     1183    if (type.compare("2D") == 0) { return CODETYPE_GPS_SEMI_CODELESS; }
     1184    if (type.compare("2C") == 0) { return CODETYPE_GPS_L2_CA; }
     1185    if (type.compare("2P") == 0) { return CODETYPE_GPS_L2_P; }
     1186    if (type.compare("2W") == 0) { return CODETYPE_GPS_L2_Z; }
     1187    if (type.compare("2S") == 0) { return CODETYPE_GPS_L2C_M; }
     1188    if (type.compare("2L") == 0) { return CODETYPE_GPS_L2C_L; }
     1189    if (type.compare("2X") == 0) { return CODETYPE_GPS_L2C_ML; }
     1190    if (type.compare("5I") == 0) { return CODETYPE_GPS_L5_I; }
     1191    if (type.compare("5Q") == 0) { return CODETYPE_GPS_L5_Q; }
     1192    if (type.compare("5X") == 0) { return CODETYPE_GPS_L5_IQ; }
     1193    if (type.compare("1S") == 0) { return CODETYPE_GPS_L1C_D; }
     1194    if (type.compare("1L") == 0) { return CODETYPE_GPS_L1C_P; }
     1195    if (type.compare("1X") == 0) { return CODETYPE_GPS_L1C_DP; }
    12201196  }
    12211197  else if (system == 'R') {
    1222     if (type.compare("1C") == 0) {return CODETYPE_GLONASS_L1_CA;}
    1223     if (type.compare("1P") == 0) {return CODETYPE_GLONASS_L1_P;}
    1224     if (type.compare("2C") == 0) {return CODETYPE_GLONASS_L2_CA;}
    1225     if (type.compare("2P") == 0) {return CODETYPE_GLONASS_L2_P;}
     1198    if (type.compare("1C") == 0) { return CODETYPE_GLONASS_L1_CA; }
     1199    if (type.compare("1P") == 0) { return CODETYPE_GLONASS_L1_P; }
     1200    if (type.compare("2C") == 0) { return CODETYPE_GLONASS_L2_CA; }
     1201    if (type.compare("2P") == 0) { return CODETYPE_GLONASS_L2_P; }
    12261202  }
    12271203  else if (system == 'E') {
    1228     if (type.compare("1A") == 0) {return CODETYPE_GALILEO_E1_A;}
    1229     if (type.compare("1B") == 0) {return CODETYPE_GALILEO_E1_B;}
    1230     if (type.compare("1C") == 0) {return CODETYPE_GALILEO_E1_C;}
    1231     if (type.compare("1X") == 0) {return CODETYPE_GALILEO_E1_BC;}
    1232     if (type.compare("1Z") == 0) {return CODETYPE_GALILEO_E1_ABC;}
    1233     if (type.compare("5I") == 0) {return CODETYPE_GALILEO_E5A_I;}
    1234     if (type.compare("5Q") == 0) {return CODETYPE_GALILEO_E5A_Q;}
    1235     if (type.compare("5X") == 0) {return CODETYPE_GALILEO_E5A_IQ;}
    1236     if (type.compare("7I") == 0) {return CODETYPE_GALILEO_E5B_I;}
    1237     if (type.compare("7Q") == 0) {return CODETYPE_GALILEO_E5B_Q;}
    1238     if (type.compare("7X") == 0) {return CODETYPE_GALILEO_E5B_IQ;}
    1239     if (type.compare("8I") == 0) {return CODETYPE_GALILEO_E5_I;}
    1240     if (type.compare("8Q") == 0) {return CODETYPE_GALILEO_E5_Q;}
    1241     if (type.compare("8X") == 0) {return CODETYPE_GALILEO_E5_IQ;}
    1242     if (type.compare("6A") == 0) {return CODETYPE_GALILEO_E6_A;}
    1243     if (type.compare("6B") == 0) {return CODETYPE_GALILEO_E6_B;}
    1244     if (type.compare("6C") == 0) {return CODETYPE_GALILEO_E6_C;}
    1245     if (type.compare("6X") == 0) {return CODETYPE_GALILEO_E6_BC;}
    1246     if (type.compare("6Z") == 0) {return CODETYPE_GALILEO_E6_ABC;}
     1204    if (type.compare("1A") == 0) { return CODETYPE_GALILEO_E1_A; }
     1205    if (type.compare("1B") == 0) { return CODETYPE_GALILEO_E1_B; }
     1206    if (type.compare("1C") == 0) { return CODETYPE_GALILEO_E1_C; }
     1207    if (type.compare("1X") == 0) { return CODETYPE_GALILEO_E1_BC; }
     1208    if (type.compare("1Z") == 0) { return CODETYPE_GALILEO_E1_ABC; }
     1209    if (type.compare("5I") == 0) { return CODETYPE_GALILEO_E5A_I; }
     1210    if (type.compare("5Q") == 0) { return CODETYPE_GALILEO_E5A_Q; }
     1211    if (type.compare("5X") == 0) { return CODETYPE_GALILEO_E5A_IQ; }
     1212    if (type.compare("7I") == 0) { return CODETYPE_GALILEO_E5B_I; }
     1213    if (type.compare("7Q") == 0) { return CODETYPE_GALILEO_E5B_Q; }
     1214    if (type.compare("7X") == 0) { return CODETYPE_GALILEO_E5B_IQ; }
     1215    if (type.compare("8I") == 0) { return CODETYPE_GALILEO_E5_I; }
     1216    if (type.compare("8Q") == 0) { return CODETYPE_GALILEO_E5_Q; }
     1217    if (type.compare("8X") == 0) { return CODETYPE_GALILEO_E5_IQ; }
     1218    if (type.compare("6A") == 0) { return CODETYPE_GALILEO_E6_A; }
     1219    if (type.compare("6B") == 0) { return CODETYPE_GALILEO_E6_B; }
     1220    if (type.compare("6C") == 0) { return CODETYPE_GALILEO_E6_C; }
     1221    if (type.compare("6X") == 0) { return CODETYPE_GALILEO_E6_BC; }
     1222    if (type.compare("6Z") == 0) { return CODETYPE_GALILEO_E6_ABC; }
    12471223  }
    1248    else if (system == 'J') {
    1249      if (type.compare("1C") == 0) {return CODETYPE_QZSS_L1_CA;}
    1250      if (type.compare("1S") == 0) {return CODETYPE_QZSS_L1C_D;}
    1251      if (type.compare("1L") == 0) {return CODETYPE_QZSS_L1C_P;}
    1252      if (type.compare("2S") == 0) {return CODETYPE_QZSS_L2C_M;}
    1253      if (type.compare("2L") == 0) {return CODETYPE_QZSS_L2C_L;}
    1254      if (type.compare("2X") == 0) {return CODETYPE_QZSS_L2C_ML;}
    1255      if (type.compare("5I") == 0) {return CODETYPE_QZSS_L5_I;}
    1256      if (type.compare("5Q") == 0) {return CODETYPE_QZSS_L5_Q;}
    1257      if (type.compare("5X") == 0) {return CODETYPE_QZSS_L5_IQ;}
    1258      if (type.compare("6S") == 0) {return CODETYPE_QZSS_L6_D;}
    1259      if (type.compare("6L") == 0) {return CODETYPE_QZSS_L6_P;}
    1260      if (type.compare("6X") == 0) {return CODETYPE_QZSS_L6_DP;}
    1261      if (type.compare("1X") == 0) {return CODETYPE_QZSS_L1C_DP;}
     1224  else if (system == 'J') {
     1225    if (type.compare("1C") == 0) { return CODETYPE_QZSS_L1_CA; }
     1226    if (type.compare("1S") == 0) { return CODETYPE_QZSS_L1C_D; }
     1227    if (type.compare("1L") == 0) { return CODETYPE_QZSS_L1C_P; }
     1228    if (type.compare("2S") == 0) { return CODETYPE_QZSS_L2C_M; }
     1229    if (type.compare("2L") == 0) { return CODETYPE_QZSS_L2C_L; }
     1230    if (type.compare("2X") == 0) { return CODETYPE_QZSS_L2C_ML; }
     1231    if (type.compare("5I") == 0) { return CODETYPE_QZSS_L5_I; }
     1232    if (type.compare("5Q") == 0) { return CODETYPE_QZSS_L5_Q; }
     1233    if (type.compare("5X") == 0) { return CODETYPE_QZSS_L5_IQ; }
     1234    if (type.compare("6S") == 0) { return CODETYPE_QZSS_L6_D; }
     1235    if (type.compare("6L") == 0) { return CODETYPE_QZSS_L6_P; }
     1236    if (type.compare("6X") == 0) { return CODETYPE_QZSS_L6_DP; }
     1237    if (type.compare("1X") == 0) { return CODETYPE_QZSS_L1C_DP; }
    12621238  }
    12631239  else if (system == 'C') {
    1264     if (type.compare("2I") == 0) {return CODETYPE_BDS_B1_I;}
    1265     if (type.compare("2Q") == 0) {return CODETYPE_BDS_B1_Q;}
    1266     if (type.compare("2X") == 0) {return CODETYPE_BDS_B1_IQ;}
    1267     if (type.compare("6I") == 0) {return CODETYPE_BDS_B3_I;}
    1268     if (type.compare("6Q") == 0) {return CODETYPE_BDS_B3_Q;}
    1269     if (type.compare("6X") == 0) {return CODETYPE_BDS_B3_IQ;}
    1270     if (type.compare("7I") == 0) {return CODETYPE_BDS_B2_I;}
    1271     if (type.compare("7Q") == 0) {return CODETYPE_BDS_B2_Q;}
    1272     if (type.compare("7X") == 0) {return CODETYPE_BDS_B2_IQ;}
    1273     if (type.compare("1D") == 0) {return CODETYPE_BDS_B1C_D;}
    1274     if (type.compare("1P") == 0) {return CODETYPE_BDS_B1C_P;}
    1275     if (type.compare("1X") == 0) {return CODETYPE_BDS_B1C_DP;}
    1276     if (type.compare("5D") == 0) {return CODETYPE_BDS_B2a_D;}
    1277     if (type.compare("5P") == 0) {return CODETYPE_BDS_B2a_P;}
    1278     if (type.compare("5X") == 0) {return CODETYPE_BDS_B2a_DP;}
    1279     if (type.compare("7D") == 0) {return CODETYPE_BDS_B2b_D;}
     1240    if (type.compare("2I") == 0) { return CODETYPE_BDS_B1_I; }
     1241    if (type.compare("2Q") == 0) { return CODETYPE_BDS_B1_Q; }
     1242    if (type.compare("2X") == 0) { return CODETYPE_BDS_B1_IQ; }
     1243    if (type.compare("6I") == 0) { return CODETYPE_BDS_B3_I; }
     1244    if (type.compare("6Q") == 0) { return CODETYPE_BDS_B3_Q; }
     1245    if (type.compare("6X") == 0) { return CODETYPE_BDS_B3_IQ; }
     1246    if (type.compare("7I") == 0) { return CODETYPE_BDS_B2_I; }
     1247    if (type.compare("7Q") == 0) { return CODETYPE_BDS_B2_Q; }
     1248    if (type.compare("7X") == 0) { return CODETYPE_BDS_B2_IQ; }
     1249    if (type.compare("1D") == 0) { return CODETYPE_BDS_B1C_D; }
     1250    if (type.compare("1P") == 0) { return CODETYPE_BDS_B1C_P; }
     1251    if (type.compare("1X") == 0) { return CODETYPE_BDS_B1C_DP; }
     1252    if (type.compare("5D") == 0) { return CODETYPE_BDS_B2a_D; }
     1253    if (type.compare("5P") == 0) { return CODETYPE_BDS_B2a_P; }
     1254    if (type.compare("5X") == 0) { return CODETYPE_BDS_B2a_DP; }
     1255    if (type.compare("7D") == 0) { return CODETYPE_BDS_B2b_D; }
    12801256  }
    12811257
    … …  
    12851261////////////////////////////////////////////////////////////////////////////
    12861262std::string SsrCorrRtcmNew::metaTypeToStr(unsigned int ind) {
    1287       if (ind == 1) return "satellite antenna PCV";
    1288       if (ind == 2) return "satellite antenna GDV";
    1289       if (ind == 3) return "solid earth tides";
    1290       if (ind == 4) return "ocean loading";
    1291       if (ind == 5) return "pole tides";
    1292       if (ind == 6) return "relativity";
    1293       if (ind == 7) return "GNSS BE reference";     
    1294 
    1295   return "reserved!";     
     1263  if (ind == 1) return "satellite antenna PCV";
     1264  if (ind == 2) return "satellite antenna GDV";
     1265  if (ind == 3) return "solid earth tides";
     1266  if (ind == 4) return "ocean loading";
     1267  if (ind == 5) return "pole tides";
     1268  if (ind == 6) return "relativity";
     1269  if (ind == 7) return "GNSS BE reference";
     1270
     1271  return "reserved!";
    12961272}

  • trunk/BNC/src/bnccore.cpp

    r10696 r11008  
    118118  qRegisterMetaType<QList<t_satPhaseBias> > ("QList<t_satPhaseBias>");
    119119  qRegisterMetaType<t_vTec>                 ("t_vTec");
     120  qRegisterMetaType<t_metaData>              ("t_metaData");
    120121}
    121122
    … …  
    731732//
    732733////////////////////////////////////////////////////////////////////////////
     734void t_bncCore::slotNewMetaData(t_metaData metaData) {
     735  QMutexLocker locker(&_mutex);
     736  emit newMetaData(metaData);
     737  if (_socketsCorr) {
     738    ostringstream out;
     739    t_metaData::write(&out, metaData);
     740    QMutableListIterator<QTcpSocket*> is(*_socketsCorr);
     741    while (is.hasNext()) {
     742      QTcpSocket* sock = is.next();
     743      if (sock->state() == QAbstractSocket::ConnectedState) {
     744        if (sock->write(out.str().c_str()) == -1) {
     745          delete sock;
     746          is.remove();
     747        }
     748      }
     749      else if (sock->state() != QAbstractSocket::ConnectingState) {
     750        delete sock;
     751        is.remove();
     752      }
     753    }
     754  }
     755}
     756
     757//
     758////////////////////////////////////////////////////////////////////////////
    733759void t_bncCore::setConfFileName(const QString& confFileName) {
    734760  if (confFileName.isEmpty()) {

  • trunk/BNC/src/bnccore.h

    r10753 r11008  
    8787  void slotNewPhaseBiases(QList<t_satPhaseBias>);
    8888  void slotNewTec(t_vTec);
     89  void slotNewMetaData(t_metaData);
    8990  void slotQuit();
    9091
    … …  
    101102  void newPhaseBiases(QList<t_satPhaseBias>);
    102103  void newTec(t_vTec);
     104  void newMetaData(t_metaData);
    103105  void providerIDChanged(QString);
    104106  void newPosition(QByteArray staID, bncTime time, QVector<double> xx);

  • trunk/BNC/src/rinex/corrfile.cpp

    r10791 r11008  
    119119      emit newTec(vTec);
    120120    }
     121    else if (corrType == t_corrSSR::metaData) {
     122      t_metaData metaData;
     123      t_metaData::read(_lastLine, _stream, metaData);
     124      emit newMetaData(metaData);
     125    }
    121126
    122127    _lastLine.clear();

  • trunk/BNC/src/rinex/corrfile.h

    r10791 r11008  
    4848  void newPhaseBiases(QList<t_satPhaseBias>);
    4949  void newTec(t_vTec);
     50  void newMetaData(t_metaData);
    5051
    5152 private:

  • trunk/BNC/src/satObs.cpp

    r11007 r11008  
    493493//
    494494////////////////////////////////////////////////////////////////////////////
     495void t_metaData::write(ostream* out, const t_metaData& md) {
     496  if (!out || md._entries.size() == 0) {
     497    return;
     498  }
     499  out->setf(ios::fixed);
     500  bncTime epoTime = md._time;
     501  *out << "> META_DATA " << epoTime.datestr(' ') << ' ' << epoTime.timestr(1, ' ') << " "
     502    << 0 << " " << md._entries.size() << ' ' << md._staID << endl;
     503  *out << md._ssrIOD << ' ' << md._providerID << ' ' << md._solutionID << endl;
     504  for (unsigned ii = 0; ii < md._entries.size(); ii++) {
     505    const t_metaDataEntry& entry = md._entries[ii];
     506    *out << setw(2) << entry._typeIndicator << ' '
     507      << setw(1) << entry._applicationIndicator << ' '
     508      << setw(1) << entry._nonDefaultIndicator << ' '
     509      << setw(2) << entry._nonDefaultIdentifier << ' '
     510      << setw(1) << entry._dataIODIndicator << ' '
     511      << setw(3) << entry._dataIOD << endl;
     512  }
     513  out->flush();
     514}
     515
     516//
     517////////////////////////////////////////////////////////////////////////////
     518void t_metaData::read(const string& epoLine, istream& inStream, t_metaData& md) {
     519  bncTime epoTime;
     520  unsigned int updateInt;
     521  int numEntries;
     522  string staID;
     523  if (t_corrSSR::readEpoLine(epoLine, epoTime, updateInt, numEntries, staID) != t_corrSSR::metaData) {
     524    return;
     525  }
     526  if (numEntries <= 0) {
     527    return;
     528  }
     529  md._time  = epoTime;
     530  md._staID = staID;
     531
     532  string line;
     533  getline(inStream, line);
     534  istringstream inHdr(line.c_str());
     535  inHdr >> md._ssrIOD >> md._providerID >> md._solutionID;
     536
     537  for (int ii = 0; ii < numEntries; ii++) {
     538    getline(inStream, line);
     539    istringstream in(line.c_str());
     540    t_metaDataEntry entry;
     541    in >> entry._typeIndicator >> entry._applicationIndicator >> entry._nonDefaultIndicator
     542       >> entry._nonDefaultIdentifier >> entry._dataIODIndicator >> entry._dataIOD;
     543    md._entries.push_back(entry);
     544  }
     545}
     546
     547//
     548////////////////////////////////////////////////////////////////////////////
    495549t_corrSSR::e_type t_corrSSR::readEpoLine(const string& line, bncTime& epoTime,
    496550  unsigned int& updateInt, int& numEntries,
    … …  
    525579    else if (typeString == "URA") {
    526580      return URA;
     581    }
     582    else if (typeString == "META_DATA") {
     583      return metaData;
    527584    }
    528585  }

  • trunk/BNC/src/satObs.h

    r10999 r11008  
    245245};
    246246
     247class t_metaDataEntry {
     248 public:
     249  t_metaDataEntry() {
     250    _typeIndicator         = 0;
     251    _applicationIndicator  = false;
     252    _nonDefaultIndicator   = false;
     253    _nonDefaultIdentifier  = 0;
     254    _dataIODIndicator      = false;
     255    _dataIOD               = 0;
     256  }
     257  unsigned int _typeIndicator;        // model correction type (solid earth tides, ocean loading, ...)
     258  bool         _applicationIndicator; // model correction applied by the provider?
     259  bool         _nonDefaultIndicator;
     260  unsigned int _nonDefaultIdentifier; // only valid if _nonDefaultIndicator
     261  bool         _dataIODIndicator;
     262  unsigned int _dataIOD;              // only valid if _dataIODIndicator
     263};
     264
     265class t_metaData {
     266 public:
     267  t_metaData() {
     268    _ssrIOD     = 0;
     269    _providerID = 0;
     270    _solutionID = 0;
     271  }
     272  static void write(std::ostream* out, const t_metaData& md);
     273  static void read(const std::string& epoLine, std::istream& in, t_metaData& md);
     274  std::string                  _staID;
     275  bncTime                      _time;
     276  unsigned int                 _ssrIOD;
     277  unsigned int                 _providerID;
     278  unsigned int                 _solutionID;
     279  std::vector<t_metaDataEntry> _entries;
     280};
     281
    247282class t_corrSSR {
    248283 public:
    249   enum e_type {clkCorr, orbCorr, codeBias, phaseBias, vTec, URA, unknown};
     284  enum e_type {clkCorr, orbCorr, codeBias, phaseBias, vTec, URA, metaData, unknown};
    250285  static e_type readEpoLine(const std::string& line, bncTime& epoTime,
    251286                            unsigned int& updateInt, int& numEntries, std::string& staID);
Note: See TracChangeset for help on using the changeset viewer.