Index: /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.c =================================================================== --- /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.c (revision 8970) +++ /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.c (revision 8970) @@ -0,0 +1,907 @@ +/* Programheader + + Name: clock_orbit_igs.c + Project: RTCM3 + Version: $Id: clock_orbit_igs.c 8963 2020-06-29 12:46:25Z stuerze $ + Authors: 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; + size_t sizeofrtcmblock; + const char *blockstart = buffer; + DECODESTART + + if (size < 7) + return GCOBR_SHORTBUFFER; + +#ifdef DEBUG + fprintf(stderr, "GetClockOrbitBias START: size %d, numbits %d\n",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 */ + + SKIPBITS(12) // G_RTCM_MESSAGE_NUMBER(a) + SKIPBITS( 3) // G_IGS_SSR_VERSION(a) + G_IGS_MESSAGE_NUMBER(type) +#ifdef DEBUG + fprintf(stderr, "type %d size %d\n",type,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) + 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) { + G_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) { + G_IONO_COEFF_S(v->Layers[l].Sinus[d][o]) + } + } + } +#ifdef DEBUG + for(type = 0; type < (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] + s) { + 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) + 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) + 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 DEBUG + for(type = 0; type < (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; + 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 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) { + 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 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; + 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 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) { + 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 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; + 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) + } + 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; + 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) + } + 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; + 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) + } + 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) + 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) + 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) + } + } + break; + default: + continue; + } +#ifdef DEBUG + for(type = 0; type < (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: /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.h =================================================================== --- /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.h (revision 8970) +++ /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_igs.h (revision 8970) @@ -0,0 +1,382 @@ +#ifndef RTCM3_CLOCK_ORBIT_IGS_H +#define RTCM3_CLOCK_ORBIT_IGS_H + +/* Programheader + + Name: clock_orbit_igs.h + Project: RTCM3 + Version: $Id: clock_orbit_igs.h 8966 2020-07-01 07:48:35Z stuerze $ + Authors: Dirk Stöcker, Andrea Stürze + Description: state space approach: IGS +*/ + +#include + +enum SatelliteReferenceDatum { + DATUM_ITRF = 0, + DATUM_LOCAL = 1 +}; + +enum IGS_NUMBERS { + RTCM_MESSAGE_NUMBER_IGS = 4076, + IGS_SSR_VERSION = 3 +}; + +enum COR_BASE {// Orbit Correction + 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_BDSORBIT = COBBASE_BDS + COBOFS_ORBIT, + COTYPE_BDSCLOCK, + COTYPE_BDSCOMBINED = COBBASE_BDS + COBOFS_COMBINED, + COTYPE_BDSHR, + COTYPE_BDSURA = COBBASE_BDS + 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_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_BDS = COBBASE_BDS + COBOFS_CBIAS, + CBTYPE_SBAS = COBBASE_SBAS + 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_BDS = COBBASE_BDS + COBOFS_PBIAS, + PBTYPE_SBAS = COBBASE_SBAS + 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_NUMBDS = 65, + CLOCKORBIT_NUMSBAS = 38, + 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_SATBDS, + CLOCKORBIT_SATSBAS, + 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_OFFSETBDS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS, + CLOCKORBIT_OFFSETSBAS = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMQZSS + CLOCKORBIT_NUMBDS, + CLOCKORBIT_COUNTSAT = CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS + CLOCKORBIT_NUMGALILEO + + CLOCKORBIT_NUMSBAS + CLOCKORBIT_NUMQZSS + 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_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 + + CODETYPE_SBAS_L1_CA = 0, + CODETYPE_SBAS_L5_I = 1, + CODETYPE_SBAS_L5_Q = 2 + //RESERVED_SBAS_L5_IQ = 3 + +}; + +#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: /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c =================================================================== --- /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c (revision 8969) +++ /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c (revision 8970) @@ -90,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) @@ -114,35 +114,35 @@ #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) +#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) { @@ -186,30 +186,4 @@ CLOCKORBIT_COUNTSAT }; -/* -//CNES PATCH MEDIAN -static double Median(int n, double x[50]) { - double temp; - int i, j; - // the following two loops sort the array x in ascending order - if (n <= 2) - return 0.0; - - for (i = 0; i < n - 1; i++) - for (j = i + 1; j < n; j++) - if (x[j] < x[i]) { - // swap elements - temp = x[i]; - x[i] = x[j]; - x[j] = temp; - } - - if (n % 2 == 0) - return ((x[n / 2] + x[n / 2 - 1]) / 2.0); - else - return x[n / 2]; -} -//PATCH MEDIAN -//PATCH CLKOFFSET - size_t MakeClockOrbit(struct ClockOrbit *co, enum ClockOrbitType type,*/ size_t MakeClockOrbit(const struct ClockOrbit *co, enum ClockOrbitType type, @@ -218,38 +192,6 @@ memset(status, 0, sizeof(status)); -/* PATCH CLKOFFSET ///////////////////////////////////////////////////// - //double tSum - double tOffset, tClock[50]; - int j, tNb; - for (s = 0; s < CLOCKORBIT_SATNUM; ++s) - { - //tSum = 0.0; - tOffset = 0.0; - tNb = 0; - for (j = 0; j < 50; j++) - tClock[j] = 0.0; - - for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) { - if (co->Sat[i].Clock.DeltaA0) { - //tSum += co->Sat[i].Clock.DeltaA0; //Average - tClock[tNb] = co->Sat[i].Clock.DeltaA0; //Median - tNb++; - } - } - //tOffset = tSum/(double)tNb; //Average - tOffset = Median(tNb, tClock); //Median - for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) - if (co->Sat[i].Clock.DeltaA0) { - //clkoffset_test -// FILE *ficOffsetClk = fopen("ClkOffset.txt","a"); -// fprintf(ficOffsetClk,"%d %d %d %lf %lf %lf\n",co->EpochTime[s], s, i, co->Sat[i].Clock.DeltaA0, tOffset, co->Sat[i].Clock.DeltaA0-tOffset); -// fclose(ficOffsetClk); - - co->Sat[i].Clock.DeltaA0 -= tOffset; - } - } - //PATCH CLKOFFSET ///////////////////////////////////////////////////// */ - - STARTDATA + + STARTDATA for (s = 0; s < CLOCKORBIT_SATNUM; ++s) { @@ -269,5 +211,5 @@ if (status[s][COBOFS_ORBIT]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s] + COBOFS_ORBIT) + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_ORBIT) switch (s) { case CLOCKORBIT_SATGPS: @@ -329,5 +271,5 @@ if (status[s][COBOFS_CLOCK]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s] + COBOFS_CLOCK) + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_CLOCK) switch (s) { case CLOCKORBIT_SATGPS: @@ -383,5 +325,5 @@ #endif INITBLOCK - T_MESSAGE_NUMBER(corbase[s] + COBOFS_COMBINED) + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_COMBINED) switch (s) { case CLOCKORBIT_SATGPS: @@ -462,5 +404,5 @@ if (status[s][COBOFS_HR]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s] + COBOFS_HR) + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_HR) switch (s) { case CLOCKORBIT_SATGPS: @@ -502,5 +444,5 @@ if (status[s][COBOFS_URA]) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s] + COBOFS_URA) + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_URA) switch (s) { case CLOCKORBIT_SATGPS: @@ -553,5 +495,5 @@ if (b->NumberOfSat[s] && (type == CBTYPE_AUTO || type == corbase[s] + COBOFS_CBIAS)) { INITBLOCK - T_MESSAGE_NUMBER(corbase[s] + COBOFS_CBIAS) + T_RTCM_MESSAGE_NUMBER(corbase[s] + COBOFS_CBIAS) switch (s) { case CLOCKORBIT_SATGPS: @@ -608,5 +550,5 @@ if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == s + PBTYPE_BASE)) { INITBLOCK - T_MESSAGE_NUMBER(s + PBTYPE_BASE) + T_RTCM_MESSAGE_NUMBER(s + PBTYPE_BASE) switch (s) { case CLOCKORBIT_SATGPS: @@ -669,5 +611,5 @@ STARTDATA INITBLOCK - T_MESSAGE_NUMBER(VTEC_BASE) + T_RTCM_MESSAGE_NUMBER(VTEC_BASE) T_GPS_EPOCH_TIME(v->EpochTime) @@ -1346,11 +1288,4 @@ 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) Index: /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h =================================================================== --- /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h (revision 8969) +++ /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h (revision 8970) @@ -38,7 +38,7 @@ 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, @@ -56,17 +56,17 @@ 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, @@ -248,22 +248,4 @@ 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 { enum ClockOrbitType messageType; @@ -271,8 +253,4 @@ 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;