Index: /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c =================================================================== --- /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c (revision 7845) +++ /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.c (revision 7845) @@ -0,0 +1,1306 @@ +/* Programheader + + Name: clock_orbit_rtcm.c + Project: RTCM3 + Version: $Id$ + Authors: Dirk Stöcker + Description: state space approach for RTCM3 +*/ + +#include +#include +#include +#ifndef sparc +#include +#else +#include +#endif +#include "clock_orbit_rtcm.h" + +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 + +/* 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) /* DF237 */ +#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_IODCRC(a) ADDBITS(24, a) /* DF471 */ + +#define T_DELTA_RADIAL(a) SCALEADDBITS(22, 10000.0, a) +#define T_DELTA_ALONG_TRACK(a) SCALEADDBITS(20, 2500.0, a) +#define T_DELTA_CROSS_TRACK(a) SCALEADDBITS(20, 2500.0, a) +#define T_DELTA_DOT_RADIAL(a) SCALEADDBITS(21, 1000000.0, a) +#define T_DELTA_DOT_ALONG_TRACK(a) SCALEADDBITS(19, 250000.0, a) +#define T_DELTA_DOT_CROSS_TRACK(a) SCALEADDBITS(19, 250000.0, a) + +#define T_SATELLITE_REFERENCE_DATUM(a) ADDBITS(1, a) +#define T_DELTA_CLOCK_C0(a) SCALEADDBITS(22, 10000.0, a) +#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_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_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_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_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_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) +{ + 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 RTCM data types */ + } /* iterate over satellite systems */ + + 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_SSR_UPDATE_INTERVAL(co->UpdateInterval) + T_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0) + T_SATELLITE_REFERENCE_DATUM(co->SatRefDatum) + 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) + { + 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_IODCRC(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) + } + ENDBLOCK + } + 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_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) + { + 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) + 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_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]) + break; + case CLOCKORBIT_SATGLONASS: + T_GLONASS_EPOCH_TIME(co->EpochTime[s]) + break; + } + 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_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) +#else + 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) + 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_IODCRC(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 +#ifdef SPLITBLOCK + start += nums; + nums = left; + left = 0; + } +#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_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) + { + 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) + } + ENDBLOCK + } + 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_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) + { + 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)) + } + 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 == BTYPE_AUTO || type == corbase[s]+COBOFS_BIAS)) + { + 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_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) + { + 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) + { + T_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 == 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_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) + { + 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) + { + 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_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_MESSAGE_NUMBER(VTEC_BASE) + + T_GPS_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(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(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) +#define G_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 */ +#define G_GLONASS_SATELLITE_ID(a) GETBITS(a, 5) + +#define G_GPS_IODE(a) GETBITS(a, 8) /* DF071 */ +#define G_GLONASS_IOD(a) GETBITS(a, 8) /* DF237 */ +#define G_GALILEO_IOD(a) GETBITS(a, 10) /* DF459 */ +#define G_SBAS_T0MOD(a) GETBITSFACTOR(a, 9, 16) /* DF468 */ +#define G_SBAS_IODCRC(a) GETBITS(a, 24) /* DF469 */ +#define G_BDS_TOEMOD(a) GETBITSFACTOR(a, 10, 8) /* DF470 */ +#define G_BDS_IODCRC(a) GETBITS(a, 24) /* DF471 */ + +/* defined values */ +#define G_DELTA_RADIAL(a) GETFLOATSIGN(a, 22, 1/10000.0) +#define G_DELTA_ALONG_TRACK(a) GETFLOATSIGN(a, 20, 1/2500.0) +#define G_DELTA_CROSS_TRACK(a) GETFLOATSIGN(a, 20, 1/2500.0) +#define G_DELTA_DOT_RADIAL(a) GETFLOATSIGN(a, 21, 1/1000000.0) +#define G_DELTA_DOT_ALONG_TRACK(a) GETFLOATSIGN(a, 19, 1/250000.0) +#define G_DELTA_DOT_CROSS_TRACK(a) GETFLOATSIGN(a, 19, 1/250000.0) + +#define G_SATELLITE_REFERENCE_DATUM(a) GETBITS(a, 1) +#define G_DELTA_CLOCK_C0(a) GETFLOATSIGN(a, 22, 1/10000.0) +#define G_DELTA_CLOCK_C1(a) GETFLOATSIGN(a, 21, 1/1000000.0) +#define G_DELTA_CLOCK_C2(a) GETFLOATSIGN(a, 27, 1/50000000.0) +#define G_NO_OF_CODE_BIASES(a) GETBITS(a, 5) +#define G_NO_OF_PHASE_BIASES(a) GETBITS(a, 5) +#define G_SIGNAL_IDENTIFIER(a) GETBITS(a, 5) +#define G_CODE_BIAS(a) GETFLOATSIGN(a, 14, 1/100.0) +#define G_YAW_ANGLE(a) GETFLOAT(a, 9, MPI/256.0) +#define G_YAW_RATE(a) GETFLOATSIGN(a, 8, MPI/8192.0) +#define G_PHASE_BIAS(a) GETFLOATSIGN(a, 20, 1/10000.0) + +#define G_GPS_EPOCH_TIME(a, b) {unsigned int temp; GETBITS(temp, 20) \ + if(b && a != temp) return GCOBR_TIMEMISMATCH; a = temp;} +#define G_GLONASS_EPOCH_TIME(a, b) {unsigned int temp; GETBITS(temp, 17) \ + if(b && a != temp) return GCOBR_TIMEMISMATCH; a = temp;} +#define G_EPOCH_TIME(a) GETBITS(a, 20) +#define G_NO_OF_SATELLITES(a) GETBITS(a, 6) +#define G_MULTIPLE_MESSAGE_INDICATOR(a) GETBITS(a, 1) +#define G_DISPERSIVE_BIAS_INDICATOR(a) GETBITS(a, 1) +#define G_MW_CONSISTENCY_INDICATOR(a) GETBITS(a, 1) +#define G_INTEGER_INDICATOR(a) GETBITS(a, 1) +#define G_WIDE_LANE_INDICATOR(a) GETBITS(a, 2) +#define G_DISCONTINUITY_COUNTER(a) GETBITS(a, 4) +#define G_SSR_URA(a) {int temp; GETBITS(temp, 6) \ + (a) = URAToValue(temp);} +#define G_HR_CLOCK_CORRECTION(a) GETFLOATSIGN(a, 22, 1/10000.0) +#define G_SSR_UPDATE_INTERVAL(a) GETBITS(a, 4) + +#define G_SSR_IOD(a) GETBITS(a, 4) +#define G_SSR_PROVIDER_ID(a) GETBITS(a, 16) +#define G_SSR_SOLUTION_ID(a) GETBITS(a, 4) + +#define G_NO_IONO_LAYERS(a) {unsigned int temp; GETBITS(temp, 2) a = temp+1; } +#define G_VTEC_QUALITY_INDICATOR(a) GETFLOAT(a, 9, 1/20.0) +#define G_IONO_COEFF(a) GETFLOATSIGN(a, 16,1/200.0) +#define G_IONO_DEGREE(a) {unsigned int temp; GETBITS(temp, 4) a = temp+1; } +#define G_IONO_ORDER(a) {unsigned int temp; GETBITS(temp, 4) a = temp+1; } +#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; + 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 */ + + 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) + { + unsigned int l, o, d; + if(!v) return GCOBR_NOVTECPARAMETER; + memset(v, 0, sizeof(*v)); + G_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(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(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 == 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; + } + 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) + { + 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) + ; + 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) + { + 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_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; + 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; + } + 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_IODCRC(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 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; + } + 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; + } + 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_IODCRC(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) + } + 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; + } + 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; + } + 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; + } + 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; + 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; + 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_rtcm.h =================================================================== --- /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h (revision 7845) +++ /trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm.h (revision 7845) @@ -0,0 +1,379 @@ +#ifndef RTCM3_CLOCK_ORBIT_RTCM_H +#define RTCM3_CLOCK_ORBIT_RTCM_H + +/* Programheader + + Name: clock_orbit_rtcm.h + Project: RTCM3 + Version: $Id$ + Authors: Dirk Stöcker + Description: state space approach for RTCM3 +*/ + +#include + +enum SatelliteReferenceDatum { DATUM_ITRF=0, DATUM_LOCAL=1 }; + +enum COR_BASE { + COBBASE_GPS = 1057, + COBBASE_GLONASS = 1063, + COBBASE_GALILEO = 1240, + COBBASE_QZSS = 1246, + COBBASE_SBAS = 1252, + COBBASE_BDS = 1258, +}; + +enum COR_OFFSET { + COBOFS_ORBIT = 0, + COBOFS_CLOCK, + COBOFS_BIAS, + COBOFS_COMBINED, + COBOFS_URA, + COBOFS_HR, + COBOFS_NUM +}; + +enum ClockOrbitType { + COTYPE_GPSORBIT = COBBASE_GPS + COBOFS_ORBIT, + COTYPE_GPSCLOCK, + COTYPE_GPSCOMBINED = COBBASE_GPS + COBOFS_COMBINED, + COTYPE_GPSURA, + COTYPE_GPSHR, + + COTYPE_GLONASSORBIT = COBBASE_GLONASS + COBOFS_ORBIT, + COTYPE_GLONASSCLOCK, + COTYPE_GLONASSCOMBINED = COBBASE_GLONASS + COBOFS_COMBINED, + COTYPE_GLONASSURA, + COTYPE_GLONASSHR, + + COTYPE_GALILEOORBIT = COBBASE_GALILEO + COBOFS_ORBIT, + COTYPE_GALILEOCLOCK, + COTYPE_GALILEOCOMBINED = COBBASE_GALILEO + COBOFS_COMBINED, + COTYPE_GALILEOURA, + COTYPE_GALILEOHR, + + COTYPE_QZSSORBIT = COBBASE_QZSS + COBOFS_ORBIT, + COTYPE_QZSSCLOCK, + COTYPE_QZSSCOMBINED = COBBASE_QZSS + COBOFS_COMBINED, + COTYPE_QZSSURA, + COTYPE_QZSSHR, + + COTYPE_SBASORBIT = COBBASE_SBAS + COBOFS_ORBIT, + COTYPE_SBASCLOCK, + COTYPE_SBASCOMBINED = COBBASE_SBAS + COBOFS_COMBINED, + COTYPE_SBASURA, + COTYPE_SBASHR, + + COTYPE_BDSORBIT = COBBASE_BDS + COBOFS_ORBIT, + COTYPE_BDSCLOCK, + COTYPE_BDSCOMBINED = COBBASE_BDS + COBOFS_COMBINED, + COTYPE_BDSURA, + COTYPE_BDSHR, + + COTYPE_AUTO = 0, +}; + +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, + PBTYPE_GLONASS, + PBTYPE_GALILEO, + PBTYPE_QZSS, + PBTYPE_SBAS, + PBTYPE_BDS, + PBTYPE_AUTO = 0 +}; + +enum VTECType { + VTEC_BASE = 1264 +}; + +/* 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=2048, + CLOCKORBIT_NUMGPS=32, + CLOCKORBIT_NUMGLONASS=26, + CLOCKORBIT_NUMGALILEO=36, + CLOCKORBIT_NUMQZSS=10, + CLOCKORBIT_NUMSBAS=38, + CLOCKORBIT_NUMBDS=37, + CLOCKORBIT_NUMBIAS=17, + CLOCKORBIT_NUMIONOLAYERS=4, + CLOCKORBIT_MAXIONOORDER=8, + CLOCKORBIT_MAXIONODEGREE=8 +}; + +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_L1_Y = 3, + CODETYPEGPS_L1_M = 4,*/ + CODETYPEGPS_L2_CA = 5, + CODETYPEGPS_SEMI_CODELESS = 6, + CODETYPEGPS_L2_CM = 7, + CODETYPEGPS_L2_CL = 8, + CODETYPEGPS_L2_CML = 9, + CODETYPEGPS_L2_P = 10, + CODETYPEGPS_L2_Z = 11, + /*CODETYPEGPS_L2_Y = 12, + CODETYPEGPS_L2_M = 13,*/ + CODETYPEGPS_L5_I = 14, + CODETYPEGPS_L5_Q = 15, + CODETYPEGPS_L5_IQ = 16, + + CODETYPEGLONASS_L1_CA = 0, + CODETYPEGLONASS_L1_P = 1, + CODETYPEGLONASS_L2_CA = 2, + CODETYPEGLONASS_L2_P = 3, + + CODETYPEGALILEO_E1_A = 0, + CODETYPEGALILEO_E1_B = 1, + CODETYPEGALILEO_E1_C = 2, + CODETYPEGALILEO_E5A_I = 5, + CODETYPEGALILEO_E5A_Q = 6, + CODETYPEGALILEO_E5B_I = 8, + CODETYPEGALILEO_E5B_Q = 9, + CODETYPEGALILEO_E5_I = 11, + CODETYPEGALILEO_E5_Q = 12, + CODETYPEGALILEO_E6_A = 14, + CODETYPEGALILEO_E6_B = 15, + CODETYPEGALILEO_E6_C = 16, + + CODETYPEQZSS_L1_CA = 0, + CODETYPEQZSS_L1C_D = 1, + CODETYPEQZSS_L1C_P = 2, + CODETYPEQZSS_L2_CM = 3, + CODETYPEQZSS_L2_CL = 4, + CODETYPEQZSS_L2_CML = 5, + CODETYPEQZSS_L5_I = 6, + CODETYPEQZSS_L5_Q = 7, + CODETYPEQZSS_L5_IQ = 8, + CODETYPEQZSS_LEX_S = 9, + CODETYPEQZSS_LEX_L = 10, + CODETYPEQZSS_LEX_SL = 11, + CODETYPEQZSS_L1C_DP = 12, + + CODETYPE_SBAS_L1_CA = 0, + CODETYPE_SBAS_L5_I = 1, + CODETYPE_SBAS_L5_Q = 2, + CODETYPE_SBAS_L5_IQ = 3, + + CODETYPE_BDS_B1_I = 0, + CODETYPE_BDS_B1_Q = 1, + CODETYPE_BDS_B1_IQ = 2, + CODETYPE_BDS_B3_I = 3, + CODETYPE_BDS_B3_Q = 4, + CODETYPE_BDS_B3_IQ = 5, + CODETYPE_BDS_B2_I = 6, + CODETYPE_BDS_B2_Q = 7, + CODETYPE_BDS_B2_IQ = 8, +}; + +#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]. */ + +#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; + 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; + 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-8 */ + unsigned int Order; /* 1-8 */ + 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_RTCM_H */