Index: branches/BNC_2.12/src/RTCM3/RTCM3Decoder.cpp =================================================================== --- branches/BNC_2.12/src/RTCM3/RTCM3Decoder.cpp (revision 8946) +++ branches/BNC_2.12/src/RTCM3/RTCM3Decoder.cpp (revision 8987) @@ -1429,6 +1429,5 @@ GETFLOATSIGN(eph._omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1)) GETFLOATSIGN(eph._OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13)) - GETFLOATSIGN(eph._BGD_1_5A, 10, - 1.0 / (double )(1 << 30) / (double )(1 << 2)) + GETFLOATSIGN(eph._BGD_1_5A, 10, 1.0 / (double )(1 << 30) / (double )(1 << 2)) if (eph._inav) { /* set unused F/NAV values */ @@ -1624,5 +1623,7 @@ * extracted data block. That does no harm, as it anyway skip everything * else. */ - if ((id >= 1057 && id <= 1068) || (id >= 1240 && id <= 1270)) { + if ((id >= 1057 && id <= 1068) || + (id >= 1240 && id <= 1270) || + (id == 4076)) { if (!_coDecoders.contains(_staID.toAscii())) _coDecoders[_staID.toAscii()] = new RTCM3coDecoder(_staID); Index: branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.cpp =================================================================== --- branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.cpp (revision 8946) +++ branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.cpp (revision 8987) @@ -647,6 +647,8 @@ } else if (epoSecGlo != -1) { +#ifdef USE_SSR_RTCM QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date(); epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day()); +#endif _lastTime.set(currentWeek, epoSecGlo); } @@ -661,8 +663,10 @@ } else if (epoSecBds != -1) { +#ifdef USE_SSR_RTCM epoSecBds += 14.0; if (epoSecBds > 604800.0) { epoSecBds -= 7.0*24.0*60.0*60.0; } +#endif _lastTime.set(currentWeek, epoSecBds); } @@ -687,6 +691,5 @@ case CODETYPEGPS_L1_P: return "1P"; case CODETYPEGPS_L1_Z: return "1W"; - //case CODETYPEGPS_L1_Y: return "1Y"; - //case CODETYPEGPS_L1_M: return "1M"; + case CODETYPEGPS_SEMI_CODELESS: return "2D"; case CODETYPEGPS_L2_CA: return "2C"; @@ -696,16 +699,18 @@ case CODETYPEGPS_L2C_M: return "2S"; case CODETYPEGPS_L2C_L: return "2L"; +#ifdef USE_SSR_RTCM case CODETYPEGPS_L2C_ML: return "2X"; - - //case CODETYPEGPS_L2_Y: return "2Y"; - //case CODETYPEGPS_L2_M: return "2M"; +#endif case CODETYPEGPS_L5_I: return "5I"; case CODETYPEGPS_L5_Q: return "5Q"; +#ifdef USE_SSR_RTCM case CODETYPEGPS_L5_IQ: return "5X"; - +#endif case CODETYPEGPS_L1C_D: return "1S"; case CODETYPEGPS_L1C_P: return "1L"; +#ifdef USE_SSR_RTCM case CODETYPEGPS_L1C_DP: return "1X"; +#endif default: return ""; } @@ -715,19 +720,21 @@ case CODETYPEGLONASS_L1_CA: return "1C"; case CODETYPEGLONASS_L1_P: return "1P"; - case CODETYPEGLONASS_L2_CA: return "2C"; case CODETYPEGLONASS_L2_P: return "2P"; - case CODETYPEGLONASS_L1a_OCd: return "4A"; case CODETYPEGLONASS_L1a_OCp: return "4B"; +#ifdef USE_SSR_RTCM case CODETYPEGLONASS_L1a_OCdp: return "4X"; - +#endif case CODETYPEGLONASS_L2a_CSI: return "6A"; case CODETYPEGLONASS_L2a_OCp: return "6B"; +#ifdef USE_SSR_RTCM case CODETYPEGLONASS_L2a_CSIOCp:return "6X"; - +#endif case CODETYPEGLONASS_L3_I: return "3I"; case CODETYPEGLONASS_L3_Q: return "3Q"; +#ifdef USE_SSR_RTCM case CODETYPEGLONASS_L3_IQ: return "3X"; +#endif default: return ""; } @@ -735,31 +742,36 @@ else if (system == 'E') { switch (type) { - case CODETYPEGALILEO_E1_A: return "1A"; - case CODETYPEGALILEO_E1_B: return "1B"; - case CODETYPEGALILEO_E1_C: return "1C"; - case CODETYPEGALILEO_E1_BC: return "1X"; - case CODETYPEGALILEO_E1_ABC: return "1Z"; - - case CODETYPEGALILEO_E5A_I: return "5I"; - case CODETYPEGALILEO_E5A_Q: return "5Q"; - case CODETYPEGALILEO_E5A_IQ: return "5X"; - - case CODETYPEGALILEO_E5B_I: return "7I"; - case CODETYPEGALILEO_E5B_Q: return "7Q"; - case CODETYPEGALILEO_E5B_IQ: return "7X"; - - case CODETYPEGALILEO_E5_I: return "8I"; - case CODETYPEGALILEO_E5_Q: return "8Q"; - case CODETYPEGALILEO_E5_IQ: return "8X"; - - case CODETYPEGALILEO_E6_A: return "6A"; - case CODETYPEGALILEO_E6_B: return "6B"; - case CODETYPEGALILEO_E6_C: return "6C"; - case CODETYPEGALILEO_E6_BC: return "6X"; - case CODETYPEGALILEO_E6_ABC: return "6Z"; + case CODETYPEGALILEO_E1_A: return "1A"; + case CODETYPEGALILEO_E1_B: return "1B"; + case CODETYPEGALILEO_E1_C: return "1C"; +#ifdef USE_SSR_RTCM + case CODETYPEGALILEO_E1_BC: return "1X"; + case CODETYPEGALILEO_E1_ABC: return "1Z"; +#endif + case CODETYPEGALILEO_E5A_I: return "5I"; + case CODETYPEGALILEO_E5A_Q: return "5Q"; +#ifdef USE_SSR_RTCM + case CODETYPEGALILEO_E5A_IQ: return "5X"; +#endif + case CODETYPEGALILEO_E5B_I: return "7I"; + case CODETYPEGALILEO_E5B_Q: return "7Q"; +#ifdef USE_SSR_RTCM + case CODETYPEGALILEO_E5B_IQ: return "7X"; + + case CODETYPEGALILEO_E5_I: return "8I"; + case CODETYPEGALILEO_E5_Q: return "8Q"; + case CODETYPEGALILEO_E5_IQ: return "8X"; +#endif + case CODETYPEGALILEO_E6_A: return "6A"; + case CODETYPEGALILEO_E6_B: return "6B"; + case CODETYPEGALILEO_E6_C: return "6C"; +#ifdef USE_SSR_RTCM + case CODETYPEGALILEO_E6_BC: return "6X"; + case CODETYPEGALILEO_E6_ABC: return "6Z"; +#endif default: return ""; } } - else if (system == 'J') { + else if (system == 'J') { switch (type) { case CODETYPEQZSS_L1_CA: return "1C"; @@ -769,12 +781,15 @@ case CODETYPEQZSS_L2C_M: return "2S"; case CODETYPEQZSS_L2C_L: return "2L"; +#ifdef USE_SSR_RTCM case CODETYPEQZSS_L2C_ML: return "2X"; - +#endif case CODETYPEQZSS_L5_I: return "5I"; case CODETYPEQZSS_L5_Q: return "5Q"; +#ifdef USE_SSR_RTCM case CODETYPEQZSS_L5_IQ: return "5X"; - +#endif case CODETYPEQZSS_L6_D: return "6S"; case CODETYPEQZSS_L6_P: return "6L"; +#ifdef USE_SSR_RTCM case CODETYPEQZSS_L6_DP: return "6X"; @@ -785,17 +800,10 @@ case CODETYPEQZSS_L5_P: return "5P"; case CODETYPEQZSS_L5_DP: return "5Z"; +#endif case CODETYPEQZSS_L6_E: return "6E"; +#ifdef USE_SSR_RTCM case CODETYPEQZSS_L6_DE: return "6Z"; - default: return ""; - } - } - else if (system == 'S') { - switch (type) { - case CODETYPE_SBAS_L1_CA: return "1C"; - - case CODETYPE_SBAS_L5_I: return "5I"; - case CODETYPE_SBAS_L5_Q: return "5Q"; - case CODETYPE_SBAS_L5_IQ: return "5X"; +#endif default: return ""; } @@ -805,21 +813,42 @@ case CODETYPE_BDS_B1_I: return "2I"; case CODETYPE_BDS_B1_Q: return "2Q"; +#ifdef USE_SSR_RTCM case CODETYPE_BDS_B1_IQ: return "2X"; - +#endif case CODETYPE_BDS_B3_I: return "6I"; case CODETYPE_BDS_B3_Q: return "6Q"; +#ifdef USE_SSR_RTCM case CODETYPE_BDS_B3_IQ: return "6X"; - +#endif case CODETYPE_BDS_B2_I: return "7I"; case CODETYPE_BDS_B2_Q: return "7Q"; +#ifdef USE_SSR_RTCM case CODETYPE_BDS_B2_IQ: return "7X"; - +#endif case CODETYPE_BDS_B1a_D: return "1D"; case CODETYPE_BDS_B1a_P: return "1P"; +#ifdef USE_SSR_RTCM case CODETYPE_BDS_B1a_DP: return "1X"; - +#endif case CODETYPE_BDS_B2a_D: return "5D"; case CODETYPE_BDS_B2a_P: return "5P"; +#ifdef USE_SSR_RTCM case CODETYPE_BDS_B2a_DP: return "5X"; +#elif USE_SSR_IGS + case CODETYPE_BDS_B1_A: return "1A"; + case CODETYPE_BDS_B3_A: return "6A"; +#endif + default: return ""; + } + } + else if (system == 'S') { + switch (type) { + case CODETYPE_SBAS_L1_CA: return "1C"; + + case CODETYPE_SBAS_L5_I: return "5I"; + case CODETYPE_SBAS_L5_Q: return "5Q"; +#ifdef USE_SSR_RTCM + case CODETYPE_SBAS_L5_IQ: return "5X"; +#endif default: return ""; } Index: branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.h =================================================================== --- branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.h (revision 8946) +++ branches/BNC_2.12/src/RTCM3/RTCM3coDecoder.h (revision 8987) @@ -32,5 +32,9 @@ extern "C" { -# include "clock_orbit_rtcm.h" +#ifdef USE_SSR_RTCM +#include "../RTCM3/clock_and_orbit/clock_orbit_rtcm.h" +#elif USE_SSR_IGS +#include "../RTCM3/clock_and_orbit/clock_orbit_igs.h" +#endif } Index: branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.c =================================================================== --- branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.c (revision 8987) +++ branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.c (revision 8987) @@ -0,0 +1,987 @@ +/* Programheader + + Name: clock_orbit_igs.c + Project: RTCM3 + Version: $Id$ + Authors: Dirk Stöcker, Andrea Stürze + Description: state space approach: IGS + */ + +#include +#include +#include +#ifndef sparc +#include +#else +#include +#endif +#include + + +static uint32_t CRC24(long size, const unsigned char *buf) { + uint32_t crc = 0; + int i; + + while (size--) { + crc ^= (*buf++) << (16); + for (i = 0; i < 8; i++) + { + crc <<= 1; + if (crc & 0x1000000) + crc ^= 0x01864cfb; + } + } + return crc; +} + +/* NOTE: These defines are interlinked with below functions and directly modify + the values. This may not be optimized in terms of final program code size but + should be optimized in terms of speed. + + modified variables are: + - everything defined in STARTDATA (only use ressize outside of the defines, + others are private) + - buffer + - size + */ + +#ifndef NOENCODE +#define STOREBITS \ + while(numbits >= 8) { \ + if(!size) return 0; \ + *(buffer++) = bitbuffer>>(numbits-8); \ + numbits -= 8; \ + ++ressize; \ + --size; \ + } + +#define ADDBITS(a, b) { \ + bitbuffer = (bitbuffer<<(a))|((b)&((1<>8; \ + blockstart[2] = len; \ + if(len > 1023) \ + return 0; \ + len = CRC24(len+3, (const unsigned char *) blockstart); \ + ADDBITS(24, len) \ + } + +#define SCALEADDBITS(a, b, c) ADDBITS(a, (int64_t)(c > 0 ? b*c+0.5 : b*c-0.5)) + +#define MPI 3.141592653589793 + +/* GNSS macros - Header part */ +#define T_RTCM_MESSAGE_NUMBER(a) ADDBITS(12, a) /* DF002 */ +#define T_IGS_SSR_VERSION(a) ADDBITS( 3, a) /* IDF001 */ +#define T_IGS_MESSAGE_NUMBER(a) ADDBITS( 8, a) /* IDF002 */ +#define T_SSR_EPOCH_TIME(a) ADDBITS(20, a) /* IDF003 */ +#define T_SSR_UPDATE_INTERVAL(a) ADDBITS( 4, a) /* DF391, IDF004 */ +#define T_MULTIPLE_MESSAGE_INDICATOR(a) ADDBITS( 1, a) /* DF388, IDF005 */ +#define T_SSR_IOD(a) ADDBITS( 4, a) /* DF413, IDF007 */ +#define T_SSR_PROVIDER_ID(a) ADDBITS(16, a) /* DF414, IDF008 */ +#define T_SSR_SOLUTION_ID(a) ADDBITS( 4, a) /* DF415, IDF009 */ +#define T_SATELLITE_REFERENCE_DATUM(a) ADDBITS( 1, a) /* DF375, IDF006 */ +#define T_NO_OF_SATELLITES(a) ADDBITS( 6, a) /* DF387, IDF010 */ + +/* GNSS macros - Satellite specific part */ +#define T_GNSS_SATELLITE_ID(a) ADDBITS( 6, a) /* IDF011 */ +#define T_GNSS_IOD(a) ADDBITS( 8, a) /* IDF012 */ +#define T_DELTA_RADIAL(a) SCALEADDBITS(22, 10000.0, a) /* DF365, IDF013 */ +#define T_DELTA_ALONG_TRACK(a) SCALEADDBITS(20, 2500.0, a) /* DF366, IDF014 */ +#define T_DELTA_CROSS_TRACK(a) SCALEADDBITS(20, 2500.0, a) /* DF367, IDF015 */ +#define T_DELTA_DOT_RADIAL(a) SCALEADDBITS(21, 1000000.0, a) /* DF368, IDF016 */ +#define T_DELTA_DOT_ALONG_TRACK(a) SCALEADDBITS(19, 250000.0, a) /* DF369, IDF017 */ +#define T_DELTA_DOT_CROSS_TRACK(a) SCALEADDBITS(19, 250000.0, a) /* DF370, IDF018 */ + +#define T_DELTA_CLOCK_C0(a) SCALEADDBITS(22, 10000.0, a) /* DF376, IDF019 */ +#define T_DELTA_CLOCK_C1(a) SCALEADDBITS(21, 1000000.0, a) /* DF377, IDF020 */ +#define T_DELTA_CLOCK_C2(a) SCALEADDBITS(27, 50000000.0, a) /* DF378, IDF021 */ +#define T_HR_CLOCK_CORRECTION(a) SCALEADDBITS(22, 10000.0, a) /* DF390, IDF022 */ + +#define T_NO_OF_BIASES(a) ADDBITS(5, a) /* IDF023 */ +#define T_GNSS_SIGNAL_IDENTIFIER(a) ADDBITS(5, a) /* IDF024 */ +#define T_CODE_BIAS(a) SCALEADDBITS(14, 100.0, a) /* DF383, IDF025 */ +#define T_YAW_ANGLE(a) SCALEADDBITS( 9, 256.0/MPI, a) /* DF480, IDF026 */ +#define T_YAW_RATE(a) SCALEADDBITS( 8, 8192.0/MPI, a) /* DF481, IDF027 */ +#define T_PHASE_BIAS(a) SCALEADDBITS(20, 10000.0, a) /* DF482, IDF028 */ + +/* Phase specific part of GNSS phase bias message */ +#define T_INTEGER_INDICATOR(a) ADDBITS( 1, a) /* DF483, IDF029 */ +#define T_WIDE_LANE_INDICATOR(a) ADDBITS( 2, a) /* DF484, IDF030 */ +#define T_DISCONTINUITY_COUNTER(a) ADDBITS( 4, a) /* DF485, IDF031 */ +#define T_DISPERSIVE_BIAS_INDICATOR(a) ADDBITS( 1, a) /* DF486, IDF032 */ +#define T_MW_CONSISTENCY_INDICATOR(a) ADDBITS( 1, a) /* DF487, IDF033 */ + +#define T_SSR_URA(a) ADDBITS( 6, a) /* DF389, IDF034 */ + +/* Ionosphere */ +#define T_NO_IONO_LAYERS(a) ADDBITS( 2, a-1) /* DF472, IDF035 */ +#define T_IONO_HEIGHT(a) SCALEADDBITS( 8, 1/10000.0, a) /* DF473, IDF036 */ +#define T_IONO_DEGREE(a) ADDBITS( 4, a-1) /* DF474, IDF037 */ +#define T_IONO_ORDER(a) ADDBITS( 4, a-1) /* DF475, IDF038 */ +#define T_IONO_COEFF_C(a) SCALEADDBITS(16, 200.0, a) /* DF476, IDF039 */ +#define T_IONO_COEFF_S(a) SCALEADDBITS(16, 200.0, a) /* DF477, IDF040 */ +#define T_VTEC_QUALITY_INDICATOR(a) SCALEADDBITS( 9, 20.0, a) /* DF478, IDF041 */ + +static double URAToValue(int ura) { + int urac, urav; + urac = ura >> 3; + urav = ura & 7; + if (!ura) + return 0; + else if (ura == 63) + return SSR_MAXURA; + return (pow(3, urac) * (1.0 + urav / 4.0) - 1.0) / 1000.0; +} + +static int ValueToURA(double val) { + int ura; + if (!val) + return 0; + else if (val > 5.4665) + return 63; + for (ura = 1; ura < 63 && val > URAToValue(ura); ++ura) + ; + return ura; +} + +static const enum ClockOrbitType corbase[CLOCKORBIT_SATNUM] = { + (int) COBBASE_GPS, + (int) COBBASE_GLONASS, + (int) COBBASE_GALILEO, + (int) COBBASE_QZSS, + (int) COBBASE_SBAS, + (int) COBBASE_BDS +}; + +static const enum COR_OFFSETS satoffset[CLOCKORBIT_SATNUM + 1] = { + CLOCKORBIT_OFFSETGPS, + CLOCKORBIT_OFFSETGLONASS, + CLOCKORBIT_OFFSETGALILEO, + CLOCKORBIT_OFFSETQZSS, + CLOCKORBIT_OFFSETSBAS, + CLOCKORBIT_OFFSETBDS, + CLOCKORBIT_COUNTSAT +}; + +size_t MakeClockOrbit(const struct ClockOrbit *co, enum ClockOrbitType type, + int moremessagesfollow, char *buffer, size_t size) { + unsigned int status[CLOCKORBIT_SATNUM][COBOFS_NUM], i, s; + + memset(status, 0, sizeof(status)); + + STARTDATA + + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + for (i = 0; i < COBOFS_NUM; ++i) { + if (co->NumberOfSat[s] && (type == COTYPE_AUTO || type == corbase[s] + i) && + (co->Supplied[i] || (i <= COBOFS_CLOCK && co->Supplied[COBOFS_COMBINED]) || + (i == COBOFS_COMBINED && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK]))) { + status[s][i] = 1; + if (i == COBOFS_COMBINED) { + status[s][COBOFS_ORBIT] = status[s][COBOFS_CLOCK] = 0; + } /* disable single blocks for combined type */ + } /* check for data */ + } /* iterate over sub-types */ + } /* iterate over satellite systems */ + + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + if (status[s][COBOFS_ORBIT]) { + INITBLOCK + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(corbase[s] + COBOFS_ORBIT) + T_SSR_EPOCH_TIME(co->EpochTime[s]) + T_SSR_UPDATE_INTERVAL(co->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SSR_IOD(co->SSRIOD) + T_SSR_PROVIDER_ID(co->SSRProviderID) + T_SSR_SOLUTION_ID(co->SSRSolutionID) + T_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) + T_NO_OF_SATELLITES(co->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + T_GNSS_SATELLITE_ID(co->Sat[i].ID) + T_GNSS_IOD(co->Sat[i].IOD) + T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial) + T_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack) + T_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack) + T_DELTA_DOT_RADIAL(co->Sat[i].Orbit.DotDeltaRadial) + T_DELTA_DOT_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack) + T_DELTA_DOT_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack) + } + ENDBLOCK + } + if (status[s][COBOFS_CLOCK]) { + INITBLOCK + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(corbase[s] + COBOFS_CLOCK) + T_SSR_EPOCH_TIME(co->EpochTime[s]) + T_SSR_UPDATE_INTERVAL(co->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SSR_IOD(co->SSRIOD) + T_SSR_PROVIDER_ID(co->SSRProviderID) + T_SSR_SOLUTION_ID(co->SSRSolutionID) + T_NO_OF_SATELLITES(co->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + T_GNSS_SATELLITE_ID(co->Sat[i].ID) + T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0) + T_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1) + T_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2) + } + ENDBLOCK + } + if (status[s][COBOFS_COMBINED]) { +#ifdef SPLITBLOCK + int nums = co->NumberOfSat[s]; + int left, start = satoffset[s]; + if(nums > 28) {/* split block when more than 28 sats */ + left = nums - 28; + nums = 28; + } + else { + left = 0; + } + while(nums) { +#endif + INITBLOCK + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(corbase[s] + COBOFS_COMBINED) + T_SSR_EPOCH_TIME(co->EpochTime[s]) + T_SSR_UPDATE_INTERVAL(co->UpdateInterval) +#ifdef SPLITBLOCK + T_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0) +#else + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) +#endif + T_SSR_IOD(co->SSRIOD) + T_SSR_PROVIDER_ID(co->SSRProviderID) + T_SSR_SOLUTION_ID(co->SSRSolutionID) + T_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) +#ifdef SPLITBLOCK + T_NO_OF_SATELLITES(nums) + for(i = start; i < start+nums; ++i) { +#else + T_NO_OF_SATELLITES(co->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { +#endif + T_GNSS_SATELLITE_ID(co->Sat[i].ID) + T_GNSS_IOD(co->Sat[i].IOD) + T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial) + T_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack) + T_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack) + T_DELTA_DOT_RADIAL(co->Sat[i].Orbit.DotDeltaRadial) + T_DELTA_DOT_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack) + T_DELTA_DOT_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack) + T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0) + T_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1) + T_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2) + } + ENDBLOCK +#ifdef SPLITBLOCK + start += nums; + nums = left; + left = 0; + } +#endif + } + if (status[s][COBOFS_HR]) { + INITBLOCK + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(corbase[s] + COBOFS_HR) + T_SSR_EPOCH_TIME(co->EpochTime[s]) + T_SSR_UPDATE_INTERVAL(co->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SSR_IOD(co->SSRIOD) + T_SSR_PROVIDER_ID(co->SSRProviderID) + T_SSR_SOLUTION_ID(co->SSRSolutionID) + T_NO_OF_SATELLITES(co->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + T_GNSS_SATELLITE_ID(co->Sat[i].ID) + T_HR_CLOCK_CORRECTION(co->Sat[i].hrclock) + } + ENDBLOCK + } + if (status[s][COBOFS_URA]) { + INITBLOCK + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(corbase[s] + COBOFS_URA) + T_SSR_EPOCH_TIME(co->EpochTime[s]) + T_SSR_UPDATE_INTERVAL(co->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SSR_IOD(co->SSRIOD) + T_SSR_PROVIDER_ID(co->SSRProviderID) + T_SSR_SOLUTION_ID(co->SSRSolutionID) + T_NO_OF_SATELLITES(co->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + T_GNSS_SATELLITE_ID(co->Sat[i].ID) + T_SSR_URA(ValueToURA(co->Sat[i].UserRangeAccuracy)) + } + ENDBLOCK + } + } + return ressize; +} + +size_t MakeCodeBias(const struct CodeBias *b, enum CodeBiasType type, + int moremessagesfollow, char *buffer, size_t size) { + unsigned int s, i, j; + + STARTDATA + + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + if (b->NumberOfSat[s] && (type == CBTYPE_AUTO || type == corbase[s] + COBOFS_CBIAS)) { + INITBLOCK + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(corbase[s] + COBOFS_CBIAS) + T_SSR_EPOCH_TIME(b->EpochTime[s]) + T_SSR_UPDATE_INTERVAL(b->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SSR_IOD(b->SSRIOD) + T_SSR_PROVIDER_ID(b->SSRProviderID) + T_SSR_SOLUTION_ID(b->SSRSolutionID) + T_NO_OF_SATELLITES(b->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) { + T_GNSS_SATELLITE_ID(b->Sat[i].ID) + T_NO_OF_BIASES(b->Sat[i].NumberOfCodeBiases) + for (j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j) { + T_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type) + T_CODE_BIAS(b->Sat[i].Biases[j].Bias) + } + } + ENDBLOCK + } + } + return ressize; +} + +size_t MakePhaseBias(const struct PhaseBias *b, enum PhaseBiasType type, + int moremessagesfollow, char *buffer, size_t size) { + unsigned int s, i, j; + + STARTDATA + + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == corbase[s] + COBOFS_PBIAS)) { + INITBLOCK + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(corbase[s] + COBOFS_PBIAS) + T_SSR_EPOCH_TIME(b->EpochTime[s]) + T_SSR_UPDATE_INTERVAL(b->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SSR_IOD(b->SSRIOD) + T_SSR_PROVIDER_ID(b->SSRProviderID) + T_SSR_SOLUTION_ID(b->SSRSolutionID) + T_DISPERSIVE_BIAS_INDICATOR(b->DispersiveBiasConsistencyIndicator ? 1 : 0) + T_MW_CONSISTENCY_INDICATOR(b->MWConsistencyIndicator ? 1 : 0) + T_NO_OF_SATELLITES(b->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) { + T_GNSS_SATELLITE_ID(b->Sat[i].ID) + T_NO_OF_BIASES(b->Sat[i].NumberOfPhaseBiases) + T_YAW_ANGLE(b->Sat[i].YawAngle) + T_YAW_RATE(b->Sat[i].YawRate) + for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) { + T_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type) + T_INTEGER_INDICATOR(b->Sat[i].Biases[j].SignalIntegerIndicator ? 1 : 0) + T_WIDE_LANE_INDICATOR(b->Sat[i].Biases[j].SignalsWideLaneIntegerIndicator) + T_DISCONTINUITY_COUNTER(b->Sat[i].Biases[j].SignalDiscontinuityCounter) + T_PHASE_BIAS(b->Sat[i].Biases[j].Bias) + } + } + ENDBLOCK + } + } + return ressize; +} + +size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, size_t size) { + unsigned int l, o, d; + + STARTDATA + INITBLOCK + + T_RTCM_MESSAGE_NUMBER(RTCM_MESSAGE_NUMBER_IGS) + T_IGS_SSR_VERSION(IGS_SSR_VERSION) + T_IGS_MESSAGE_NUMBER(VTEC_BASE) + T_SSR_EPOCH_TIME(v->EpochTime) + T_SSR_UPDATE_INTERVAL(v->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SSR_IOD(v->SSRIOD) + T_SSR_PROVIDER_ID(v->SSRProviderID) + T_SSR_SOLUTION_ID(v->SSRSolutionID) + T_VTEC_QUALITY_INDICATOR(v->Quality) + T_NO_IONO_LAYERS(v->NumLayers) + for (l = 0; l < v->NumLayers; ++l) { + T_IONO_HEIGHT(v->Layers[l].Height) + T_IONO_DEGREE(v->Layers[l].Degree) + T_IONO_ORDER(v->Layers[l].Order) + for (o = 0; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { + T_IONO_COEFF_C(v->Layers[l].Cosinus[d][o]) + } + } + for (o = 1; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { + T_IONO_COEFF_S(v->Layers[l].Sinus[d][o]) + } + } + } + ENDBLOCK + return ressize; +} +#endif /* NOENCODE */ + +#ifndef NODECODE + +#define DECODESTART \ + int numbits=0; \ + uint64_t bitbuffer=0; + +#define LOADBITS(a) { \ + while((a) > numbits) { \ + if(!size--) return GCOBR_SHORTMESSAGE; \ + bitbuffer = (bitbuffer<<8)|((unsigned char)*(buffer++)); \ + numbits += 8; \ + } \ +} + +/* extract bits from data stream + b = variable to store result, a = number of bits */ +#define GETBITS(b, a) { \ + LOADBITS(a) \ + b = (bitbuffer<<(64-numbits))>>(64-(a)); \ + numbits -= (a); \ +} + +/* extract bits from data stream + b = variable to store result, a = number of bits */ +#define GETBITSFACTOR(b, a, c) { \ + LOADBITS(a) \ + b = ((bitbuffer<<(64-numbits))>>(64-(a)))*(c); \ + numbits -= (a); \ +} + +/* extract signed floating value from data stream + b = variable to store result, a = number of bits */ +#define GETFLOATSIGN(b, a, c) { \ + LOADBITS(a) \ + b = ((double)(((int64_t)(bitbuffer<<(64-numbits)))>>(64-(a))))*(c); \ + numbits -= (a); \ +} + +/* extract floating value from data stream + b = variable to store result, a = number of bits, c = scale factor */ +#define GETFLOAT(b, a, c) { \ + LOADBITS(a) \ + b = ((double)((bitbuffer<<(sizeof(bitbuffer)*8-numbits))>>(sizeof(bitbuffer)*8-(a))))*(c); \ + numbits -= (a); \ +} + +#define SKIPBITS(b) { LOADBITS(b) numbits -= (b); } + +/* GPS macros also used for other systems when matching! */ +#define G_HEADER(a) GETBITS(a, 8) +#define G_RESERVEDH(a) GETBITS(a, 6) +#define G_SIZE(a) GETBITS(a, 10) + +/* GNSS macros - Header part */ +#define G_RTCM_MESSAGE_NUMBER(a) GETBITS(a, 12) /* DF002 */ +#define G_IGS_SSR_VERSION(a) GETBITS(a, 3) /* IDF001 */ +#define G_IGS_MESSAGE_NUMBER(a) GETBITS(a, 8) /* IDF002 */ +#define G_SSR_EPOCH_TIME(a) GETBITS(a, 20) /* IDF003 */ +#define G_SSR_EPOCH_TIME_CHECK(a, b) {unsigned int temp; GETBITS(temp, 20) \ + if(b && a != temp) return GCOBR_TIMEMISMATCH; a = temp;} +#define G_SSR_UPDATE_INTERVAL(a) GETBITS(a, 4) /* DF391, IDF004 */ +#define G_MULTIPLE_MESSAGE_INDICATOR(a) GETBITS(a, 1) /* DF388, IDF005 */ +#define G_SSR_IOD(a) GETBITS(a, 4) /* DF413, IDF007 */ +#define G_SSR_PROVIDER_ID(a) GETBITS(a, 16) /* DF414, IDF008 */ +#define G_SSR_SOLUTION_ID(a) GETBITS(a, 4) /* DF415, IDF009 */ +#define G_SATELLITE_REFERENCE_DATUM(a) GETBITS(a, 1) /* DF375, IDF006 */ +#define G_NO_OF_SATELLITES(a) GETBITS(a, 6) /* DF387, IDF010 */ + +/* GNSS macros - Satellite specific part */ +#define G_GNSS_SATELLITE_ID(a) GETBITS(a, 6) /* IDF011 */ +#define G_GNSS_IOD(a) GETBITS(a, 8) /* IDF012 */ + +#define G_DELTA_RADIAL(a) GETFLOATSIGN(a, 22, 1/10000.0) /* DF365, IDF013 */ +#define G_DELTA_ALONG_TRACK(a) GETFLOATSIGN(a, 20, 1/2500.0) /* DF366, IDF014 */ +#define G_DELTA_CROSS_TRACK(a) GETFLOATSIGN(a, 20, 1/2500.0) /* DF367, IDF015 */ +#define G_DELTA_DOT_RADIAL(a) GETFLOATSIGN(a, 21, 1/1000000.0) /* DF368, IDF016 */ +#define G_DELTA_DOT_ALONG_TRACK(a) GETFLOATSIGN(a, 19, 1/250000.0) /* DF369, IDF017 */ +#define G_DELTA_DOT_CROSS_TRACK(a) GETFLOATSIGN(a, 19, 1/250000.0) /* DF370, IDF018 */ + +#define G_DELTA_CLOCK_C0(a) GETFLOATSIGN(a, 22, 1/10000.0) /* DF376, IDF019 */ +#define G_DELTA_CLOCK_C1(a) GETFLOATSIGN(a, 21, 1/1000000.0) /* DF377, IDF020 */ +#define G_DELTA_CLOCK_C2(a) GETFLOATSIGN(a, 27, 1/50000000.0) /* DF378, IDF021 */ +#define G_HR_CLOCK_CORRECTION(a) GETFLOATSIGN(a, 22, 1/10000.0) /* DF390, IDF022 */ + +#define G_NO_OF_BIASES(a) GETBITS(a, 5) /* IDF023 */ +#define G_GNSS_SIGNAL_IDENTIFIER(a) GETBITS(a, 5) /* IDF024 */ +#define G_CODE_BIAS(a) GETFLOATSIGN(a, 14, 1/100.0) /* DF383, IDF025 */ +#define G_YAW_ANGLE(a) GETFLOAT (a, 9, MPI/256.0) /* DF480, IDF026 */ +#define G_YAW_RATE(a) GETFLOATSIGN(a, 8, MPI/8192.0) /* DF481, IDF027 */ +#define G_PHASE_BIAS(a) GETFLOATSIGN(a, 20, 1/10000.) /* DF482, IDF028 */ + +#define G_INTEGER_INDICATOR(a) GETBITS(a, 1) /* DF483, IDF029 */ +#define G_WIDE_LANE_INDICATOR(a) GETBITS(a, 2) /* DF484, IDF030 */ +#define G_DISCONTINUITY_COUNTER(a) GETBITS(a, 4) /* DF485, IDF031 */ +#define G_DISPERSIVE_BIAS_INDICATOR(a) GETBITS(a, 1) /* DF486, IDF032 */ +#define G_MW_CONSISTENCY_INDICATOR(a) GETBITS(a, 1) /* DF487, IDF033 */ + +#define G_SSR_URA(a) {int temp; GETBITS(temp, 6) \ + (a) = URAToValue(temp);} /* DF389, IDF034 */ + +/* Ionosphere */ +#define G_NO_IONO_LAYERS(a) {unsigned int temp; GETBITS(temp, 2) a = temp+1;} /* DF472, IDF035 */ +#define G_IONO_HEIGHT(a) GETFLOAT(a, 8 , 10000.0) /* DF473, IDF036 */ +#define G_IONO_DEGREE(a) {unsigned int temp; GETBITS(temp, 4) a = temp+1;} /* DF474, IDF037 */ +#define G_IONO_ORDER(a) {unsigned int temp; GETBITS(temp, 4) a = temp+1;} /* DF475, IDF038 */ +#define G_IONO_COEFF_C(a) GETFLOATSIGN(a, 16,1/200.0) /* DF476, IDF039 */ +#define G_IONO_COEFF_S(a) GETFLOATSIGN(a, 16,1/200.0) /* DF477, IDF040 */ +#define G_VTEC_QUALITY_INDICATOR(a) GETFLOAT (a, 9, 1/20.0) /* DF478, IDF041 */ + +enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b,struct VTEC *v, + struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused) { + int mmi = 0, h, rs; + unsigned int type, pos, i, j, s, nums, id, version; + size_t sizeofrtcmblock; + const char *blockstart = buffer; + DECODESTART + + if (size < 7) + return GCOBR_SHORTBUFFER; + +#ifdef BNC_DEBUG + fprintf(stderr, "GetSSR START: size %d, numbits %d\n",(int)size, numbits); +#endif + + G_HEADER(h) + G_RESERVEDH(rs) + G_SIZE(sizeofrtcmblock); + + if ((unsigned char) h != 0xD3 || rs) + return GCOBR_UNKNOWNDATA; + if (size < sizeofrtcmblock + 3) /* 3 header bytes already removed */ + return GCOBR_MESSAGEEXCEEDSBUFFER; + if (CRC24(sizeofrtcmblock + 3, (const unsigned char *) blockstart) != + (uint32_t) ((((unsigned char) buffer[sizeofrtcmblock]) << 16) | + (((unsigned char) buffer[sizeofrtcmblock + 1]) << 8) | + (((unsigned char) buffer[sizeofrtcmblock + 2])))) + return GCOBR_CRCMISMATCH; + size = sizeofrtcmblock; /* reduce size, so overflows are detected */ + + G_RTCM_MESSAGE_NUMBER(type) + G_IGS_SSR_VERSION(version) +#ifdef BNC_DEBUG + fprintf(stderr, "rtcmType %d igsVersion %d ",type, version); +#endif + G_IGS_MESSAGE_NUMBER(type) +#ifdef BNC_DEBUG + fprintf(stderr, "igsType IM%d size %d\n",type,(int)sizeofrtcmblock); +#endif + if (bytesused) + *bytesused = sizeofrtcmblock + 6; + + if (type == VTEC_BASE) { + unsigned int l, o, d; + if (!v) + return GCOBR_NOVTECPARAMETER; + memset(v, 0, sizeof(*v)); + G_SSR_EPOCH_TIME(v->EpochTime) + G_SSR_UPDATE_INTERVAL(v->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(v->SSRIOD) + G_SSR_PROVIDER_ID(v->SSRProviderID) + G_SSR_SOLUTION_ID(v->SSRSolutionID) + G_VTEC_QUALITY_INDICATOR(v->Quality) + G_NO_IONO_LAYERS(v->NumLayers) +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d ssrIod %d providerId %d solId %d vtecQ %8.3f numLay %d \n", + v->EpochTime, v->UpdateInterval, mmi, + v->SSRIOD, v->SSRProviderID, v->SSRSolutionID, v->Quality, v->NumLayers); +#endif + for (l = 0; l < v->NumLayers; ++l) { + G_IONO_HEIGHT(v->Layers[l].Height) + G_IONO_DEGREE(v->Layers[l].Degree) + G_IONO_ORDER(v->Layers[l].Order) +#ifdef BNC_DEBUG + fprintf(stderr, "h %8.3f deg %d ord %d \n", + v->Layers[l].Height, v->Layers[l].Degree, v->Layers[l].Order); +#endif + for (o = 0; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { + G_IONO_COEFF_C(v->Layers[l].Cosinus[d][o]) +#ifdef BNC_DEBUG + fprintf(stderr, "C[%02d][%02d] %8.3f \n", + d, o, v->Layers[l].Cosinus[d][o]); +#endif + } + } + for (o = 1; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { + G_IONO_COEFF_S(v->Layers[l].Sinus[d][o]) +#ifdef BNC_DEBUG + fprintf(stderr, "S[%02d][%02d] %8.3f \n", + d, o, v->Layers[l].Sinus[d][o]); +#endif + } + } + } +#ifdef BNC_DEBUG + for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type) + numbits += 8; + fprintf(stderr, "numbits left %d\n",numbits); +#endif + return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK; + } + for (s = CLOCKORBIT_SATNUM; s-- > 0;) { + if (type >= corbase[s]) { + switch (type - corbase[s]) { + case COBOFS_ORBIT: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + G_SSR_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s]) + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_ORBIT] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + G_GNSS_SATELLITE_ID(id) + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + G_GNSS_IOD(co->Sat[pos].IOD) + G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial) + G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack) + G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack) + G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial) + G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack) + G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack) +#ifdef BNC_DEBUG + 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", + co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial, + co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack, + co->Sat[pos].Orbit.DotDeltaRadial, + co->Sat[pos].Orbit.DotDeltaAlongTrack, + co->Sat[pos].Orbit.DotDeltaCrossTrack); +#endif + } + break; + case COBOFS_CLOCK: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + G_SSR_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s]) + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_CLOCK] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + G_GNSS_SATELLITE_ID(id) + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0) + G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1) + G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n", + co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, + co->Sat[pos].Clock.DeltaA2); +#endif + } + break; + case COBOFS_COMBINED: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + G_SSR_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s]) + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_ORBIT] |= 1; + co->Supplied[COBOFS_CLOCK] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + G_GNSS_SATELLITE_ID(id) + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + G_GNSS_IOD(co->Sat[pos].IOD) + G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial) + G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack) + G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack) + G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial) + G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack) + G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack) + G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0) + G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1) + G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2) +#ifdef BNC_DEBUG + 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", + co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial, + co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack, + co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack, + co->Sat[pos].Orbit.DotDeltaCrossTrack, + co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2); +#endif + } + break; + case COBOFS_URA: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + G_SSR_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s]) + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_URA] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + G_GNSS_SATELLITE_ID(id) + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + G_SSR_URA(co->Sat[pos].UserRangeAccuracy) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d ura %8.3f \n", + co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy); +#endif + } + break; + case COBOFS_HR: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + G_SSR_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s]) + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_HR] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + G_GNSS_SATELLITE_ID(id) + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + G_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d hrClock %8.3f \n", + co->Sat[pos].ID, co->Sat[pos].hrclock); +#endif + } + break; + case COBOFS_CBIAS: + if (!b) + return GCOBR_NOCODEBIASPARAMETER; + b->messageType = type; + G_SSR_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s]) + G_SSR_UPDATE_INTERVAL(b->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(b->SSRIOD) + G_SSR_PROVIDER_ID(b->SSRProviderID) + G_SSR_SOLUTION_ID(b->SSRSolutionID) + G_NO_OF_SATELLITES(nums) +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + b->EpochTime[s], b->UpdateInterval,mmi,b->NumberOfSat[s],nums, + b->SSRIOD, b->SSRProviderID, b->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + G_GNSS_SATELLITE_ID(id) + for (pos = satoffset[s]; + pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == b->NumberOfSat[s] + satoffset[s]) + ++b->NumberOfSat[s]; + b->Sat[pos].ID = id; + G_NO_OF_BIASES(b->Sat[pos].NumberOfCodeBiases) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d #%d ", + b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases); +#endif + for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) { + G_GNSS_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type) + G_CODE_BIAS(b->Sat[pos].Biases[j].Bias) +#ifdef BNC_DEBUG + fprintf(stderr, "t%02d b %8.2f ", + b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias); +#endif + } +#ifdef BNC_DEBUG + fprintf(stderr, "\n"); +#endif + } + break; + case COBOFS_PBIAS: + if (!pb) + return GCOBR_NOPHASEBIASPARAMETER; + pb->messageType = type; + G_SSR_EPOCH_TIME_CHECK(pb->EpochTime[s], pb->NumberOfSat[s]) + G_SSR_UPDATE_INTERVAL(pb->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(pb->SSRIOD) + G_SSR_PROVIDER_ID(pb->SSRProviderID) + G_SSR_SOLUTION_ID(pb->SSRSolutionID) + G_DISPERSIVE_BIAS_INDICATOR(pb->DispersiveBiasConsistencyIndicator) + G_MW_CONSISTENCY_INDICATOR(pb->MWConsistencyIndicator) + G_NO_OF_SATELLITES(nums) +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d dispInd %d mwInd %d\n", + pb->EpochTime[s], pb->UpdateInterval,mmi,pb->NumberOfSat[s],nums, + pb->SSRIOD, pb->SSRProviderID, pb->SSRSolutionID, + pb->DispersiveBiasConsistencyIndicator, pb->MWConsistencyIndicator); +#endif + for (i = 0; i < nums; ++i) { + G_GNSS_SATELLITE_ID(id) + for (pos = satoffset[s]; + pos < satoffset[s] + pb->NumberOfSat[s] && pb->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == pb->NumberOfSat[s] + satoffset[s]) + ++pb->NumberOfSat[s]; + pb->Sat[pos].ID = id; + G_NO_OF_BIASES(pb->Sat[pos].NumberOfPhaseBiases) + G_YAW_ANGLE(pb->Sat[pos].YawAngle) + G_YAW_RATE(pb->Sat[pos].YawRate) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ", + pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases, + pb->Sat[pos].YawAngle/MPI, pb->Sat[pos].YawRate/MPI); +#endif + for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) { + G_GNSS_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type) + G_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].SignalIntegerIndicator) + G_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator) + G_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].SignalDiscontinuityCounter) + G_PHASE_BIAS(pb->Sat[pos].Biases[j].Bias) +#ifdef BNC_DEBUG + fprintf(stderr, "t%02d int %d wl %d disc %d b %8.4f ", + pb->Sat[pos].Biases[j].Type, + pb->Sat[pos].Biases[j].SignalIntegerIndicator, + pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator, + pb->Sat[pos].Biases[j].SignalDiscontinuityCounter, + pb->Sat[pos].Biases[j].Bias); +#endif + } +#ifdef BNC_DEBUG + fprintf(stderr, "\n"); +#endif + } + break; + default: + continue; + } +#ifdef BNC_DEBUG + for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type) + numbits += 8; + fprintf(stderr, "numbits left %d\n",numbits); +#endif + return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK; + } + } + return GCOBR_UNKNOWNTYPE; +} +#endif /* NODECODE */ + + + Index: branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.h =================================================================== --- branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.h (revision 8987) +++ branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_igs.h (revision 8987) @@ -0,0 +1,381 @@ +#ifndef RTCM3_CLOCK_ORBIT_IGS_H +#define RTCM3_CLOCK_ORBIT_IGS_H + +/* Programheader + + Name: clock_orbit_igs.h + Project: RTCM3 + Version: $Id$ + Authors: Dirk Stöcker, Andrea Stürze + Description: state space approach: IGS +*/ + +#include + +enum IGS_NUMBERS { + RTCM_MESSAGE_NUMBER_IGS = 4076, + IGS_SSR_VERSION = 3 +}; + +enum SatelliteReferenceDatum { + DATUM_ITRF = 0, + DATUM_LOCAL = 1 +}; + +enum COR_BASE { + COBBASE_GPS = 21, + COBBASE_GLONASS = 41, + COBBASE_GALILEO = 61, + COBBASE_QZSS = 81, + COBBASE_BDS = 101, + COBBASE_SBAS = 121, + COBBASE_NUM +}; + +enum COR_OFFSET { // sub-type message, for example: + COBOFS_ORBIT = 0, // GPS: IM21 + COBOFS_CLOCK, // GPS: IM22 + COBOFS_COMBINED, // GPS: IM23 + COBOFS_HR, // GPS: IM24 + COBOFS_CBIAS, // GPS: IM25 + COBOFS_PBIAS, // GPS: IM26 + COBOFS_URA, // GPS: IM27 + COBOFS_NUM +}; + +enum ClockOrbitType { + COTYPE_GPSORBIT = COBBASE_GPS + COBOFS_ORBIT, + COTYPE_GPSCLOCK, + COTYPE_GPSCOMBINED = COBBASE_GPS + COBOFS_COMBINED, + COTYPE_GPSHR, + COTYPE_GPSURA = COBBASE_GPS + COBOFS_URA, + + COTYPE_GLONASSORBIT = COBBASE_GLONASS + COBOFS_ORBIT, + COTYPE_GLONASSCLOCK, + COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED, + COTYPE_GLONASSHR, + COTYPE_GLONASSURA = COBBASE_GLONASS + COBOFS_URA, + + COTYPE_GALILEOORBIT = COBBASE_GALILEO + COBOFS_ORBIT, + COTYPE_GALILEOCLOCK, + COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED, + COTYPE_GALILEOHR, + COTYPE_GALILEOURA = COBBASE_GALILEO + COBOFS_URA, + + COTYPE_QZSSORBIT = COBBASE_QZSS + COBOFS_ORBIT, + COTYPE_QZSSCLOCK, + COTYPE_QZSSCOMBINED = COBBASE_QZSS + COBOFS_COMBINED, + COTYPE_QZSSHR, + COTYPE_QZSSURA = COBBASE_QZSS + COBOFS_URA, + + COTYPE_SBASORBIT = COBBASE_SBAS + COBOFS_ORBIT, + COTYPE_SBASCLOCK, + COTYPE_SBASCOMBINED = COBBASE_SBAS + COBOFS_COMBINED, + COTYPE_SBASHR, + COTYPE_SBASURA = COBBASE_SBAS + COBOFS_URA, + + COTYPE_BDSORBIT = COBBASE_BDS + COBOFS_ORBIT, + COTYPE_BDSCLOCK, + COTYPE_BDSCOMBINED = COBBASE_BDS + COBOFS_COMBINED, + COTYPE_BDSHR, + COTYPE_BDSURA = COBBASE_BDS + COBOFS_URA, + + COTYPE_AUTO = 0, +}; + +enum CodeBiasType { + CBTYPE_GPS = COBBASE_GPS + COBOFS_CBIAS, + CBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_CBIAS, + CBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_CBIAS, + CBTYPE_QZSS = COBBASE_QZSS + COBOFS_CBIAS, + CBTYPE_SBAS = COBBASE_SBAS + COBOFS_CBIAS, + CBTYPE_BDS = COBBASE_BDS + COBOFS_CBIAS, + CBTYPE_AUTO = 0 +}; + +enum PhaseBiasType { + PBTYPE_GPS = COBBASE_GPS + COBOFS_PBIAS, + PBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_PBIAS, + PBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_PBIAS, + PBTYPE_QZSS = COBBASE_QZSS + COBOFS_PBIAS, + PBTYPE_SBAS = COBBASE_SBAS + COBOFS_PBIAS, + PBTYPE_BDS = COBBASE_BDS + COBOFS_PBIAS, + PBTYPE_AUTO = 0 +}; + +enum VTECType { + VTEC_BASE = 201 +}; + +/* if some systems aren't supported at all, change the following numbers to zero +for these systems to save space */ +enum COR_CONSTANTS { + CLOCKORBIT_BUFFERSIZE = 8192, + CLOCKORBIT_NUMGPS = 32, + CLOCKORBIT_NUMGLONASS = 26, + CLOCKORBIT_NUMGALILEO = 36, + CLOCKORBIT_NUMQZSS = 10, + CLOCKORBIT_NUMSBAS = 38, + CLOCKORBIT_NUMBDS = 65, + CLOCKORBIT_NUMBIAS = 100, + CLOCKORBIT_NUMIONOLAYERS = 4, + CLOCKORBIT_MAXIONOORDER = 16, + CLOCKORBIT_MAXIONODEGREE = 16 +}; + +enum COR_SATSYSTEM { + CLOCKORBIT_SATGPS=0, + CLOCKORBIT_SATGLONASS, + CLOCKORBIT_SATGALILEO, + CLOCKORBIT_SATQZSS, + CLOCKORBIT_SATSBAS, + CLOCKORBIT_SATBDS, + CLOCKORBIT_SATNUM +}; + +enum COR_OFFSETS { + CLOCKORBIT_OFFSETGPS = 0, + CLOCKORBIT_OFFSETGLONASS = CLOCKORBIT_NUMGPS, + CLOCKORBIT_OFFSETGALILEO = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS, + CLOCKORBIT_OFFSETQZSS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO, + CLOCKORBIT_OFFSETSBAS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS, + CLOCKORBIT_OFFSETBDS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS, + CLOCKORBIT_COUNTSAT = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS + CLOCKORBIT_NUMBDS +}; + +enum CodeType { + CODETYPEGPS_L1_CA = 0, + CODETYPEGPS_L1_P = 1, + CODETYPEGPS_L1_Z = 2, + CODETYPEGPS_L1C_D = 3, + CODETYPEGPS_L1C_P = 4, + CODETYPEGPS_L2_CA = 5, + CODETYPEGPS_SEMI_CODELESS = 6, + CODETYPEGPS_L2C_M = 7, + CODETYPEGPS_L2C_L = 8, + //RESERVED = 9, + CODETYPEGPS_L2_P = 10, + CODETYPEGPS_L2_Z = 11, + //RESERVED = 12, + //RESERVED = 13, + CODETYPEGPS_L5_I = 14, + CODETYPEGPS_L5_Q = 15, + + CODETYPEGLONASS_L1_CA = 0, + CODETYPEGLONASS_L1_P = 1, + CODETYPEGLONASS_L2_CA = 2, + CODETYPEGLONASS_L2_P = 3, + CODETYPEGLONASS_L1a_OCd = 4, + CODETYPEGLONASS_L1a_OCp = 5, + CODETYPEGLONASS_L2a_CSI = 6, + CODETYPEGLONASS_L2a_OCp = 7, + CODETYPEGLONASS_L3_I = 8, + CODETYPEGLONASS_L3_Q = 9, + + CODETYPEGALILEO_E1_A = 0, + CODETYPEGALILEO_E1_B = 1, + CODETYPEGALILEO_E1_C = 2, + //RESERVED_E1_BC = 3, + //RESERVED_E1_ABC = 4, + CODETYPEGALILEO_E5A_I = 5, + CODETYPEGALILEO_E5A_Q = 6, + //RESERVED_E5A_IQ = 7, + CODETYPEGALILEO_E5B_I = 8, + CODETYPEGALILEO_E5B_Q = 9, + //RESERVED_E5B_IQ = 10, + //RESERVED_E5_I = 11, + //RESERVED_E5_Q = 12, + //RESERVED_E5_IQ = 13, + CODETYPEGALILEO_E6_A = 14, + CODETYPEGALILEO_E6_B = 15, + CODETYPEGALILEO_E6_C = 16, + //RESERVED_E6_BC = 17, + //RESERVED_E6_ABC = 18, + + CODETYPEQZSS_L1_CA = 0, + CODETYPEQZSS_L1C_D = 1, + CODETYPEQZSS_L1C_P = 2, + CODETYPEQZSS_L2C_M = 3, + CODETYPEQZSS_L2C_L = 4, + //RESEVED_L2C_ML = 5, + CODETYPEQZSS_L5_I = 6, + CODETYPEQZSS_L5_Q = 7, + //RESERVED_L5_IQ = 8, + CODETYPEQZSS_L6_D = 9, + CODETYPEQZSS_L6_P = 10, + //RESERVED_L6_DP = 11, + //RESERVED_L1C_DP = 12, + //RESERVED_L1_S = 13, + //RESERVED_L5_D = 14, + //RESERVED_L5_P = 15, + //RESERVED_L5_DP = 16, + CODETYPEQZSS_L6_E = 17, + //RESERVED_L6_DE = 18, + + CODETYPE_SBAS_L1_CA = 0, + CODETYPE_SBAS_L5_I = 1, + CODETYPE_SBAS_L5_Q = 2, + //RESERVED_SBAS_L5_IQ = 3, + + CODETYPE_BDS_B1_I = 0, + CODETYPE_BDS_B1_Q = 1, + //RESERVED_BDS_B1_IQ = 2, + CODETYPE_BDS_B3_I = 3, + CODETYPE_BDS_B3_Q = 4, + //RESERVED_BDS_B3_IQ = 5, + CODETYPE_BDS_B2_I = 6, + CODETYPE_BDS_B2_Q = 7, + //RESERVED_BDS_B2_IQ = 8, + CODETYPE_BDS_B1a_D = 9, + CODETYPE_BDS_B1a_P = 10, + //RESERVED_BDS_B1a_DP = 11, + CODETYPE_BDS_B2a_D = 12, + CODETYPE_BDS_B2a_P = 13, + //RESEVED_BDS_B2a_DP = 14, + CODETYPE_BDS_B1_A = 15, //NEW 1A + //RESERVED = 16, + //RESERVED = 17, + CODETYPE_BDS_B3_A = 18 //NEW 6A +}; + +#define SSR_MAXURA 5.5 /* > 5466.5mm in meter */ + +/* satellite system data is stored with offset CLOCKORBIT_OFFSET... +in the data structures. So first GLONASS satellite is at +xxx->Sat[CLOCKORBIT_OFFSETGLONASS], first GPS satellite is +xxx->Sat[CLOCKORBIT_OFFSETGPS]. */ + +struct ClockOrbit { + enum ClockOrbitType messageType; + unsigned int EpochTime[CLOCKORBIT_SATNUM]; /* 0 .. system specific maximum */ + unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */ + unsigned int Supplied[COBOFS_NUM]; /* boolean */ + unsigned int SSRIOD; + unsigned int SSRProviderID; + unsigned int SSRSolutionID; + unsigned int UpdateInterval; + enum SatelliteReferenceDatum SatRefDatum; + struct SatData { + unsigned int ID; /* all */ + unsigned int IOD; /* all */ + unsigned int toe; /* SBAS, BDS */ + double UserRangeAccuracy; /* accuracy values in [m] */ + double hrclock; + struct OrbitPart { + double DeltaRadial; /* m */ + double DeltaAlongTrack; /* m */ + double DeltaCrossTrack; /* m */ + double DotDeltaRadial; /* m/s */ + double DotDeltaAlongTrack; /* m/s */ + double DotDeltaCrossTrack; /* m/s */ + } Orbit; + struct ClockPart { + double DeltaA0; /* m */ + double DeltaA1; /* m/s */ + double DeltaA2; /* m/ss */ + } Clock; + } Sat[CLOCKORBIT_COUNTSAT]; +}; + +struct CodeBias { + enum CodeBiasType messageType; + unsigned int EpochTime[CLOCKORBIT_SATNUM]; /* 0 .. system specific maximum */ + unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */ + unsigned int UpdateInterval; + unsigned int SSRIOD; + unsigned int SSRProviderID; + unsigned int SSRSolutionID; + struct BiasSat { + unsigned int ID; /* all */ + unsigned int NumberOfCodeBiases; + struct CodeBiasEntry { + enum CodeType Type; + float Bias; /* m */ + } Biases[CLOCKORBIT_NUMBIAS]; + } Sat[CLOCKORBIT_COUNTSAT]; +}; + +struct PhaseBias { + enum PhaseBiasType messageType; + unsigned int EpochTime[CLOCKORBIT_SATNUM]; /* 0 .. system specific maximum */ + unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */ + unsigned int UpdateInterval; + unsigned int SSRIOD; + unsigned int SSRProviderID; + unsigned int SSRSolutionID; + unsigned int DispersiveBiasConsistencyIndicator; + unsigned int MWConsistencyIndicator; + struct PhaseBiasSat { + unsigned int ID; /* all */ + unsigned int NumberOfPhaseBiases; + double YawAngle; /* radiant */ + double YawRate; /* radiant/s */ + struct PhaseBiasEntry { + enum CodeType Type; + unsigned int SignalIntegerIndicator; + unsigned int SignalsWideLaneIntegerIndicator; + unsigned int SignalDiscontinuityCounter; + float Bias; /* m */ + } Biases[CLOCKORBIT_NUMBIAS]; + } Sat[CLOCKORBIT_COUNTSAT]; +}; + +struct VTEC { + unsigned int EpochTime; /* GPS */ + unsigned int UpdateInterval; + unsigned int SSRIOD; + unsigned int SSRProviderID; + unsigned int SSRSolutionID; + unsigned int NumLayers; /* 1-4 */ + double Quality; + struct IonoLayers { + double Height; /* m */ + unsigned int Degree; /* 1-16 */ + unsigned int Order; /* 1-16 */ + double Sinus[CLOCKORBIT_MAXIONODEGREE][CLOCKORBIT_MAXIONOORDER]; + double Cosinus[CLOCKORBIT_MAXIONODEGREE][CLOCKORBIT_MAXIONOORDER]; + } Layers[CLOCKORBIT_NUMIONOLAYERS]; +}; + +/* return size of resulting data or 0 in case of an error */ +size_t MakeClockOrbit(const struct ClockOrbit *co, enum ClockOrbitType type, + int moremessagesfollow, char *buffer, size_t size); +size_t MakeCodeBias(const struct CodeBias *b, enum CodeBiasType type, + int moremessagesfollow, char *buffer, size_t size); +size_t MakePhaseBias(const struct PhaseBias *b, enum PhaseBiasType type, + int moremessagesfollow, char *buffer, size_t size); +size_t MakeVTEC(const struct VTEC *b, int moremessagesfollow, char *buffer, + size_t size); + +enum GCOB_RETURN { + /* all well */ + GCOBR_MESSAGEFOLLOWS = 1, + GCOBR_OK = 0, + /* unknown data, a warning */ + GCOBR_UNKNOWNTYPE = -1, + GCOBR_UNKNOWNDATA = -2, + GCOBR_CRCMISMATCH = -3, + GCOBR_SHORTMESSAGE = -4, + /* failed to do the work */ + GCOBR_NOCLOCKORBITPARAMETER = -10, + GCOBR_NOCODEBIASPARAMETER = -11, + GCOBR_NOPHASEBIASPARAMETER = -12, + GCOBR_NOVTECPARAMETER = -13, + /* data mismatch - data in storage does not match new data */ + GCOBR_TIMEMISMATCH = -20, + GCOBR_DATAMISMATCH = -21, + /* not enough data - can decode the block completely */ + GCOBR_SHORTBUFFER = -30, + GCOBR_MESSAGEEXCEEDSBUFFER = -31}; + +/* 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 +function to have a clean state. */ + +/* buffer should point to a RTCM3 block */ +enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b, struct VTEC *v, + struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused); + +#endif /* RTCM3_CLOCK_ORBIT_IGS_H */ Index: branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c =================================================================== --- branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c (revision 8946) +++ branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c (revision 8987) @@ -18,16 +18,14 @@ #include "clock_orbit_rtcm.h" -static uint32_t CRC24(long size, const unsigned char *buf) -{ +static uint32_t CRC24(long size, const unsigned char *buf) { uint32_t crc = 0; int i; - while(size--) - { + while (size--) { crc ^= (*buf++) << (16); - for(i = 0; i < 8; i++) - { + for (i = 0; i < 8; i++) + { crc <<= 1; - if(crc & 0x1000000) + if (crc & 0x1000000) crc ^= 0x01864cfb; } @@ -37,18 +35,17 @@ /* NOTE: These defines are interlinked with below functions and directly modify -the values. This may not be optimized in terms of final program code size but -should be optimized in terms of speed. - -modified variables are: -- everything defined in STARTDATA (only use ressize outside of the defines, - others are private) -- buffer -- size -*/ + the values. This may not be optimized in terms of final program code size but + should be optimized in terms of speed. + + modified variables are: + - everything defined in STARTDATA (only use ressize outside of the defines, + others are private) + - buffer + - size + */ #ifndef NOENCODE #define STOREBITS \ - while(numbits >= 8) \ - { \ + while(numbits >= 8) { \ if(!size) return 0; \ *(buffer++) = bitbuffer>>(numbits-8); \ @@ -58,6 +55,5 @@ } -#define ADDBITS(a, b) \ - { \ +#define ADDBITS(a, b) { \ bitbuffer = (bitbuffer<<(a))|((b)&((1<>8; \ @@ -95,16 +90,16 @@ /* GPS macros also used for other systems when matching! */ -#define T_MESSAGE_NUMBER(a) ADDBITS(12, a) /* DF002 */ -#define T_GPS_SATELLITE_ID(a) ADDBITS(6, a) /* DF068 */ -#define T_QZSS_SATELLITE_ID(a) ADDBITS(4, a) /* DF249 */ -#define T_GLONASS_SATELLITE_ID(a) ADDBITS(5, a) - -#define T_GPS_IODE(a) ADDBITS(8, a) /* DF071 */ -#define T_GLONASS_IOD(a) ADDBITS(8, a) /* DF239 */ -#define T_GALILEO_IOD(a) ADDBITS(10, a) /* DF459 */ -#define T_SBAS_T0MOD(a) ADDBITS(9, (a/16)) /* DF468 */ -#define T_SBAS_IODCRC(a) ADDBITS(24, a) /* DF469 */ -#define T_BDS_TOEMOD(a) ADDBITS(10, (a/8)) /* DF470 */ -#define T_BDS_IOD(a) ADDBITS(8, a) /* DF471 */ +#define T_RTCM_MESSAGE_NUMBER(a) ADDBITS(12, a) /* DF002 */ +#define T_GPS_SATELLITE_ID(a) ADDBITS( 6, a) /* DF068 */ +#define T_QZSS_SATELLITE_ID(a) ADDBITS( 4, a) /* DF249 */ +#define T_GLONASS_SATELLITE_ID(a) ADDBITS( 5, a) + +#define T_GPS_IODE(a) ADDBITS( 8, a) /* DF071 */ +#define T_GLONASS_IOD(a) ADDBITS( 8, a) /* DF239 */ +#define T_GALILEO_IOD(a) ADDBITS(10, a) /* DF459 */ +#define T_SBAS_T0MOD(a) ADDBITS( 9, (a/16)) /* DF468 */ +#define T_SBAS_IODCRC(a) ADDBITS(24, a) /* DF469 */ +#define T_BDS_TOEMOD(a) ADDBITS(10, (a/8)) /* DF470 */ +#define T_BDS_IOD(a) ADDBITS( 8, a) /* DF471 */ #define T_DELTA_RADIAL(a) SCALEADDBITS(22, 10000.0, a) @@ -119,92 +114,92 @@ #define T_DELTA_CLOCK_C1(a) SCALEADDBITS(21, 1000000.0, a) #define T_DELTA_CLOCK_C2(a) SCALEADDBITS(27, 50000000.0, a) -#define T_NO_OF_CODE_BIASES(a) ADDBITS(5, a) -#define T_NO_OF_PHASE_BIASES(a) ADDBITS(5, a) -#define T_SIGNAL_IDENTIFIER(a) ADDBITS(5, a) +#define T_NO_OF_CODE_BIASES(a) ADDBITS( 5, a) +#define T_NO_OF_PHASE_BIASES(a) ADDBITS( 5, a) +#define T_SIGNAL_IDENTIFIER(a) ADDBITS( 5, a) #define T_CODE_BIAS(a) SCALEADDBITS(14, 100.0, a) -#define T_YAW_ANGLE(a) SCALEADDBITS(9, 256.0/MPI, a) -#define T_YAW_RATE(a) SCALEADDBITS(8, 8192.0/MPI, a) +#define T_YAW_ANGLE(a) SCALEADDBITS( 9, 256.0/MPI, a) +#define T_YAW_RATE(a) SCALEADDBITS( 8, 8192.0/MPI, a) #define T_PHASE_BIAS(a) SCALEADDBITS(20, 10000.0, a) #define T_GPS_EPOCH_TIME(a) ADDBITS(20, a) #define T_GLONASS_EPOCH_TIME(a) ADDBITS(17, a) -#define T_NO_OF_SATELLITES(a) ADDBITS(6, a) -#define T_MULTIPLE_MESSAGE_INDICATOR(a) ADDBITS(1, a) -#define T_DISPERSIVE_BIAS_INDICATOR(a) ADDBITS(1, a) -#define T_MW_CONSISTENCY_INDICATOR(a) ADDBITS(1, a) -#define T_INTEGER_INDICATOR(a) ADDBITS(1, a) -#define T_WIDE_LANE_INDICATOR(a) ADDBITS(2, a) -#define T_DISCONTINUITY_COUNTER(a) ADDBITS(4, a) -#define T_SSR_URA(a) ADDBITS(6, a) +#define T_NO_OF_SATELLITES(a) ADDBITS( 6, a) +#define T_MULTIPLE_MESSAGE_INDICATOR(a) ADDBITS( 1, a) +#define T_DISPERSIVE_BIAS_INDICATOR(a) ADDBITS( 1, a) +#define T_MW_CONSISTENCY_INDICATOR(a) ADDBITS( 1, a) +#define T_INTEGER_INDICATOR(a) ADDBITS( 1, a) +#define T_WIDE_LANE_INDICATOR(a) ADDBITS( 2, a) +#define T_DISCONTINUITY_COUNTER(a) ADDBITS( 4, a) +#define T_SSR_URA(a) ADDBITS( 6, a) #define T_HR_CLOCK_CORRECTION(a) SCALEADDBITS(22, 10000.0, a) -#define T_SSR_UPDATE_INTERVAL(a) ADDBITS(4, a) - -#define T_SSR_IOD(a) ADDBITS(4, a) +#define T_SSR_UPDATE_INTERVAL(a) ADDBITS( 4, a) + +#define T_SSR_IOD(a) ADDBITS( 4, a) #define T_SSR_PROVIDER_ID(a) ADDBITS(16, a) -#define T_SSR_SOLUTION_ID(a) ADDBITS(4, a) - -#define T_NO_IONO_LAYERS(a) ADDBITS(2, a-1) -#define T_VTEC_QUALITY_INDICATOR(a) SCALEADDBITS(9, 20.0, a) +#define T_SSR_SOLUTION_ID(a) ADDBITS( 4, a) + +#define T_NO_IONO_LAYERS(a) ADDBITS( 2, a-1) +#define T_VTEC_QUALITY_INDICATOR(a) SCALEADDBITS( 9, 20.0, a) #define T_IONO_COEFF(a) SCALEADDBITS(16, 200.0, a) -#define T_IONO_DEGREE(a) ADDBITS(4, a-1) -#define T_IONO_ORDER(a) ADDBITS(4, a-1) -#define T_IONO_HEIGHT(a) SCALEADDBITS(8, 1/10000.0, a) - -static double URAToValue(int ura) -{ +#define T_IONO_DEGREE(a) ADDBITS( 4, a-1) +#define T_IONO_ORDER(a) ADDBITS( 4, a-1) +#define T_IONO_HEIGHT(a) SCALEADDBITS( 8, 1/10000.0, a) + +static double URAToValue(int ura) { int urac, urav; urac = ura >> 3; urav = ura & 7; - if(!ura) + if (!ura) return 0; - else if(ura == 63) + else if (ura == 63) return SSR_MAXURA; - return (pow(3,urac)*(1.0+urav/4.0)-1.0)/1000.0; + return (pow(3, urac) * (1.0 + urav / 4.0) - 1.0) / 1000.0; } -static int ValueToURA(double val) -{ +static int ValueToURA(double val) { int ura; - if(!val) + if (!val) return 0; - else if(val > 5.4665) + else if (val > 5.4665) return 63; - for(ura = 1; ura < 63 && val > URAToValue(ura); ++ura) + for (ura = 1; ura < 63 && val > URAToValue(ura); ++ura) ; return ura; } -static const enum ClockOrbitType corbase[CLOCKORBIT_SATNUM] = -{ - (int) COBBASE_GPS, (int) COBBASE_GLONASS, (int) COBBASE_GALILEO, - (int) COBBASE_QZSS, (int) COBBASE_SBAS, (int) COBBASE_BDS +static const enum ClockOrbitType corbase[CLOCKORBIT_SATNUM] = { + (int) COBBASE_GPS, + (int) COBBASE_GLONASS, + (int) COBBASE_GALILEO, + (int) COBBASE_QZSS, + (int) COBBASE_SBAS, + (int) COBBASE_BDS }; -static const enum COR_OFFSETS satoffset[CLOCKORBIT_SATNUM+1] = -{ - CLOCKORBIT_OFFSETGPS, CLOCKORBIT_OFFSETGLONASS, CLOCKORBIT_OFFSETGALILEO, - CLOCKORBIT_OFFSETQZSS, CLOCKORBIT_OFFSETSBAS, CLOCKORBIT_OFFSETBDS, + +static const enum COR_OFFSETS satoffset[CLOCKORBIT_SATNUM + 1] = { + CLOCKORBIT_OFFSETGPS, + CLOCKORBIT_OFFSETGLONASS, + CLOCKORBIT_OFFSETGALILEO, + CLOCKORBIT_OFFSETQZSS, + CLOCKORBIT_OFFSETSBAS, + CLOCKORBIT_OFFSETBDS, CLOCKORBIT_COUNTSAT }; size_t MakeClockOrbit(const struct ClockOrbit *co, enum ClockOrbitType type, -int moremessagesfollow, char *buffer, size_t size) -{ + int moremessagesfollow, char *buffer, size_t size) { unsigned int status[CLOCKORBIT_SATNUM][COBOFS_NUM], i, s; memset(status, 0, sizeof(status)); + STARTDATA - for(s = 0; s < CLOCKORBIT_SATNUM; ++s) - { - for(i = 0; i < COBOFS_NUM; ++i) - { - if(co->NumberOfSat[s] && (type == COTYPE_AUTO - || type == corbase[s]+i) && (co->Supplied[i] || (i <= COBOFS_CLOCK - && co->Supplied[COBOFS_COMBINED]) || (i == COBOFS_COMBINED - && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK]))) - { + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + for (i = 0; i < COBOFS_NUM; ++i) { + if (co->NumberOfSat[s] && (type == COTYPE_AUTO || type == corbase[s] + i) && + (co->Supplied[i] || (i <= COBOFS_CLOCK && co->Supplied[COBOFS_COMBINED]) || + (i == COBOFS_COMBINED && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK]))) { status[s][i] = 1; - if(i == COBOFS_COMBINED) - { + if (i == COBOFS_COMBINED) { status[s][COBOFS_ORBIT] = status[s][COBOFS_CLOCK] = 0; } /* disable single blocks for combined type */ @@ -213,20 +208,19 @@ } /* iterate over satellite systems */ - for(s = 0; s < CLOCKORBIT_SATNUM; ++s) - { - if(status[s][COBOFS_ORBIT]) - { + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + if (status[s][COBOFS_ORBIT]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s]+COBOFS_ORBIT) - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - T_GPS_EPOCH_TIME(co->EpochTime[s]) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_EPOCH_TIME(co->EpochTime[s]) - break; + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_ORBIT) + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_EPOCH_TIME(co->EpochTime[s]) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_EPOCH_TIME(co->EpochTime[s]) + break; } T_SSR_UPDATE_INTERVAL(co->UpdateInterval) @@ -237,34 +231,32 @@ T_SSR_SOLUTION_ID(co->SSRSolutionID) T_NO_OF_SATELLITES(co->NumberOfSat[s]) - for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: - T_GPS_SATELLITE_ID(co->Sat[i].ID) - T_GPS_IODE(co->Sat[i].IOD) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_SATELLITE_ID(co->Sat[i].ID) - T_GLONASS_IOD(co->Sat[i].IOD) - break; - case CLOCKORBIT_SATGALILEO: - T_GPS_SATELLITE_ID(co->Sat[i].ID) - T_GALILEO_IOD(co->Sat[i].IOD) - break; - case CLOCKORBIT_SATQZSS: - T_QZSS_SATELLITE_ID(co->Sat[i].ID) - T_GPS_IODE(co->Sat[i].IOD) - break; - case CLOCKORBIT_SATSBAS: - T_GPS_SATELLITE_ID(co->Sat[i].ID) - T_SBAS_T0MOD(co->Sat[i].toe) - T_SBAS_IODCRC(co->Sat[i].IOD) - break; - case CLOCKORBIT_SATBDS: - T_GPS_SATELLITE_ID(co->Sat[i].ID) - T_BDS_TOEMOD(co->Sat[i].toe) - T_BDS_IOD(co->Sat[i].IOD) - break; + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + T_GPS_SATELLITE_ID(co->Sat[i].ID) + T_GPS_IODE(co->Sat[i].IOD) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_SATELLITE_ID(co->Sat[i].ID) + T_GLONASS_IOD(co->Sat[i].IOD) + break; + case CLOCKORBIT_SATGALILEO: + T_GPS_SATELLITE_ID(co->Sat[i].ID) + T_GALILEO_IOD(co->Sat[i].IOD) + break; + case CLOCKORBIT_SATQZSS: + T_QZSS_SATELLITE_ID(co->Sat[i].ID) + T_GPS_IODE(co->Sat[i].IOD) + break; + case CLOCKORBIT_SATSBAS: + T_GPS_SATELLITE_ID(co->Sat[i].ID) + T_SBAS_T0MOD(co->Sat[i].toe) + T_SBAS_IODCRC(co->Sat[i].IOD) + break; + case CLOCKORBIT_SATBDS: + T_GPS_SATELLITE_ID(co->Sat[i].ID) + T_BDS_TOEMOD(co->Sat[i].toe) + T_BDS_IOD(co->Sat[i].IOD) + break; } T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial) @@ -277,18 +269,18 @@ ENDBLOCK } - if(status[s][COBOFS_CLOCK]) - { + if (status[s][COBOFS_CLOCK]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s]+COBOFS_CLOCK) - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - T_GPS_EPOCH_TIME(co->EpochTime[s]) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_EPOCH_TIME(co->EpochTime[s]) - break; + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_CLOCK) + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_EPOCH_TIME(co->EpochTime[s]) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_EPOCH_TIME(co->EpochTime[s]) + break; } T_SSR_UPDATE_INTERVAL(co->UpdateInterval) @@ -298,18 +290,18 @@ T_SSR_SOLUTION_ID(co->SSRSolutionID) T_NO_OF_SATELLITES(co->NumberOfSat[s]) - for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - T_GPS_SATELLITE_ID(co->Sat[i].ID) - break; - case CLOCKORBIT_SATQZSS: - T_QZSS_SATELLITE_ID(co->Sat[i].ID) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_SATELLITE_ID(co->Sat[i].ID) - break; + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_SATELLITE_ID(co->Sat[i].ID) + break; + case CLOCKORBIT_SATQZSS: + T_QZSS_SATELLITE_ID(co->Sat[i].ID) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_SATELLITE_ID(co->Sat[i].ID) + break; } T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0) @@ -319,27 +311,24 @@ ENDBLOCK } - if(status[s][COBOFS_COMBINED]) - { + if (status[s][COBOFS_COMBINED]) { #ifdef SPLITBLOCK int nums = co->NumberOfSat[s]; int left, start = satoffset[s]; - if(nums > 28) /* split block when more than 28 sats */ - { + if(nums > 28) {/* split block when more than 28 sats */ left = nums - 28; nums = 28; } - else - { + else { left = 0; } - while(nums) - { -#endif - INITBLOCK - T_MESSAGE_NUMBER(corbase[s]+COBOFS_COMBINED) - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: + while(nums) { +#endif + INITBLOCK + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_COMBINED) + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: T_GPS_EPOCH_TIME(co->EpochTime[s]) @@ -348,25 +337,24 @@ T_GLONASS_EPOCH_TIME(co->EpochTime[s]) break; - } - T_SSR_UPDATE_INTERVAL(co->UpdateInterval) + } + T_SSR_UPDATE_INTERVAL(co->UpdateInterval) #ifdef SPLITBLOCK - T_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0) + T_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0) #else - T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) -#endif - T_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) - T_SSR_IOD(co->SSRIOD) - T_SSR_PROVIDER_ID(co->SSRProviderID) - T_SSR_SOLUTION_ID(co->SSRSolutionID) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) +#endif + T_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) + T_SSR_IOD(co->SSRIOD) + T_SSR_PROVIDER_ID(co->SSRProviderID) + T_SSR_SOLUTION_ID(co->SSRSolutionID) #ifdef SPLITBLOCK - T_NO_OF_SATELLITES(nums) - for(i = start; i < start+nums; ++i) + T_NO_OF_SATELLITES(nums) + for(i = start; i < start+nums; ++i) #else - T_NO_OF_SATELLITES(co->NumberOfSat[s]) - for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i) -#endif - { - switch(s) - { + T_NO_OF_SATELLITES(co->NumberOfSat[s]) + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) +#endif + { + switch (s) { case CLOCKORBIT_SATGPS: T_GPS_SATELLITE_ID(co->Sat[i].ID) @@ -395,37 +383,37 @@ T_BDS_IOD(co->Sat[i].IOD) break; - } - T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial) - T_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack) - T_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack) - T_DELTA_DOT_RADIAL(co->Sat[i].Orbit.DotDeltaRadial) - T_DELTA_DOT_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack) - T_DELTA_DOT_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack) - T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0) - T_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1) - T_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2) } - ENDBLOCK + T_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial) + T_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack) + T_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack) + T_DELTA_DOT_RADIAL(co->Sat[i].Orbit.DotDeltaRadial) + T_DELTA_DOT_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack) + T_DELTA_DOT_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack) + T_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0) + T_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1) + T_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2) + } + ENDBLOCK #ifdef SPLITBLOCK - start += nums; - nums = left; - left = 0; - } -#endif + start += nums; + nums = left; + left = 0; } - if(status[s][COBOFS_HR]) - { +#endif + } + if (status[s][COBOFS_HR]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s]+COBOFS_HR) - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - T_GPS_EPOCH_TIME(co->EpochTime[s]) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_EPOCH_TIME(co->EpochTime[s]) - break; + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_HR) + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_EPOCH_TIME(co->EpochTime[s]) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_EPOCH_TIME(co->EpochTime[s]) + break; } T_SSR_UPDATE_INTERVAL(co->UpdateInterval) @@ -435,18 +423,18 @@ T_SSR_SOLUTION_ID(co->SSRSolutionID) T_NO_OF_SATELLITES(co->NumberOfSat[s]) - for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - T_GPS_SATELLITE_ID(co->Sat[i].ID) - break; - case CLOCKORBIT_SATQZSS: - T_QZSS_SATELLITE_ID(co->Sat[i].ID) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_SATELLITE_ID(co->Sat[i].ID) - break; + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_SATELLITE_ID(co->Sat[i].ID) + break; + case CLOCKORBIT_SATQZSS: + T_QZSS_SATELLITE_ID(co->Sat[i].ID) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_SATELLITE_ID(co->Sat[i].ID) + break; } T_HR_CLOCK_CORRECTION(co->Sat[i].hrclock) @@ -454,18 +442,18 @@ ENDBLOCK } - if(status[s][COBOFS_URA]) - { + if (status[s][COBOFS_URA]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s]+COBOFS_URA) - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - T_GPS_EPOCH_TIME(co->EpochTime[s]) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_EPOCH_TIME(co->EpochTime[s]) - break; + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_URA) + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_EPOCH_TIME(co->EpochTime[s]) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_EPOCH_TIME(co->EpochTime[s]) + break; } T_SSR_UPDATE_INTERVAL(co->UpdateInterval) @@ -475,18 +463,18 @@ T_SSR_SOLUTION_ID(co->SSRSolutionID) T_NO_OF_SATELLITES(co->NumberOfSat[s]) - for(i = satoffset[s]; i < satoffset[s]+co->NumberOfSat[s]; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - T_GPS_SATELLITE_ID(co->Sat[i].ID) - break; - case CLOCKORBIT_SATQZSS: - T_QZSS_SATELLITE_ID(co->Sat[i].ID) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_SATELLITE_ID(co->Sat[i].ID) - break; + for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_SATELLITE_ID(co->Sat[i].ID) + break; + case CLOCKORBIT_SATQZSS: + T_QZSS_SATELLITE_ID(co->Sat[i].ID) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_SATELLITE_ID(co->Sat[i].ID) + break; } T_SSR_URA(ValueToURA(co->Sat[i].UserRangeAccuracy)) @@ -499,26 +487,24 @@ size_t MakeCodeBias(const struct CodeBias *b, enum CodeBiasType type, -int moremessagesfollow, char *buffer, size_t size) -{ + int moremessagesfollow, char *buffer, size_t size) { unsigned int s, i, j; STARTDATA - for(s = 0; s < CLOCKORBIT_SATNUM; ++s) - { - if(b->NumberOfSat[s] && (type == BTYPE_AUTO || type == corbase[s]+COBOFS_BIAS)) - { + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + if (b->NumberOfSat[s] && (type == CBTYPE_AUTO || type == corbase[s] + COBOFS_CBIAS)) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s]+COBOFS_BIAS) - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - T_GPS_EPOCH_TIME(b->EpochTime[s]) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_EPOCH_TIME(b->EpochTime[s]) - break; + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_CBIAS) + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_EPOCH_TIME(b->EpochTime[s]) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_EPOCH_TIME(b->EpochTime[s]) + break; } T_SSR_UPDATE_INTERVAL(b->UpdateInterval) @@ -528,22 +514,21 @@ T_SSR_SOLUTION_ID(b->SSRSolutionID) T_NO_OF_SATELLITES(b->NumberOfSat[s]) - for(i = satoffset[s]; i < satoffset[s]+b->NumberOfSat[s]; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - T_GPS_SATELLITE_ID(b->Sat[i].ID) - break; - case CLOCKORBIT_SATQZSS: - T_QZSS_SATELLITE_ID(b->Sat[i].ID) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_SATELLITE_ID(b->Sat[i].ID) - break; + for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_SATELLITE_ID(b->Sat[i].ID) + break; + case CLOCKORBIT_SATQZSS: + T_QZSS_SATELLITE_ID(b->Sat[i].ID) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_SATELLITE_ID(b->Sat[i].ID) + break; } T_NO_OF_CODE_BIASES(b->Sat[i].NumberOfCodeBiases) - for(j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j) - { + for (j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j) { T_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type) T_CODE_BIAS(b->Sat[i].Biases[j].Bias) @@ -557,26 +542,24 @@ size_t MakePhaseBias(const struct PhaseBias *b, enum PhaseBiasType type, -int moremessagesfollow, char *buffer, size_t size) -{ + int moremessagesfollow, char *buffer, size_t size) { unsigned int s, i, j; STARTDATA - for(s = 0; s < CLOCKORBIT_SATNUM; ++s) - { - if(b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == s+PBTYPE_BASE)) - { + for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { + if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == s + PBTYPE_BASE)) { INITBLOCK - T_MESSAGE_NUMBER(s+PBTYPE_BASE) - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - T_GPS_EPOCH_TIME(b->EpochTime[s]) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_EPOCH_TIME(b->EpochTime[s]) - break; + T_RTCM_MESSAGE_NUMBER(s + PBTYPE_BASE) + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_EPOCH_TIME(b->EpochTime[s]) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_EPOCH_TIME(b->EpochTime[s]) + break; } T_SSR_UPDATE_INTERVAL(b->UpdateInterval) @@ -588,28 +571,30 @@ T_MW_CONSISTENCY_INDICATOR(b->MWConsistencyIndicator ? 1 : 0) T_NO_OF_SATELLITES(b->NumberOfSat[s]) - for(i = satoffset[s]; i < satoffset[s]+b->NumberOfSat[s]; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - T_GPS_SATELLITE_ID(b->Sat[i].ID) - break; - case CLOCKORBIT_SATQZSS: - T_QZSS_SATELLITE_ID(b->Sat[i].ID) - break; - case CLOCKORBIT_SATGLONASS: - T_GLONASS_SATELLITE_ID(b->Sat[i].ID) - break; + for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + T_GPS_SATELLITE_ID(b->Sat[i].ID) + break; + case CLOCKORBIT_SATQZSS: + T_QZSS_SATELLITE_ID(b->Sat[i].ID) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_SATELLITE_ID(b->Sat[i].ID) + break; } T_NO_OF_PHASE_BIASES(b->Sat[i].NumberOfPhaseBiases) T_YAW_ANGLE(b->Sat[i].YawAngle) T_YAW_RATE(b->Sat[i].YawRate) - for(j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) - { + for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) { T_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type) - T_INTEGER_INDICATOR(b->Sat[i].Biases[j].SignalIntegerIndicator ? 1 : 0) - T_WIDE_LANE_INDICATOR(b->Sat[i].Biases[j].SignalsWideLaneIntegerIndicator) - T_DISCONTINUITY_COUNTER(b->Sat[i].Biases[j].SignalDiscontinuityCounter) + T_INTEGER_INDICATOR( + b->Sat[i].Biases[j].SignalIntegerIndicator ? 1 : 0) + T_WIDE_LANE_INDICATOR( + b->Sat[i].Biases[j].SignalsWideLaneIntegerIndicator) + T_DISCONTINUITY_COUNTER( + b->Sat[i].Biases[j].SignalDiscontinuityCounter) T_PHASE_BIAS(b->Sat[i].Biases[j].Bias) } @@ -621,12 +606,10 @@ } -size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, -size_t size) -{ +size_t MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, size_t size) { unsigned int l, o, d; STARTDATA - INITBLOCK - T_MESSAGE_NUMBER(VTEC_BASE) + INITBLOCK + T_RTCM_MESSAGE_NUMBER(VTEC_BASE) T_GPS_EPOCH_TIME(v->EpochTime) @@ -638,20 +621,15 @@ T_VTEC_QUALITY_INDICATOR(v->Quality) T_NO_IONO_LAYERS(v->NumLayers) - for(l = 0; l < v->NumLayers; ++l) - { + for (l = 0; l < v->NumLayers; ++l) { T_IONO_HEIGHT(v->Layers[l].Height) T_IONO_DEGREE(v->Layers[l].Degree) T_IONO_ORDER(v->Layers[l].Order) - for(o = 0; o <= v->Layers[l].Order; ++o) - { - for(d = o; d <= v->Layers[l].Degree; ++d) - { + for (o = 0; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { T_IONO_COEFF(v->Layers[l].Cosinus[d][o]) } } - for(o = 1; o <= v->Layers[l].Order; ++o) - { - for(d = o; d <= v->Layers[l].Degree; ++d) - { + for (o = 1; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { T_IONO_COEFF(v->Layers[l].Sinus[d][o]) } @@ -669,6 +647,5 @@ uint64_t bitbuffer=0; -#define LOADBITS(a) \ -{ \ +#define LOADBITS(a) { \ while((a) > numbits) \ { \ @@ -680,7 +657,6 @@ /* extract bits from data stream - b = variable to store result, a = number of bits */ -#define GETBITS(b, a) \ -{ \ + b = variable to store result, a = number of bits */ +#define GETBITS(b, a) { \ LOADBITS(a) \ b = (bitbuffer<<(64-numbits))>>(64-(a)); \ @@ -689,7 +665,6 @@ /* extract bits from data stream - b = variable to store result, a = number of bits */ -#define GETBITSFACTOR(b, a, c) \ -{ \ + b = variable to store result, a = number of bits */ +#define GETBITSFACTOR(b, a, c) { \ LOADBITS(a) \ b = ((bitbuffer<<(64-numbits))>>(64-(a)))*(c); \ @@ -698,7 +673,6 @@ /* extract signed floating value from data stream - b = variable to store result, a = number of bits */ -#define GETFLOATSIGN(b, a, c) \ -{ \ + b = variable to store result, a = number of bits */ +#define GETFLOATSIGN(b, a, c) { \ LOADBITS(a) \ b = ((double)(((int64_t)(bitbuffer<<(64-numbits)))>>(64-(a))))*(c); \ @@ -707,7 +681,6 @@ /* extract floating value from data stream - b = variable to store result, a = number of bits, c = scale factor */ -#define GETFLOAT(b, a, c) \ -{ \ + b = variable to store result, a = number of bits, c = scale factor */ +#define GETFLOAT(b, a, c) { \ LOADBITS(a) \ b = ((double)((bitbuffer<<(sizeof(bitbuffer)*8-numbits))>>(sizeof(bitbuffer)*8-(a))))*(c); \ @@ -721,5 +694,5 @@ #define G_RESERVEDH(a) GETBITS(a,6) #define G_SIZE(a) GETBITS(a, 10) -#define G_MESSAGE_NUMBER(a) GETBITS(a, 12) /* DF002 */ +#define G_RTCM_MESSAGE_NUMBER(a) GETBITS(a, 12) /* DF002 */ #define G_GPS_SATELLITE_ID(a) GETBITS(a, 6) /* DF068 */ #define G_QZSS_SATELLITE_ID(a) GETBITS(a, 4) /* DF249 */ @@ -782,8 +755,7 @@ #define G_IONO_HEIGHT(a) GETFLOAT(a, 8 , 10000.0) -enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b, struct VTEC *v, -struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused) -{ - int mmi=0, h, rs; +enum GCOB_RETURN GetSSR(struct ClockOrbit *co, struct CodeBias *b,struct VTEC *v, + struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused) { + int mmi = 0, h, rs; unsigned int type, pos, i, j, s, nums, id; size_t sizeofrtcmblock; @@ -791,9 +763,9 @@ DECODESTART - if(size < 7) + if (size < 7) return GCOBR_SHORTBUFFER; -#ifdef DEBUG - fprintf(stderr, "GetClockOrbitBias START: size %d, numbits %d\n",size, numbits); +#ifdef BNC_DEBUG + fprintf(stderr, "GetSSR START: size %d, numbits %d\n",(int)size, numbits); #endif @@ -802,25 +774,25 @@ G_SIZE(sizeofrtcmblock); - if((unsigned char)h != 0xD3 || rs) + if ((unsigned char) h != 0xD3 || rs) return GCOBR_UNKNOWNDATA; - if(size < sizeofrtcmblock + 3) /* 3 header bytes already removed */ + if (size < sizeofrtcmblock + 3) /* 3 header bytes already removed */ return GCOBR_MESSAGEEXCEEDSBUFFER; - if(CRC24(sizeofrtcmblock+3, (const unsigned char *) blockstart) != - (uint32_t)((((unsigned char)buffer[sizeofrtcmblock])<<16)| - (((unsigned char)buffer[sizeofrtcmblock+1])<<8)| - (((unsigned char)buffer[sizeofrtcmblock+2])))) + if (CRC24(sizeofrtcmblock + 3, (const unsigned char *) blockstart) != + (uint32_t) ((((unsigned char) buffer[sizeofrtcmblock]) << 16) | + (((unsigned char) buffer[sizeofrtcmblock + 1]) << 8) | + (((unsigned char) buffer[sizeofrtcmblock + 2])))) return GCOBR_CRCMISMATCH; size = sizeofrtcmblock; /* reduce size, so overflows are detected */ - G_MESSAGE_NUMBER(type) -#ifdef DEBUG -fprintf(stderr, "type %d size %d\n",type,sizeofrtcmblock); -#endif - if(bytesused) - *bytesused = sizeofrtcmblock+6; - if(type == VTEC_BASE) - { + G_RTCM_MESSAGE_NUMBER(type) +#ifdef BNC_DEBUG + fprintf(stderr, "type %d size %d\n",type,(int)sizeofrtcmblock); +#endif + if (bytesused) + *bytesused = sizeofrtcmblock + 6; + if (type == VTEC_BASE) { unsigned int l, o, d; - if(!v) return GCOBR_NOVTECPARAMETER; + if (!v) + return GCOBR_NOVTECPARAMETER; memset(v, 0, sizeof(*v)); G_EPOCH_TIME(v->EpochTime) @@ -832,47 +804,59 @@ G_VTEC_QUALITY_INDICATOR(v->Quality) G_NO_IONO_LAYERS(v->NumLayers) - for(l = 0; l < v->NumLayers; ++l) - { +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d ssrIod %d providerId %d solId %d vtecQ %8.3f numLay %d \n", + v->EpochTime, v->UpdateInterval, mmi, + v->SSRIOD, v->SSRProviderID, v->SSRSolutionID, v->Quality, v->NumLayers); +#endif + for (l = 0; l < v->NumLayers; ++l) { G_IONO_HEIGHT(v->Layers[l].Height) G_IONO_DEGREE(v->Layers[l].Degree) G_IONO_ORDER(v->Layers[l].Order) - for(o = 0; o <= v->Layers[l].Order; ++o) - { - for(d = o; d <= v->Layers[l].Degree; ++d) - { +#ifdef BNC_DEBUG + fprintf(stderr, "h %8.3f deg %d ord %d \n", + v->Layers[l].Height, v->Layers[l].Degree, v->Layers[l].Order); +#endif + for (o = 0; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { G_IONO_COEFF(v->Layers[l].Cosinus[d][o]) +#ifdef BNC_DEBUG + fprintf(stderr, "C[%02d][%02d] %8.3f \n", + d, o, v->Layers[l].Cosinus[d][o]); +#endif } } - for(o = 1; o <= v->Layers[l].Order; ++o) - { - for(d = o; d <= v->Layers[l].Degree; ++d) - { + for (o = 1; o <= v->Layers[l].Order; ++o) { + for (d = o; d <= v->Layers[l].Degree; ++d) { G_IONO_COEFF(v->Layers[l].Sinus[d][o]) +#ifdef BNC_DEBUG + fprintf(stderr, "S[%02d][%02d] %8.3f \n", + d, o, v->Layers[l].Sinus[d][o]); +#endif } } } -#ifdef DEBUG - for(type = 0; type < (int)size && (unsigned char)buffer[type] != 0xD3; ++type) - numbits += 8; +#ifdef BNC_DEBUG + for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type) + numbits += 8; fprintf(stderr, "numbits left %d\n",numbits); #endif return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK; } - for(s = CLOCKORBIT_SATNUM; s-- > 0;) - { - if(type == PBTYPE_BASE+s) - { - if(!pb) return GCOBR_NOPHASEBIASPARAMETER; + for (s = CLOCKORBIT_SATNUM; s-- > 0;) { + if (type == PBTYPE_BASE + s) { + if (!pb) + return GCOBR_NOPHASEBIASPARAMETER; pb->messageType = type; - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - G_GPS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s]) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s]) - break; + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s]) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_EPOCH_TIME(pb->EpochTime[s], pb->NumberOfSat[s]) + break; } G_SSR_UPDATE_INTERVAL(pb->UpdateInterval) @@ -884,417 +868,512 @@ G_MW_CONSISTENCY_INDICATOR(pb->MWConsistencyIndicator) G_NO_OF_SATELLITES(nums) - for(i = 0; i < nums; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - G_GPS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATQZSS: - G_QZSS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_SATELLITE_ID(id) - break; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d dispInd %d mwInd %d\n", + pb->EpochTime[s], pb->UpdateInterval,mmi,pb->NumberOfSat[s],nums, + pb->SSRIOD, pb->SSRProviderID, pb->SSRSolutionID, + pb->DispersiveBiasConsistencyIndicator, pb->MWConsistencyIndicator); +#endif + for (i = 0; i < nums; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATQZSS: + G_QZSS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_SATELLITE_ID(id) + break; } - for(pos = satoffset[s]; pos < satoffset[s]+pb->NumberOfSat[s] && pb->Sat[pos].ID != id; ++pos) + for (pos = satoffset[s]; + pos < satoffset[s] + pb->NumberOfSat[s] && pb->Sat[pos].ID != id; + ++pos) ; - if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH; - else if(pos == pb->NumberOfSat[s] + satoffset[s]) ++pb->NumberOfSat[s]; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == pb->NumberOfSat[s] + satoffset[s]) + ++pb->NumberOfSat[s]; pb->Sat[pos].ID = id; - G_NO_OF_PHASE_BIASES(pb->Sat[pos].NumberOfPhaseBiases) G_YAW_ANGLE(pb->Sat[pos].YawAngle) G_YAW_RATE(pb->Sat[pos].YawRate) - for(j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) - { +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ", + pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases, + pb->Sat[pos].YawAngle/MPI, pb->Sat[pos].YawRate/MPI); +#endif + for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) { G_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type) G_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].SignalIntegerIndicator) - G_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator) - G_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].SignalDiscontinuityCounter) + G_WIDE_LANE_INDICATOR( + pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator) + G_DISCONTINUITY_COUNTER( + pb->Sat[pos].Biases[j].SignalDiscontinuityCounter) G_PHASE_BIAS(pb->Sat[pos].Biases[j].Bias) +#ifdef BNC_DEBUG + fprintf(stderr, "t%02d int %d wl %d disc %d b %8.4f ", + pb->Sat[pos].Biases[j].Type, + pb->Sat[pos].Biases[j].SignalIntegerIndicator, + pb->Sat[pos].Biases[j].SignalsWideLaneIntegerIndicator, + pb->Sat[pos].Biases[j].SignalDiscontinuityCounter, + pb->Sat[pos].Biases[j].Bias); +#endif } - } -#ifdef DEBUG - for(type = 0; type < (int)size && (unsigned char)buffer[type] != 0xD3; ++type) - numbits += 8; +#ifdef BNC_DEBUG + fprintf(stderr, "\n"); +#endif + } +#ifdef BNC_DEBUG + for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type) + numbits += 8; fprintf(stderr, "numbits left %d\n",numbits); #endif return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK; } - else if(type >= corbase[s]) - { - switch(type-corbase[s]) - { - case COBOFS_ORBIT: - if(!co) return GCOBR_NOCLOCKORBITPARAMETER; - co->messageType = type; - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - } - G_SSR_UPDATE_INTERVAL(co->UpdateInterval) - G_MULTIPLE_MESSAGE_INDICATOR(mmi) - G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) - G_SSR_IOD(co->SSRIOD) - G_SSR_PROVIDER_ID(co->SSRProviderID) - G_SSR_SOLUTION_ID(co->SSRSolutionID) - G_NO_OF_SATELLITES(nums) - co->Supplied[COBOFS_ORBIT] |= 1; -#ifdef DEBUG - fprintf(stderr, "epochtime %d ui %d mmi %d sats %d/%d rd %d\n",co->EpochTime[s], - co->UpdateInterval,mmi,co->NumberOfSat[s],nums, co->SatRefDatum); -#endif - for(i = 0; i < nums; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - G_GPS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATQZSS: - G_QZSS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_SATELLITE_ID(id) - break; + else if (type >= corbase[s]) { + switch (type - corbase[s]) { + case COBOFS_ORBIT: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; } - for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos) - ; - if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH; - else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s]; - co->Sat[pos].ID = id; - - switch(s) - { - case CLOCKORBIT_SATGPS: - case CLOCKORBIT_SATQZSS: - G_GPS_IODE(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_IOD(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATGALILEO: - G_GALILEO_IOD(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATSBAS: - G_SBAS_T0MOD(co->Sat[pos].toe) - G_SBAS_IODCRC(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATBDS: - G_BDS_TOEMOD(co->Sat[pos].toe) - G_BDS_IOD(co->Sat[pos].IOD) - break; + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_ORBIT] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATQZSS: + G_QZSS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_SATELLITE_ID(id) + break; + } + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATQZSS: + G_GPS_IODE(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_IOD(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATGALILEO: + G_GALILEO_IOD(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATSBAS: + G_SBAS_T0MOD(co->Sat[pos].toe) + G_SBAS_IODCRC(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATBDS: + G_BDS_TOEMOD(co->Sat[pos].toe) + G_BDS_IOD(co->Sat[pos].IOD) + break; + } + G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial) + G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack) + G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack) + G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial) + G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack) + G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack) +#ifdef BNC_DEBUG + 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", + co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial, + co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack, + co->Sat[pos].Orbit.DotDeltaRadial, + co->Sat[pos].Orbit.DotDeltaAlongTrack, + co->Sat[pos].Orbit.DotDeltaCrossTrack); +#endif } - G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial) - G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack) - G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack) - G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial) - G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack) - G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack) -#ifdef DEBUG - 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", - co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial, - co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack, - co->Sat[pos].Orbit.DotDeltaRadial, - co->Sat[pos].Orbit.DotDeltaAlongTrack, - co->Sat[pos].Orbit.DotDeltaCrossTrack); -#endif - } - break; - case COBOFS_CLOCK: - if(!co) return GCOBR_NOCLOCKORBITPARAMETER; - co->messageType = type; - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - } - G_SSR_UPDATE_INTERVAL(co->UpdateInterval) - G_MULTIPLE_MESSAGE_INDICATOR(mmi) - G_SSR_IOD(co->SSRIOD) - G_SSR_PROVIDER_ID(co->SSRProviderID) - G_SSR_SOLUTION_ID(co->SSRSolutionID) - G_NO_OF_SATELLITES(nums) - co->Supplied[COBOFS_CLOCK] |= 1; -#ifdef DEBUG - fprintf(stderr, "epochtime %d ui %d mmi %d sats %d/%d\n",co->EpochTime[s], - co->UpdateInterval,mmi,co->NumberOfSat[s],nums); -#endif - for(i = 0; i < nums; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - G_GPS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATQZSS: - G_QZSS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_SATELLITE_ID(id) - break; + break; + case COBOFS_CLOCK: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; } - for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos) - ; - if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH; - else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s]; - co->Sat[pos].ID = id; - - G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0) - G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1) - G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2) -#ifdef DEBUG - fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n", - co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, - co->Sat[pos].Clock.DeltaA2); -#endif - } - break; - case COBOFS_COMBINED: - if(!co) return GCOBR_NOCLOCKORBITPARAMETER; - co->messageType = type; - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - } - G_SSR_UPDATE_INTERVAL(co->UpdateInterval) - G_MULTIPLE_MESSAGE_INDICATOR(mmi) - G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) - G_SSR_IOD(co->SSRIOD) - G_SSR_PROVIDER_ID(co->SSRProviderID) - G_SSR_SOLUTION_ID(co->SSRSolutionID) - G_NO_OF_SATELLITES(nums) - co->Supplied[COBOFS_ORBIT] |= 1; - co->Supplied[COBOFS_CLOCK] |= 1; - for(i = 0; i < nums; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - G_GPS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATQZSS: - G_QZSS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_SATELLITE_ID(id) - break; + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_CLOCK] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATQZSS: + G_QZSS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_SATELLITE_ID(id) + break; + } + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + + G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0) + G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1) + G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n", + co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, + co->Sat[pos].Clock.DeltaA2); +#endif } - for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos) - ; - if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH; - else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s]; - co->Sat[pos].ID = id; - - switch(s) - { - case CLOCKORBIT_SATGPS: - case CLOCKORBIT_SATQZSS: - G_GPS_IODE(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_IOD(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATGALILEO: - G_GALILEO_IOD(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATSBAS: - G_SBAS_T0MOD(co->Sat[pos].toe) - G_SBAS_IODCRC(co->Sat[pos].IOD) - break; - case CLOCKORBIT_SATBDS: - G_BDS_TOEMOD(co->Sat[pos].toe) - G_BDS_IOD(co->Sat[pos].IOD) - break; + break; + case COBOFS_COMBINED: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; } - G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial) - G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack) - G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack) - G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial) - G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack) - G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack) - G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0) - G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1) - G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2) - } - break; - case COBOFS_URA: - if(!co) return GCOBR_NOCLOCKORBITPARAMETER; - co->messageType = type; - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - } - G_SSR_UPDATE_INTERVAL(co->UpdateInterval) - G_MULTIPLE_MESSAGE_INDICATOR(mmi) - G_SSR_IOD(co->SSRIOD) - G_SSR_PROVIDER_ID(co->SSRProviderID) - G_SSR_SOLUTION_ID(co->SSRSolutionID) - G_NO_OF_SATELLITES(nums) - co->Supplied[COBOFS_URA] |= 1; - for(i = 0; i < nums; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - G_GPS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATQZSS: - G_QZSS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_SATELLITE_ID(id) - break; + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_ORBIT] |= 1; + co->Supplied[COBOFS_CLOCK] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATQZSS: + G_QZSS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_SATELLITE_ID(id) + break; + } + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATQZSS: + G_GPS_IODE(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_IOD(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATGALILEO: + G_GALILEO_IOD(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATSBAS: + G_SBAS_T0MOD(co->Sat[pos].toe) + G_SBAS_IODCRC(co->Sat[pos].IOD) + break; + case CLOCKORBIT_SATBDS: + G_BDS_TOEMOD(co->Sat[pos].toe) + G_BDS_IOD(co->Sat[pos].IOD) + break; + } + G_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial) + G_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack) + G_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack) + G_DELTA_DOT_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial) + G_DELTA_DOT_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack) + G_DELTA_DOT_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack) + G_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0) + G_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1) + G_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2) +#ifdef BNC_DEBUG + 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", + co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial, + co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack, + co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack, + co->Sat[pos].Orbit.DotDeltaCrossTrack, + co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2); +#endif } - for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos) - ; - if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH; - else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s]; - co->Sat[pos].ID = id; - - G_SSR_URA(co->Sat[pos].UserRangeAccuracy) - } - break; - case COBOFS_HR: - if(!co) return GCOBR_NOCLOCKORBITPARAMETER; - co->messageType = type; - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) - break; - } - G_SSR_UPDATE_INTERVAL(co->UpdateInterval) - G_MULTIPLE_MESSAGE_INDICATOR(mmi) - G_SSR_IOD(co->SSRIOD) - G_SSR_PROVIDER_ID(co->SSRProviderID) - G_SSR_SOLUTION_ID(co->SSRSolutionID) - G_NO_OF_SATELLITES(nums) - co->Supplied[COBOFS_HR] |= 1; - for(i = 0; i < nums; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - G_GPS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATQZSS: - G_QZSS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_SATELLITE_ID(id) - break; + break; + case COBOFS_URA: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; } - for(pos = satoffset[s]; pos < satoffset[s]+co->NumberOfSat[s] && co->Sat[pos].ID != id; ++pos) - ; - if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH; - else if(pos == co->NumberOfSat[s] + satoffset[s]) ++co->NumberOfSat[s]; - co->Sat[pos].ID = id; - - G_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock) - } - break; - case COBOFS_BIAS: - if(!b) return GCOBR_NOCODEBIASPARAMETER; - b->messageType = type; - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATQZSS: case CLOCKORBIT_SATSBAS: - case CLOCKORBIT_SATBDS: - G_GPS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s]) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s]) - break; - } - G_SSR_UPDATE_INTERVAL(b->UpdateInterval) - G_MULTIPLE_MESSAGE_INDICATOR(mmi) - G_SSR_IOD(b->SSRIOD) - G_SSR_PROVIDER_ID(b->SSRProviderID) - G_SSR_SOLUTION_ID(b->SSRSolutionID) - G_NO_OF_SATELLITES(nums) - for(i = 0; i < nums; ++i) - { - switch(s) - { - case CLOCKORBIT_SATGPS: case CLOCKORBIT_SATGALILEO: - case CLOCKORBIT_SATSBAS: case CLOCKORBIT_SATBDS: - G_GPS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATQZSS: - G_QZSS_SATELLITE_ID(id) - break; - case CLOCKORBIT_SATGLONASS: - G_GLONASS_SATELLITE_ID(id) - break; + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_URA] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATQZSS: + G_QZSS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_SATELLITE_ID(id) + break; + } + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + G_SSR_URA(co->Sat[pos].UserRangeAccuracy) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d ura %8.3f \n", + co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy); +#endif } - for(pos = satoffset[s]; pos < satoffset[s]+b->NumberOfSat[s] && b->Sat[pos].ID != id; ++pos) - ; - if(pos >= satoffset[s+1]) return GCOBR_DATAMISMATCH; - else if(pos == b->NumberOfSat[s] + satoffset[s]) ++b->NumberOfSat[s]; - b->Sat[pos].ID = id; - - G_NO_OF_CODE_BIASES(b->Sat[pos].NumberOfCodeBiases) - for(j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) - { - G_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type) - G_CODE_BIAS(b->Sat[pos].Biases[j].Bias) + break; + case COBOFS_HR: + if (!co) + return GCOBR_NOCLOCKORBITPARAMETER; + co->messageType = type; + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_EPOCH_TIME(co->EpochTime[s], co->NumberOfSat[s]) + break; } - } - break; - default: - continue; - } -#ifdef COR_LATENCY - if(s == CLOCKORBIT_SATGPS && type-corbase[s] != COBOFS_BIAS) - { - co->epochGPS[co->epochSize] = co->EpochTime[s]; - if(co->epochSize < COR_LATENCYCOUNT) - ++co->epochSize; - } -#endif -#ifdef DEBUG - for(type = 0; type < (int)size && (unsigned char)buffer[type] != 0xD3; ++type) - numbits += 8; + G_SSR_UPDATE_INTERVAL(co->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(co->SSRIOD) + G_SSR_PROVIDER_ID(co->SSRProviderID) + G_SSR_SOLUTION_ID(co->SSRSolutionID) + G_NO_OF_SATELLITES(nums) + co->Supplied[COBOFS_HR] |= 1; +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums, + co->SSRIOD, co->SSRProviderID, co->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATQZSS: + G_QZSS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_SATELLITE_ID(id) + break; + } + for (pos = satoffset[s]; + pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == co->NumberOfSat[s] + satoffset[s]) + ++co->NumberOfSat[s]; + co->Sat[pos].ID = id; + G_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d hrClock %8.3f \n", + co->Sat[pos].ID, co->Sat[pos].hrclock); +#endif + } + break; + case COBOFS_CBIAS: + if (!b) + return GCOBR_NOCODEBIASPARAMETER; + b->messageType = type; + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATQZSS: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s]) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_EPOCH_TIME(b->EpochTime[s], b->NumberOfSat[s]) + break; + } + G_SSR_UPDATE_INTERVAL(b->UpdateInterval) + G_MULTIPLE_MESSAGE_INDICATOR(mmi) + G_SSR_IOD(b->SSRIOD) + G_SSR_PROVIDER_ID(b->SSRProviderID) + G_SSR_SOLUTION_ID(b->SSRSolutionID) + G_NO_OF_SATELLITES(nums) +#ifdef BNC_DEBUG + fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n", + b->EpochTime[s], b->UpdateInterval,mmi,b->NumberOfSat[s],nums, + b->SSRIOD, b->SSRProviderID, b->SSRSolutionID); +#endif + for (i = 0; i < nums; ++i) { + switch (s) { + case CLOCKORBIT_SATGPS: + case CLOCKORBIT_SATGALILEO: + case CLOCKORBIT_SATSBAS: + case CLOCKORBIT_SATBDS: + G_GPS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATQZSS: + G_QZSS_SATELLITE_ID(id) + break; + case CLOCKORBIT_SATGLONASS: + G_GLONASS_SATELLITE_ID(id) + break; + } + for (pos = satoffset[s]; + pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id; + ++pos) + ; + if (pos >= satoffset[s + 1]) + return GCOBR_DATAMISMATCH; + else if (pos == b->NumberOfSat[s] + satoffset[s]) + ++b->NumberOfSat[s]; + b->Sat[pos].ID = id; + G_NO_OF_CODE_BIASES(b->Sat[pos].NumberOfCodeBiases) +#ifdef BNC_DEBUG + fprintf(stderr, "id %2d #%d ", + b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases); +#endif + for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) { + G_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type) + G_CODE_BIAS(b->Sat[pos].Biases[j].Bias) +#ifdef BNC_DEBUG + fprintf(stderr, "t%02d b %8.2f ", + b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias); +#endif + } +#ifdef BNC_DEBUG + fprintf(stderr, "\n"); +#endif + } + break; + default: + continue; + } +#ifdef BNC_DEBUG + for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type) + numbits += 8; fprintf(stderr, "numbits left %d\n",numbits); #endif Index: branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h =================================================================== --- branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h (revision 8946) +++ branches/BNC_2.12/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h (revision 8987) @@ -13,13 +13,22 @@ #include -enum SatelliteReferenceDatum { DATUM_ITRF=0, DATUM_LOCAL=1 }; + + + + + +enum SatelliteReferenceDatum { + DATUM_ITRF = 0, + DATUM_LOCAL = 1 +}; enum COR_BASE { - COBBASE_GPS = 1057, + COBBASE_GPS = 1057, COBBASE_GLONASS = 1063, COBBASE_GALILEO = 1240, - COBBASE_QZSS = 1246, - COBBASE_SBAS = 1252, - COBBASE_BDS = 1258, + COBBASE_QZSS = 1246, + COBBASE_SBAS = 1252, + COBBASE_BDS = 1258, + COBBASE_NUM }; @@ -27,5 +36,5 @@ COBOFS_ORBIT = 0, COBOFS_CLOCK, - COBOFS_BIAS, + COBOFS_CBIAS, COBOFS_COMBINED, COBOFS_URA, @@ -35,11 +44,11 @@ enum ClockOrbitType { - COTYPE_GPSORBIT = COBBASE_GPS + COBOFS_ORBIT, + COTYPE_GPSORBIT = COBBASE_GPS + COBOFS_ORBIT, COTYPE_GPSCLOCK, - COTYPE_GPSCOMBINED = COBBASE_GPS + COBOFS_COMBINED, + COTYPE_GPSCOMBINED = COBBASE_GPS + COBOFS_COMBINED, COTYPE_GPSURA, COTYPE_GPSHR, - COTYPE_GLONASSORBIT = COBBASE_GLONASS + COBOFS_ORBIT, + COTYPE_GLONASSORBIT = COBBASE_GLONASS + COBOFS_ORBIT, COTYPE_GLONASSCLOCK, COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED, @@ -47,5 +56,5 @@ COTYPE_GLONASSHR, - COTYPE_GALILEOORBIT = COBBASE_GALILEO + COBOFS_ORBIT, + COTYPE_GALILEOORBIT = COBBASE_GALILEO + COBOFS_ORBIT, COTYPE_GALILEOCLOCK, COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED, @@ -53,19 +62,19 @@ COTYPE_GALILEOHR, - COTYPE_QZSSORBIT = COBBASE_QZSS + COBOFS_ORBIT, + COTYPE_QZSSORBIT = COBBASE_QZSS + COBOFS_ORBIT, COTYPE_QZSSCLOCK, - COTYPE_QZSSCOMBINED = COBBASE_QZSS + COBOFS_COMBINED, + COTYPE_QZSSCOMBINED = COBBASE_QZSS + COBOFS_COMBINED, COTYPE_QZSSURA, COTYPE_QZSSHR, - COTYPE_SBASORBIT = COBBASE_SBAS + COBOFS_ORBIT, + COTYPE_SBASORBIT = COBBASE_SBAS + COBOFS_ORBIT, COTYPE_SBASCLOCK, - COTYPE_SBASCOMBINED = COBBASE_SBAS + COBOFS_COMBINED, + COTYPE_SBASCOMBINED = COBBASE_SBAS + COBOFS_COMBINED, COTYPE_SBASURA, COTYPE_SBASHR, - COTYPE_BDSORBIT = COBBASE_BDS + COBOFS_ORBIT, + COTYPE_BDSORBIT = COBBASE_BDS + COBOFS_ORBIT, COTYPE_BDSCLOCK, - COTYPE_BDSCOMBINED = COBBASE_BDS + COBOFS_COMBINED, + COTYPE_BDSCOMBINED = COBBASE_BDS + COBOFS_COMBINED, COTYPE_BDSURA, COTYPE_BDSHR, @@ -75,16 +84,16 @@ enum CodeBiasType { - BTYPE_GPS = COBBASE_GPS + COBOFS_BIAS, - BTYPE_GLONASS = COBBASE_GLONASS + COBOFS_BIAS, - BTYPE_GALILEO = COBBASE_GALILEO + COBOFS_BIAS, - BTYPE_QZSS = COBBASE_QZSS + COBOFS_BIAS, - BTYPE_SBAS = COBBASE_SBAS + COBOFS_BIAS, - BTYPE_BDS = COBBASE_BDS + COBOFS_BIAS, - BTYPE_AUTO = 0 -}; - -enum PhaseBiasType { - PBTYPE_BASE = 1265, - PBTYPE_GPS = PBTYPE_BASE, + CBTYPE_GPS = COBBASE_GPS + COBOFS_CBIAS, + CBTYPE_GLONASS = COBBASE_GLONASS + COBOFS_CBIAS, + CBTYPE_GALILEO = COBBASE_GALILEO + COBOFS_CBIAS, + CBTYPE_QZSS = COBBASE_QZSS + COBOFS_CBIAS, + CBTYPE_SBAS = COBBASE_SBAS + COBOFS_CBIAS, + CBTYPE_BDS = COBBASE_BDS + COBOFS_CBIAS, + CBTYPE_AUTO = 0 +}; + +enum PhaseBiasType{ + PBTYPE_BASE = 1265, + PBTYPE_GPS = PBTYPE_BASE, PBTYPE_GLONASS, PBTYPE_GALILEO, @@ -92,5 +101,5 @@ PBTYPE_SBAS, PBTYPE_BDS, - PBTYPE_AUTO = 0 + PBTYPE_AUTO = 0 }; @@ -102,15 +111,15 @@ for these systems to save space */ enum COR_CONSTANTS { - CLOCKORBIT_BUFFERSIZE=8192, - CLOCKORBIT_NUMGPS=32, - CLOCKORBIT_NUMGLONASS=26, - CLOCKORBIT_NUMGALILEO=36, - CLOCKORBIT_NUMQZSS=10, - CLOCKORBIT_NUMSBAS=38, - CLOCKORBIT_NUMBDS=65, - CLOCKORBIT_NUMBIAS=100, - CLOCKORBIT_NUMIONOLAYERS=4, - CLOCKORBIT_MAXIONOORDER=16, - CLOCKORBIT_MAXIONODEGREE=16 + CLOCKORBIT_BUFFERSIZE = 8192, + CLOCKORBIT_NUMGPS = 32, + CLOCKORBIT_NUMGLONASS = 26, + CLOCKORBIT_NUMGALILEO = 36, + CLOCKORBIT_NUMQZSS = 10, + CLOCKORBIT_NUMSBAS = 38, + CLOCKORBIT_NUMBDS = 65, + CLOCKORBIT_NUMBIAS = 100, + CLOCKORBIT_NUMIONOLAYERS = 4, + CLOCKORBIT_MAXIONOORDER = 16, + CLOCKORBIT_MAXIONODEGREE = 16 }; @@ -126,16 +135,14 @@ enum COR_OFFSETS { - CLOCKORBIT_OFFSETGPS=0, - CLOCKORBIT_OFFSETGLONASS=CLOCKORBIT_NUMGPS, - CLOCKORBIT_OFFSETGALILEO=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS, - CLOCKORBIT_OFFSETQZSS=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS - +CLOCKORBIT_NUMGALILEO, - CLOCKORBIT_OFFSETSBAS=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS - +CLOCKORBIT_NUMGALILEO+CLOCKORBIT_NUMQZSS, - CLOCKORBIT_OFFSETBDS=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS - +CLOCKORBIT_NUMGALILEO+CLOCKORBIT_NUMQZSS+CLOCKORBIT_NUMSBAS, - CLOCKORBIT_COUNTSAT=CLOCKORBIT_NUMGPS+CLOCKORBIT_NUMGLONASS - +CLOCKORBIT_NUMGALILEO+CLOCKORBIT_NUMQZSS+CLOCKORBIT_NUMSBAS - +CLOCKORBIT_NUMBDS + CLOCKORBIT_OFFSETGPS = 0, + CLOCKORBIT_OFFSETGLONASS = CLOCKORBIT_NUMGPS, + CLOCKORBIT_OFFSETGALILEO = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS, + CLOCKORBIT_OFFSETQZSS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO, + CLOCKORBIT_OFFSETSBAS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS, + CLOCKORBIT_OFFSETBDS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS, + CLOCKORBIT_COUNTSAT = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS + CLOCKORBIT_NUMBDS }; @@ -220,4 +227,5 @@ CODETYPE_SBAS_L5_Q = 2, CODETYPE_SBAS_L5_IQ = 3, + CODETYPE_BDS_B1_I = 0, CODETYPE_BDS_B1_Q = 1, @@ -234,8 +242,5 @@ CODETYPE_BDS_B2a_D = 12, CODETYPE_BDS_B2a_P = 13, - CODETYPE_BDS_B2a_DP = 14, - - CODETYPE_IRNSS_S_SPS = 8, - CODETYPE_IRNSS_L5_SPS = 22 + CODETYPE_BDS_B2a_DP = 14 }; @@ -247,33 +252,9 @@ xxx->Sat[CLOCKORBIT_OFFSETGPS]. */ -#ifdef COR_LEGACY -/* old names */ -#define NumberOfGPSSat NumberOfSat[CLOCKORBIT_SATGPS] -#define NumberOfGLONASSSat NumberOfSat[CLOCKORBIT_SATGLONASS] -#define GPSEpochTime EpochTime[CLOCKORBIT_SATGPS] /* 0 .. 604799 s */ -#define GLONASSEpochTime EpochTime[CLOCKORBIT_SATGLONASS] /* 0 .. 86399 s (86400 for leap second) */ -#define ClockDataSupplied Supplied[COBOFS_CLOCK] -#define HRDataSupplied Supplied[COBOFS_HR] -#define OrbitDataSupplied Supplied[COBOFS_ORBIT] -#define URADataSupplied Supplied[COBOFS_URA] -#define GetClockOrbitBias(a,b,c,d,e) GetSSR(a,b,0,0,c,d,e) -#endif /* COR_LEGACY */ - -/* latency check code, disabled by default */ -#ifdef COR_LATENCY -#define COR_LATENCYCOUNT 100 -#endif - -struct ClockOrbit -{ +struct ClockOrbit { enum ClockOrbitType messageType; unsigned int EpochTime[CLOCKORBIT_SATNUM]; /* 0 .. system specific maximum */ unsigned int NumberOfSat[CLOCKORBIT_SATNUM]; /* 0 .. CLOCKORBIT_NUM... */ - unsigned int Supplied[COBOFS_NUM]; /* boolean */ -#ifdef COR_LATENCY - unsigned int epochGPS[COR_LATENCYCOUNT+1]; /* Weber, for latency */ - unsigned int epochSize; /* Weber, for latency */ -#endif unsigned int SSRIOD; unsigned int SSRProviderID; @@ -287,6 +268,5 @@ double UserRangeAccuracy; /* accuracy values in [m] */ double hrclock; - struct OrbitPart - { + struct OrbitPart { double DeltaRadial; /* m */ double DeltaAlongTrack; /* m */ @@ -296,6 +276,5 @@ double DotDeltaCrossTrack; /* m/s */ } Orbit; - struct ClockPart - { + struct ClockPart { double DeltaA0; /* m */ double DeltaA1; /* m/s */ @@ -305,6 +284,5 @@ }; -struct CodeBias -{ +struct CodeBias { enum CodeBiasType messageType; unsigned int EpochTime[CLOCKORBIT_SATNUM]; /* 0 .. system specific maximum */ @@ -314,10 +292,8 @@ unsigned int SSRProviderID; unsigned int SSRSolutionID; - struct BiasSat - { + struct BiasSat { unsigned int ID; /* all */ unsigned int NumberOfCodeBiases; - struct CodeBiasEntry - { + struct CodeBiasEntry { enum CodeType Type; float Bias; /* m */ @@ -326,6 +302,5 @@ }; -struct PhaseBias -{ +struct PhaseBias { enum PhaseBiasType messageType; unsigned int EpochTime[CLOCKORBIT_SATNUM]; /* 0 .. system specific maximum */ @@ -337,12 +312,10 @@ unsigned int DispersiveBiasConsistencyIndicator; unsigned int MWConsistencyIndicator; - struct PhaseBiasSat - { + struct PhaseBiasSat { unsigned int ID; /* all */ unsigned int NumberOfPhaseBiases; double YawAngle; /* radiant */ double YawRate; /* radiant/s */ - struct PhaseBiasEntry - { + struct PhaseBiasEntry { enum CodeType Type; unsigned int SignalIntegerIndicator; @@ -354,6 +327,5 @@ }; -struct VTEC -{ +struct VTEC { unsigned int EpochTime; /* GPS */ unsigned int UpdateInterval; @@ -384,22 +356,22 @@ enum GCOB_RETURN { /* all well */ - GCOBR_MESSAGEFOLLOWS = 1, - GCOBR_OK = 0, + GCOBR_MESSAGEFOLLOWS = 1, + GCOBR_OK = 0, /* unknown data, a warning */ - GCOBR_UNKNOWNTYPE = -1, - GCOBR_UNKNOWNDATA = -2, - GCOBR_CRCMISMATCH = -3, - GCOBR_SHORTMESSAGE = -4, + GCOBR_UNKNOWNTYPE = -1, + GCOBR_UNKNOWNDATA = -2, + GCOBR_CRCMISMATCH = -3, + GCOBR_SHORTMESSAGE = -4, /* failed to do the work */ GCOBR_NOCLOCKORBITPARAMETER = -10, - GCOBR_NOCODEBIASPARAMETER = -11, - GCOBR_NOPHASEBIASPARAMETER = -12, - GCOBR_NOVTECPARAMETER = -13, + GCOBR_NOCODEBIASPARAMETER = -11, + GCOBR_NOPHASEBIASPARAMETER = -12, + GCOBR_NOVTECPARAMETER = -13, /* data mismatch - data in storage does not match new data */ - GCOBR_TIMEMISMATCH = -20, - GCOBR_DATAMISMATCH = -21, + GCOBR_TIMEMISMATCH = -20, + GCOBR_DATAMISMATCH = -21, /* not enough data - can decode the block completely */ - GCOBR_SHORTBUFFER = -30, - GCOBR_MESSAGEEXCEEDSBUFFER = -31}; + GCOBR_SHORTBUFFER = -30, + GCOBR_MESSAGEEXCEEDSBUFFER = -31}; /* 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 Index: branches/BNC_2.12/src/src.pri =================================================================== --- branches/BNC_2.12/src/src.pri (revision 8946) +++ branches/BNC_2.12/src/src.pri (revision 8987) @@ -60,5 +60,4 @@ RTCM3/RTCM3Decoder.h RTCM3/bits.h RTCM3/gnss.h \ RTCM3/RTCM3coDecoder.h RTCM3/ephEncoder.h \ - RTCM3/clock_and_orbit/clock_orbit_rtcm.h \ rinex/rnxobsfile.h \ rinex/rnxnavfile.h rinex/corrfile.h \ @@ -97,5 +96,4 @@ RTCM3/RTCM3Decoder.cpp \ RTCM3/RTCM3coDecoder.cpp RTCM3/ephEncoder.cpp \ - RTCM3/clock_and_orbit/clock_orbit_rtcm.c \ rinex/rnxobsfile.cpp \ rinex/rnxnavfile.cpp rinex/corrfile.cpp \ @@ -113,4 +111,17 @@ QT += network + +# Format of SSR corrections +# ------------------------- +DEFINES += USE_SSR_RTCM +#DEFINES += USE_SSR_IGS +contains(DEFINES, USE_SSR_IGS) { + HEADERS += RTCM3/clock_and_orbit/clock_orbit_igs.h + SOURCES += RTCM3/clock_and_orbit/clock_orbit_igs.c +} +else { + HEADERS += RTCM3/clock_and_orbit/clock_orbit_rtcm.h + SOURCES += RTCM3/clock_and_orbit/clock_orbit_rtcm.c +} exists(PPP) { Index: branches/BNC_2.12/src/upload/bncrtnetuploadcaster.cpp =================================================================== --- branches/BNC_2.12/src/upload/bncrtnetuploadcaster.cpp (revision 8946) +++ branches/BNC_2.12/src/upload/bncrtnetuploadcaster.cpp (revision 8987) @@ -150,9 +150,10 @@ _t0 = 2020.0; } - // Transformation Parameters from IGb14 to SIRGAS2000 (Sonia Costa, BRA) + // Transformation Parameters from IGb14 to SIRGAS2000 (Thanks to Sonia Costa, BRA) + // June 29 2020: TX:-0.0027 m TY:-0.0025 m TZ:-0.0042 m SCL:1.20 (ppb) no rotations and no rates.*/ else if (_crdTrafo == "SIRGAS2000") { - _dx = 0.0026; - _dy = 0.0018; - _dz = -0.0061; + _dx = -0.0027; + _dy = -0.0025; + _dz = -0.0042; _dxr = 0.0000; @@ -168,5 +169,5 @@ _ozr = 0.000000; - _sc = -1.00000; + _sc = 1.20000; _scr = 0.00000; _t0 = 2000.0; @@ -553,10 +554,11 @@ else if (prn.system() == 'E') { sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS - + co.NumberOfSat[CLOCKORBIT_SATGALILEO]; + + co.NumberOfSat[CLOCKORBIT_SATGALILEO]; ++co.NumberOfSat[CLOCKORBIT_SATGALILEO]; } else if (prn.system() == 'J') { sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS - + CLOCKORBIT_NUMGALILEO + co.NumberOfSat[CLOCKORBIT_SATQZSS]; + + CLOCKORBIT_NUMGALILEO + + co.NumberOfSat[CLOCKORBIT_SATQZSS]; ++co.NumberOfSat[CLOCKORBIT_SATQZSS]; } @@ -569,5 +571,6 @@ else if (prn.system() == 'C') { sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS - + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS + + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + + CLOCKORBIT_NUMSBAS + co.NumberOfSat[CLOCKORBIT_SATBDS]; ++co.NumberOfSat[CLOCKORBIT_SATBDS]; @@ -594,27 +597,29 @@ else if (prn.system() == 'R') { biasSat = bias.Sat + CLOCKORBIT_NUMGPS - + bias.NumberOfSat[CLOCKORBIT_SATGLONASS]; + + bias.NumberOfSat[CLOCKORBIT_SATGLONASS]; ++bias.NumberOfSat[CLOCKORBIT_SATGLONASS]; } else if (prn.system() == 'E') { biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS - + bias.NumberOfSat[CLOCKORBIT_SATGALILEO]; + + bias.NumberOfSat[CLOCKORBIT_SATGALILEO]; ++bias.NumberOfSat[CLOCKORBIT_SATGALILEO]; } else if (prn.system() == 'J') { biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS - + CLOCKORBIT_NUMGALILEO + bias.NumberOfSat[CLOCKORBIT_SATQZSS]; + + CLOCKORBIT_NUMGALILEO + + bias.NumberOfSat[CLOCKORBIT_SATQZSS]; ++bias.NumberOfSat[CLOCKORBIT_SATQZSS]; } else if (prn.system() == 'S') { biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS - + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS - + bias.NumberOfSat[CLOCKORBIT_SATSBAS]; + + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + + bias.NumberOfSat[CLOCKORBIT_SATSBAS]; ++bias.NumberOfSat[CLOCKORBIT_SATSBAS]; } else if (prn.system() == 'C') { biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS - + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS - + bias.NumberOfSat[CLOCKORBIT_SATBDS]; + + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + + CLOCKORBIT_NUMSBAS + + bias.NumberOfSat[CLOCKORBIT_SATBDS]; ++bias.NumberOfSat[CLOCKORBIT_SATBDS]; } @@ -652,4 +657,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "1X") { int ii = biasSat->NumberOfCodeBiases; @@ -660,4 +666,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "1P") { int ii = biasSat->NumberOfCodeBiases; @@ -708,4 +715,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "2X") { int ii = biasSat->NumberOfCodeBiases; @@ -716,4 +724,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "2P") { int ii = biasSat->NumberOfCodeBiases; @@ -748,4 +757,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "5X") { int ii = biasSat->NumberOfCodeBiases; @@ -756,4 +766,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif } } @@ -810,4 +821,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "4X") { int ii = biasSat->NumberOfCodeBiases; @@ -818,4 +830,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "6A") { int ii = biasSat->NumberOfCodeBiases; @@ -834,4 +847,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "6X") { int ii = biasSat->NumberOfCodeBiases; @@ -842,4 +856,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "3I") { int ii = biasSat->NumberOfCodeBiases; @@ -858,4 +873,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "3X") { int ii = biasSat->NumberOfCodeBiases; @@ -866,4 +882,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif } } @@ -896,4 +913,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "1X") { int ii = biasSat->NumberOfCodeBiases; @@ -912,4 +930,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "5I") { int ii = biasSat->NumberOfCodeBiases; @@ -928,4 +947,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "5X") { int ii = biasSat->NumberOfCodeBiases; @@ -936,4 +956,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "7I") { int ii = biasSat->NumberOfCodeBiases; @@ -952,4 +973,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "7X") { int ii = biasSat->NumberOfCodeBiases; @@ -984,4 +1006,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "6A") { int ii = biasSat->NumberOfCodeBiases; @@ -1008,4 +1031,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "6X") { int ii = biasSat->NumberOfCodeBiases; @@ -1024,4 +1048,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif } } @@ -1070,4 +1095,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "2X") { int ii = biasSat->NumberOfCodeBiases; @@ -1078,4 +1104,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "5I") { int ii = biasSat->NumberOfCodeBiases; @@ -1094,4 +1121,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "5X") { int ii = biasSat->NumberOfCodeBiases; @@ -1102,4 +1130,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "6S") { int ii = biasSat->NumberOfCodeBiases; @@ -1118,4 +1147,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "6X") { int ii = biasSat->NumberOfCodeBiases; @@ -1166,4 +1196,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "6E") { int ii = biasSat->NumberOfCodeBiases; @@ -1174,4 +1205,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "6Z") { int ii = biasSat->NumberOfCodeBiases; @@ -1182,4 +1214,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif } } @@ -1212,4 +1245,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "5X") { int ii = biasSat->NumberOfCodeBiases; @@ -1220,4 +1254,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif } } @@ -1242,4 +1277,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "2X") { int ii = biasSat->NumberOfCodeBiases; @@ -1250,4 +1286,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "6I") { int ii = biasSat->NumberOfCodeBiases; @@ -1266,4 +1303,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "6X") { int ii = biasSat->NumberOfCodeBiases; @@ -1274,4 +1312,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "7I") { int ii = biasSat->NumberOfCodeBiases; @@ -1290,4 +1329,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "7X") { int ii = biasSat->NumberOfCodeBiases; @@ -1298,4 +1338,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "1D") { int ii = biasSat->NumberOfCodeBiases; @@ -1314,4 +1355,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "1X") { int ii = biasSat->NumberOfCodeBiases; @@ -1322,4 +1364,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#endif else if (it.key() == "5D") { int ii = biasSat->NumberOfCodeBiases; @@ -1338,4 +1381,5 @@ biasSat->Biases[ii].Bias = it.value(); } +#ifdef USE_SSR_RTCM else if (it.key() == "5X") { int ii = biasSat->NumberOfCodeBiases; @@ -1346,47 +1390,63 @@ biasSat->Biases[ii].Bias = it.value(); } +#elif USE_SSR_IGS + else if (it.key() == "1A") { + int ii = biasSat->NumberOfCodeBiases; + if (ii >= CLOCKORBIT_NUMBIAS) + break; + biasSat->NumberOfCodeBiases += 1; + biasSat->Biases[ii].Type = CODETYPE_BDS_B1_A; + biasSat->Biases[ii].Bias = it.value(); } - } - } + else if (it.key() == "6A") { + int ii = biasSat->NumberOfCodeBiases; + if (ii >= CLOCKORBIT_NUMBIAS) + break; + biasSat->NumberOfCodeBiases += 1; + biasSat->Biases[ii].Type = CODETYPE_BDS_B3_A; + biasSat->Biases[ii].Bias = it.value(); + } +#endif + } + } + } + // Phase Biases // ------------ struct PhaseBias::PhaseBiasSat* phasebiasSat = 0; -// if (!phaseBiasList.isEmpty()) { // to allow yaw angle without phase bias list - if (prn.system() == 'G') { - phasebiasSat = phasebias.Sat - + phasebias.NumberOfSat[CLOCKORBIT_SATGPS]; - ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS]; - } - else if (prn.system() == 'R') { - phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS - + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS]; - ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS]; - } - else if (prn.system() == 'E') { - phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS - + CLOCKORBIT_NUMGLONASS - + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO]; - ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO]; - } - else if (prn.system() == 'J') { - phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS - + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO - + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS]; - ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS]; - } - else if (prn.system() == 'S') { - phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS - + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO - + CLOCKORBIT_NUMQZSS + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS]; - ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS]; - } - else if (prn.system() == 'C') { - phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS - + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO - + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMSBAS - + phasebias.NumberOfSat[CLOCKORBIT_SATBDS]; - ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS]; - } - //} + if (prn.system() == 'G') { + phasebiasSat = phasebias.Sat + + phasebias.NumberOfSat[CLOCKORBIT_SATGPS]; + ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS]; + } + else if (prn.system() == 'R') { + phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS + + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS]; + ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS]; + } + else if (prn.system() == 'E') { + phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO]; + ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO]; + } + else if (prn.system() == 'J') { + phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + + CLOCKORBIT_NUMGALILEO + + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS]; + ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS]; + } + else if (prn.system() == 'S') { + phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS]; + ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS]; + } + else if (prn.system() == 'C') { + phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS + + CLOCKORBIT_NUMSBAS + + phasebias.NumberOfSat[CLOCKORBIT_SATBDS]; + ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS]; + } if (phasebiasSat) { @@ -1478,4 +1538,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "2X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1489,4 +1550,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "2P") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1533,4 +1595,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "5X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1544,4 +1607,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "1S") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1566,4 +1630,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "1X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1577,4 +1642,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif } } @@ -1649,4 +1715,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "4X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1660,4 +1727,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "6A") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1682,4 +1750,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "6X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1693,4 +1762,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "3I") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1715,4 +1785,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "3X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1726,4 +1797,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif } } @@ -1765,4 +1837,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "1X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1787,4 +1860,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "5I") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1809,4 +1883,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "5X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1820,4 +1895,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "7I") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1842,4 +1918,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "7X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1886,4 +1963,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "6A") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1919,4 +1997,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "6X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -1941,4 +2020,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif } } @@ -2001,4 +2081,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "2X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2011,4 +2092,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "5I") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2033,4 +2115,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "5X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2044,4 +2127,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "6S") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2066,4 +2150,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "6X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2077,5 +2162,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } - else if (pbSig.type == "1X") { + else if (pbSig.type == "1X") { int ii = phasebiasSat->NumberOfPhaseBiases; if (ii >= CLOCKORBIT_NUMBIAS) @@ -2132,4 +2217,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "6E") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2143,4 +2229,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "6Z") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2154,4 +2241,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif } } @@ -2192,4 +2280,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "5X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2203,4 +2292,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif } } @@ -2231,4 +2321,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "2X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2242,4 +2333,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "6I") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2264,4 +2356,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "6X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2275,4 +2368,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "7I") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2297,4 +2391,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "7X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2307,4 +2402,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "1D") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2327,4 +2423,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "1X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2337,4 +2434,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#endif else if (pbSig.type == "5D") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2357,4 +2455,5 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#ifdef USE_SSR_RTCM else if (pbSig.type == "5X") { int ii = phasebiasSat->NumberOfPhaseBiases; @@ -2367,4 +2466,26 @@ phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; } +#elif USE_SSR_IGS + else if (pbSig.type == "1A") { + int ii = phasebiasSat->NumberOfPhaseBiases; + if (ii >= CLOCKORBIT_NUMBIAS) + break; + phasebiasSat->NumberOfPhaseBiases += 1; + phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B1_A; + phasebiasSat->Biases[ii].Bias = pbSig.bias; + phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator; + phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; + } + else if (pbSig.type == "6A") { + int ii = phasebiasSat->NumberOfPhaseBiases; + if (ii >= CLOCKORBIT_NUMBIAS) + break; + phasebiasSat->NumberOfPhaseBiases += 1; + phasebiasSat->Biases[ii].Type = CODETYPE_BDS_B3_A; + phasebiasSat->Biases[ii].Bias = pbSig.bias; + phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator; + phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter; + } +#endif } } @@ -2372,4 +2493,5 @@ } } + QByteArray hlpBufferCo; @@ -2525,5 +2647,5 @@ || bias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) { char obuffer[CLOCKORBIT_BUFFERSIZE]; - int len = MakeCodeBias(&bias, BTYPE_AUTO, 0, obuffer, sizeof(obuffer)); + int len = MakeCodeBias(&bias, CBTYPE_AUTO, 0, obuffer, sizeof(obuffer)); if (len > 0) { hlpBufferBias = QByteArray(obuffer, len);