Changeset 8987 in ntrip


Ignore:
Timestamp:
Jul 20, 2020, 3:54:44 PM (3 weeks ago)
Author:
stuerze
Message:

initial import igs ssr encoding and decoding + debug output

Location:
branches/BNC_2.12/src
Files:
2 added
7 edited

Legend:

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

    r8938 r8987  
    14291429    GETFLOATSIGN(eph._omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))
    14301430    GETFLOATSIGN(eph._OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))
    1431     GETFLOATSIGN(eph._BGD_1_5A, 10,
    1432         1.0 / (double )(1 << 30) / (double )(1 << 2))
     1431    GETFLOATSIGN(eph._BGD_1_5A, 10, 1.0 / (double )(1 << 30) / (double )(1 << 2))
    14331432    if (eph._inav) {
    14341433      /* set unused F/NAV values */
     
    16241623       * extracted data block. That does no harm, as it anyway skip everything
    16251624       * else. */
    1626       if ((id >= 1057 && id <= 1068) || (id >= 1240 && id <= 1270)) {
     1625      if ((id >= 1057 && id <= 1068) ||
     1626          (id >= 1240 && id <= 1270) ||
     1627          (id == 4076)) {
    16271628        if (!_coDecoders.contains(_staID.toAscii()))
    16281629          _coDecoders[_staID.toAscii()] = new RTCM3coDecoder(_staID);
  • branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.cpp

    r8943 r8987  
    647647  }
    648648  else if (epoSecGlo != -1) {
     649#ifdef USE_SSR_RTCM
    649650    QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
    650651    epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
     652#endif
    651653    _lastTime.set(currentWeek, epoSecGlo);
    652654  }
     
    661663  }
    662664  else if (epoSecBds != -1) {
     665#ifdef USE_SSR_RTCM
    663666    epoSecBds += 14.0;
    664667    if (epoSecBds > 604800.0) {
    665668      epoSecBds -= 7.0*24.0*60.0*60.0;
    666669    }
     670#endif
    667671    _lastTime.set(currentWeek, epoSecBds);
    668672  }
     
    687691      case CODETYPEGPS_L1_P:          return "1P";
    688692      case CODETYPEGPS_L1_Z:          return "1W";
    689       //case CODETYPEGPS_L1_Y:          return "1Y";
    690       //case CODETYPEGPS_L1_M:          return "1M";
     693
    691694      case CODETYPEGPS_SEMI_CODELESS: return "2D";
    692695      case CODETYPEGPS_L2_CA:         return "2C";
     
    696699      case CODETYPEGPS_L2C_M:         return "2S";
    697700      case CODETYPEGPS_L2C_L:         return "2L";
     701#ifdef USE_SSR_RTCM
    698702      case CODETYPEGPS_L2C_ML:        return "2X";
    699 
    700       //case CODETYPEGPS_L2_Y:          return "2Y";
    701       //case CODETYPEGPS_L2_M:          return "2M";
     703#endif
    702704
    703705      case CODETYPEGPS_L5_I:          return "5I";
    704706      case CODETYPEGPS_L5_Q:          return "5Q";
     707#ifdef USE_SSR_RTCM
    705708      case CODETYPEGPS_L5_IQ:         return "5X";
    706 
     709#endif
    707710      case CODETYPEGPS_L1C_D:         return "1S";
    708711      case CODETYPEGPS_L1C_P:         return "1L";
     712#ifdef USE_SSR_RTCM
    709713      case CODETYPEGPS_L1C_DP:        return "1X";
     714#endif
    710715      default: return "";
    711716    }
     
    715720      case CODETYPEGLONASS_L1_CA:     return "1C";
    716721      case CODETYPEGLONASS_L1_P:      return "1P";
    717 
    718722      case CODETYPEGLONASS_L2_CA:     return "2C";
    719723      case CODETYPEGLONASS_L2_P:      return "2P";
    720 
    721724      case CODETYPEGLONASS_L1a_OCd:   return "4A";
    722725      case CODETYPEGLONASS_L1a_OCp:   return "4B";
     726#ifdef USE_SSR_RTCM
    723727      case CODETYPEGLONASS_L1a_OCdp:  return "4X";
    724 
     728#endif
    725729      case CODETYPEGLONASS_L2a_CSI:   return "6A";
    726730      case CODETYPEGLONASS_L2a_OCp:   return "6B";
     731#ifdef USE_SSR_RTCM
    727732      case CODETYPEGLONASS_L2a_CSIOCp:return "6X";
    728 
     733#endif
    729734      case CODETYPEGLONASS_L3_I:      return "3I";
    730735      case CODETYPEGLONASS_L3_Q:      return "3Q";
     736#ifdef USE_SSR_RTCM
    731737      case CODETYPEGLONASS_L3_IQ:     return "3X";
     738#endif
    732739      default: return "";
    733740    }
     
    735742  else if (system == 'E') {
    736743    switch (type) {
    737       case CODETYPEGALILEO_E1_A:      return "1A";
    738       case CODETYPEGALILEO_E1_B:      return "1B";
    739       case CODETYPEGALILEO_E1_C:      return "1C";
    740       case CODETYPEGALILEO_E1_BC:     return "1X";
    741       case CODETYPEGALILEO_E1_ABC:    return "1Z";
    742 
    743       case CODETYPEGALILEO_E5A_I:     return "5I";
    744       case CODETYPEGALILEO_E5A_Q:     return "5Q";
    745       case CODETYPEGALILEO_E5A_IQ:    return "5X";
    746 
    747       case CODETYPEGALILEO_E5B_I:     return "7I";
    748       case CODETYPEGALILEO_E5B_Q:     return "7Q";
    749       case CODETYPEGALILEO_E5B_IQ:    return "7X";
    750 
    751       case CODETYPEGALILEO_E5_I:      return "8I";
    752       case CODETYPEGALILEO_E5_Q:      return "8Q";
    753       case CODETYPEGALILEO_E5_IQ:     return "8X";
    754 
    755       case CODETYPEGALILEO_E6_A:      return "6A";
    756       case CODETYPEGALILEO_E6_B:      return "6B";
    757       case CODETYPEGALILEO_E6_C:      return "6C";
    758       case CODETYPEGALILEO_E6_BC:     return "6X";
    759       case CODETYPEGALILEO_E6_ABC:    return "6Z";
     744      case CODETYPEGALILEO_E1_A:       return "1A";
     745      case CODETYPEGALILEO_E1_B:       return "1B";
     746      case CODETYPEGALILEO_E1_C:       return "1C";
     747#ifdef USE_SSR_RTCM
     748      case CODETYPEGALILEO_E1_BC:      return "1X";
     749      case CODETYPEGALILEO_E1_ABC:     return "1Z";
     750#endif
     751      case CODETYPEGALILEO_E5A_I:      return "5I";
     752      case CODETYPEGALILEO_E5A_Q:      return "5Q";
     753#ifdef USE_SSR_RTCM
     754      case CODETYPEGALILEO_E5A_IQ:     return "5X";
     755#endif
     756      case CODETYPEGALILEO_E5B_I:      return "7I";
     757      case CODETYPEGALILEO_E5B_Q:      return "7Q";
     758#ifdef USE_SSR_RTCM
     759      case CODETYPEGALILEO_E5B_IQ:     return "7X";
     760
     761      case CODETYPEGALILEO_E5_I:       return "8I";
     762      case CODETYPEGALILEO_E5_Q:       return "8Q";
     763      case CODETYPEGALILEO_E5_IQ:      return "8X";
     764#endif
     765      case CODETYPEGALILEO_E6_A:       return "6A";
     766      case CODETYPEGALILEO_E6_B:       return "6B";
     767      case CODETYPEGALILEO_E6_C:       return "6C";
     768#ifdef USE_SSR_RTCM
     769      case CODETYPEGALILEO_E6_BC:      return "6X";
     770      case CODETYPEGALILEO_E6_ABC:     return "6Z";
     771#endif
    760772      default: return "";
    761773    }
    762774  }
    763   else if (system == 'J') {
     775   else if (system == 'J') {
    764776    switch (type) {
    765777      case CODETYPEQZSS_L1_CA:         return "1C";
     
    769781      case CODETYPEQZSS_L2C_M:         return "2S";
    770782      case CODETYPEQZSS_L2C_L:         return "2L";
     783#ifdef USE_SSR_RTCM
    771784      case CODETYPEQZSS_L2C_ML:        return "2X";
    772 
     785#endif
    773786      case CODETYPEQZSS_L5_I:          return "5I";
    774787      case CODETYPEQZSS_L5_Q:          return "5Q";
     788#ifdef USE_SSR_RTCM
    775789      case CODETYPEQZSS_L5_IQ:         return "5X";
    776 
     790#endif
    777791      case CODETYPEQZSS_L6_D:          return "6S";
    778792      case CODETYPEQZSS_L6_P:          return "6L";
     793#ifdef USE_SSR_RTCM
    779794      case CODETYPEQZSS_L6_DP:         return "6X";
    780795
     
    785800      case CODETYPEQZSS_L5_P:          return "5P";
    786801      case CODETYPEQZSS_L5_DP:         return "5Z";
     802#endif
    787803
    788804      case CODETYPEQZSS_L6_E:          return "6E";
     805#ifdef USE_SSR_RTCM
    789806      case CODETYPEQZSS_L6_DE:         return "6Z";
    790       default: return "";
    791     }
    792   }
    793   else if (system == 'S') {
    794     switch (type) {
    795       case CODETYPE_SBAS_L1_CA:       return "1C";
    796 
    797       case CODETYPE_SBAS_L5_I:        return "5I";
    798       case CODETYPE_SBAS_L5_Q:        return "5Q";
    799       case CODETYPE_SBAS_L5_IQ:       return "5X";
     807#endif
    800808      default: return "";
    801809    }
     
    805813      case CODETYPE_BDS_B1_I:         return "2I";
    806814      case CODETYPE_BDS_B1_Q:         return "2Q";
     815#ifdef USE_SSR_RTCM
    807816      case CODETYPE_BDS_B1_IQ:        return "2X";
    808 
     817#endif
    809818      case CODETYPE_BDS_B3_I:         return "6I";
    810819      case CODETYPE_BDS_B3_Q:         return "6Q";
     820#ifdef USE_SSR_RTCM
    811821      case CODETYPE_BDS_B3_IQ:        return "6X";
    812 
     822#endif
    813823      case CODETYPE_BDS_B2_I:         return "7I";
    814824      case CODETYPE_BDS_B2_Q:         return "7Q";
     825#ifdef USE_SSR_RTCM
    815826      case CODETYPE_BDS_B2_IQ:        return "7X";
    816 
     827#endif
    817828      case CODETYPE_BDS_B1a_D:        return "1D";
    818829      case CODETYPE_BDS_B1a_P:        return "1P";
     830#ifdef USE_SSR_RTCM
    819831      case CODETYPE_BDS_B1a_DP:       return "1X";
    820 
     832#endif
    821833      case CODETYPE_BDS_B2a_D:        return "5D";
    822834      case CODETYPE_BDS_B2a_P:        return "5P";
     835#ifdef USE_SSR_RTCM
    823836      case CODETYPE_BDS_B2a_DP:       return "5X";
     837#elif USE_SSR_IGS
     838      case CODETYPE_BDS_B1_A:         return "1A";
     839      case CODETYPE_BDS_B3_A:         return "6A";
     840#endif
     841      default: return "";
     842    }
     843  }
     844  else if (system == 'S') {
     845    switch (type) {
     846      case CODETYPE_SBAS_L1_CA:       return "1C";
     847
     848      case CODETYPE_SBAS_L5_I:        return "5I";
     849      case CODETYPE_SBAS_L5_Q:        return "5Q";
     850#ifdef USE_SSR_RTCM
     851      case CODETYPE_SBAS_L5_IQ:       return "5X";
     852#endif
    824853      default: return "";
    825854    }
  • branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.h

    r7169 r8987  
    3232
    3333extern "C" {
    34 # include "clock_orbit_rtcm.h"
     34#ifdef USE_SSR_RTCM
     35#include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h"
     36#elif  USE_SSR_IGS
     37#include "../RTCM3/clock_and_orbit/clock_orbit_igs.h"
     38#endif
    3539}
    3640
  • branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c

    r8942 r8987  
    1818#include "clock_orbit_rtcm.h"
    1919
    20 static uint32_t CRC24(long size, const unsigned char *buf)
    21 {
     20static uint32_t CRC24(long size, const unsigned char *buf) {
    2221  uint32_t crc = 0;
    2322  int i;
    2423
    25   while(size--)
    26   {
     24  while (size--) {
    2725    crc ^= (*buf++) << (16);
    28     for(i = 0; i < 8; i++)
    29     {
     26    for (i = 0; i < 8; i++)
     27        {
    3028      crc <<= 1;
    31       if(crc & 0x1000000)
     29      if (crc & 0x1000000)
    3230        crc ^= 0x01864cfb;
    3331    }
     
    3735
    3836/* NOTE: These defines are interlinked with below functions and directly modify
    39 the values. This may not be optimized in terms of final program code size but
    40 should be optimized in terms of speed.
    41 
    42 modified variables are:
    43 - everything defined in STARTDATA (only use ressize outside of the defines,
    44   others are private)
    45 - buffer
    46 - size
    47 */
     37 the values. This may not be optimized in terms of final program code size but
     38 should be optimized in terms of speed.
     39
     40 modified variables are:
     41 - everything defined in STARTDATA (only use ressize outside of the defines,
     42 others are private)
     43 - buffer
     44 - size
     45 */
    4846
    4947#ifndef NOENCODE
    5048#define STOREBITS \
    51   while(numbits >= 8) \
    52   { \
     49  while(numbits >= 8) { \
    5350    if(!size) return 0; \
    5451    *(buffer++) = bitbuffer>>(numbits-8); \
     
    5855  }
    5956
    60 #define ADDBITS(a, b) \
    61   { \
     57#define ADDBITS(a, b) { \
    6258    bitbuffer = (bitbuffer<<(a))|((b)&((1<<a)-1)); \
    6359    numbits += (a); \
     
    7975
    8076#define ENDBLOCK \
    81   if(numbits) { ADDBITS((8-numbits), 0) } \
    82   { \
     77  if(numbits) { ADDBITS((8-numbits), 0) } { \
    8378    int len = buffer-blockstart-3; \
    8479    blockstart[1] |= len>>8; \
     
    9590
    9691/* GPS macros also used for other systems when matching! */
    97 #define T_MESSAGE_NUMBER(a)              ADDBITS(12, a)     /* DF002 */
    98 #define T_GPS_SATELLITE_ID(a)            ADDBITS(6, a)      /* DF068 */
    99 #define T_QZSS_SATELLITE_ID(a)           ADDBITS(4, a)      /* DF249 */
    100 #define T_GLONASS_SATELLITE_ID(a)        ADDBITS(5, a)
    101 
    102 #define T_GPS_IODE(a)                    ADDBITS(8, a)      /* DF071 */
    103 #define T_GLONASS_IOD(a)                 ADDBITS(8, a)      /* DF239 */
    104 #define T_GALILEO_IOD(a)                 ADDBITS(10, a)     /* DF459 */
    105 #define T_SBAS_T0MOD(a)                  ADDBITS(9, (a/16)) /* DF468 */
    106 #define T_SBAS_IODCRC(a)                 ADDBITS(24, a)     /* DF469 */
    107 #define T_BDS_TOEMOD(a)                  ADDBITS(10, (a/8)) /* DF470 */
    108 #define T_BDS_IOD(a)                     ADDBITS(8, a)      /* DF471 */
     92#define T_RTCM_MESSAGE_NUMBER(a)         ADDBITS(12, a)      /* DF002 */
     93#define T_GPS_SATELLITE_ID(a)            ADDBITS( 6, a)      /* DF068 */
     94#define T_QZSS_SATELLITE_ID(a)           ADDBITS( 4, a)      /* DF249 */
     95#define T_GLONASS_SATELLITE_ID(a)        ADDBITS( 5, a)
     96
     97#define T_GPS_IODE(a)                    ADDBITS( 8, a)      /* DF071 */
     98#define T_GLONASS_IOD(a)                 ADDBITS( 8, a)      /* DF239 */
     99#define T_GALILEO_IOD(a)                 ADDBITS(10, a)      /* DF459 */
     100#define T_SBAS_T0MOD(a)                  ADDBITS( 9, (a/16)) /* DF468 */
     101#define T_SBAS_IODCRC(a)                 ADDBITS(24, a)      /* DF469 */
     102#define T_BDS_TOEMOD(a)                  ADDBITS(10, (a/8))  /* DF470 */
     103#define T_BDS_IOD(a)                     ADDBITS( 8, a)      /* DF471 */
    109104
    110105#define T_DELTA_RADIAL(a)                SCALEADDBITS(22,    10000.0, a)
     
    119114#define T_DELTA_CLOCK_C1(a)              SCALEADDBITS(21,  1000000.0, a)
    120115#define T_DELTA_CLOCK_C2(a)              SCALEADDBITS(27, 50000000.0, a)
    121 #define T_NO_OF_CODE_BIASES(a)           ADDBITS(5, a)
    122 #define T_NO_OF_PHASE_BIASES(a)          ADDBITS(5, a)
    123 #define T_SIGNAL_IDENTIFIER(a)           ADDBITS(5, a)
     116#define T_NO_OF_CODE_BIASES(a)           ADDBITS( 5, a)
     117#define T_NO_OF_PHASE_BIASES(a)          ADDBITS( 5, a)
     118#define T_SIGNAL_IDENTIFIER(a)           ADDBITS( 5, a)
    124119#define T_CODE_BIAS(a)                   SCALEADDBITS(14,      100.0, a)
    125 #define T_YAW_ANGLE(a)                   SCALEADDBITS(9,   256.0/MPI, a)
    126 #define T_YAW_RATE(a)                    SCALEADDBITS(8, 8192.0/MPI, a)
     120#define T_YAW_ANGLE(a)                   SCALEADDBITS( 9,  256.0/MPI, a)
     121#define T_YAW_RATE(a)                    SCALEADDBITS( 8, 8192.0/MPI, a)
    127122#define T_PHASE_BIAS(a)                  SCALEADDBITS(20,    10000.0, a)
    128123
    129124#define T_GPS_EPOCH_TIME(a)              ADDBITS(20, a)
    130125#define T_GLONASS_EPOCH_TIME(a)          ADDBITS(17, a)
    131 #define T_NO_OF_SATELLITES(a)            ADDBITS(6, a)
    132 #define T_MULTIPLE_MESSAGE_INDICATOR(a)  ADDBITS(1, a)
    133 #define T_DISPERSIVE_BIAS_INDICATOR(a)   ADDBITS(1, a)
    134 #define T_MW_CONSISTENCY_INDICATOR(a)    ADDBITS(1, a)
    135 #define T_INTEGER_INDICATOR(a)           ADDBITS(1, a)
    136 #define T_WIDE_LANE_INDICATOR(a)         ADDBITS(2, a)
    137 #define T_DISCONTINUITY_COUNTER(a)       ADDBITS(4, a)
    138 #define T_SSR_URA(a)                     ADDBITS(6, a)
     126#define T_NO_OF_SATELLITES(a)            ADDBITS( 6, a)
     127#define T_MULTIPLE_MESSAGE_INDICATOR(a)  ADDBITS( 1, a)
     128#define T_DISPERSIVE_BIAS_INDICATOR(a)   ADDBITS( 1, a)
     129#define T_MW_CONSISTENCY_INDICATOR(a)    ADDBITS( 1, a)
     130#define T_INTEGER_INDICATOR(a)           ADDBITS( 1, a)
     131#define T_WIDE_LANE_INDICATOR(a)         ADDBITS( 2, a)
     132#define T_DISCONTINUITY_COUNTER(a)       ADDBITS( 4, a)
     133#define T_SSR_URA(a)                     ADDBITS( 6, a)
    139134#define T_HR_CLOCK_CORRECTION(a)         SCALEADDBITS(22,    10000.0, a)
    140 #define T_SSR_UPDATE_INTERVAL(a)         ADDBITS(4, a)
    141 
    142 #define T_SSR_IOD(a)                     ADDBITS(4, a)
     135#define T_SSR_UPDATE_INTERVAL(a)         ADDBITS( 4, a)
     136
     137#define T_SSR_IOD(a)                     ADDBITS( 4, a)
    143138#define T_SSR_PROVIDER_ID(a)             ADDBITS(16, a)
    144 #define T_SSR_SOLUTION_ID(a)             ADDBITS(4, a)
    145 
    146 #define T_NO_IONO_LAYERS(a)              ADDBITS(2, a-1)
    147 #define T_VTEC_QUALITY_INDICATOR(a)      SCALEADDBITS(9,        20.0, a)
     139#define T_SSR_SOLUTION_ID(a)             ADDBITS( 4, a)
     140
     141#define T_NO_IONO_LAYERS(a)              ADDBITS( 2, a-1)
     142#define T_VTEC_QUALITY_INDICATOR(a)      SCALEADDBITS( 9,       20.0, a)
    148143#define T_IONO_COEFF(a)                  SCALEADDBITS(16,      200.0, a)
    149 #define T_IONO_DEGREE(a)                 ADDBITS(4, a-1)
    150 #define T_IONO_ORDER(a)                  ADDBITS(4, a-1)
    151 #define T_IONO_HEIGHT(a)                 SCALEADDBITS(8,   1/10000.0, a)
    152 
    153 static double URAToValue(int ura)
    154 {
     144#define T_IONO_DEGREE(a)                 ADDBITS( 4, a-1)
     145#define T_IONO_ORDER(a)                  ADDBITS( 4, a-1)
     146#define T_IONO_HEIGHT(a)                 SCALEADDBITS( 8,   1/10000.0, a)
     147
     148static double URAToValue(int ura) {
    155149  int urac, urav;
    156150  urac = ura >> 3;
    157151  urav = ura & 7;
    158   if(!ura)
     152  if (!ura)
    159153    return 0;
    160   else if(ura == 63)
     154  else if (ura == 63)
    161155    return SSR_MAXURA;
    162   return (pow(3,urac)*(1.0+urav/4.0)-1.0)/1000.0;
     156  return (pow(3, urac) * (1.0 + urav / 4.0) - 1.0) / 1000.0;
    163157}
    164158
    165 static int ValueToURA(double val)
    166 {
     159static int ValueToURA(double val) {
    167160  int ura;
    168   if(!val)
     161  if (!val)
    169162    return 0;
    170   else if(val > 5.4665)
     163  else if (val > 5.4665)
    171164    return 63;
    172   for(ura = 1; ura < 63 && val > URAToValue(ura); ++ura)
     165  for (ura = 1; ura < 63 && val > URAToValue(ura); ++ura)
    173166    ;
    174167  return ura;
    175168}
    176169
    177 static const enum ClockOrbitType corbase[CLOCKORBIT_SATNUM] =
    178 {
    179   (int) COBBASE_GPS, (int) COBBASE_GLONASS, (int) COBBASE_GALILEO,
    180   (int) COBBASE_QZSS, (int) COBBASE_SBAS, (int) COBBASE_BDS
     170static const enum ClockOrbitType corbase[CLOCKORBIT_SATNUM] = {
     171  (int) COBBASE_GPS,
     172  (int) COBBASE_GLONASS,
     173  (int) COBBASE_GALILEO,
     174  (int) COBBASE_QZSS,
     175  (int) COBBASE_SBAS,
     176  (int) COBBASE_BDS
    181177};
    182 static const enum COR_OFFSETS satoffset[CLOCKORBIT_SATNUM+1] =
    183 {
    184   CLOCKORBIT_OFFSETGPS, CLOCKORBIT_OFFSETGLONASS, CLOCKORBIT_OFFSETGALILEO,
    185   CLOCKORBIT_OFFSETQZSS, CLOCKORBIT_OFFSETSBAS, CLOCKORBIT_OFFSETBDS,
     178
     179static const enum COR_OFFSETS satoffset[CLOCKORBIT_SATNUM + 1] = {
     180  CLOCKORBIT_OFFSETGPS,
     181  CLOCKORBIT_OFFSETGLONASS,
     182  CLOCKORBIT_OFFSETGALILEO,
     183  CLOCKORBIT_OFFSETQZSS,
     184  CLOCKORBIT_OFFSETSBAS,
     185  CLOCKORBIT_OFFSETBDS,
    186186  CLOCKORBIT_COUNTSAT
    187187};
    188188
    189189size_t MakeClockOrbit(const struct ClockOrbit *co, enum ClockOrbitType type,
    190 int moremessagesfollow, char *buffer, size_t size)
    191 {
     190    int moremessagesfollow, char *buffer, size_t size) {
    192191  unsigned int status[CLOCKORBIT_SATNUM][COBOFS_NUM], i, s;
    193192
    194193  memset(status, 0, sizeof(status));
     194
    195195  STARTDATA
    196196
    197   for(s = 0; s < CLOCKORBIT_SATNUM; ++s)
    198   {
    199     for(i = 0; i < COBOFS_NUM; ++i)
    200     {
    201       if(co->NumberOfSat[s] && (type == COTYPE_AUTO
    202       || type == corbase[s]+i) && (co->Supplied[i] || (i <= COBOFS_CLOCK
    203       && co->Supplied[COBOFS_COMBINED]) || (i == COBOFS_COMBINED
    204       && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK])))
    205       {
     197  for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
     198    for (i = 0; i < COBOFS_NUM; ++i) {
     199      if (co->NumberOfSat[s] && (type == COTYPE_AUTO || type == corbase[s] + i) &&
     200           (co->Supplied[i] || (i <= COBOFS_CLOCK &&  co->Supplied[COBOFS_COMBINED]) ||
     201           (i == COBOFS_COMBINED && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK]))) {
    206202        status[s][i] = 1;
    207         if(i == COBOFS_COMBINED)
    208         {
     203        if (i == COBOFS_COMBINED) {
    209204          status[s][COBOFS_ORBIT] = status[s][COBOFS_CLOCK] = 0;
    210205        } /* disable single blocks for combined type */
     
    213208  } /* iterate over satellite systems */
    214209
    215   for(s = 0; s < CLOCKORBIT_SATNUM; ++s)
    216   {
    217     if(status[s][COBOFS_ORBIT])
    218     {
     210  for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
     211    if (status[s][COBOFS_ORBIT]) {
    219212      INITBLOCK
    220       T_MESSAGE_NUMBER(corbase[s]+COBOFS_ORBIT)
    221       switch(s)
    222       {
    223       case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    224       case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    225       case CLOCKORBIT_SATBDS:
    226         T_GPS_EPOCH_TIME(co->EpochTime[s])
    227         break;
    228       case CLOCKORBIT_SATGLONASS:
    229         T_GLONASS_EPOCH_TIME(co->EpochTime[s])
    230         break;
     213      T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_ORBIT)
     214      switch (s) {
     215        case CLOCKORBIT_SATGPS:
     216        case CLOCKORBIT_SATGALILEO:
     217        case CLOCKORBIT_SATQZSS:
     218        case CLOCKORBIT_SATSBAS:
     219        case CLOCKORBIT_SATBDS:
     220          T_GPS_EPOCH_TIME(co->EpochTime[s])
     221          break;
     222        case CLOCKORBIT_SATGLONASS:
     223          T_GLONASS_EPOCH_TIME(co->EpochTime[s])
     224          break;
    231225      }
    232226      T_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     
    237231      T_SSR_SOLUTION_ID(co->SSRSolutionID)
    238232      T_NO_OF_SATELLITES(co->NumberOfSat[s])
    239       for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i)
    240       {
    241         switch(s)
    242         {
    243         case CLOCKORBIT_SATGPS:
    244           T_GPS_SATELLITE_ID(co->Sat[i].ID)
    245           T_GPS_IODE(co->Sat[i].IOD)
    246           break;
    247         case CLOCKORBIT_SATGLONASS:
    248           T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
    249           T_GLONASS_IOD(co->Sat[i].IOD)
    250           break;
    251         case CLOCKORBIT_SATGALILEO:
    252           T_GPS_SATELLITE_ID(co->Sat[i].ID)
    253           T_GALILEO_IOD(co->Sat[i].IOD)
    254           break;
    255         case CLOCKORBIT_SATQZSS:
    256           T_QZSS_SATELLITE_ID(co->Sat[i].ID)
    257           T_GPS_IODE(co->Sat[i].IOD)
    258           break;
    259         case CLOCKORBIT_SATSBAS:
    260           T_GPS_SATELLITE_ID(co->Sat[i].ID)
    261           T_SBAS_T0MOD(co->Sat[i].toe)
    262           T_SBAS_IODCRC(co->Sat[i].IOD)
    263           break;
    264         case CLOCKORBIT_SATBDS:
    265           T_GPS_SATELLITE_ID(co->Sat[i].ID)
    266           T_BDS_TOEMOD(co->Sat[i].toe)
    267           T_BDS_IOD(co->Sat[i].IOD)
    268           break;
     233      for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     234        switch (s)         {
     235          case CLOCKORBIT_SATGPS:
     236            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     237            T_GPS_IODE(co->Sat[i].IOD)
     238            break;
     239          case CLOCKORBIT_SATGLONASS:
     240            T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
     241            T_GLONASS_IOD(co->Sat[i].IOD)
     242            break;
     243          case CLOCKORBIT_SATGALILEO:
     244            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     245            T_GALILEO_IOD(co->Sat[i].IOD)
     246            break;
     247          case CLOCKORBIT_SATQZSS:
     248            T_QZSS_SATELLITE_ID(co->Sat[i].ID)
     249            T_GPS_IODE(co->Sat[i].IOD)
     250            break;
     251          case CLOCKORBIT_SATSBAS:
     252            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     253            T_SBAS_T0MOD(co->Sat[i].toe)
     254            T_SBAS_IODCRC(co->Sat[i].IOD)
     255            break;
     256          case CLOCKORBIT_SATBDS:
     257            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     258            T_BDS_TOEMOD(co->Sat[i].toe)
     259            T_BDS_IOD(co->Sat[i].IOD)
     260            break;
    269261        }
    270262        T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
     
    277269      ENDBLOCK
    278270    }
    279     if(status[s][COBOFS_CLOCK])
    280     {
     271    if (status[s][COBOFS_CLOCK]) {
    281272      INITBLOCK
    282       T_MESSAGE_NUMBER(corbase[s]+COBOFS_CLOCK)
    283       switch(s)
    284       {
    285       case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    286       case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    287       case CLOCKORBIT_SATBDS:
    288         T_GPS_EPOCH_TIME(co->EpochTime[s])
    289         break;
    290       case CLOCKORBIT_SATGLONASS:
    291         T_GLONASS_EPOCH_TIME(co->EpochTime[s])
    292         break;
     273      T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_CLOCK)
     274      switch (s) {
     275        case CLOCKORBIT_SATGPS:
     276        case CLOCKORBIT_SATGALILEO:
     277        case CLOCKORBIT_SATQZSS:
     278        case CLOCKORBIT_SATSBAS:
     279        case CLOCKORBIT_SATBDS:
     280          T_GPS_EPOCH_TIME(co->EpochTime[s])
     281          break;
     282        case CLOCKORBIT_SATGLONASS:
     283          T_GLONASS_EPOCH_TIME(co->EpochTime[s])
     284          break;
    293285      }
    294286      T_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     
    298290      T_SSR_SOLUTION_ID(co->SSRSolutionID)
    299291      T_NO_OF_SATELLITES(co->NumberOfSat[s])
    300       for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i)
    301       {
    302         switch(s)
    303         {
    304         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    305         case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    306           T_GPS_SATELLITE_ID(co->Sat[i].ID)
    307           break;
    308         case CLOCKORBIT_SATQZSS:
    309           T_QZSS_SATELLITE_ID(co->Sat[i].ID)
    310           break;
    311         case CLOCKORBIT_SATGLONASS:
    312           T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
    313           break;
     292      for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     293        switch (s) {
     294          case CLOCKORBIT_SATGPS:
     295          case CLOCKORBIT_SATGALILEO:
     296          case CLOCKORBIT_SATSBAS:
     297          case CLOCKORBIT_SATBDS:
     298            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     299            break;
     300          case CLOCKORBIT_SATQZSS:
     301            T_QZSS_SATELLITE_ID(co->Sat[i].ID)
     302            break;
     303          case CLOCKORBIT_SATGLONASS:
     304            T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
     305            break;
    314306        }
    315307        T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
     
    319311      ENDBLOCK
    320312    }
    321     if(status[s][COBOFS_COMBINED])
    322     {
     313    if (status[s][COBOFS_COMBINED]) {
    323314#ifdef SPLITBLOCK
    324315      int nums = co->NumberOfSat[s];
    325316      int left, start = satoffset[s];
    326       if(nums > 28) /* split block when more than 28 sats */
    327       {
     317      if(nums > 28) {/* split block when more than 28 sats */
    328318        left = nums - 28;
    329319        nums = 28;
    330320      }
    331       else
    332       {
     321      else {
    333322        left = 0;
    334323      }
    335       while(nums)
    336       {
    337 #endif
    338         INITBLOCK
    339         T_MESSAGE_NUMBER(corbase[s]+COBOFS_COMBINED)
    340         switch(s)
    341         {
    342         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    343         case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
     324      while(nums) {
     325#endif
     326      INITBLOCK
     327      T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_COMBINED)
     328      switch (s) {
     329        case CLOCKORBIT_SATGPS:
     330        case CLOCKORBIT_SATGALILEO:
     331        case CLOCKORBIT_SATQZSS:
     332        case CLOCKORBIT_SATSBAS:
    344333        case CLOCKORBIT_SATBDS:
    345334          T_GPS_EPOCH_TIME(co->EpochTime[s])
     
    348337          T_GLONASS_EPOCH_TIME(co->EpochTime[s])
    349338          break;
    350         }
    351         T_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     339      }
     340      T_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    352341#ifdef SPLITBLOCK
    353         T_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0)
     342      T_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0)
    354343#else
    355         T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
    356 #endif
    357         T_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
    358         T_SSR_IOD(co->SSRIOD)
    359         T_SSR_PROVIDER_ID(co->SSRProviderID)
    360         T_SSR_SOLUTION_ID(co->SSRSolutionID)
     344      T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
     345#endif
     346      T_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
     347      T_SSR_IOD(co->SSRIOD)
     348      T_SSR_PROVIDER_ID(co->SSRProviderID)
     349      T_SSR_SOLUTION_ID(co->SSRSolutionID)
    361350#ifdef SPLITBLOCK
    362         T_NO_OF_SATELLITES(nums)
    363         for(i = start; i < start+nums; ++i)
     351      T_NO_OF_SATELLITES(nums)
     352      for(i = start; i < start+nums; ++i)
    364353#else
    365         T_NO_OF_SATELLITES(co->NumberOfSat[s])
    366         for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i)
    367 #endif
    368         {
    369           switch(s)
    370           {
     354      T_NO_OF_SATELLITES(co->NumberOfSat[s])
     355      for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i)
     356#endif
     357      {
     358        switch (s) {
    371359          case CLOCKORBIT_SATGPS:
    372360            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     
    395383            T_BDS_IOD(co->Sat[i].IOD)
    396384            break;
    397           }
    398           T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
    399           T_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
    400           T_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
    401           T_DELTA_DOT_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
    402           T_DELTA_DOT_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
    403           T_DELTA_DOT_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
    404           T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
    405           T_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
    406           T_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
    407385        }
    408         ENDBLOCK
     386        T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
     387        T_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
     388        T_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
     389        T_DELTA_DOT_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
     390        T_DELTA_DOT_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
     391        T_DELTA_DOT_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
     392        T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
     393        T_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
     394        T_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
     395      }
     396      ENDBLOCK
    409397#ifdef SPLITBLOCK
    410         start += nums;
    411         nums = left;
    412         left = 0;
    413       }
    414 #endif
     398      start += nums;
     399      nums = left;
     400      left = 0;
    415401    }
    416     if(status[s][COBOFS_HR])
    417     {
     402#endif
     403    }
     404    if (status[s][COBOFS_HR]) {
    418405      INITBLOCK
    419       T_MESSAGE_NUMBER(corbase[s]+COBOFS_HR)
    420       switch(s)
    421       {
    422       case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    423       case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    424       case CLOCKORBIT_SATBDS:
    425         T_GPS_EPOCH_TIME(co->EpochTime[s])
    426         break;
    427       case CLOCKORBIT_SATGLONASS:
    428         T_GLONASS_EPOCH_TIME(co->EpochTime[s])
    429         break;
     406      T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_HR)
     407      switch (s) {
     408        case CLOCKORBIT_SATGPS:
     409        case CLOCKORBIT_SATGALILEO:
     410        case CLOCKORBIT_SATQZSS:
     411        case CLOCKORBIT_SATSBAS:
     412        case CLOCKORBIT_SATBDS:
     413          T_GPS_EPOCH_TIME(co->EpochTime[s])
     414          break;
     415        case CLOCKORBIT_SATGLONASS:
     416          T_GLONASS_EPOCH_TIME(co->EpochTime[s])
     417          break;
    430418      }
    431419      T_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     
    435423      T_SSR_SOLUTION_ID(co->SSRSolutionID)
    436424      T_NO_OF_SATELLITES(co->NumberOfSat[s])
    437       for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i)
    438       {
    439         switch(s)
    440         {
    441         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    442         case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    443           T_GPS_SATELLITE_ID(co->Sat[i].ID)
    444           break;
    445         case CLOCKORBIT_SATQZSS:
    446           T_QZSS_SATELLITE_ID(co->Sat[i].ID)
    447           break;
    448         case CLOCKORBIT_SATGLONASS:
    449           T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
    450           break;
     425      for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     426        switch (s) {
     427          case CLOCKORBIT_SATGPS:
     428            case CLOCKORBIT_SATGALILEO:
     429            case CLOCKORBIT_SATSBAS:
     430            case CLOCKORBIT_SATBDS:
     431            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     432            break;
     433          case CLOCKORBIT_SATQZSS:
     434            T_QZSS_SATELLITE_ID(co->Sat[i].ID)
     435            break;
     436          case CLOCKORBIT_SATGLONASS:
     437            T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
     438            break;
    451439        }
    452440        T_HR_CLOCK_CORRECTION(co->Sat[i].hrclock)
     
    454442      ENDBLOCK
    455443    }
    456     if(status[s][COBOFS_URA])
    457     {
     444    if (status[s][COBOFS_URA]) {
    458445      INITBLOCK
    459       T_MESSAGE_NUMBER(corbase[s]+COBOFS_URA)
    460       switch(s)
    461       {
    462       case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    463       case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    464       case CLOCKORBIT_SATBDS:
    465         T_GPS_EPOCH_TIME(co->EpochTime[s])
    466         break;
    467       case CLOCKORBIT_SATGLONASS:
    468         T_GLONASS_EPOCH_TIME(co->EpochTime[s])
    469         break;
     446      T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_URA)
     447      switch (s) {
     448        case CLOCKORBIT_SATGPS:
     449        case CLOCKORBIT_SATGALILEO:
     450        case CLOCKORBIT_SATQZSS:
     451        case CLOCKORBIT_SATSBAS:
     452        case CLOCKORBIT_SATBDS:
     453          T_GPS_EPOCH_TIME(co->EpochTime[s])
     454          break;
     455        case CLOCKORBIT_SATGLONASS:
     456          T_GLONASS_EPOCH_TIME(co->EpochTime[s])
     457          break;
    470458      }
    471459      T_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     
    475463      T_SSR_SOLUTION_ID(co->SSRSolutionID)
    476464      T_NO_OF_SATELLITES(co->NumberOfSat[s])
    477       for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i)
    478       {
    479         switch(s)
    480         {
    481         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    482         case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    483           T_GPS_SATELLITE_ID(co->Sat[i].ID)
    484           break;
    485         case CLOCKORBIT_SATQZSS:
    486           T_QZSS_SATELLITE_ID(co->Sat[i].ID)
    487           break;
    488         case CLOCKORBIT_SATGLONASS:
    489           T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
    490           break;
     465      for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
     466        switch (s) {
     467          case CLOCKORBIT_SATGPS:
     468          case CLOCKORBIT_SATGALILEO:
     469          case CLOCKORBIT_SATSBAS:
     470          case CLOCKORBIT_SATBDS:
     471            T_GPS_SATELLITE_ID(co->Sat[i].ID)
     472            break;
     473          case CLOCKORBIT_SATQZSS:
     474            T_QZSS_SATELLITE_ID(co->Sat[i].ID)
     475            break;
     476          case CLOCKORBIT_SATGLONASS:
     477            T_GLONASS_SATELLITE_ID(co->Sat[i].ID)
     478            break;
    491479        }
    492480        T_SSR_URA(ValueToURA(co->Sat[i].UserRangeAccuracy))
     
    499487
    500488size_t MakeCodeBias(const struct CodeBias *b, enum CodeBiasType type,
    501 int moremessagesfollow, char *buffer, size_t size)
    502 {
     489    int moremessagesfollow, char *buffer, size_t size) {
    503490  unsigned int s, i, j;
    504491
    505492  STARTDATA
    506493
    507   for(s = 0; s < CLOCKORBIT_SATNUM; ++s)
    508   {
    509     if(b->NumberOfSat[s] && (type == BTYPE_AUTO || type == corbase[s]+COBOFS_BIAS))
    510     {
     494  for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
     495    if (b->NumberOfSat[s] && (type == CBTYPE_AUTO || type == corbase[s] + COBOFS_CBIAS)) {
    511496      INITBLOCK
    512       T_MESSAGE_NUMBER(corbase[s]+COBOFS_BIAS)
    513       switch(s)
    514       {
    515       case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    516       case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    517       case CLOCKORBIT_SATBDS:
    518         T_GPS_EPOCH_TIME(b->EpochTime[s])
    519         break;
    520       case CLOCKORBIT_SATGLONASS:
    521         T_GLONASS_EPOCH_TIME(b->EpochTime[s])
    522         break;
     497      T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_CBIAS)
     498      switch (s) {
     499        case CLOCKORBIT_SATGPS:
     500        case CLOCKORBIT_SATGALILEO:
     501        case CLOCKORBIT_SATQZSS:
     502        case CLOCKORBIT_SATSBAS:
     503        case CLOCKORBIT_SATBDS:
     504          T_GPS_EPOCH_TIME(b->EpochTime[s])
     505          break;
     506        case CLOCKORBIT_SATGLONASS:
     507          T_GLONASS_EPOCH_TIME(b->EpochTime[s])
     508          break;
    523509      }
    524510      T_SSR_UPDATE_INTERVAL(b->UpdateInterval)
     
    528514      T_SSR_SOLUTION_ID(b->SSRSolutionID)
    529515      T_NO_OF_SATELLITES(b->NumberOfSat[s])
    530       for(i = satoffset[s]; i < satoffset[s]+b->NumberOfSat[s]; ++i)
    531       {
    532         switch(s)
    533         {
    534         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    535         case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    536           T_GPS_SATELLITE_ID(b->Sat[i].ID)
    537           break;
    538         case CLOCKORBIT_SATQZSS:
    539           T_QZSS_SATELLITE_ID(b->Sat[i].ID)
    540           break;
    541         case CLOCKORBIT_SATGLONASS:
    542           T_GLONASS_SATELLITE_ID(b->Sat[i].ID)
    543           break;
     516      for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
     517        switch (s) {
     518          case CLOCKORBIT_SATGPS:
     519          case CLOCKORBIT_SATGALILEO:
     520          case CLOCKORBIT_SATSBAS:
     521          case CLOCKORBIT_SATBDS:
     522            T_GPS_SATELLITE_ID(b->Sat[i].ID)
     523            break;
     524          case CLOCKORBIT_SATQZSS:
     525            T_QZSS_SATELLITE_ID(b->Sat[i].ID)
     526            break;
     527          case CLOCKORBIT_SATGLONASS:
     528            T_GLONASS_SATELLITE_ID(b->Sat[i].ID)
     529            break;
    544530        }
    545531        T_NO_OF_CODE_BIASES(b->Sat[i].NumberOfCodeBiases)
    546         for(j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j)
    547         {
     532        for (j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j) {
    548533          T_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
    549534          T_CODE_BIAS(b->Sat[i].Biases[j].Bias)
     
    557542
    558543size_t MakePhaseBias(const struct PhaseBias *b, enum PhaseBiasType type,
    559 int moremessagesfollow, char *buffer, size_t size)
    560 {
     544    int moremessagesfollow, char *buffer, size_t size) {
    561545  unsigned int s, i, j;
    562546
    563547  STARTDATA
    564548
    565   for(s = 0; s < CLOCKORBIT_SATNUM; ++s)
    566   {
    567     if(b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == s+PBTYPE_BASE))
    568     {
     549  for (s = 0; s < CLOCKORBIT_SATNUM; ++s)       {
     550    if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == s + PBTYPE_BASE)) {
    569551      INITBLOCK
    570       T_MESSAGE_NUMBER(s+PBTYPE_BASE)
    571       switch(s)
    572       {
    573       case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    574       case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    575       case CLOCKORBIT_SATBDS:
    576         T_GPS_EPOCH_TIME(b->EpochTime[s])
    577         break;
    578       case CLOCKORBIT_SATGLONASS:
    579         T_GLONASS_EPOCH_TIME(b->EpochTime[s])
    580         break;
     552      T_RTCM_MESSAGE_NUMBER(s + PBTYPE_BASE)
     553      switch (s) {
     554        case CLOCKORBIT_SATGPS:
     555        case CLOCKORBIT_SATGALILEO:
     556        case CLOCKORBIT_SATQZSS:
     557        case CLOCKORBIT_SATSBAS:
     558        case CLOCKORBIT_SATBDS:
     559          T_GPS_EPOCH_TIME(b->EpochTime[s])
     560          break;
     561        case CLOCKORBIT_SATGLONASS:
     562          T_GLONASS_EPOCH_TIME(b->EpochTime[s])
     563          break;
    581564      }
    582565      T_SSR_UPDATE_INTERVAL(b->UpdateInterval)
     
    588571      T_MW_CONSISTENCY_INDICATOR(b->MWConsistencyIndicator ? 1 : 0)
    589572      T_NO_OF_SATELLITES(b->NumberOfSat[s])
    590       for(i = satoffset[s]; i < satoffset[s]+b->NumberOfSat[s]; ++i)
    591       {
    592         switch(s)
    593         {
    594         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    595         case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    596           T_GPS_SATELLITE_ID(b->Sat[i].ID)
    597           break;
    598         case CLOCKORBIT_SATQZSS:
    599           T_QZSS_SATELLITE_ID(b->Sat[i].ID)
    600           break;
    601         case CLOCKORBIT_SATGLONASS:
    602           T_GLONASS_SATELLITE_ID(b->Sat[i].ID)
    603           break;
     573      for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
     574        switch (s) {
     575          case CLOCKORBIT_SATGPS:
     576            case CLOCKORBIT_SATGALILEO:
     577            case CLOCKORBIT_SATSBAS:
     578            case CLOCKORBIT_SATBDS:
     579            T_GPS_SATELLITE_ID(b->Sat[i].ID)
     580            break;
     581          case CLOCKORBIT_SATQZSS:
     582            T_QZSS_SATELLITE_ID(b->Sat[i].ID)
     583            break;
     584          case CLOCKORBIT_SATGLONASS:
     585            T_GLONASS_SATELLITE_ID(b->Sat[i].ID)
     586            break;
    604587        }
    605588        T_NO_OF_PHASE_BIASES(b->Sat[i].NumberOfPhaseBiases)
    606589        T_YAW_ANGLE(b->Sat[i].YawAngle)
    607590        T_YAW_RATE(b->Sat[i].YawRate)
    608         for(j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j)
    609         {
     591        for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
    610592          T_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
    611           T_INTEGER_INDICATOR(b->Sat[i].Biases[j].SignalIntegerIndicator ? 1 : 0)
    612           T_WIDE_LANE_INDICATOR(b->Sat[i].Biases[j].SignalsWideLaneIntegerIndicator)
    613           T_DISCONTINUITY_COUNTER(b->Sat[i].Biases[j].SignalDiscontinuityCounter)
     593          T_INTEGER_INDICATOR(
     594              b->Sat[i].Biases[j].SignalIntegerIndicator ? 1 : 0)
     595          T_WIDE_LANE_INDICATOR(
     596              b->Sat[i].Biases[j].SignalsWideLaneIntegerIndicator)
     597          T_DISCONTINUITY_COUNTER(
     598              b->Sat[i].Biases[j].SignalDiscontinuityCounter)
    614599          T_PHASE_BIAS(b->Sat[i].Biases[j].Bias)
    615600        }
     
    621606}
    622607
    623 size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer,
    624 size_t size)
    625 {
     608size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, size_t size) {
    626609  unsigned int l, o, d;
    627610
    628611  STARTDATA
    629   INITBLOCK
    630   T_MESSAGE_NUMBER(VTEC_BASE)
     612    INITBLOCK
     613  T_RTCM_MESSAGE_NUMBER(VTEC_BASE)
    631614
    632615  T_GPS_EPOCH_TIME(v->EpochTime)
     
    638621  T_VTEC_QUALITY_INDICATOR(v->Quality)
    639622  T_NO_IONO_LAYERS(v->NumLayers)
    640   for(l = 0; l < v->NumLayers; ++l)
    641   {
     623  for (l = 0; l < v->NumLayers; ++l) {
    642624    T_IONO_HEIGHT(v->Layers[l].Height)
    643625    T_IONO_DEGREE(v->Layers[l].Degree)
    644626    T_IONO_ORDER(v->Layers[l].Order)
    645     for(o = 0; o <= v->Layers[l].Order; ++o)
    646     {
    647       for(d = o; d <= v->Layers[l].Degree; ++d)
    648       {
     627    for (o = 0; o <= v->Layers[l].Order; ++o) {
     628      for (d = o; d <= v->Layers[l].Degree; ++d) {
    649629        T_IONO_COEFF(v->Layers[l].Cosinus[d][o])
    650630      }
    651631    }
    652     for(o = 1; o <= v->Layers[l].Order; ++o)
    653     {
    654       for(d = o; d <= v->Layers[l].Degree; ++d)
    655       {
     632    for (o = 1; o <= v->Layers[l].Order; ++o) {
     633      for (d = o; d <= v->Layers[l].Degree; ++d) {
    656634        T_IONO_COEFF(v->Layers[l].Sinus[d][o])
    657635      }
     
    669647  uint64_t bitbuffer=0;
    670648
    671 #define LOADBITS(a) \
    672 { \
     649#define LOADBITS(a) { \
    673650  while((a) > numbits) \
    674651  { \
     
    680657
    681658/* extract bits from data stream
    682    b = variable to store result, a = number of bits */
    683 #define GETBITS(b, a) \
    684 { \
     659 b = variable to store result, a = number of bits */
     660#define GETBITS(b, a) { \
    685661  LOADBITS(a) \
    686662  b = (bitbuffer<<(64-numbits))>>(64-(a)); \
     
    689665
    690666/* extract bits from data stream
    691    b = variable to store result, a = number of bits */
    692 #define GETBITSFACTOR(b, a, c) \
    693 { \
     667 b = variable to store result, a = number of bits */
     668#define GETBITSFACTOR(b, a, c) { \
    694669  LOADBITS(a) \
    695670  b = ((bitbuffer<<(64-numbits))>>(64-(a)))*(c); \
     
    698673
    699674/* extract signed floating value from data stream
    700    b = variable to store result, a = number of bits */
    701 #define GETFLOATSIGN(b, a, c) \
    702 { \
     675 b = variable to store result, a = number of bits */
     676#define GETFLOATSIGN(b, a, c) { \
    703677  LOADBITS(a) \
    704678  b = ((double)(((int64_t)(bitbuffer<<(64-numbits)))>>(64-(a))))*(c); \
     
    707681
    708682/* extract floating value from data stream
    709    b = variable to store result, a = number of bits, c = scale factor */
    710 #define GETFLOAT(b, a, c) \
    711 { \
     683 b = variable to store result, a = number of bits, c = scale factor */
     684#define GETFLOAT(b, a, c) { \
    712685  LOADBITS(a) \
    713686  b = ((double)((bitbuffer<<(sizeof(bitbuffer)*8-numbits))>>(sizeof(bitbuffer)*8-(a))))*(c); \
     
    721694#define G_RESERVEDH(a)                   GETBITS(a,6)
    722695#define G_SIZE(a)                        GETBITS(a, 10)
    723 #define G_MESSAGE_NUMBER(a)              GETBITS(a, 12)          /* DF002 */
     696#define G_RTCM_MESSAGE_NUMBER(a)         GETBITS(a, 12)          /* DF002 */
    724697#define G_GPS_SATELLITE_ID(a)            GETBITS(a, 6)           /* DF068 */
    725698#define G_QZSS_SATELLITE_ID(a)           GETBITS(a, 4)           /* DF249 */
     
    782755#define G_IONO_HEIGHT(a)                 GETFLOAT(a, 8 ,    10000.0)
    783756
    784 enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b, struct VTEC *v,
    785 struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused)
    786 {
    787   int mmi=0, h, rs;
     757enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b,struct VTEC *v,
     758    struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused) {
     759  int mmi = 0, h, rs;
    788760  unsigned int type, pos, i, j, s, nums, id;
    789761  size_t sizeofrtcmblock;
     
    791763  DECODESTART
    792764
    793   if(size < 7)
     765  if (size < 7)
    794766    return GCOBR_SHORTBUFFER;
    795767
    796 #ifdef DEBUG
    797   fprintf(stderr, "GetClockOrbitBias START: size %d, numbits %d\n",size, numbits);
     768#ifdef BNC_DEBUG
     769  fprintf(stderr, "GetSSR START: size %d, numbits %d\n",(int)size, numbits);
    798770#endif
    799771
     
    802774  G_SIZE(sizeofrtcmblock);
    803775
    804   if((unsigned char)h != 0xD3 || rs)
     776  if ((unsigned char) h != 0xD3 || rs)
    805777    return GCOBR_UNKNOWNDATA;
    806   if(size < sizeofrtcmblock + 3) /* 3 header bytes already removed */
     778  if (size < sizeofrtcmblock + 3) /* 3 header bytes already removed */
    807779    return GCOBR_MESSAGEEXCEEDSBUFFER;
    808   if(CRC24(sizeofrtcmblock+3, (const unsigned char *) blockstart) !=
    809   (uint32_t)((((unsigned char)buffer[sizeofrtcmblock])<<16)|
    810   (((unsigned char)buffer[sizeofrtcmblock+1])<<8)|
    811   (((unsigned char)buffer[sizeofrtcmblock+2]))))
     780  if (CRC24(sizeofrtcmblock + 3, (const unsigned char *) blockstart) !=
     781      (uint32_t) ((((unsigned char) buffer[sizeofrtcmblock]) << 16) |
     782          (((unsigned char) buffer[sizeofrtcmblock + 1]) << 8) |
     783          (((unsigned char) buffer[sizeofrtcmblock + 2]))))
    812784    return GCOBR_CRCMISMATCH;
    813785  size = sizeofrtcmblock; /* reduce size, so overflows are detected */
    814786
    815   G_MESSAGE_NUMBER(type)
    816 #ifdef DEBUG
    817 fprintf(stderr, "type %d size %d\n",type,sizeofrtcmblock);
    818 #endif
    819   if(bytesused)
    820     *bytesused = sizeofrtcmblock+6;
    821   if(type == VTEC_BASE)
    822   {
     787  G_RTCM_MESSAGE_NUMBER(type)
     788#ifdef BNC_DEBUG
     789  fprintf(stderr, "type %d size %d\n",type,(int)sizeofrtcmblock);
     790#endif
     791  if (bytesused)
     792    *bytesused = sizeofrtcmblock + 6;
     793  if (type == VTEC_BASE) {
    823794    unsigned int l, o, d;
    824     if(!v) return GCOBR_NOVTECPARAMETER;
     795    if (!v)
     796      return GCOBR_NOVTECPARAMETER;
    825797    memset(v, 0, sizeof(*v));
    826798    G_EPOCH_TIME(v->EpochTime)
     
    832804    G_VTEC_QUALITY_INDICATOR(v->Quality)
    833805    G_NO_IONO_LAYERS(v->NumLayers)
    834     for(l = 0; l < v->NumLayers; ++l)
    835     {
     806#ifdef BNC_DEBUG
     807          fprintf(stderr, "epochTime %d ui %d mmi %d ssrIod %d providerId %d solId %d vtecQ %8.3f numLay %d \n",
     808                          v->EpochTime, v->UpdateInterval, mmi,
     809                                  v->SSRIOD, v->SSRProviderID, v->SSRSolutionID, v->Quality, v->NumLayers);
     810#endif
     811    for (l = 0; l < v->NumLayers; ++l) {
    836812      G_IONO_HEIGHT(v->Layers[l].Height)
    837813      G_IONO_DEGREE(v->Layers[l].Degree)
    838814      G_IONO_ORDER(v->Layers[l].Order)
    839       for(o = 0; o <= v->Layers[l].Order; ++o)
    840       {
    841         for(d = o; d <= v->Layers[l].Degree; ++d)
    842         {
     815#ifdef BNC_DEBUG
     816          fprintf(stderr, "h  %8.3f deg %d ord %d \n",
     817                          v->Layers[l].Height, v->Layers[l].Degree, v->Layers[l].Order);
     818#endif
     819      for (o = 0; o <= v->Layers[l].Order; ++o) {
     820        for (d = o; d <= v->Layers[l].Degree; ++d) {
    843821          G_IONO_COEFF(v->Layers[l].Cosinus[d][o])
     822#ifdef BNC_DEBUG
     823          fprintf(stderr, "C[%02d][%02d]  %8.3f \n",
     824                          d, o, v->Layers[l].Cosinus[d][o]);
     825#endif
    844826        }
    845827      }
    846       for(o = 1; o <= v->Layers[l].Order; ++o)
    847       {
    848         for(d = o; d <= v->Layers[l].Degree; ++d)
    849         {
     828      for (o = 1; o <= v->Layers[l].Order; ++o) {
     829        for (d = o; d <= v->Layers[l].Degree; ++d) {
    850830          G_IONO_COEFF(v->Layers[l].Sinus[d][o])
     831#ifdef BNC_DEBUG
     832          fprintf(stderr, "S[%02d][%02d]  %8.3f \n",
     833                          d, o, v->Layers[l].Sinus[d][o]);
     834#endif
    851835        }
    852836      }
    853837    }
    854 #ifdef DEBUG
    855     for(type = 0; type < (int)size && (unsigned char)buffer[type] != 0xD3; ++type)
    856       numbits += 8;
     838#ifdef BNC_DEBUG
     839    for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
     840    numbits += 8;
    857841    fprintf(stderr, "numbits left %d\n",numbits);
    858842#endif
    859843    return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
    860844  }
    861   for(s = CLOCKORBIT_SATNUM; s-- > 0;)
    862   {
    863     if(type == PBTYPE_BASE+s)
    864     {
    865       if(!pb) return GCOBR_NOPHASEBIASPARAMETER;
     845  for (s = CLOCKORBIT_SATNUM; s-- > 0;) {
     846    if (type == PBTYPE_BASE + s) {
     847      if (!pb)
     848        return GCOBR_NOPHASEBIASPARAMETER;
    866849      pb->messageType = type;
    867       switch(s)
    868       {
    869       case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    870       case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    871       case CLOCKORBIT_SATBDS:
    872         G_GPS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s])
    873         break;
    874       case CLOCKORBIT_SATGLONASS:
    875         G_GLONASS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s])
    876         break;
     850      switch (s) {
     851        case CLOCKORBIT_SATGPS:
     852        case CLOCKORBIT_SATGALILEO:
     853        case CLOCKORBIT_SATQZSS:
     854        case CLOCKORBIT_SATSBAS:
     855        case CLOCKORBIT_SATBDS:
     856          G_GPS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s])
     857          break;
     858        case CLOCKORBIT_SATGLONASS:
     859          G_GLONASS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s])
     860          break;
    877861      }
    878862      G_SSR_UPDATE_INTERVAL(pb->UpdateInterval)
     
    884868      G_MW_CONSISTENCY_INDICATOR(pb->MWConsistencyIndicator)
    885869      G_NO_OF_SATELLITES(nums)
    886       for(i = 0; i < nums; ++i)
    887       {
    888         switch(s)
    889         {
    890         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    891         case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    892           G_GPS_SATELLITE_ID(id)
    893           break;
    894         case CLOCKORBIT_SATQZSS:
    895           G_QZSS_SATELLITE_ID(id)
    896           break;
    897         case CLOCKORBIT_SATGLONASS:
    898           G_GLONASS_SATELLITE_ID(id)
    899           break;
     870#ifdef BNC_DEBUG
     871          fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d dispInd %d mwInd %d\n",
     872                          pb->EpochTime[s], pb->UpdateInterval,mmi,pb->NumberOfSat[s],nums,
     873                                  pb->SSRIOD, pb->SSRProviderID, pb->SSRSolutionID,
     874                                  pb->DispersiveBiasConsistencyIndicator, pb->MWConsistencyIndicator);
     875#endif
     876      for (i = 0; i < nums; ++i) {
     877        switch (s) {
     878          case CLOCKORBIT_SATGPS:
     879          case CLOCKORBIT_SATGALILEO:
     880          case CLOCKORBIT_SATSBAS:
     881          case CLOCKORBIT_SATBDS:
     882            G_GPS_SATELLITE_ID(id)
     883            break;
     884          case CLOCKORBIT_SATQZSS:
     885            G_QZSS_SATELLITE_ID(id)
     886            break;
     887          case CLOCKORBIT_SATGLONASS:
     888            G_GLONASS_SATELLITE_ID(id)
     889            break;
    900890        }
    901         for(pos = satoffset[s]; pos < satoffset[s]+pb->NumberOfSat[s] && pb->Sat[pos].ID != id; ++pos)
     891        for (pos = satoffset[s];
     892            pos < satoffset[s] + pb->NumberOfSat[s] && pb->Sat[pos].ID != id;
     893            ++pos)
    902894          ;
    903         if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH;
    904         else if(pos == pb->NumberOfSat[s] + satoffset[s]) ++pb->NumberOfSat[s];
     895        if (pos >= satoffset[s + 1])
     896          return GCOBR_DATAMISMATCH;
     897        else if (pos == pb->NumberOfSat[s] + satoffset[s])
     898          ++pb->NumberOfSat[s];
    905899        pb->Sat[pos].ID = id;
    906 
    907900        G_NO_OF_PHASE_BIASES(pb->Sat[pos].NumberOfPhaseBiases)
    908901        G_YAW_ANGLE(pb->Sat[pos].YawAngle)
    909902        G_YAW_RATE(pb->Sat[pos].YawRate)
    910         for(j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j)
    911         {
     903#ifdef BNC_DEBUG
     904            fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ",
     905                    pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases,
     906                                        pb->Sat[pos].YawAngle/MPI, pb->Sat[pos].YawRate/MPI);
     907#endif
     908        for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
    912909          G_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type)
    913910          G_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].SignalIntegerIndicator)
    914           G_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator)
    915           G_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].SignalDiscontinuityCounter)
     911          G_WIDE_LANE_INDICATOR(
     912              pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator)
     913          G_DISCONTINUITY_COUNTER(
     914              pb->Sat[pos].Biases[j].SignalDiscontinuityCounter)
    916915          G_PHASE_BIAS(pb->Sat[pos].Biases[j].Bias)
     916#ifdef BNC_DEBUG
     917            fprintf(stderr, "t%02d int %d wl %d disc %d b %8.4f ",
     918                    pb->Sat[pos].Biases[j].Type,
     919                                        pb->Sat[pos].Biases[j].SignalIntegerIndicator,
     920                                        pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator,
     921                                        pb->Sat[pos].Biases[j].SignalDiscontinuityCounter,
     922                                        pb->Sat[pos].Biases[j].Bias);
     923#endif
    917924        }
    918       }
    919 #ifdef DEBUG
    920       for(type = 0; type < (int)size && (unsigned char)buffer[type] != 0xD3; ++type)
    921         numbits += 8;
     925#ifdef BNC_DEBUG
     926            fprintf(stderr, "\n");
     927#endif
     928      }
     929#ifdef BNC_DEBUG
     930      for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
     931      numbits += 8;
    922932      fprintf(stderr, "numbits left %d\n",numbits);
    923933#endif
    924934      return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
    925935    }
    926     else if(type >= corbase[s])
    927     {
    928       switch(type-corbase[s])
    929       {
    930       case COBOFS_ORBIT:
    931         if(!co) return GCOBR_NOCLOCKORBITPARAMETER;
    932         co->messageType = type;
    933         switch(s)
    934         {
    935         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    936         case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    937         case CLOCKORBIT_SATBDS:
    938           G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    939           break;
    940         case CLOCKORBIT_SATGLONASS:
    941           G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    942           break;
    943         }
    944         G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    945         G_MULTIPLE_MESSAGE_INDICATOR(mmi)
    946         G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
    947         G_SSR_IOD(co->SSRIOD)
    948         G_SSR_PROVIDER_ID(co->SSRProviderID)
    949         G_SSR_SOLUTION_ID(co->SSRSolutionID)
    950         G_NO_OF_SATELLITES(nums)
    951         co->Supplied[COBOFS_ORBIT] |= 1;
    952 #ifdef DEBUG
    953         fprintf(stderr, "epochtime %d ui %d mmi %d sats %d/%d rd %d\n",co->EpochTime[s],
    954         co->UpdateInterval,mmi,co->NumberOfSat[s],nums, co->SatRefDatum);
    955 #endif
    956         for(i = 0; i < nums; ++i)
    957         {
    958           switch(s)
    959           {
    960           case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    961           case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    962             G_GPS_SATELLITE_ID(id)
    963             break;
    964           case CLOCKORBIT_SATQZSS:
    965             G_QZSS_SATELLITE_ID(id)
    966             break;
    967           case CLOCKORBIT_SATGLONASS:
    968             G_GLONASS_SATELLITE_ID(id)
    969             break;
     936    else if (type >= corbase[s]) {
     937      switch (type - corbase[s]) {
     938        case COBOFS_ORBIT:
     939          if (!co)
     940            return GCOBR_NOCLOCKORBITPARAMETER;
     941          co->messageType = type;
     942          switch (s) {
     943            case CLOCKORBIT_SATGPS:
     944            case CLOCKORBIT_SATGALILEO:
     945            case CLOCKORBIT_SATQZSS:
     946            case CLOCKORBIT_SATSBAS:
     947            case CLOCKORBIT_SATBDS:
     948              G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     949              break;
     950            case CLOCKORBIT_SATGLONASS:
     951              G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     952              break;
    970953          }
    971           for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos)
    972             ;
    973           if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH;
    974           else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s];
    975           co->Sat[pos].ID = id;
    976 
    977           switch(s)
    978           {
    979           case CLOCKORBIT_SATGPS:
    980           case CLOCKORBIT_SATQZSS:
    981             G_GPS_IODE(co->Sat[pos].IOD)
    982             break;
    983           case CLOCKORBIT_SATGLONASS:
    984             G_GLONASS_IOD(co->Sat[pos].IOD)
    985             break;
    986           case CLOCKORBIT_SATGALILEO:
    987             G_GALILEO_IOD(co->Sat[pos].IOD)
    988             break;
    989           case CLOCKORBIT_SATSBAS:
    990             G_SBAS_T0MOD(co->Sat[pos].toe)
    991             G_SBAS_IODCRC(co->Sat[pos].IOD)
    992             break;
    993           case CLOCKORBIT_SATBDS:
    994             G_BDS_TOEMOD(co->Sat[pos].toe)
    995             G_BDS_IOD(co->Sat[pos].IOD)
    996             break;
     954          G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     955          G_MULTIPLE_MESSAGE_INDICATOR(mmi)
     956          G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
     957          G_SSR_IOD(co->SSRIOD)
     958          G_SSR_PROVIDER_ID(co->SSRProviderID)
     959          G_SSR_SOLUTION_ID(co->SSRSolutionID)
     960          G_NO_OF_SATELLITES(nums)
     961          co->Supplied[COBOFS_ORBIT] |= 1;
     962#ifdef BNC_DEBUG
     963          fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
     964                          co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
     965                                  co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     966#endif
     967          for (i = 0; i < nums; ++i) {
     968            switch (s) {
     969              case CLOCKORBIT_SATGPS:
     970              case CLOCKORBIT_SATGALILEO:
     971              case CLOCKORBIT_SATSBAS:
     972              case CLOCKORBIT_SATBDS:
     973                G_GPS_SATELLITE_ID(id)
     974                break;
     975              case CLOCKORBIT_SATQZSS:
     976                G_QZSS_SATELLITE_ID(id)
     977                break;
     978              case CLOCKORBIT_SATGLONASS:
     979                G_GLONASS_SATELLITE_ID(id)
     980                break;
     981            }
     982            for (pos = satoffset[s];
     983                pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     984                ++pos)
     985              ;
     986            if (pos >= satoffset[s + 1])
     987              return GCOBR_DATAMISMATCH;
     988            else if (pos == co->NumberOfSat[s] + satoffset[s])
     989              ++co->NumberOfSat[s];
     990            co->Sat[pos].ID = id;
     991
     992            switch (s) {
     993              case CLOCKORBIT_SATGPS:
     994                case CLOCKORBIT_SATQZSS:
     995                G_GPS_IODE(co->Sat[pos].IOD)
     996                break;
     997              case CLOCKORBIT_SATGLONASS:
     998                G_GLONASS_IOD(co->Sat[pos].IOD)
     999                break;
     1000              case CLOCKORBIT_SATGALILEO:
     1001                G_GALILEO_IOD(co->Sat[pos].IOD)
     1002                break;
     1003              case CLOCKORBIT_SATSBAS:
     1004                G_SBAS_T0MOD(co->Sat[pos].toe)
     1005                G_SBAS_IODCRC(co->Sat[pos].IOD)
     1006                break;
     1007              case CLOCKORBIT_SATBDS:
     1008                G_BDS_TOEMOD(co->Sat[pos].toe)
     1009                G_BDS_IOD(co->Sat[pos].IOD)
     1010                break;
     1011            }
     1012            G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
     1013            G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
     1014            G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
     1015            G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
     1016            G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
     1017            G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
     1018#ifdef BNC_DEBUG
     1019            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",
     1020                co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
     1021                co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
     1022                co->Sat[pos].Orbit.DotDeltaRadial,
     1023                co->Sat[pos].Orbit.DotDeltaAlongTrack,
     1024                co->Sat[pos].Orbit.DotDeltaCrossTrack);
     1025#endif
    9971026          }
    998           G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
    999           G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
    1000           G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
    1001           G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
    1002           G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
    1003           G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
    1004 #ifdef DEBUG
    1005           fprintf(stderr, "id %2d iod %3d dr %8.3f da %8.3f dc %8.3f dr %8.3f da %8.3f dc %8.3f\n",
    1006           co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
    1007           co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
    1008           co->Sat[pos].Orbit.DotDeltaRadial,
    1009           co->Sat[pos].Orbit.DotDeltaAlongTrack,
    1010           co->Sat[pos].Orbit.DotDeltaCrossTrack);
    1011 #endif
    1012         }
    1013         break;
    1014       case COBOFS_CLOCK:
    1015         if(!co) return GCOBR_NOCLOCKORBITPARAMETER;
    1016         co->messageType = type;
    1017         switch(s)
    1018         {
    1019         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1020         case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    1021         case CLOCKORBIT_SATBDS:
    1022           G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1023           break;
    1024         case CLOCKORBIT_SATGLONASS:
    1025           G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1026           break;
    1027         }
    1028         G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    1029         G_MULTIPLE_MESSAGE_INDICATOR(mmi)
    1030         G_SSR_IOD(co->SSRIOD)
    1031         G_SSR_PROVIDER_ID(co->SSRProviderID)
    1032         G_SSR_SOLUTION_ID(co->SSRSolutionID)
    1033         G_NO_OF_SATELLITES(nums)
    1034         co->Supplied[COBOFS_CLOCK] |= 1;
    1035 #ifdef DEBUG
    1036         fprintf(stderr, "epochtime %d ui %d mmi %d sats %d/%d\n",co->EpochTime[s],
    1037         co->UpdateInterval,mmi,co->NumberOfSat[s],nums);
    1038 #endif
    1039         for(i = 0; i < nums; ++i)
    1040         {
    1041           switch(s)
    1042           {
    1043           case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1044           case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    1045             G_GPS_SATELLITE_ID(id)
    1046             break;
    1047           case CLOCKORBIT_SATQZSS:
    1048             G_QZSS_SATELLITE_ID(id)
    1049             break;
    1050           case CLOCKORBIT_SATGLONASS:
    1051             G_GLONASS_SATELLITE_ID(id)
    1052             break;
     1027          break;
     1028        case COBOFS_CLOCK:
     1029          if (!co)
     1030            return GCOBR_NOCLOCKORBITPARAMETER;
     1031          co->messageType = type;
     1032          switch (s) {
     1033            case CLOCKORBIT_SATGPS:
     1034            case CLOCKORBIT_SATGALILEO:
     1035            case CLOCKORBIT_SATQZSS:
     1036            case CLOCKORBIT_SATSBAS:
     1037            case CLOCKORBIT_SATBDS:
     1038              G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1039              break;
     1040            case CLOCKORBIT_SATGLONASS:
     1041              G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1042              break;
    10531043          }
    1054           for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos)
    1055             ;
    1056           if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH;
    1057           else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s];
    1058           co->Sat[pos].ID = id;
    1059 
    1060           G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
    1061           G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
    1062           G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
    1063 #ifdef DEBUG
    1064           fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n",
    1065           co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1,
    1066           co->Sat[pos].Clock.DeltaA2);
    1067 #endif
    1068         }
    1069         break;
    1070       case COBOFS_COMBINED:
    1071         if(!co) return GCOBR_NOCLOCKORBITPARAMETER;
    1072         co->messageType = type;
    1073         switch(s)
    1074         {
    1075         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1076         case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    1077         case CLOCKORBIT_SATBDS:
    1078           G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1079           break;
    1080         case CLOCKORBIT_SATGLONASS:
    1081           G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1082           break;
    1083         }
    1084         G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    1085         G_MULTIPLE_MESSAGE_INDICATOR(mmi)
    1086         G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
    1087         G_SSR_IOD(co->SSRIOD)
    1088         G_SSR_PROVIDER_ID(co->SSRProviderID)
    1089         G_SSR_SOLUTION_ID(co->SSRSolutionID)
    1090         G_NO_OF_SATELLITES(nums)
    1091         co->Supplied[COBOFS_ORBIT] |= 1;
    1092         co->Supplied[COBOFS_CLOCK] |= 1;
    1093         for(i = 0; i < nums; ++i)
    1094         {
    1095           switch(s)
    1096           {
    1097           case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1098           case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    1099             G_GPS_SATELLITE_ID(id)
    1100             break;
    1101           case CLOCKORBIT_SATQZSS:
    1102             G_QZSS_SATELLITE_ID(id)
    1103             break;
    1104           case CLOCKORBIT_SATGLONASS:
    1105             G_GLONASS_SATELLITE_ID(id)
    1106             break;
     1044          G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     1045          G_MULTIPLE_MESSAGE_INDICATOR(mmi)
     1046          G_SSR_IOD(co->SSRIOD)
     1047          G_SSR_PROVIDER_ID(co->SSRProviderID)
     1048          G_SSR_SOLUTION_ID(co->SSRSolutionID)
     1049          G_NO_OF_SATELLITES(nums)
     1050          co->Supplied[COBOFS_CLOCK] |= 1;
     1051#ifdef BNC_DEBUG
     1052          fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     1053                          co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
     1054                                  co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     1055#endif
     1056          for (i = 0; i < nums; ++i) {
     1057            switch (s) {
     1058              case CLOCKORBIT_SATGPS:
     1059                case CLOCKORBIT_SATGALILEO:
     1060                case CLOCKORBIT_SATSBAS:
     1061                case CLOCKORBIT_SATBDS:
     1062                G_GPS_SATELLITE_ID(id)
     1063                break;
     1064              case CLOCKORBIT_SATQZSS:
     1065                G_QZSS_SATELLITE_ID(id)
     1066                break;
     1067              case CLOCKORBIT_SATGLONASS:
     1068                G_GLONASS_SATELLITE_ID(id)
     1069                break;
     1070            }
     1071            for (pos = satoffset[s];
     1072                pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     1073                ++pos)
     1074              ;
     1075            if (pos >= satoffset[s + 1])
     1076              return GCOBR_DATAMISMATCH;
     1077            else if (pos == co->NumberOfSat[s] + satoffset[s])
     1078              ++co->NumberOfSat[s];
     1079            co->Sat[pos].ID = id;
     1080
     1081            G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
     1082            G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
     1083            G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
     1084#ifdef BNC_DEBUG
     1085            fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n",
     1086                co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1,
     1087                co->Sat[pos].Clock.DeltaA2);
     1088#endif
    11071089          }
    1108           for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos)
    1109             ;
    1110           if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH;
    1111           else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s];
    1112           co->Sat[pos].ID = id;
    1113 
    1114           switch(s)
    1115           {
    1116           case CLOCKORBIT_SATGPS:
    1117           case CLOCKORBIT_SATQZSS:
    1118             G_GPS_IODE(co->Sat[pos].IOD)
    1119             break;
    1120           case CLOCKORBIT_SATGLONASS:
    1121             G_GLONASS_IOD(co->Sat[pos].IOD)
    1122             break;
    1123           case CLOCKORBIT_SATGALILEO:
    1124             G_GALILEO_IOD(co->Sat[pos].IOD)
    1125             break;
    1126           case CLOCKORBIT_SATSBAS:
    1127             G_SBAS_T0MOD(co->Sat[pos].toe)
    1128             G_SBAS_IODCRC(co->Sat[pos].IOD)
    1129             break;
    1130           case CLOCKORBIT_SATBDS:
    1131             G_BDS_TOEMOD(co->Sat[pos].toe)
    1132             G_BDS_IOD(co->Sat[pos].IOD)
    1133             break;
     1090          break;
     1091        case COBOFS_COMBINED:
     1092          if (!co)
     1093            return GCOBR_NOCLOCKORBITPARAMETER;
     1094          co->messageType = type;
     1095          switch (s) {
     1096            case CLOCKORBIT_SATGPS:
     1097            case CLOCKORBIT_SATGALILEO:
     1098            case CLOCKORBIT_SATQZSS:
     1099            case CLOCKORBIT_SATSBAS:
     1100            case CLOCKORBIT_SATBDS:
     1101              G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1102              break;
     1103            case CLOCKORBIT_SATGLONASS:
     1104              G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1105              break;
    11341106          }
    1135           G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
    1136           G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
    1137           G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
    1138           G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
    1139           G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
    1140           G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
    1141           G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
    1142           G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
    1143           G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
    1144         }
    1145         break;
    1146       case COBOFS_URA:
    1147         if(!co) return GCOBR_NOCLOCKORBITPARAMETER;
    1148         co->messageType = type;
    1149         switch(s)
    1150         {
    1151         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1152         case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    1153         case CLOCKORBIT_SATBDS:
    1154           G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1155           break;
    1156         case CLOCKORBIT_SATGLONASS:
    1157           G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1158           break;
    1159         }
    1160         G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    1161         G_MULTIPLE_MESSAGE_INDICATOR(mmi)
    1162         G_SSR_IOD(co->SSRIOD)
    1163         G_SSR_PROVIDER_ID(co->SSRProviderID)
    1164         G_SSR_SOLUTION_ID(co->SSRSolutionID)
    1165         G_NO_OF_SATELLITES(nums)
    1166         co->Supplied[COBOFS_URA] |= 1;
    1167         for(i = 0; i < nums; ++i)
    1168         {
    1169           switch(s)
    1170           {
    1171           case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1172           case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    1173             G_GPS_SATELLITE_ID(id)
    1174             break;
    1175           case CLOCKORBIT_SATQZSS:
    1176             G_QZSS_SATELLITE_ID(id)
    1177             break;
    1178           case CLOCKORBIT_SATGLONASS:
    1179             G_GLONASS_SATELLITE_ID(id)
    1180             break;
     1107          G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     1108          G_MULTIPLE_MESSAGE_INDICATOR(mmi)
     1109          G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
     1110          G_SSR_IOD(co->SSRIOD)
     1111          G_SSR_PROVIDER_ID(co->SSRProviderID)
     1112          G_SSR_SOLUTION_ID(co->SSRSolutionID)
     1113          G_NO_OF_SATELLITES(nums)
     1114          co->Supplied[COBOFS_ORBIT] |= 1;
     1115          co->Supplied[COBOFS_CLOCK] |= 1;
     1116#ifdef BNC_DEBUG
     1117          fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
     1118                          co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
     1119                                  co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     1120#endif
     1121          for (i = 0; i < nums; ++i) {
     1122            switch (s) {
     1123              case CLOCKORBIT_SATGPS:
     1124              case CLOCKORBIT_SATGALILEO:
     1125              case CLOCKORBIT_SATSBAS:
     1126              case CLOCKORBIT_SATBDS:
     1127                G_GPS_SATELLITE_ID(id)
     1128                break;
     1129              case CLOCKORBIT_SATQZSS:
     1130                G_QZSS_SATELLITE_ID(id)
     1131                break;
     1132              case CLOCKORBIT_SATGLONASS:
     1133                G_GLONASS_SATELLITE_ID(id)
     1134                break;
     1135            }
     1136            for (pos = satoffset[s];
     1137                pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     1138                ++pos)
     1139              ;
     1140            if (pos >= satoffset[s + 1])
     1141              return GCOBR_DATAMISMATCH;
     1142            else if (pos == co->NumberOfSat[s] + satoffset[s])
     1143              ++co->NumberOfSat[s];
     1144            co->Sat[pos].ID = id;
     1145
     1146            switch (s) {
     1147              case CLOCKORBIT_SATGPS:
     1148                case CLOCKORBIT_SATQZSS:
     1149                G_GPS_IODE(co->Sat[pos].IOD)
     1150                break;
     1151              case CLOCKORBIT_SATGLONASS:
     1152                G_GLONASS_IOD(co->Sat[pos].IOD)
     1153                break;
     1154              case CLOCKORBIT_SATGALILEO:
     1155                G_GALILEO_IOD(co->Sat[pos].IOD)
     1156                break;
     1157              case CLOCKORBIT_SATSBAS:
     1158                G_SBAS_T0MOD(co->Sat[pos].toe)
     1159                G_SBAS_IODCRC(co->Sat[pos].IOD)
     1160                break;
     1161              case CLOCKORBIT_SATBDS:
     1162                G_BDS_TOEMOD(co->Sat[pos].toe)
     1163                G_BDS_IOD(co->Sat[pos].IOD)
     1164                break;
     1165            }
     1166            G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
     1167            G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
     1168            G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
     1169            G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
     1170            G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
     1171            G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
     1172            G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
     1173            G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
     1174            G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
     1175#ifdef BNC_DEBUG
     1176            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",
     1177                co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
     1178                co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
     1179                co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack,
     1180                co->Sat[pos].Orbit.DotDeltaCrossTrack,
     1181                                co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2);
     1182#endif
    11811183          }
    1182           for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos)
    1183             ;
    1184           if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH;
    1185           else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s];
    1186           co->Sat[pos].ID = id;
    1187 
    1188           G_SSR_URA(co->Sat[pos].UserRangeAccuracy)
    1189         }
    1190         break;
    1191       case COBOFS_HR:
    1192         if(!co) return GCOBR_NOCLOCKORBITPARAMETER;
    1193         co->messageType = type;
    1194         switch(s)
    1195         {
    1196         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1197         case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    1198         case CLOCKORBIT_SATBDS:
    1199           G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1200           break;
    1201         case CLOCKORBIT_SATGLONASS:
    1202           G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
    1203           break;
    1204         }
    1205         G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
    1206         G_MULTIPLE_MESSAGE_INDICATOR(mmi)
    1207         G_SSR_IOD(co->SSRIOD)
    1208         G_SSR_PROVIDER_ID(co->SSRProviderID)
    1209         G_SSR_SOLUTION_ID(co->SSRSolutionID)
    1210         G_NO_OF_SATELLITES(nums)
    1211         co->Supplied[COBOFS_HR] |= 1;
    1212         for(i = 0; i < nums; ++i)
    1213         {
    1214           switch(s)
    1215           {
    1216           case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1217           case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    1218             G_GPS_SATELLITE_ID(id)
    1219             break;
    1220           case CLOCKORBIT_SATQZSS:
    1221             G_QZSS_SATELLITE_ID(id)
    1222             break;
    1223           case CLOCKORBIT_SATGLONASS:
    1224             G_GLONASS_SATELLITE_ID(id)
    1225             break;
     1184          break;
     1185        case COBOFS_URA:
     1186          if (!co)
     1187            return GCOBR_NOCLOCKORBITPARAMETER;
     1188          co->messageType = type;
     1189          switch (s) {
     1190            case CLOCKORBIT_SATGPS:
     1191            case CLOCKORBIT_SATGALILEO:
     1192            case CLOCKORBIT_SATQZSS:
     1193            case CLOCKORBIT_SATSBAS:
     1194            case CLOCKORBIT_SATBDS:
     1195              G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1196              break;
     1197            case CLOCKORBIT_SATGLONASS:
     1198              G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1199              break;
    12261200          }
    1227           for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos)
    1228             ;
    1229           if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH;
    1230           else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s];
    1231           co->Sat[pos].ID = id;
    1232 
    1233           G_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock)
    1234         }
    1235         break;
    1236       case COBOFS_BIAS:
    1237         if(!b) return GCOBR_NOCODEBIASPARAMETER;
    1238         b->messageType = type;
    1239         switch(s)
    1240         {
    1241         case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1242         case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS:
    1243         case CLOCKORBIT_SATBDS:
    1244           G_GPS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s])
    1245           break;
    1246         case CLOCKORBIT_SATGLONASS:
    1247           G_GLONASS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s])
    1248           break;
    1249         }
    1250         G_SSR_UPDATE_INTERVAL(b->UpdateInterval)
    1251         G_MULTIPLE_MESSAGE_INDICATOR(mmi)
    1252         G_SSR_IOD(b->SSRIOD)
    1253         G_SSR_PROVIDER_ID(b->SSRProviderID)
    1254         G_SSR_SOLUTION_ID(b->SSRSolutionID)
    1255         G_NO_OF_SATELLITES(nums)
    1256         for(i = 0; i < nums; ++i)
    1257         {
    1258           switch(s)
    1259           {
    1260           case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO:
    1261           case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS:
    1262             G_GPS_SATELLITE_ID(id)
    1263             break;
    1264           case CLOCKORBIT_SATQZSS:
    1265             G_QZSS_SATELLITE_ID(id)
    1266             break;
    1267           case CLOCKORBIT_SATGLONASS:
    1268             G_GLONASS_SATELLITE_ID(id)
    1269             break;
     1201          G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     1202          G_MULTIPLE_MESSAGE_INDICATOR(mmi)
     1203          G_SSR_IOD(co->SSRIOD)
     1204          G_SSR_PROVIDER_ID(co->SSRProviderID)
     1205          G_SSR_SOLUTION_ID(co->SSRSolutionID)
     1206          G_NO_OF_SATELLITES(nums)
     1207          co->Supplied[COBOFS_URA] |= 1;
     1208#ifdef BNC_DEBUG
     1209          fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     1210                          co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
     1211                                  co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     1212#endif
     1213          for (i = 0; i < nums; ++i) {
     1214            switch (s) {
     1215              case CLOCKORBIT_SATGPS:
     1216              case CLOCKORBIT_SATGALILEO:
     1217              case CLOCKORBIT_SATSBAS:
     1218              case CLOCKORBIT_SATBDS:
     1219                G_GPS_SATELLITE_ID(id)
     1220                break;
     1221              case CLOCKORBIT_SATQZSS:
     1222                G_QZSS_SATELLITE_ID(id)
     1223                break;
     1224              case CLOCKORBIT_SATGLONASS:
     1225                G_GLONASS_SATELLITE_ID(id)
     1226                break;
     1227            }
     1228            for (pos = satoffset[s];
     1229                pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     1230                ++pos)
     1231              ;
     1232            if (pos >= satoffset[s + 1])
     1233              return GCOBR_DATAMISMATCH;
     1234            else if (pos == co->NumberOfSat[s] + satoffset[s])
     1235              ++co->NumberOfSat[s];
     1236            co->Sat[pos].ID = id;
     1237            G_SSR_URA(co->Sat[pos].UserRangeAccuracy)
     1238#ifdef BNC_DEBUG
     1239            fprintf(stderr, "id %2d ura %8.3f \n",
     1240                co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy);
     1241#endif
    12701242          }
    1271           for(pos = satoffset[s]; pos < satoffset[s]+b->NumberOfSat[s] && b->Sat[pos].ID != id; ++pos)
    1272             ;
    1273           if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH;
    1274           else if(pos == b->NumberOfSat[s] + satoffset[s]) ++b->NumberOfSat[s];
    1275           b->Sat[pos].ID = id;
    1276 
    1277           G_NO_OF_CODE_BIASES(b->Sat[pos].NumberOfCodeBiases)
    1278           for(j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j)
    1279           {
    1280             G_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type)
    1281             G_CODE_BIAS(b->Sat[pos].Biases[j].Bias)
     1243          break;
     1244        case COBOFS_HR:
     1245          if (!co)
     1246            return GCOBR_NOCLOCKORBITPARAMETER;
     1247          co->messageType = type;
     1248          switch (s) {
     1249            case CLOCKORBIT_SATGPS:
     1250            case CLOCKORBIT_SATGALILEO:
     1251            case CLOCKORBIT_SATQZSS:
     1252            case CLOCKORBIT_SATSBAS:
     1253            case CLOCKORBIT_SATBDS:
     1254              G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1255              break;
     1256            case CLOCKORBIT_SATGLONASS:
     1257              G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s])
     1258              break;
    12821259          }
    1283         }
    1284         break;
    1285       default:
    1286         continue;
    1287       }
    1288 #ifdef COR_LATENCY
    1289       if(s == CLOCKORBIT_SATGPS && type-corbase[s] != COBOFS_BIAS)
    1290       {
    1291         co->epochGPS[co->epochSize] = co->EpochTime[s];
    1292         if(co->epochSize < COR_LATENCYCOUNT)
    1293           ++co->epochSize;
    1294       }
    1295 #endif
    1296 #ifdef DEBUG
    1297       for(type = 0; type < (int)size && (unsigned char)buffer[type] != 0xD3; ++type)
    1298         numbits += 8;
     1260          G_SSR_UPDATE_INTERVAL(co->UpdateInterval)
     1261          G_MULTIPLE_MESSAGE_INDICATOR(mmi)
     1262          G_SSR_IOD(co->SSRIOD)
     1263          G_SSR_PROVIDER_ID(co->SSRProviderID)
     1264          G_SSR_SOLUTION_ID(co->SSRSolutionID)
     1265          G_NO_OF_SATELLITES(nums)
     1266          co->Supplied[COBOFS_HR] |= 1;
     1267#ifdef BNC_DEBUG
     1268          fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     1269                          co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
     1270                                  co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
     1271#endif
     1272          for (i = 0; i < nums; ++i) {
     1273            switch (s) {
     1274              case CLOCKORBIT_SATGPS:
     1275              case CLOCKORBIT_SATGALILEO:
     1276              case CLOCKORBIT_SATSBAS:
     1277              case CLOCKORBIT_SATBDS:
     1278                G_GPS_SATELLITE_ID(id)
     1279                break;
     1280              case CLOCKORBIT_SATQZSS:
     1281                G_QZSS_SATELLITE_ID(id)
     1282                break;
     1283              case CLOCKORBIT_SATGLONASS:
     1284                G_GLONASS_SATELLITE_ID(id)
     1285                break;
     1286            }
     1287            for (pos = satoffset[s];
     1288                pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
     1289                ++pos)
     1290              ;
     1291            if (pos >= satoffset[s + 1])
     1292              return GCOBR_DATAMISMATCH;
     1293            else if (pos == co->NumberOfSat[s] + satoffset[s])
     1294              ++co->NumberOfSat[s];
     1295            co->Sat[pos].ID = id;
     1296            G_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock)
     1297#ifdef BNC_DEBUG
     1298            fprintf(stderr, "id %2d hrClock %8.3f \n",
     1299                    co->Sat[pos].ID, co->Sat[pos].hrclock);
     1300#endif
     1301          }
     1302          break;
     1303        case COBOFS_CBIAS:
     1304          if (!b)
     1305            return GCOBR_NOCODEBIASPARAMETER;
     1306          b->messageType = type;
     1307          switch (s) {
     1308            case CLOCKORBIT_SATGPS:
     1309            case CLOCKORBIT_SATGALILEO:
     1310            case CLOCKORBIT_SATQZSS:
     1311            case CLOCKORBIT_SATSBAS:
     1312            case CLOCKORBIT_SATBDS:
     1313              G_GPS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s])
     1314              break;
     1315            case CLOCKORBIT_SATGLONASS:
     1316              G_GLONASS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s])
     1317              break;
     1318          }
     1319          G_SSR_UPDATE_INTERVAL(b->UpdateInterval)
     1320          G_MULTIPLE_MESSAGE_INDICATOR(mmi)
     1321          G_SSR_IOD(b->SSRIOD)
     1322          G_SSR_PROVIDER_ID(b->SSRProviderID)
     1323          G_SSR_SOLUTION_ID(b->SSRSolutionID)
     1324          G_NO_OF_SATELLITES(nums)
     1325#ifdef BNC_DEBUG
     1326          fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
     1327                          b->EpochTime[s], b->UpdateInterval,mmi,b->NumberOfSat[s],nums,
     1328                                  b->SSRIOD, b->SSRProviderID, b->SSRSolutionID);
     1329#endif
     1330          for (i = 0; i < nums; ++i) {
     1331            switch (s) {
     1332              case CLOCKORBIT_SATGPS:
     1333              case CLOCKORBIT_SATGALILEO:
     1334              case CLOCKORBIT_SATSBAS:
     1335              case CLOCKORBIT_SATBDS:
     1336                G_GPS_SATELLITE_ID(id)
     1337                break;
     1338              case CLOCKORBIT_SATQZSS:
     1339                G_QZSS_SATELLITE_ID(id)
     1340                break;
     1341              case CLOCKORBIT_SATGLONASS:
     1342                G_GLONASS_SATELLITE_ID(id)
     1343                break;
     1344            }
     1345            for (pos = satoffset[s];
     1346                pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id;
     1347                ++pos)
     1348              ;
     1349            if (pos >= satoffset[s + 1])
     1350              return GCOBR_DATAMISMATCH;
     1351            else if (pos == b->NumberOfSat[s] + satoffset[s])
     1352              ++b->NumberOfSat[s];
     1353            b->Sat[pos].ID = id;
     1354            G_NO_OF_CODE_BIASES(b->Sat[pos].NumberOfCodeBiases)
     1355#ifdef BNC_DEBUG
     1356            fprintf(stderr, "id %2d #%d ",
     1357                    b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases);
     1358#endif
     1359            for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) {
     1360              G_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type)
     1361              G_CODE_BIAS(b->Sat[pos].Biases[j].Bias)
     1362#ifdef BNC_DEBUG
     1363            fprintf(stderr, "t%02d b %8.2f ",
     1364                    b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias);
     1365#endif
     1366            }
     1367#ifdef BNC_DEBUG
     1368            fprintf(stderr, "\n");
     1369#endif
     1370          }
     1371          break;
     1372        default:
     1373          continue;
     1374      }
     1375#ifdef BNC_DEBUG
     1376      for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
     1377      numbits += 8;
    12991378      fprintf(stderr, "numbits left %d\n",numbits);
    13001379#endif
  • branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h

    r8943 r8987  
    1313#include <string.h>
    1414
    15 enum SatelliteReferenceDatum { DATUM_ITRF=0, DATUM_LOCAL=1 };
     15
     16
     17
     18
     19
     20enum SatelliteReferenceDatum {
     21  DATUM_ITRF  = 0,
     22  DATUM_LOCAL = 1
     23};
    1624
    1725enum COR_BASE {
    18   COBBASE_GPS = 1057,
     26  COBBASE_GPS     = 1057,
    1927  COBBASE_GLONASS = 1063,
    2028  COBBASE_GALILEO = 1240,
    21   COBBASE_QZSS = 1246,
    22   COBBASE_SBAS = 1252,
    23   COBBASE_BDS = 1258,
     29  COBBASE_QZSS    = 1246,
     30  COBBASE_SBAS    = 1252,
     31  COBBASE_BDS     = 1258,
     32  COBBASE_NUM
    2433};
    2534
     
    2736  COBOFS_ORBIT = 0,
    2837  COBOFS_CLOCK,
    29   COBOFS_BIAS,
     38  COBOFS_CBIAS,
    3039  COBOFS_COMBINED,
    3140  COBOFS_URA,
     
    3544
    3645enum ClockOrbitType {
    37   COTYPE_GPSORBIT = COBBASE_GPS + COBOFS_ORBIT,
     46  COTYPE_GPSORBIT        = COBBASE_GPS    + COBOFS_ORBIT,
    3847  COTYPE_GPSCLOCK,
    39   COTYPE_GPSCOMBINED = COBBASE_GPS + COBOFS_COMBINED,
     48  COTYPE_GPSCOMBINED     = COBBASE_GPS    + COBOFS_COMBINED,
    4049  COTYPE_GPSURA,
    4150  COTYPE_GPSHR,
    4251
    43   COTYPE_GLONASSORBIT = COBBASE_GLONASS + COBOFS_ORBIT,
     52  COTYPE_GLONASSORBIT    = COBBASE_GLONASS + COBOFS_ORBIT,
    4453  COTYPE_GLONASSCLOCK,
    4554  COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED,
     
    4756  COTYPE_GLONASSHR,
    4857
    49   COTYPE_GALILEOORBIT = COBBASE_GALILEO + COBOFS_ORBIT,
     58  COTYPE_GALILEOORBIT    = COBBASE_GALILEO + COBOFS_ORBIT,
    5059  COTYPE_GALILEOCLOCK,
    5160  COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED,
     
    5362  COTYPE_GALILEOHR,
    5463
    55   COTYPE_QZSSORBIT = COBBASE_QZSS + COBOFS_ORBIT,
     64  COTYPE_QZSSORBIT       = COBBASE_QZSS    + COBOFS_ORBIT,
    5665  COTYPE_QZSSCLOCK,
    57   COTYPE_QZSSCOMBINED = COBBASE_QZSS + COBOFS_COMBINED,
     66  COTYPE_QZSSCOMBINED    = COBBASE_QZSS    + COBOFS_COMBINED,
    5867  COTYPE_QZSSURA,
    5968  COTYPE_QZSSHR,
    6069
    61   COTYPE_SBASORBIT = COBBASE_SBAS + COBOFS_ORBIT,
     70  COTYPE_SBASORBIT       = COBBASE_SBAS    + COBOFS_ORBIT,
    6271  COTYPE_SBASCLOCK,
    63   COTYPE_SBASCOMBINED = COBBASE_SBAS + COBOFS_COMBINED,
     72  COTYPE_SBASCOMBINED    = COBBASE_SBAS    + COBOFS_COMBINED,
    6473  COTYPE_SBASURA,
    6574  COTYPE_SBASHR,
    6675
    67   COTYPE_BDSORBIT = COBBASE_BDS + COBOFS_ORBIT,
     76  COTYPE_BDSORBIT        = COBBASE_BDS    + COBOFS_ORBIT,
    6877  COTYPE_BDSCLOCK,
    69   COTYPE_BDSCOMBINED = COBBASE_BDS + COBOFS_COMBINED,
     78  COTYPE_BDSCOMBINED     = COBBASE_BDS + COBOFS_COMBINED,
    7079  COTYPE_BDSURA,
    7180  COTYPE_BDSHR,
     
    7584
    7685enum CodeBiasType {
    77   BTYPE_GPS = COBBASE_GPS + COBOFS_BIAS,
    78   BTYPE_GLONASS = COBBASE_GLONASS + COBOFS_BIAS,
    79   BTYPE_GALILEO = COBBASE_GALILEO + COBOFS_BIAS,
    80   BTYPE_QZSS = COBBASE_QZSS + COBOFS_BIAS,
    81   BTYPE_SBAS = COBBASE_SBAS + COBOFS_BIAS,
    82   BTYPE_BDS = COBBASE_BDS + COBOFS_BIAS,
    83   BTYPE_AUTO = 0
    84 };
    85 
    86 enum PhaseBiasType {
    87   PBTYPE_BASE = 1265,
    88   PBTYPE_GPS = PBTYPE_BASE,
     86  CBTYPE_GPS     = COBBASE_GPS     + COBOFS_CBIAS,
     87  CBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_CBIAS,
     88  CBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_CBIAS,
     89  CBTYPE_QZSS    = COBBASE_QZSS    + COBOFS_CBIAS,
     90  CBTYPE_SBAS    = COBBASE_SBAS    + COBOFS_CBIAS,
     91  CBTYPE_BDS     = COBBASE_BDS     + COBOFS_CBIAS,
     92  CBTYPE_AUTO    = 0
     93};
     94
     95enum PhaseBiasType{
     96  PBTYPE_BASE    = 1265,
     97  PBTYPE_GPS     = PBTYPE_BASE,
    8998  PBTYPE_GLONASS,
    9099  PBTYPE_GALILEO,
     
    92101  PBTYPE_SBAS,
    93102  PBTYPE_BDS,
    94   PBTYPE_AUTO = 0
     103  PBTYPE_AUTO    = 0
    95104};
    96105
     
    102111for these systems to save space */
    103112enum COR_CONSTANTS {
    104   CLOCKORBIT_BUFFERSIZE=8192,
    105   CLOCKORBIT_NUMGPS=32,
    106   CLOCKORBIT_NUMGLONASS=26,
    107   CLOCKORBIT_NUMGALILEO=36,
    108   CLOCKORBIT_NUMQZSS=10,
    109   CLOCKORBIT_NUMSBAS=38,
    110   CLOCKORBIT_NUMBDS=65,
    111   CLOCKORBIT_NUMBIAS=100,
    112   CLOCKORBIT_NUMIONOLAYERS=4,
    113   CLOCKORBIT_MAXIONOORDER=16,
    114   CLOCKORBIT_MAXIONODEGREE=16
     113  CLOCKORBIT_BUFFERSIZE    = 8192,
     114  CLOCKORBIT_NUMGPS        =   32,
     115  CLOCKORBIT_NUMGLONASS    =   26,
     116  CLOCKORBIT_NUMGALILEO    =   36,
     117  CLOCKORBIT_NUMQZSS       =   10,
     118  CLOCKORBIT_NUMSBAS       =   38,
     119  CLOCKORBIT_NUMBDS        =   65,
     120  CLOCKORBIT_NUMBIAS       =  100,
     121  CLOCKORBIT_NUMIONOLAYERS =    4,
     122  CLOCKORBIT_MAXIONOORDER  =   16,
     123  CLOCKORBIT_MAXIONODEGREE =   16
    115124};
    116125
     
    126135
    127136enum COR_OFFSETS {
    128   CLOCKORBIT_OFFSETGPS=0,
    129   CLOCKORBIT_OFFSETGLONASS=CLOCKORBIT_NUMGPS,
    130   CLOCKORBIT_OFFSETGALILEO=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS,
    131   CLOCKORBIT_OFFSETQZSS=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS
    132   +CLOCKORBIT_NUMGALILEO,
    133   CLOCKORBIT_OFFSETSBAS=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS
    134   +CLOCKORBIT_NUMGALILEO+CLOCKORBIT_NUMQZSS,
    135   CLOCKORBIT_OFFSETBDS=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS
    136   +CLOCKORBIT_NUMGALILEO+CLOCKORBIT_NUMQZSS+CLOCKORBIT_NUMSBAS,
    137   CLOCKORBIT_COUNTSAT=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS
    138   +CLOCKORBIT_NUMGALILEO+CLOCKORBIT_NUMQZSS+CLOCKORBIT_NUMSBAS
    139   +CLOCKORBIT_NUMBDS
     137  CLOCKORBIT_OFFSETGPS     = 0,
     138  CLOCKORBIT_OFFSETGLONASS = CLOCKORBIT_NUMGPS,
     139  CLOCKORBIT_OFFSETGALILEO = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS,
     140  CLOCKORBIT_OFFSETQZSS    = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO,
     141  CLOCKORBIT_OFFSETSBAS    = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
     142                           + CLOCKORBIT_NUMQZSS,
     143  CLOCKORBIT_OFFSETBDS     = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
     144                           + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS,
     145  CLOCKORBIT_COUNTSAT      = CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
     146                           + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS    + CLOCKORBIT_NUMBDS
    140147};
    141148
     
    220227  CODETYPE_SBAS_L5_Q         = 2,
    221228  CODETYPE_SBAS_L5_IQ        = 3,
     229
    222230  CODETYPE_BDS_B1_I          = 0,
    223231  CODETYPE_BDS_B1_Q          = 1,
     
    234242  CODETYPE_BDS_B2a_D         = 12,
    235243  CODETYPE_BDS_B2a_P         = 13,
    236   CODETYPE_BDS_B2a_DP        = 14,
    237 
    238   CODETYPE_IRNSS_S_SPS       = 8,
    239   CODETYPE_IRNSS_L5_SPS      = 22
     244  CODETYPE_BDS_B2a_DP        = 14
    240245};
    241246
     
    247252xxx->Sat[CLOCKORBIT_OFFSETGPS]. */
    248253
    249 #ifdef COR_LEGACY
    250 /* old names */
    251 #define NumberOfGPSSat     NumberOfSat[CLOCKORBIT_SATGPS]
    252 #define NumberOfGLONASSSat NumberOfSat[CLOCKORBIT_SATGLONASS]
    253 #define GPSEpochTime       EpochTime[CLOCKORBIT_SATGPS] /* 0 .. 604799 s */
    254 #define GLONASSEpochTime   EpochTime[CLOCKORBIT_SATGLONASS] /* 0 .. 86399 s (86400 for leap second) */
    255 #define ClockDataSupplied  Supplied[COBOFS_CLOCK]
    256 #define HRDataSupplied     Supplied[COBOFS_HR]
    257 #define OrbitDataSupplied  Supplied[COBOFS_ORBIT]
    258 #define URADataSupplied    Supplied[COBOFS_URA]
    259 #define GetClockOrbitBias(a,b,c,d,e) GetSSR(a,b,0,0,c,d,e)
    260 #endif /* COR_LEGACY */
    261 
    262 /* latency check code, disabled by default */
    263 #ifdef COR_LATENCY
    264 #define COR_LATENCYCOUNT 100
    265 #endif
    266 
    267 struct ClockOrbit
    268 {
     254struct ClockOrbit {
    269255  enum ClockOrbitType messageType;
    270256  unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
    271257  unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */
    272 
    273258  unsigned int Supplied[COBOFS_NUM];           /* boolean */
    274 #ifdef COR_LATENCY
    275   unsigned int epochGPS[COR_LATENCYCOUNT+1];   /* Weber, for latency */
    276   unsigned int epochSize;                      /* Weber, for latency */
    277 #endif
    278259  unsigned int SSRIOD;
    279260  unsigned int SSRProviderID;
     
    287268    double UserRangeAccuracy; /* accuracy values in [m] */
    288269    double hrclock;
    289     struct OrbitPart
    290     {
     270    struct OrbitPart {
    291271      double DeltaRadial;           /* m */
    292272      double DeltaAlongTrack;       /* m */
     
    296276      double DotDeltaCrossTrack;    /* m/s */
    297277    } Orbit;
    298     struct ClockPart
    299     {
     278    struct ClockPart {
    300279      double DeltaA0;               /* m */
    301280      double DeltaA1;               /* m/s */
     
    305284};
    306285
    307 struct CodeBias
    308 {
     286struct CodeBias {
    309287  enum CodeBiasType messageType;
    310288  unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
     
    314292  unsigned int SSRProviderID;
    315293  unsigned int SSRSolutionID;
    316   struct BiasSat
    317   {
     294  struct BiasSat {
    318295    unsigned int ID; /* all */
    319296    unsigned int NumberOfCodeBiases;
    320     struct CodeBiasEntry
    321     {
     297    struct CodeBiasEntry {
    322298      enum CodeType Type;
    323299      float         Bias;           /* m */
     
    326302};
    327303
    328 struct PhaseBias
    329 {
     304struct PhaseBias {
    330305  enum PhaseBiasType messageType;
    331306  unsigned int EpochTime[CLOCKORBIT_SATNUM];   /* 0 .. system specific maximum */
     
    337312  unsigned int DispersiveBiasConsistencyIndicator;
    338313  unsigned int MWConsistencyIndicator;
    339   struct PhaseBiasSat
    340   {
     314  struct PhaseBiasSat {
    341315    unsigned int ID; /* all */
    342316    unsigned int NumberOfPhaseBiases;
    343317    double YawAngle; /* radiant */
    344318    double YawRate;  /* radiant/s */
    345     struct PhaseBiasEntry
    346     {
     319    struct PhaseBiasEntry {
    347320      enum CodeType Type;
    348321      unsigned int  SignalIntegerIndicator;
     
    354327};
    355328
    356 struct VTEC
    357 {
     329struct VTEC {
    358330  unsigned int EpochTime; /* GPS */
    359331  unsigned int UpdateInterval;
     
    384356enum GCOB_RETURN {
    385357  /* all well */
    386   GCOBR_MESSAGEFOLLOWS = 1,
    387   GCOBR_OK = 0,
     358  GCOBR_MESSAGEFOLLOWS        = 1,
     359  GCOBR_OK                    = 0,
    388360  /* unknown data, a warning */
    389   GCOBR_UNKNOWNTYPE = -1,
    390   GCOBR_UNKNOWNDATA = -2,
    391   GCOBR_CRCMISMATCH = -3,
    392   GCOBR_SHORTMESSAGE = -4,
     361  GCOBR_UNKNOWNTYPE           = -1,
     362  GCOBR_UNKNOWNDATA           = -2,
     363  GCOBR_CRCMISMATCH           = -3,
     364  GCOBR_SHORTMESSAGE          = -4,
    393365  /* failed to do the work */
    394366  GCOBR_NOCLOCKORBITPARAMETER = -10,
    395   GCOBR_NOCODEBIASPARAMETER = -11,
    396   GCOBR_NOPHASEBIASPARAMETER = -12,
    397   GCOBR_NOVTECPARAMETER = -13,
     367  GCOBR_NOCODEBIASPARAMETER   = -11,
     368  GCOBR_NOPHASEBIASPARAMETER  = -12,
     369  GCOBR_NOVTECPARAMETER       = -13,
    398370  /* data mismatch - data in storage does not match new data */
    399   GCOBR_TIMEMISMATCH = -20,
    400   GCOBR_DATAMISMATCH = -21,
     371  GCOBR_TIMEMISMATCH          = -20,
     372  GCOBR_DATAMISMATCH          = -21,
    401373  /* not enough data - can decode the block completely */
    402   GCOBR_SHORTBUFFER = -30,
    403   GCOBR_MESSAGEEXCEEDSBUFFER = -31};
     374  GCOBR_SHORTBUFFER           = -30,
     375  GCOBR_MESSAGEEXCEEDSBUFFER  = -31};
    404376
    405377/* NOTE: When an error message has been emitted, the output structures may have been modified. Make a copy of the previous variant before calling the
  • branches/BNC_2.12/src/src.pri

    r7858 r8987  
    6060          RTCM3/RTCM3Decoder.h RTCM3/bits.h RTCM3/gnss.h              \
    6161          RTCM3/RTCM3coDecoder.h RTCM3/ephEncoder.h                   \
    62           RTCM3/clock_and_orbit/clock_orbit_rtcm.h                    \
    6362          rinex/rnxobsfile.h                                          \
    6463          rinex/rnxnavfile.h       rinex/corrfile.h                   \
     
    9796          RTCM3/RTCM3Decoder.cpp                                      \
    9897          RTCM3/RTCM3coDecoder.cpp RTCM3/ephEncoder.cpp               \
    99           RTCM3/clock_and_orbit/clock_orbit_rtcm.c                    \
    10098          rinex/rnxobsfile.cpp                                        \
    10199          rinex/rnxnavfile.cpp     rinex/corrfile.cpp                 \
     
    113111
    114112QT += network
     113
     114# Format of SSR corrections
     115# -------------------------
     116DEFINES += USE_SSR_RTCM
     117#DEFINES += USE_SSR_IGS
     118contains(DEFINES, USE_SSR_IGS) {
     119  HEADERS += RTCM3/clock_and_orbit/clock_orbit_igs.h
     120  SOURCES += RTCM3/clock_and_orbit/clock_orbit_igs.c
     121}
     122else {
     123  HEADERS += RTCM3/clock_and_orbit/clock_orbit_rtcm.h
     124  SOURCES += RTCM3/clock_and_orbit/clock_orbit_rtcm.c
     125}
    115126
    116127exists(PPP) {
  • branches/BNC_2.12/src/upload/bncrtnetuploadcaster.cpp

    r8946 r8987  
    150150    _t0  = 2020.0;
    151151  }
    152   // Transformation Parameters from IGb14 to SIRGAS2000 (Sonia Costa, BRA)
     152  // Transformation Parameters from IGb14 to SIRGAS2000 (Thanks to Sonia Costa, BRA)
     153  // June 29 2020: TX:-0.0027 m  TY:-0.0025 m  TZ:-0.0042 m  SCL:1.20 (ppb) no rotations and no rates.*/
    153154  else if (_crdTrafo == "SIRGAS2000") {
    154     _dx  =  0.0026;
    155     _dy  =  0.0018;
    156     _dz  = -0.0061;
     155    _dx  = -0.0027;
     156    _dy  = -0.0025;
     157    _dz  = -0.0042;
    157158
    158159    _dxr =  0.0000;
     
    168169    _ozr =  0.000000;
    169170
    170     _sc  = -1.00000;
     171    _sc  =  1.20000;
    171172    _scr =  0.00000;
    172173    _t0  =  2000.0;
     
    553554      else if (prn.system() == 'E') {
    554555        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    555             + co.NumberOfSat[CLOCKORBIT_SATGALILEO];
     556           + co.NumberOfSat[CLOCKORBIT_SATGALILEO];
    556557        ++co.NumberOfSat[CLOCKORBIT_SATGALILEO];
    557558      }
    558559      else if (prn.system() == 'J') {
    559560        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    560             + CLOCKORBIT_NUMGALILEO + co.NumberOfSat[CLOCKORBIT_SATQZSS];
     561           + CLOCKORBIT_NUMGALILEO
     562           + co.NumberOfSat[CLOCKORBIT_SATQZSS];
    561563        ++co.NumberOfSat[CLOCKORBIT_SATQZSS];
    562564      }
     
    569571      else if (prn.system() == 'C') {
    570572        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    571             + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS
     573            + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     574            + CLOCKORBIT_NUMSBAS
    572575            + co.NumberOfSat[CLOCKORBIT_SATBDS];
    573576        ++co.NumberOfSat[CLOCKORBIT_SATBDS];
     
    594597        else if (prn.system() == 'R') {
    595598          biasSat = bias.Sat + CLOCKORBIT_NUMGPS
    596               + bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     599                  + bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    597600          ++bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    598601        }
    599602        else if (prn.system() == 'E') {
    600603          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    601               + bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     604                  + bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    602605          ++bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    603606        }
    604607        else if (prn.system() == 'J') {
    605608          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    606               + CLOCKORBIT_NUMGALILEO + bias.NumberOfSat[CLOCKORBIT_SATQZSS];
     609                  + CLOCKORBIT_NUMGALILEO
     610                  + bias.NumberOfSat[CLOCKORBIT_SATQZSS];
    607611          ++bias.NumberOfSat[CLOCKORBIT_SATQZSS];
    608612        }
    609613        else if (prn.system() == 'S') {
    610614          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    611               + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    612               + bias.NumberOfSat[CLOCKORBIT_SATSBAS];
     615                  + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     616                  + bias.NumberOfSat[CLOCKORBIT_SATSBAS];
    613617          ++bias.NumberOfSat[CLOCKORBIT_SATSBAS];
    614618        }
    615619        else if (prn.system() == 'C') {
    616620          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    617               + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS
    618               + bias.NumberOfSat[CLOCKORBIT_SATBDS];
     621                  + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     622                  + CLOCKORBIT_NUMSBAS
     623                  + bias.NumberOfSat[CLOCKORBIT_SATBDS];
    619624          ++bias.NumberOfSat[CLOCKORBIT_SATBDS];
    620625        }
     
    652657              biasSat->Biases[ii].Bias = it.value();
    653658            }
     659#ifdef USE_SSR_RTCM
    654660            else if (it.key() == "1X") {
    655661              int ii = biasSat->NumberOfCodeBiases;
     
    660666              biasSat->Biases[ii].Bias = it.value();
    661667            }
     668#endif
    662669            else if (it.key() == "1P") {
    663670              int ii = biasSat->NumberOfCodeBiases;
     
    708715              biasSat->Biases[ii].Bias = it.value();
    709716            }
     717#ifdef USE_SSR_RTCM
    710718            else if (it.key() == "2X") {
    711719              int ii = biasSat->NumberOfCodeBiases;
     
    716724              biasSat->Biases[ii].Bias = it.value();
    717725            }
     726#endif
    718727            else if (it.key() == "2P") {
    719728              int ii = biasSat->NumberOfCodeBiases;
     
    748757              biasSat->Biases[ii].Bias = it.value();
    749758            }
     759#ifdef USE_SSR_RTCM
    750760            else if (it.key() == "5X") {
    751761              int ii = biasSat->NumberOfCodeBiases;
     
    756766              biasSat->Biases[ii].Bias = it.value();
    757767            }
     768#endif
    758769          }
    759770        }
     
    810821              biasSat->Biases[ii].Bias = it.value();
    811822            }
     823#ifdef USE_SSR_RTCM
    812824            else if (it.key() == "4X") {
    813825              int ii = biasSat->NumberOfCodeBiases;
     
    818830              biasSat->Biases[ii].Bias = it.value();
    819831            }
     832#endif
    820833            else if (it.key() == "6A") {
    821834              int ii = biasSat->NumberOfCodeBiases;
     
    834847              biasSat->Biases[ii].Bias = it.value();
    835848            }
     849#ifdef USE_SSR_RTCM
    836850            else if (it.key() == "6X") {
    837851              int ii = biasSat->NumberOfCodeBiases;
     
    842856              biasSat->Biases[ii].Bias = it.value();
    843857            }
     858#endif
    844859            else if (it.key() == "3I") {
    845860              int ii = biasSat->NumberOfCodeBiases;
     
    858873              biasSat->Biases[ii].Bias = it.value();
    859874            }
     875#ifdef USE_SSR_RTCM
    860876            else if (it.key() == "3X") {
    861877              int ii = biasSat->NumberOfCodeBiases;
     
    866882              biasSat->Biases[ii].Bias = it.value();
    867883            }
     884#endif
    868885          }
    869886        }
     
    896913              biasSat->Biases[ii].Bias = it.value();
    897914            }
     915#ifdef USE_SSR_RTCM
    898916            else if (it.key() == "1X") {
    899917              int ii = biasSat->NumberOfCodeBiases;
     
    912930              biasSat->Biases[ii].Bias = it.value();
    913931            }
     932#endif
    914933            else if (it.key() == "5I") {
    915934              int ii = biasSat->NumberOfCodeBiases;
     
    928947              biasSat->Biases[ii].Bias = it.value();
    929948            }
     949#ifdef USE_SSR_RTCM
    930950            else if (it.key() == "5X") {
    931951              int ii = biasSat->NumberOfCodeBiases;
     
    936956              biasSat->Biases[ii].Bias = it.value();
    937957            }
     958#endif
    938959            else if (it.key() == "7I") {
    939960              int ii = biasSat->NumberOfCodeBiases;
     
    952973              biasSat->Biases[ii].Bias = it.value();
    953974            }
     975#ifdef USE_SSR_RTCM
    954976            else if (it.key() == "7X") {
    955977              int ii = biasSat->NumberOfCodeBiases;
     
    9841006              biasSat->Biases[ii].Bias = it.value();
    9851007            }
     1008#endif
    9861009            else if (it.key() == "6A") {
    9871010              int ii = biasSat->NumberOfCodeBiases;
     
    10081031              biasSat->Biases[ii].Bias = it.value();
    10091032            }
     1033#ifdef USE_SSR_RTCM
    10101034            else if (it.key() == "6X") {
    10111035              int ii = biasSat->NumberOfCodeBiases;
     
    10241048              biasSat->Biases[ii].Bias = it.value();
    10251049            }
     1050#endif
    10261051          }
    10271052        }
     
    10701095              biasSat->Biases[ii].Bias = it.value();
    10711096            }
     1097#ifdef USE_SSR_RTCM
    10721098            else if (it.key() == "2X") {
    10731099              int ii = biasSat->NumberOfCodeBiases;
     
    10781104              biasSat->Biases[ii].Bias = it.value();
    10791105            }
     1106#endif
    10801107            else if (it.key() == "5I") {
    10811108              int ii = biasSat->NumberOfCodeBiases;
     
    10941121              biasSat->Biases[ii].Bias = it.value();
    10951122            }
     1123#ifdef USE_SSR_RTCM
    10961124            else if (it.key() == "5X") {
    10971125              int ii = biasSat->NumberOfCodeBiases;
     
    11021130              biasSat->Biases[ii].Bias = it.value();
    11031131            }
     1132#endif
    11041133            else if (it.key() == "6S") {
    11051134              int ii = biasSat->NumberOfCodeBiases;
     
    11181147              biasSat->Biases[ii].Bias = it.value();
    11191148            }
     1149#ifdef USE_SSR_RTCM
    11201150            else if (it.key() == "6X") {
    11211151              int ii = biasSat->NumberOfCodeBiases;
     
    11661196              biasSat->Biases[ii].Bias = it.value();
    11671197            }
     1198#endif
    11681199            else if (it.key() == "6E") {
    11691200              int ii = biasSat->NumberOfCodeBiases;
     
    11741205              biasSat->Biases[ii].Bias = it.value();
    11751206            }
     1207#ifdef USE_SSR_RTCM
    11761208            else if (it.key() == "6Z") {
    11771209              int ii = biasSat->NumberOfCodeBiases;
     
    11821214              biasSat->Biases[ii].Bias = it.value();
    11831215            }
     1216#endif
    11841217          }
    11851218        }
     
    12121245              biasSat->Biases[ii].Bias = it.value();
    12131246            }
     1247#ifdef USE_SSR_RTCM
    12141248            else if (it.key() == "5X") {
    12151249              int ii = biasSat->NumberOfCodeBiases;
     
    12201254              biasSat->Biases[ii].Bias = it.value();
    12211255            }
     1256#endif
    12221257          }
    12231258        }
     
    12421277              biasSat->Biases[ii].Bias = it.value();
    12431278            }
     1279#ifdef USE_SSR_RTCM
    12441280            else if (it.key() == "2X") {
    12451281              int ii = biasSat->NumberOfCodeBiases;
     
    12501286              biasSat->Biases[ii].Bias = it.value();
    12511287            }
     1288#endif
    12521289            else if (it.key() == "6I") {
    12531290              int ii = biasSat->NumberOfCodeBiases;
     
    12661303              biasSat->Biases[ii].Bias = it.value();
    12671304            }
     1305#ifdef USE_SSR_RTCM
    12681306            else if (it.key() == "6X") {
    12691307              int ii = biasSat->NumberOfCodeBiases;
     
    12741312              biasSat->Biases[ii].Bias = it.value();
    12751313            }
     1314#endif
    12761315            else if (it.key() == "7I") {
    12771316              int ii = biasSat->NumberOfCodeBiases;
     
    12901329              biasSat->Biases[ii].Bias = it.value();
    12911330            }
     1331#ifdef USE_SSR_RTCM
    12921332            else if (it.key() == "7X") {
    12931333              int ii = biasSat->NumberOfCodeBiases;
     
    12981338              biasSat->Biases[ii].Bias = it.value();
    12991339            }
     1340#endif
    13001341            else if (it.key() == "1D") {
    13011342              int ii = biasSat->NumberOfCodeBiases;
     
    13141355              biasSat->Biases[ii].Bias = it.value();
    13151356            }
     1357#ifdef USE_SSR_RTCM
    13161358            else if (it.key() == "1X") {
    13171359              int ii = biasSat->NumberOfCodeBiases;
     
    13221364              biasSat->Biases[ii].Bias = it.value();
    13231365            }
     1366#endif
    13241367            else if (it.key() == "5D") {
    13251368              int ii = biasSat->NumberOfCodeBiases;
     
    13381381              biasSat->Biases[ii].Bias = it.value();
    13391382            }
     1383#ifdef USE_SSR_RTCM
    13401384            else if (it.key() == "5X") {
    13411385              int ii = biasSat->NumberOfCodeBiases;
     
    13461390              biasSat->Biases[ii].Bias = it.value();
    13471391            }
     1392#elif USE_SSR_IGS
     1393            else if (it.key() == "1A") {
     1394              int ii = biasSat->NumberOfCodeBiases;
     1395              if (ii >= CLOCKORBIT_NUMBIAS)
     1396                break;
     1397              biasSat->NumberOfCodeBiases += 1;
     1398              biasSat->Biases[ii].Type = CODETYPE_BDS_B1_A;
     1399              biasSat->Biases[ii].Bias = it.value();
    13481400          }
    1349         }
    1350       }
     1401            else if (it.key() == "6A") {
     1402              int ii = biasSat->NumberOfCodeBiases;
     1403              if (ii >= CLOCKORBIT_NUMBIAS)
     1404                break;
     1405              biasSat->NumberOfCodeBiases += 1;
     1406              biasSat->Biases[ii].Type = CODETYPE_BDS_B3_A;
     1407              biasSat->Biases[ii].Bias = it.value();
     1408            }
     1409#endif
     1410          }
     1411        }
     1412      }
     1413     
    13511414      // Phase Biases
    13521415      // ------------
    13531416      struct PhaseBias::PhaseBiasSat* phasebiasSat = 0;
    1354 //      if (!phaseBiasList.isEmpty()) { // to allow yaw angle without phase bias list
    1355         if (prn.system() == 'G') {
    1356           phasebiasSat = phasebias.Sat
    1357               + phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
    1358           ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
    1359         }
    1360         else if (prn.system() == 'R') {
    1361           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
    1362               + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    1363           ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    1364         }
    1365         else if (prn.system() == 'E') {
    1366           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
    1367               + CLOCKORBIT_NUMGLONASS
    1368               + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    1369           ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    1370         }
    1371         else if (prn.system() == 'J') {
    1372           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
    1373               + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    1374               + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
    1375           ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
    1376         }
    1377         else if (prn.system() == 'S') {
    1378           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
    1379               + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    1380               + CLOCKORBIT_NUMQZSS + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
    1381           ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
    1382         }
    1383         else if (prn.system() == 'C') {
    1384           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
    1385               + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO
    1386               + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS
    1387               + phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
    1388           ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
    1389         }
    1390       //}
     1417      if (prn.system()      == 'G') {
     1418        phasebiasSat = phasebias.Sat
     1419                     + phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
     1420        ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
     1421      }
     1422      else if (prn.system() == 'R') {
     1423        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
     1424                     + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     1425        ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     1426      }
     1427      else if (prn.system() == 'E') {
     1428        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     1429                     + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     1430        ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     1431      }
     1432      else if (prn.system() == 'J') {
     1433        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     1434                     + CLOCKORBIT_NUMGALILEO
     1435                     + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
     1436        ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
     1437      }
     1438      else if (prn.system() == 'S') {
     1439        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     1440                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     1441                     + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
     1442        ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
     1443      }
     1444      else if (prn.system() == 'C') {
     1445        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     1446                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     1447                     + CLOCKORBIT_NUMSBAS
     1448                     + phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
     1449        ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
     1450      }
    13911451
    13921452      if (phasebiasSat) {
     
    14781538              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    14791539            }
     1540#ifdef USE_SSR_RTCM
    14801541            else if (pbSig.type == "2X") {
    14811542              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    14891550              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    14901551            }
     1552#endif
    14911553            else if (pbSig.type == "2P") {
    14921554              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    15331595              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    15341596            }
     1597#ifdef USE_SSR_RTCM
    15351598            else if (pbSig.type == "5X") {
    15361599              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    15441607              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    15451608            }
     1609#endif
    15461610            else if (pbSig.type == "1S") {
    15471611              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    15661630              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    15671631            }
     1632#ifdef USE_SSR_RTCM
    15681633            else if (pbSig.type == "1X") {
    15691634              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    15771642              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    15781643            }
     1644#endif
    15791645          }
    15801646        }
     
    16491715              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    16501716            }
     1717#ifdef USE_SSR_RTCM
    16511718            else if (pbSig.type == "4X") {
    16521719              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    16601727              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    16611728            }
     1729#endif
    16621730            else if (pbSig.type == "6A") {
    16631731              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    16821750              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    16831751            }
     1752#ifdef USE_SSR_RTCM
    16841753            else if (pbSig.type == "6X") {
    16851754              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    16931762              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    16941763            }
     1764#endif
    16951765            else if (pbSig.type == "3I") {
    16961766              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    17151785              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    17161786            }
     1787#ifdef USE_SSR_RTCM
    17171788            else if (pbSig.type == "3X") {
    17181789              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    17261797              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    17271798            }
     1799#endif
    17281800          }
    17291801        }
     
    17651837              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    17661838            }
     1839#ifdef USE_SSR_RTCM
    17671840            else if (pbSig.type == "1X") {
    17681841              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    17871860              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    17881861            }
     1862#endif
    17891863            else if (pbSig.type == "5I") {
    17901864              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    18091883              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    18101884            }
     1885#ifdef USE_SSR_RTCM
    18111886            else if (pbSig.type == "5X") {
    18121887              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    18201895              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    18211896            }
     1897#endif
    18221898            else if (pbSig.type == "7I") {
    18231899              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    18421918              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    18431919            }
     1920#ifdef USE_SSR_RTCM
    18441921            else if (pbSig.type == "7X") {
    18451922              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    18861963              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    18871964            }
     1965#endif
    18881966            else if (pbSig.type == "6A") {
    18891967              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    19191997              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    19201998            }
     1999#ifdef USE_SSR_RTCM
    19212000            else if (pbSig.type == "6X") {
    19222001              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    19412020              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    19422021            }
     2022#endif
    19432023          }
    19442024        }
     
    20012081              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    20022082            }
     2083#ifdef USE_SSR_RTCM
    20032084            else if (pbSig.type == "2X") {
    20042085              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    20112092              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    20122093            }
     2094#endif
    20132095            else if (pbSig.type == "5I") {
    20142096              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    20332115              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    20342116            }
     2117#ifdef USE_SSR_RTCM
    20352118            else if (pbSig.type == "5X") {
    20362119              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    20442127              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    20452128            }
     2129#endif
    20462130            else if (pbSig.type == "6S") {
    20472131              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    20662150              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    20672151            }
     2152#ifdef USE_SSR_RTCM
    20682153            else if (pbSig.type == "6X") {
    20692154              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    20772162              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    20782163            }
    2079             else if (pbSig.type == "1X") {
     2164                        else if (pbSig.type == "1X") {
    20802165              int ii = phasebiasSat->NumberOfPhaseBiases;
    20812166              if (ii >= CLOCKORBIT_NUMBIAS)
     
    21322217              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    21332218            }
     2219#endif
    21342220            else if (pbSig.type == "6E") {
    21352221              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    21432229              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    21442230            }
     2231#ifdef USE_SSR_RTCM
    21452232            else if (pbSig.type == "6Z") {
    21462233              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    21542241              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    21552242            }
     2243#endif
    21562244          }
    21572245        }
     
    21922280              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    21932281            }
     2282#ifdef USE_SSR_RTCM
    21942283            else if (pbSig.type == "5X") {
    21952284              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    22032292              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    22042293            }
     2294#endif
    22052295          }
    22062296        }
     
    22312321              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    22322322            }
     2323#ifdef USE_SSR_RTCM
    22332324            else if (pbSig.type == "2X") {
    22342325              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    22422333              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    22432334            }
     2335#endif
    22442336            else if (pbSig.type == "6I") {
    22452337              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    22642356              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    22652357            }
     2358#ifdef USE_SSR_RTCM
    22662359            else if (pbSig.type == "6X") {
    22672360              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    22752368              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    22762369            }
     2370#endif
    22772371            else if (pbSig.type == "7I") {
    22782372              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    22972391              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    22982392            }
     2393#ifdef USE_SSR_RTCM
    22992394            else if (pbSig.type == "7X") {
    23002395              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    23072402              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    23082403            }
     2404#endif
    23092405            else if (pbSig.type == "1D") {
    23102406              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    23272423              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    23282424            }
     2425#ifdef USE_SSR_RTCM
    23292426            else if (pbSig.type == "1X") {
    23302427              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    23372434              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    23382435            }
     2436#endif
    23392437            else if (pbSig.type == "5D") {
    23402438              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    23572455              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    23582456            }
     2457#ifdef USE_SSR_RTCM
    23592458            else if (pbSig.type == "5X") {
    23602459              int ii = phasebiasSat->NumberOfPhaseBiases;
     
    23672466              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    23682467            }
     2468#elif USE_SSR_IGS
     2469            else if (pbSig.type == "1A") {
     2470              int ii = phasebiasSat->NumberOfPhaseBiases;
     2471              if (ii >= CLOCKORBIT_NUMBIAS)
     2472                break;
     2473              phasebiasSat->NumberOfPhaseBiases += 1;
     2474              phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1_A;
     2475              phasebiasSat->Biases[ii].Bias = pbSig.bias;
     2476              phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
     2477              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
     2478            }
     2479            else if (pbSig.type == "6A") {
     2480              int ii = phasebiasSat->NumberOfPhaseBiases;
     2481              if (ii >= CLOCKORBIT_NUMBIAS)
     2482                break;
     2483              phasebiasSat->NumberOfPhaseBiases += 1;
     2484              phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B3_A;
     2485              phasebiasSat->Biases[ii].Bias = pbSig.bias;
     2486              phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
     2487              phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
     2488            }
     2489#endif
    23692490          }
    23702491        }
     
    23722493    }
    23732494  }
     2495
    23742496
    23752497  QByteArray hlpBufferCo;
     
    25252647      || bias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
    25262648    char obuffer[CLOCKORBIT_BUFFERSIZE];
    2527     int len = MakeCodeBias(&bias, BTYPE_AUTO, 0, obuffer, sizeof(obuffer));
     2649    int len = MakeCodeBias(&bias, CBTYPE_AUTO, 0, obuffer, sizeof(obuffer));
    25282650    if (len > 0) {
    25292651      hlpBufferBias = QByteArray(obuffer, len);
Note: See TracChangeset for help on using the changeset viewer.