source: ntrip/trunk/BNC/src/RTCM3/clock_and_orbit/clock_orbit_rtcm_new.cpp@ 11001

Last change on this file since 11001 was 11001, checked in by stuerze, 5 weeks ago

minor changes regarding RTCM-SSR
  • Property svn:executable set to *
File size: 47.5 KB
Line 
1/* Programheader
2
3 Name: clock_orbit_rtcm_new.c
4 Project: RTCM3
5 Version: $Id: clock_orbit_rtcm_new.c 8996 2020-07-22 08:29:10Z stuerze $
6 Authors: Dirk Stöcker
7 Description: state space approach: RTCM_NEW
8 */
9
10#include <math.h>
11#include <stdio.h>
12#include <string.h>
13#ifndef sparc
14#include <stdint.h>
15#else
16#include <sys/types.h>
17#endif
18#include "clock_orbit_rtcm_new.h"
19
20SsrCorrRtcmNew::SsrCorrRtcmNew() {
21 setCorBase();
22 setCoType();
23 setCbType();
24 setPbType();
25 setPbExtType();
26 setVtecType();
27 setSatAntType();
28 setGridDefType();
29 setTropoType();
30 setRegIonoType();
31 setMetaDataType();
32 setCodeType();
33 setCorType(); /* must run after the type setters above: it reads their constants */
34
35 satoffset << CLOCKORBIT_OFFSETGPS
36 << CLOCKORBIT_OFFSETGLONASS
37 << CLOCKORBIT_OFFSETGALILEO
38 << CLOCKORBIT_OFFSETQZSS
39 << CLOCKORBIT_OFFSETSBAS
40 << CLOCKORBIT_OFFSETBDS
41 << CLOCKORBIT_COUNTSAT;
42}
43SsrCorrRtcmNew::~SsrCorrRtcmNew() {};
44
45size_t SsrCorrRtcmNew::MakeClockOrbit(const struct ClockOrbit *co, ClockOrbitType type,
46 int moremessagesfollow, char *buffer, size_t size) {
47 std::vector< std::vector<unsigned int> > status(CLOCKORBIT_SATNUM, std::vector<unsigned int>(COBOFS_MAXNUM));
48 unsigned int i, s;
49
50 //memset(status, 0, sizeof(status));
51
52 STARTDATA
53
54 for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
55 for (i = 0; i < COBOFS_MAXNUM; ++i) {
56 if (co->NumberOfSat[s] && (type == COTYPE_AUTO || type == corType[s][i]) && (co->Supplied[i] ||
57 (i <= COBOFS_CLOCK && co->Supplied[COBOFS_COMBINED]) ||
58 (i == COBOFS_COMBINED && co->Supplied[COBOFS_ORBIT] && co->Supplied[COBOFS_CLOCK]))) {
59 status[s][i] = 1;
60 if (i == COBOFS_COMBINED) {
61 status[s][COBOFS_ORBIT] = status[s][COBOFS_CLOCK] = 0;
62 } /* disable single blocks for combined type */
63 } /* check for data */
64 } /* iterate over RTCM data types */
65 } /* iterate over satellite systems */
66
67 for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
68 if (status[s][COBOFS_ORBIT]) {
69 INITBLOCK
70 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_ORBIT])
71 switch (s) {
72 case CLOCKORBIT_SATGPS:
73 case CLOCKORBIT_SATGALILEO:
74 case CLOCKORBIT_SATQZSS:
75 case CLOCKORBIT_SATSBAS:
76 case CLOCKORBIT_SATBDS:
77 E_GPS_EPOCH_TIME(co->EpochTime[s])
78 break;
79 case CLOCKORBIT_SATGLONASS:
80 E_GLONASS_EPOCH_TIME(co->EpochTime[s])
81 break;
82 }
83 E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
84 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
85 E_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
86 E_SSR_IOD(co->SSRIOD)
87 E_SSR_PROVIDER_ID(co->SSRProviderID)
88 E_SSR_SOLUTION_ID(co->SSRSolutionID)
89 E_NO_OF_SATELLITES(co->NumberOfSat[s])
90 for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
91 switch (s) {
92 case CLOCKORBIT_SATGPS:
93 E_GPS_SATELLITE_ID(co->Sat[i].ID)
94 E_GPS_IODE(co->Sat[i].IOD)
95 break;
96 case CLOCKORBIT_SATGLONASS:
97 E_GLONASS_SATELLITE_ID(co->Sat[i].ID)
98 E_GLONASS_IOD(co->Sat[i].IOD)
99 break;
100 case CLOCKORBIT_SATGALILEO:
101 E_GPS_SATELLITE_ID(co->Sat[i].ID)
102 E_GALILEO_IOD(co->Sat[i].IOD)
103 break;
104 case CLOCKORBIT_SATQZSS:
105 E_QZSS_SATELLITE_ID(co->Sat[i].ID)
106 E_GPS_IODE(co->Sat[i].IOD)
107 break;
108 case CLOCKORBIT_SATSBAS:
109 E_GPS_SATELLITE_ID(co->Sat[i].ID)
110 E_SBAS_T0MOD(co->Sat[i].toe)
111 E_SBAS_IODCRC(co->Sat[i].IOD)
112 break;
113 case CLOCKORBIT_SATBDS:
114 E_GPS_SATELLITE_ID(co->Sat[i].ID)
115 E_BDS_IOD(co->Sat[i].IOD)
116 break;
117 }
118 E_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
119 E_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
120 E_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
121 E_DOT_DELTA_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
122 E_DOT_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
123 E_DOT_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
124 }
125 ENDBLOCK
126 }
127 if (status[s][COBOFS_CLOCK]) {
128 INITBLOCK
129 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_CLOCK])
130 switch (s) {
131 case CLOCKORBIT_SATGPS:
132 case CLOCKORBIT_SATGALILEO:
133 case CLOCKORBIT_SATQZSS:
134 case CLOCKORBIT_SATSBAS:
135 case CLOCKORBIT_SATBDS:
136 E_GPS_EPOCH_TIME(co->EpochTime[s])
137 break;
138 case CLOCKORBIT_SATGLONASS:
139 E_GLONASS_EPOCH_TIME(co->EpochTime[s])
140 break;
141 }
142 E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
143 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
144 E_SSR_IOD(co->SSRIOD)
145 E_SSR_PROVIDER_ID(co->SSRProviderID)
146 E_SSR_SOLUTION_ID(co->SSRSolutionID)
147 E_NO_OF_SATELLITES(co->NumberOfSat[s])
148 for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
149 E_GPS_SATELLITE_ID(co->Sat[i].ID)
150 E_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
151 E_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
152 E_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
153 }
154 ENDBLOCK
155 }
156 if (status[s][COBOFS_COMBINED]) {
157#ifdef SPLITBLOCK
158 unsigned int nums = co->NumberOfSat[s];
159 unsigned int left, start = satoffset[s];
160 if(nums > 28) {/* split block when more than 28 sats */
161 left = nums - 28;
162 nums = 28;
163 }
164 else {
165 left = 0;
166 }
167 while(nums) {
168#endif
169 INITBLOCK
170 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_COMBINED])
171 switch (s) {
172 case CLOCKORBIT_SATGPS:
173 case CLOCKORBIT_SATGALILEO:
174 case CLOCKORBIT_SATQZSS:
175 case CLOCKORBIT_SATSBAS:
176 case CLOCKORBIT_SATBDS:
177 E_GPS_EPOCH_TIME(co->EpochTime[s])
178 break;
179 case CLOCKORBIT_SATGLONASS:
180 E_GLONASS_EPOCH_TIME(co->EpochTime[s])
181 break;
182 }
183 E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
184#ifdef SPLITBLOCK
185 E_MULTIPLE_MESSAGE_INDICATOR((moremessagesfollow || left) ? 1 : 0)
186#else
187 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
188#endif
189 E_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
190 E_SSR_IOD(co->SSRIOD)
191 E_SSR_PROVIDER_ID(co->SSRProviderID)
192 E_SSR_SOLUTION_ID(co->SSRSolutionID)
193#ifdef SPLITBLOCK
194 E_NO_OF_SATELLITES(nums)
195 for(i = start; i < start+nums; ++i)
196#else
197 E_NO_OF_SATELLITES(co->NumberOfSat[s])
198 for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i)
199#endif
200 {
201 switch (s) {
202 case CLOCKORBIT_SATGPS:
203 E_GPS_SATELLITE_ID(co->Sat[i].ID)
204 E_GPS_IODE(co->Sat[i].IOD)
205 break;
206 case CLOCKORBIT_SATGLONASS:
207 E_GLONASS_SATELLITE_ID(co->Sat[i].ID)
208 E_GLONASS_IOD(co->Sat[i].IOD)
209 break;
210 case CLOCKORBIT_SATGALILEO:
211 E_GPS_SATELLITE_ID(co->Sat[i].ID)
212 E_GALILEO_IOD(co->Sat[i].IOD)
213 break;
214 case CLOCKORBIT_SATQZSS:
215 E_QZSS_SATELLITE_ID(co->Sat[i].ID)
216 E_GPS_IODE(co->Sat[i].IOD)
217 break;
218 case CLOCKORBIT_SATSBAS:
219 E_GPS_SATELLITE_ID(co->Sat[i].ID)
220 E_SBAS_T0MOD(co->Sat[i].toe)
221 E_SBAS_IODCRC(co->Sat[i].IOD)
222 break;
223 case CLOCKORBIT_SATBDS:
224 E_GPS_SATELLITE_ID(co->Sat[i].ID)
225 E_BDS_IOD(co->Sat[i].IOD)
226 break;
227 }
228 E_DELTA_RADIAL(co->Sat[i].Orbit.DeltaRadial)
229 E_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DeltaAlongTrack)
230 E_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DeltaCrossTrack)
231 E_DOT_DELTA_RADIAL(co->Sat[i].Orbit.DotDeltaRadial)
232 E_DOT_DELTA_ALONG_TRACK(co->Sat[i].Orbit.DotDeltaAlongTrack)
233 E_DOT_DELTA_CROSS_TRACK(co->Sat[i].Orbit.DotDeltaCrossTrack)
234 E_DELTA_CLOCK_C0(co->Sat[i].Clock.DeltaA0)
235 E_DELTA_CLOCK_C1(co->Sat[i].Clock.DeltaA1)
236 E_DELTA_CLOCK_C2(co->Sat[i].Clock.DeltaA2)
237 }
238 ENDBLOCK
239#ifdef SPLITBLOCK
240 start += nums;
241 nums = left;
242 left = 0;
243 }
244#endif
245 }
246 if (status[s][COBOFS_HR]) {
247 INITBLOCK
248 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_HR])
249 switch (s) {
250 case CLOCKORBIT_SATGPS:
251 case CLOCKORBIT_SATGALILEO:
252 case CLOCKORBIT_SATQZSS:
253 case CLOCKORBIT_SATSBAS:
254 case CLOCKORBIT_SATBDS:
255 E_GPS_EPOCH_TIME(co->EpochTime[s])
256 break;
257 case CLOCKORBIT_SATGLONASS:
258 E_GLONASS_EPOCH_TIME(co->EpochTime[s])
259 break;
260 }
261 E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
262 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
263 E_SSR_IOD(co->SSRIOD)
264 E_SSR_PROVIDER_ID(co->SSRProviderID)
265 E_SSR_SOLUTION_ID(co->SSRSolutionID)
266 E_NO_OF_SATELLITES(co->NumberOfSat[s])
267 for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
268 E_GPS_SATELLITE_ID(co->Sat[i].ID)
269 E_HR_CLOCK_CORRECTION(co->Sat[i].hrclock)
270 }
271 ENDBLOCK
272 }
273 if (status[s][COBOFS_URA]) {
274 INITBLOCK
275 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_URA])
276 switch (s) {
277 case CLOCKORBIT_SATGPS:
278 case CLOCKORBIT_SATGALILEO:
279 case CLOCKORBIT_SATQZSS:
280 case CLOCKORBIT_SATSBAS:
281 case CLOCKORBIT_SATBDS:
282 E_GPS_EPOCH_TIME(co->EpochTime[s])
283 break;
284 case CLOCKORBIT_SATGLONASS:
285 E_GLONASS_EPOCH_TIME(co->EpochTime[s])
286 break;
287 }
288 E_SSR_UPDATE_INTERVAL(co->UpdateInterval)
289 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
290 E_SSR_IOD(co->SSRIOD)
291 E_SSR_PROVIDER_ID(co->SSRProviderID)
292 E_SSR_SOLUTION_ID(co->SSRSolutionID)
293 E_NO_OF_SATELLITES(co->NumberOfSat[s])
294 for (i = satoffset[s]; i < satoffset[s] + co->NumberOfSat[s]; ++i) {
295 E_GPS_SATELLITE_ID(co->Sat[i].ID)
296 E_SSR_URA(ValueToURA(co->Sat[i].UserRangeAccuracy))
297 }
298 ENDBLOCK
299 }
300 }
301 return ressize;
302}
303
304size_t SsrCorrRtcmNew::MakeCodeBias(const struct CodeBias *b, CodeBiasType type,
305 int moremessagesfollow, char *buffer, size_t size) {
306 unsigned int s, i, j;
307
308 STARTDATA
309
310 for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
311 if (b->NumberOfSat[s] && (type == CBTYPE_AUTO || type == corType[s][COBOFS_CBIAS])) {
312 INITBLOCK
313 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_CBIAS])
314 switch (s) {
315 case CLOCKORBIT_SATGPS:
316 case CLOCKORBIT_SATGALILEO:
317 case CLOCKORBIT_SATQZSS:
318 case CLOCKORBIT_SATSBAS:
319 case CLOCKORBIT_SATBDS:
320 E_GPS_EPOCH_TIME(b->EpochTime[s])
321 break;
322 case CLOCKORBIT_SATGLONASS:
323 E_GLONASS_EPOCH_TIME(b->EpochTime[s])
324 break;
325 }
326 E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
327 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
328 E_SSR_IOD(b->SSRIOD)
329 E_SSR_PROVIDER_ID(b->SSRProviderID)
330 E_SSR_SOLUTION_ID(b->SSRSolutionID)
331 E_NO_OF_SATELLITES(b->NumberOfSat[s])
332 for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
333 E_GPS_SATELLITE_ID(b->Sat[i].ID)
334 E_NO_OF_BIASES(b->Sat[i].NumberOfCodeBiases)
335 for (j = 0; j < b->Sat[i].NumberOfCodeBiases; ++j) {
336 E_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
337 E_CODE_BIAS(b->Sat[i].Biases[j].Bias)
338 }
339 }
340 ENDBLOCK
341 }
342 }
343 return ressize;
344}
345
346size_t SsrCorrRtcmNew::MakePhaseBias(const struct PhaseBias *b, PhaseBiasType type,
347 int moremessagesfollow, char *buffer, size_t size) {
348 unsigned int s, i, j;
349
350 STARTDATA
351
352 for (s = 0; s < CLOCKORBIT_SATNUM; ++s) {
353 /* Satellite Phase Bias Message */
354 if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == corType[s][COBOFS_PBIAS])) {
355 INITBLOCK
356 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_PBIAS])
357 switch (s) {
358 case CLOCKORBIT_SATGPS:
359 case CLOCKORBIT_SATGALILEO:
360 case CLOCKORBIT_SATQZSS:
361 case CLOCKORBIT_SATSBAS:
362 case CLOCKORBIT_SATBDS:
363 E_GPS_EPOCH_TIME(b->EpochTime[s])
364 break;
365 case CLOCKORBIT_SATGLONASS:
366 E_GLONASS_EPOCH_TIME(b->EpochTime[s])
367 break;
368 }
369 E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
370 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
371 E_SSR_IOD(b->SSRIOD)
372 E_SSR_PROVIDER_ID(b->SSRProviderID)
373 E_SSR_SOLUTION_ID(b->SSRSolutionID)
374 E_YAW_INFO_INDICATOR(b->SatelliteYawInformationIndicator)
375 E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
376 E_NO_OF_SATELLITES(b->NumberOfSat[s])
377 for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
378 E_GPS_SATELLITE_ID(b->Sat[i].ID)
379 E_NO_OF_BIASES(b->Sat[i].NumberOfPhaseBiases)
380 if (b->SatelliteYawInformationIndicator) {
381 E_YAW_ANGLE(b->Sat[i].YawAngle)
382 E_YAW_RATE(b->Sat[i].YawRate)
383 }
384 for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
385 E_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
386 E_INTEGER_INDICATOR(b->Sat[i].Biases[j].IntegerIndicator ? 1 : 0)
387 E_DISCONTINUITY_COUNTER(b->Sat[i].Biases[j].DiscontinuityCounter)
388 E_PHASE_BIAS_CORRECTION(b->Sat[i].Biases[j].Bias)
389 }
390 }
391 ENDBLOCK
392 }
393 /* Extended Satellite Phase Bias Message
394 The Widelane Signal Group Indicator shall be releated for every satellite and signal
395 included in the corresponding Satellite Phase Bias Message in the same order. The
396 Extended Satellite Phase Bias Message shall be sent BEFORE the corresponding
397 Satellite Phase Bias Message VICE VERSA??*/
398 if (b->NumberOfSat[s] && (type == PBEXTTYPE_AUTO || type == corType[s][COBOFS_PBEXT])) {
399 INITBLOCK
400 E_RTCM_MESSAGE_NUMBER(corType[s][COBOFS_PBEXT])
401 switch (s) {
402 case CLOCKORBIT_SATGPS:
403 case CLOCKORBIT_SATGALILEO:
404 case CLOCKORBIT_SATQZSS:
405 case CLOCKORBIT_SATSBAS:
406 case CLOCKORBIT_SATBDS:
407 E_GPS_EPOCH_TIME(b->EpochTime[s])
408 break;
409 case CLOCKORBIT_SATGLONASS:
410 E_GLONASS_EPOCH_TIME(b->EpochTime[s])
411 break;
412 }
413 E_SSR_IOD(b->SSRIOD)
414 E_SSR_PROVIDER_ID(b->SSRProviderID)
415 E_SSR_SOLUTION_ID(b->SSRSolutionID)
416 E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
417 for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
418 for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
419 E_WIDE_LANE_INDICATOR(b->Sat[i].Biases[j].WidelaneGroupIndicator)
420 }
421 }
422 ENDBLOCK
423 }
424 }
425 return ressize;
426}
427
428size_t SsrCorrRtcmNew::MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, size_t size) {
429 unsigned int l, o, d;
430
431 STARTDATA
432 INITBLOCK
433 E_RTCM_MESSAGE_NUMBER(VTEC_BASE)
434 E_GPS_EPOCH_TIME(v->EpochTime)
435 E_SSR_UPDATE_INTERVAL(v->UpdateInterval)
436 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
437 E_SSR_IOD(v->SSRIOD)
438 E_SSR_PROVIDER_ID(v->SSRProviderID)
439 E_SSR_SOLUTION_ID(v->SSRSolutionID)
440 E_VTEC_QUALITY_INDICATOR(v->Quality)
441 E_NO_IONO_LAYERS(v->NumLayers)
442 for (l = 0; l < v->NumLayers; ++l) {
443 E_IONO_HEIGHT(v->Layers[l].Height)
444 E_IONO_DEGREE(v->Layers[l].Degree)
445 E_IONO_ORDER(v->Layers[l].Order)
446 for (o = 0; o <= v->Layers[l].Order; ++o) {
447 for (d = o; d <= v->Layers[l].Degree; ++d) {
448 E_IONO_COEFF_C(v->Layers[l].Cosinus[d][o])
449 }
450 }
451 for (o = 1; o <= v->Layers[l].Order; ++o) {
452 for (d = o; d <= v->Layers[l].Degree; ++d) {
453 E_IONO_COEFF_S(v->Layers[l].Sinus[d][o])
454 }
455 }
456 }
457 ENDBLOCK
458 return ressize;
459}
460
461enum GCOB_RETURN SsrCorrRtcmNew::GetSSR(struct ClockOrbit *co, struct CodeBias *b,struct VTEC *v,
462 struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused) {
463 int mmi = 0, h, rs;
464 unsigned int type, pos, i, j, s, nums, id;
465 size_t sizeofrtcmblock;
466 const char *blockstart = buffer;
467 DECODESTART
468
469 if (size < 7)
470 return GCOBR_SHORTBUFFER;
471
472#ifdef BNC_DEBUG_SSR
473 fprintf(stderr, "GetSSR-RTCM START: size %d, numbits %d\n",(int)size, numbits);
474#endif
475
476 D_HEADER(h)
477 D_RESERVEDH(rs)
478 D_SIZE(sizeofrtcmblock);
479
480 if ((unsigned char) h != 0xD3 || rs)
481 return GCOBR_UNKNOWNDATA;
482
483 if (size < sizeofrtcmblock + 3) /* 3 header bytes already removed */
484 return GCOBR_MESSAGEEXCEEDSBUFFER;
485
486 if (CRC24(sizeofrtcmblock + 3, (const unsigned char *) blockstart) !=
487 (uint32_t) ((((unsigned char) buffer[sizeofrtcmblock]) << 16) |
488 (((unsigned char) buffer[sizeofrtcmblock + 1]) << 8) |
489 (((unsigned char) buffer[sizeofrtcmblock + 2]))))
490 return GCOBR_CRCMISMATCH;
491
492 size = sizeofrtcmblock; /* reduce size, so overflows are detected */
493
494 D_RTCM_MESSAGE_NUMBER(type)
495
496#ifdef BNC_DEBUG_SSR
497 fprintf(stderr, "type %d size %d\n",type,(int)sizeofrtcmblock);
498#endif
499
500 if (bytesused)
501 *bytesused = sizeofrtcmblock + 6;
502
503 if (type == VTEC_BASE) {
504 unsigned int l, o, d;
505 if (!v)
506 return GCOBR_NOVTECPARAMETER;
507 memset(v, 0, sizeof(*v));
508 D_GPS_EPOCH_TIME(v->EpochTime)
509 D_SSR_UPDATE_INTERVAL(v->UpdateInterval)
510 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
511 D_SSR_IOD(v->SSRIOD)
512 D_SSR_PROVIDER_ID(v->SSRProviderID)
513 D_SSR_SOLUTION_ID(v->SSRSolutionID)
514 D_VTEC_QUALITY_INDICATOR(v->Quality)
515 D_NO_IONO_LAYERS(v->NumLayers)
516#ifdef BNC_DEBUG_SSR
517 fprintf(stderr, "epochTime %d ui %d mmi %d ssrIod %d providerId %d solId %d vtecQ %8.3f numLay %d \n",
518 v->EpochTime, v->UpdateInterval, mmi,
519 v->SSRIOD, v->SSRProviderID, v->SSRSolutionID, v->Quality, v->NumLayers);
520#endif
521 for (l = 0; l < v->NumLayers; ++l) {
522 D_IONO_HEIGHT(v->Layers[l].Height)
523 D_IONO_DEGREE(v->Layers[l].Degree)
524 D_IONO_ORDER(v->Layers[l].Order)
525#ifdef BNC_DEBUG_SSR
526 fprintf(stderr, "h %8.3f deg %d ord %d \n",
527 v->Layers[l].Height, v->Layers[l].Degree, v->Layers[l].Order);
528#endif
529 for (o = 0; o <= v->Layers[l].Order; ++o) {
530 for (d = o; d <= v->Layers[l].Degree; ++d) {
531 D_IONO_COEFF_C(v->Layers[l].Cosinus[d][o])
532#ifdef BNC_DEBUG_SSR
533 fprintf(stderr, "C[%02d][%02d] %8.3f \n",
534 d, o, v->Layers[l].Cosinus[d][o]);
535#endif
536 }
537 }
538 for (o = 1; o <= v->Layers[l].Order; ++o) {
539 for (d = o; d <= v->Layers[l].Degree; ++d) {
540 D_IONO_COEFF_S(v->Layers[l].Sinus[d][o])
541#ifdef BNC_DEBUG_SSR
542 fprintf(stderr, "S[%02d][%02d] %8.3f \n",
543 d, o, v->Layers[l].Sinus[d][o]);
544#endif
545 }
546 }
547 }
548#ifdef BNC_DEBUG_SSR
549 for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
550 numbits += 8;
551 fprintf(stderr, "numbits left %d\n",numbits);
552#endif
553 return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
554 }
555
556 {
557 unsigned int kind;
558 if (!lookupCorType(type, s, kind))
559 return GCOBR_UNKNOWNTYPE;
560
561 /* COBOFS_* are per-instance (set in setCorType()), not compile-time
562 constants, so this has to be an if/else-if chain rather than a switch. */
563 if (kind == COBOFS_PBIAS) {
564 if (!pb)
565 return GCOBR_NOPHASEBIASPARAMETER;
566 pb->messageType = type;
567 /* Header Part*/
568 switch (s) {
569 case CLOCKORBIT_SATGPS:
570 case CLOCKORBIT_SATGALILEO:
571 case CLOCKORBIT_SATQZSS:
572 case CLOCKORBIT_SATSBAS:
573 case CLOCKORBIT_SATBDS:
574 D_GPS_EPOCH_TIME_CHECK(pb->EpochTime[s], pb->NumberOfSat[s])
575 break;
576 case CLOCKORBIT_SATGLONASS:
577 D_GLONASS_EPOCH_TIME_CHECK(pb->EpochTime[s], pb->NumberOfSat[s])
578 break;
579 }
580 D_SSR_UPDATE_INTERVAL(pb->UpdateInterval)
581 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
582 D_SSR_IOD(pb->SSRIOD)
583 D_SSR_PROVIDER_ID(pb->SSRProviderID)
584 D_SSR_SOLUTION_ID(pb->SSRSolutionID)
585 D_YAW_INFO_INDICATOR(pb->SatelliteYawInformationIndicator)
586 D_EXTENDED_PHASE_BIAS_ID(pb->ExtendedPhaseBiasPropertyID)
587 D_NO_OF_SATELLITES(nums)
588#ifdef BNC_DEBUG_SSR
589 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d yawInd %d extpbInd %d\n",
590 pb->EpochTime[s], pb->UpdateInterval,mmi,pb->NumberOfSat[s],nums,
591 pb->SSRIOD, pb->SSRProviderID, pb->SSRSolutionID,
592 pb->SatelliteYawInformationIndicator, pb->ExtendedPhaseBiasPropertyID);
593#endif
594 /* Satellite Specific Part*/
595 for (i = 0; i < nums; ++i) {
596 D_GPS_SATELLITE_ID(id)
597 for (pos = satoffset[s];
598 pos < satoffset[s] + pb->NumberOfSat[s] && pb->Sat[pos].ID != id;
599 ++pos)
600 ;
601 if (pos >= satoffset[s + 1])
602 return GCOBR_DATAMISMATCH;
603 else if (pos == pb->NumberOfSat[s] + satoffset[s])
604 ++pb->NumberOfSat[s];
605 pb->Sat[pos].ID = id;
606 D_NO_OF_BIASES(pb->Sat[pos].NumberOfPhaseBiases)
607 if (pb->SatelliteYawInformationIndicator) {
608 D_YAW_ANGLE(pb->Sat[pos].YawAngle)
609 D_YAW_RATE(pb->Sat[pos].YawRate)
610 }
611#ifdef BNC_DEBUG_SSR
612 fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ",
613 pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases,
614 pb->Sat[pos].YawAngle/MPI, pb->Sat[pos].YawRate/MPI);
615#endif
616 /* Signal Specific Part */
617 for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
618 D_GNSS_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type)
619 D_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].IntegerIndicator)
620 D_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].DiscontinuityCounter)
621 D_PHASE_BIAS_CORRECTION(pb->Sat[pos].Biases[j].Bias)
622#ifdef BNC_DEBUG_SSR
623 fprintf(stderr, "t %02d int %02d disc %d b %8.4f ",
624 pb->Sat[pos].Biases[j].Type,
625 pb->Sat[pos].Biases[j].IntegerIndicator,
626 pb->Sat[pos].Biases[j].DiscontinuityCounter,
627 pb->Sat[pos].Biases[j].Bias);
628#endif
629 }
630#ifdef BNC_DEBUG_SSR
631 fprintf(stderr, "\n");
632#endif
633 }
634 }
635 else if (kind == COBOFS_PBEXT) {
636 unsigned int EpochTime, SSRIOD, SSRProviderID, SSRSolutionID, ExtendedPhaseBiasPropertyID;
637 if (!pb)
638 return GCOBR_NOPHASEBIASPARAMETER;
639 pb->messageExtType = type;
640 switch (s) {
641 case CLOCKORBIT_SATGPS:
642 case CLOCKORBIT_SATGALILEO:
643 case CLOCKORBIT_SATQZSS:
644 case CLOCKORBIT_SATSBAS:
645 case CLOCKORBIT_SATBDS:
646 D_GPS_EPOCH_TIME(EpochTime)
647 break;
648 case CLOCKORBIT_SATGLONASS:
649 D_GLONASS_EPOCH_TIME(EpochTime)
650 break;
651 }
652 D_SSR_IOD(SSRIOD)
653 D_SSR_PROVIDER_ID(SSRProviderID)
654 D_SSR_SOLUTION_ID(SSRSolutionID)
655 D_EXTENDED_PHASE_BIAS_ID(ExtendedPhaseBiasPropertyID)
656#ifdef BNC_DEBUG_SSR
657 fprintf(stderr, "epochTime %d/%d ssrIod %d/%d providerId %d/%d solId %d/%d extpbInd %d/%d \n",
658 EpochTime, pb->EpochTime[s],
659 SSRIOD, pb->SSRIOD,
660 SSRProviderID, pb->SSRProviderID,
661 SSRSolutionID, pb->SSRSolutionID,
662 ExtendedPhaseBiasPropertyID, pb->ExtendedPhaseBiasPropertyID);
663#endif
664 if (EpochTime == pb->EpochTime[s] &&
665 ExtendedPhaseBiasPropertyID == pb->ExtendedPhaseBiasPropertyID) {
666 for (i = 0; i < pb->NumberOfSat[s]; ++i) {
667 for (pos = satoffset[s];
668 pos < satoffset[s] + pb->NumberOfSat[s];
669 ++pos)
670 ;
671 if (pos >= satoffset[s + 1])
672 return GCOBR_DATAMISMATCH;
673 else if (pos == pb->NumberOfSat[s] + satoffset[s])
674 ++pb->NumberOfSat[s];
675#ifdef BNC_DEBUG_SSR
676 fprintf(stderr, "id %2d ", pb->Sat[pos].ID);
677#endif
678 for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
679 D_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].WidelaneGroupIndicator)
680#ifdef BNC_DEBUG_SSR
681 fprintf(stderr, "t %02d wl %d ",
682 pb->Sat[pos].Biases[j].Type,
683 pb->Sat[pos].Biases[j].WidelaneGroupIndicator);
684#endif
685 }
686#ifdef BNC_DEBUG_SSR
687 fprintf(stderr, "\n");
688#endif
689 }
690 }
691 }
692 else if (kind == COBOFS_ORBIT) {
693 if (!co)
694 return GCOBR_NOCLOCKORBITPARAMETER;
695 co->messageType = type;
696 switch (s) {
697 case CLOCKORBIT_SATGPS:
698 case CLOCKORBIT_SATGALILEO:
699 case CLOCKORBIT_SATQZSS:
700 case CLOCKORBIT_SATSBAS:
701 case CLOCKORBIT_SATBDS:
702 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
703 break;
704 case CLOCKORBIT_SATGLONASS:
705 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
706 break;
707 }
708 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
709 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
710 D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
711 D_SSR_IOD(co->SSRIOD)
712 D_SSR_PROVIDER_ID(co->SSRProviderID)
713 D_SSR_SOLUTION_ID(co->SSRSolutionID)
714 D_NO_OF_SATELLITES(nums)
715 co->Supplied[COBOFS_ORBIT] |= 1;
716#ifdef BNC_DEBUG_SSR
717 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
718 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
719 co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
720#endif
721 for (i = 0; i < nums; ++i) {
722 D_GPS_SATELLITE_ID(id)
723 for (pos = satoffset[s];
724 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
725 ++pos)
726 ;
727 if (pos >= satoffset[s + 1])
728 return GCOBR_DATAMISMATCH;
729 else if (pos == co->NumberOfSat[s] + satoffset[s])
730 ++co->NumberOfSat[s];
731 co->Sat[pos].ID = id;
732
733 switch (s) {
734 case CLOCKORBIT_SATGPS:
735 case CLOCKORBIT_SATQZSS:
736 D_GPS_IODE(co->Sat[pos].IOD)
737 break;
738 case CLOCKORBIT_SATGLONASS:
739 D_GLONASS_IOD(co->Sat[pos].IOD)
740 break;
741 case CLOCKORBIT_SATGALILEO:
742 D_GALILEO_IOD(co->Sat[pos].IOD)
743 break;
744 case CLOCKORBIT_SATSBAS:
745 D_SBAS_T0MOD(co->Sat[pos].toe)
746 D_SBAS_IODCRC(co->Sat[pos].IOD)
747 break;
748 case CLOCKORBIT_SATBDS:
749 D_GPS_IODE(co->Sat[pos].IOD)
750 break;
751 }
752 D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
753 D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
754 D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
755 D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
756 D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
757 D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
758#ifdef BNC_DEBUG_SSR
759 fprintf(stderr, "id %2d iod %3d dr %8.4f da %8.4f dc %8.4f dr %8.3f da %8.3f dc %8.3f\n",
760 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
761 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
762 co->Sat[pos].Orbit.DotDeltaRadial,
763 co->Sat[pos].Orbit.DotDeltaAlongTrack,
764 co->Sat[pos].Orbit.DotDeltaCrossTrack);
765#endif
766 }
767 }
768 else if (kind == COBOFS_CLOCK) {
769 if (!co)
770 return GCOBR_NOCLOCKORBITPARAMETER;
771 co->messageType = type;
772 switch (s) {
773 case CLOCKORBIT_SATGPS:
774 case CLOCKORBIT_SATGALILEO:
775 case CLOCKORBIT_SATQZSS:
776 case CLOCKORBIT_SATSBAS:
777 case CLOCKORBIT_SATBDS:
778 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
779 break;
780 case CLOCKORBIT_SATGLONASS:
781 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
782 break;
783 }
784 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
785 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
786 D_SSR_IOD(co->SSRIOD)
787 D_SSR_PROVIDER_ID(co->SSRProviderID)
788 D_SSR_SOLUTION_ID(co->SSRSolutionID)
789 D_NO_OF_SATELLITES(nums)
790 co->Supplied[COBOFS_CLOCK] |= 1;
791#ifdef BNC_DEBUG_SSR
792 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
793 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
794 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
795#endif
796 for (i = 0; i < nums; ++i) {
797 D_GPS_SATELLITE_ID(id)
798 for (pos = satoffset[s];
799 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
800 ++pos)
801 ;
802 if (pos >= satoffset[s + 1])
803 return GCOBR_DATAMISMATCH;
804 else if (pos == co->NumberOfSat[s] + satoffset[s])
805 ++co->NumberOfSat[s];
806 co->Sat[pos].ID = id;
807
808 D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
809 D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
810 D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
811#ifdef BNC_DEBUG_SSR
812 fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n",
813 co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1,
814 co->Sat[pos].Clock.DeltaA2);
815#endif
816 }
817 }
818 else if (kind == COBOFS_COMBINED) {
819 if (!co)
820 return GCOBR_NOCLOCKORBITPARAMETER;
821 co->messageType = type;
822 switch (s) {
823 case CLOCKORBIT_SATGPS:
824 case CLOCKORBIT_SATGALILEO:
825 case CLOCKORBIT_SATQZSS:
826 case CLOCKORBIT_SATSBAS:
827 case CLOCKORBIT_SATBDS:
828 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
829 break;
830 case CLOCKORBIT_SATGLONASS:
831 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
832 break;
833 }
834 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
835 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
836 D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
837 D_SSR_IOD(co->SSRIOD)
838 D_SSR_PROVIDER_ID(co->SSRProviderID)
839 D_SSR_SOLUTION_ID(co->SSRSolutionID)
840 D_NO_OF_SATELLITES(nums)
841 co->Supplied[COBOFS_ORBIT] |= 1;
842 co->Supplied[COBOFS_CLOCK] |= 1;
843#ifdef BNC_DEBUG_SSR
844 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
845 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
846 co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
847#endif
848 for (i = 0; i < nums; ++i) {
849 D_GPS_SATELLITE_ID(id)
850 for (pos = satoffset[s];
851 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
852 ++pos)
853 ;
854 if (pos >= satoffset[s + 1])
855 return GCOBR_DATAMISMATCH;
856 else if (pos == co->NumberOfSat[s] + satoffset[s])
857 ++co->NumberOfSat[s];
858 co->Sat[pos].ID = id;
859
860 switch (s) {
861 case CLOCKORBIT_SATGPS:
862 case CLOCKORBIT_SATQZSS:
863 D_GPS_IODE(co->Sat[pos].IOD)
864 break;
865 case CLOCKORBIT_SATGLONASS:
866 D_GLONASS_IOD(co->Sat[pos].IOD)
867 break;
868 case CLOCKORBIT_SATGALILEO:
869 D_GALILEO_IOD(co->Sat[pos].IOD)
870 break;
871 case CLOCKORBIT_SATSBAS:
872 D_SBAS_T0MOD(co->Sat[pos].toe)
873 D_SBAS_IODCRC(co->Sat[pos].IOD)
874 break;
875 case CLOCKORBIT_SATBDS:
876 D_GPS_IODE(co->Sat[pos].IOD)
877 break;
878 }
879 D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
880 D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
881 D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
882 D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
883 D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
884 D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
885 D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
886 D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
887 D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
888#ifdef BNC_DEBUG_SSR
889 fprintf(stderr, "id %2d iod %3d dr %10.6f da %10.6f dc %10.6f dr %10.6f da %10.6f dc %10.6f c0 %10.6f c1 %10.6f c2 %10.6f\n",
890 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
891 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
892 co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack,
893 co->Sat[pos].Orbit.DotDeltaCrossTrack,
894 co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2);
895#endif
896 }
897 }
898 else if (kind == COBOFS_URA) {
899 if (!co)
900 return GCOBR_NOCLOCKORBITPARAMETER;
901 co->messageType = type;
902 switch (s) {
903 case CLOCKORBIT_SATGPS:
904 case CLOCKORBIT_SATGALILEO:
905 case CLOCKORBIT_SATQZSS:
906 case CLOCKORBIT_SATSBAS:
907 case CLOCKORBIT_SATBDS:
908 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
909 break;
910 case CLOCKORBIT_SATGLONASS:
911 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
912 break;
913 }
914 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
915 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
916 D_SSR_IOD(co->SSRIOD)
917 D_SSR_PROVIDER_ID(co->SSRProviderID)
918 D_SSR_SOLUTION_ID(co->SSRSolutionID)
919 D_NO_OF_SATELLITES(nums)
920 co->Supplied[COBOFS_URA] |= 1;
921#ifdef BNC_DEBUG_SSR
922 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
923 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
924 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
925#endif
926 for (i = 0; i < nums; ++i) {
927 D_GPS_SATELLITE_ID(id)
928 for (pos = satoffset[s];
929 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
930 ++pos)
931 ;
932 if (pos >= satoffset[s + 1])
933 return GCOBR_DATAMISMATCH;
934 else if (pos == co->NumberOfSat[s] + satoffset[s])
935 ++co->NumberOfSat[s];
936 co->Sat[pos].ID = id;
937 D_SSR_URA(co->Sat[pos].UserRangeAccuracy)
938#ifdef BNC_DEBUG_SSR
939 fprintf(stderr, "id %2d ura %8.3f \n",
940 co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy);
941#endif
942 }
943 }
944 else if (kind == COBOFS_HR) {
945 if (!co)
946 return GCOBR_NOCLOCKORBITPARAMETER;
947 co->messageType = type;
948 switch (s) {
949 case CLOCKORBIT_SATGPS:/* Phase specific part of GNSS phase bias message */
950 case CLOCKORBIT_SATGALILEO:
951 case CLOCKORBIT_SATQZSS:
952 case CLOCKORBIT_SATSBAS:
953 case CLOCKORBIT_SATBDS:
954 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
955 break;
956 case CLOCKORBIT_SATGLONASS:
957 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
958 break;
959 }
960 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
961 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
962 D_SSR_IOD(co->SSRIOD)
963 D_SSR_PROVIDER_ID(co->SSRProviderID)
964 D_SSR_SOLUTION_ID(co->SSRSolutionID)
965 D_NO_OF_SATELLITES(nums)
966 co->Supplied[COBOFS_HR] |= 1;
967#ifdef BNC_DEBUG_SSR
968 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
969 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
970 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
971#endif
972 for (i = 0; i < nums; ++i) {
973 D_GPS_SATELLITE_ID(id)
974 for (pos = satoffset[s];
975 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
976 ++pos)
977 ;
978 if (pos >= satoffset[s + 1])
979 return GCOBR_DATAMISMATCH;
980 else if (pos == co->NumberOfSat[s] + satoffset[s])
981 ++co->NumberOfSat[s];
982 co->Sat[pos].ID = id;
983 D_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock)
984#ifdef BNC_DEBUG_SSR
985 fprintf(stderr, "id %2d hrClock %8.3f \n",
986 co->Sat[pos].ID, co->Sat[pos].hrclock);
987#endif
988 }
989 }
990 else if (kind == COBOFS_CBIAS) {
991 if (!b)
992 return GCOBR_NOCODEBIASPARAMETER;
993 b->messageType = type;
994 switch (s) {
995 case CLOCKORBIT_SATGPS:
996 case CLOCKORBIT_SATGALILEO:
997 case CLOCKORBIT_SATQZSS:
998 case CLOCKORBIT_SATSBAS:
999 case CLOCKORBIT_SATBDS:
1000 D_GPS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
1001 break;
1002 case CLOCKORBIT_SATGLONASS:
1003 D_GLONASS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
1004 break;
1005 }
1006 D_SSR_UPDATE_INTERVAL(b->UpdateInterval)
1007 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
1008 D_SSR_IOD(b->SSRIOD)
1009 D_SSR_PROVIDER_ID(b->SSRProviderID)
1010 D_SSR_SOLUTION_ID(b->SSRSolutionID)
1011 D_NO_OF_SATELLITES(nums)
1012#ifdef BNC_DEBUG_SSR
1013 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
1014 b->EpochTime[s], b->UpdateInterval,mmi,b->NumberOfSat[s],nums,
1015 b->SSRIOD, b->SSRProviderID, b->SSRSolutionID);
1016#endif
1017 for (i = 0; i < nums; ++i) {
1018 D_GPS_SATELLITE_ID(id)
1019 for (pos = satoffset[s];
1020 pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id;
1021 ++pos)
1022 ;
1023 if (pos >= satoffset[s + 1])
1024 return GCOBR_DATAMISMATCH;
1025 else if (pos == b->NumberOfSat[s] + satoffset[s])
1026 ++b->NumberOfSat[s];
1027 b->Sat[pos].ID = id;
1028 D_NO_OF_BIASES(b->Sat[pos].NumberOfCodeBiases)
1029#ifdef BNC_DEBUG_SSR
1030 fprintf(stderr, "id %2d #%d ",
1031 b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases);
1032#endif
1033 for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) {
1034 D_GNSS_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type)
1035 D_CODE_BIAS(b->Sat[pos].Biases[j].Bias)
1036#ifdef BNC_DEBUG_SSR
1037 fprintf(stderr, "t %02d b %8.2f ",
1038 b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias);
1039#endif
1040 }
1041#ifdef BNC_DEBUG_SSR
1042 fprintf(stderr, "\n");
1043#endif
1044 }
1045 }
1046 else {
1047 /* COBOFS_PBEXT / COBOFS_SATANT / COBOFS_REGIONO: message numbers are
1048 recognized (see setCorType()) but decoding is not implemented yet */
1049 return GCOBR_UNKNOWNTYPE;
1050 }
1051
1052#ifdef BNC_DEBUG_SSR
1053 for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
1054 numbits += 8;
1055 fprintf(stderr, "numbits left %d\n",numbits);
1056#endif
1057 return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
1058 }
1059}
1060
1061//
1062////////////////////////////////////////////////////////////////////////////
1063std::string SsrCorrRtcmNew::codeTypeToRnxType(char system, CodeType type) {
1064 if (system == 'G') {
1065 if (type == CODETYPE_GPS_L1_CA) return "1C";
1066 if (type == CODETYPE_GPS_L1_P) return "1P";
1067 if (type == CODETYPE_GPS_L1_Z) return "1W";
1068 if (type == CODETYPE_GPS_SEMI_CODELESS) return "2D";
1069 if (type == CODETYPE_GPS_L2_CA) return "2C";
1070 if (type == CODETYPE_GPS_L2_P) return "2P";
1071 if (type == CODETYPE_GPS_L2_Z) return "2W";
1072 if (type == CODETYPE_GPS_L2C_M) return "2S";
1073 if (type == CODETYPE_GPS_L2C_L) return "2L";
1074 if (type == CODETYPE_GPS_L2C_ML) return "2X";
1075 if (type == CODETYPE_GPS_L5_I) return "5I";
1076 if (type == CODETYPE_GPS_L5_Q) return "5Q";
1077 if (type == CODETYPE_GPS_L5_IQ) return "5X";
1078 if (type == CODETYPE_GPS_L1C_D) return "1S";
1079 if (type == CODETYPE_GPS_L1C_P) return "1L";
1080 if (type == CODETYPE_GPS_L1C_DP) return "1X";
1081 }
1082 else if (system == 'R') {
1083 if (type == CODETYPE_GLONASS_L1_CA) return "1C";
1084 if (type == CODETYPE_GLONASS_L1_P) return "1P";
1085 if (type == CODETYPE_GLONASS_L2_CA) return "2C";
1086 if (type == CODETYPE_GLONASS_L2_P) return "2P";
1087 }
1088 else if (system == 'E') {
1089 if (type == CODETYPE_GALILEO_E1_A) return "1A";
1090 if (type == CODETYPE_GALILEO_E1_B) return "1B";
1091 if (type == CODETYPE_GALILEO_E1_C) return "1C";
1092 if (type == CODETYPE_GALILEO_E1_BC) return "1X";
1093 if (type == CODETYPE_GALILEO_E1_ABC) return "1Z";
1094 if (type == CODETYPE_GALILEO_E5A_I) return "5I";
1095 if (type == CODETYPE_GALILEO_E5A_Q) return "5Q";
1096 if (type == CODETYPE_GALILEO_E5A_IQ) return "5X";
1097 if (type == CODETYPE_GALILEO_E5B_I) return "7I";
1098 if (type == CODETYPE_GALILEO_E5B_Q) return "7Q";
1099 if (type == CODETYPE_GALILEO_E5B_IQ) return "7X";
1100 if (type == CODETYPE_GALILEO_E5_I) return "8I";
1101 if (type == CODETYPE_GALILEO_E5_Q) return "8Q";
1102 if (type == CODETYPE_GALILEO_E5_IQ) return "8X";
1103 if (type == CODETYPE_GALILEO_E6_A) return "6A";
1104 if (type == CODETYPE_GALILEO_E6_B) return "6B";
1105 if (type == CODETYPE_GALILEO_E6_C) return "6C";
1106 if (type == CODETYPE_GALILEO_E6_BC) return "6X";
1107 if (type == CODETYPE_GALILEO_E6_ABC) return "6Z";
1108 }
1109 else if (system == 'J') {
1110 if (type == CODETYPE_QZSS_L1_CA) return "1C";
1111 if (type == CODETYPE_QZSS_L1C_D) return "1S";
1112 if (type == CODETYPE_QZSS_L1C_P) return "1L";
1113 if (type == CODETYPE_QZSS_L2C_M) return "2S";
1114 if (type == CODETYPE_QZSS_L2C_L) return "2L";
1115 if (type == CODETYPE_QZSS_L2C_ML) return "2X";
1116 if (type == CODETYPE_QZSS_L5_I) return "5I";
1117 if (type == CODETYPE_QZSS_L5_Q) return "5Q";
1118 if (type == CODETYPE_QZSS_L5_IQ) return "5X";
1119 if (type == CODETYPE_QZSS_L6_D) return "6S";
1120 if (type == CODETYPE_QZSS_L6_P) return "6L";
1121 if (type == CODETYPE_QZSS_L6_DP) return "6X";
1122 if (type == CODETYPE_QZSS_L1C_DP) return "1X";
1123 }
1124 else if (system == 'C') {
1125 if (type == CODETYPE_BDS_B1_I) return "2I";
1126 if (type == CODETYPE_BDS_B1_Q) return "2Q";
1127 if (type == CODETYPE_BDS_B1_IQ) return "2X";
1128 if (type == CODETYPE_BDS_B3_I) return "6I";
1129 if (type == CODETYPE_BDS_B3_Q) return "6Q";
1130 if (type == CODETYPE_BDS_B3_IQ) return "6X";
1131 if (type == CODETYPE_BDS_B2_I) return "7I";
1132 if (type == CODETYPE_BDS_B2_Q) return "7Q";
1133 if (type == CODETYPE_BDS_B2_IQ) return "7X";
1134 if (type == CODETYPE_BDS_B1C_D) return "1D";
1135 if (type == CODETYPE_BDS_B1C_P) return "1P";
1136 if (type == CODETYPE_BDS_B1C_DP) return "1X";
1137 if (type == CODETYPE_BDS_B2a_D) return "5D";
1138 if (type == CODETYPE_BDS_B2a_P) return "5P";
1139 if (type == CODETYPE_BDS_B2a_DP) return "5X";
1140 if (type == CODETYPE_BDS_B2b_D) return "7D";
1141 }
1142
1143 return "";
1144}
1145
1146//
1147////////////////////////////////////////////////////////////////////////////
1148SsrCorr::CodeType SsrCorrRtcmNew::rnxTypeToCodeType(char system, std::string type) {
1149 if (system == 'G') {
1150 if (type.compare("1C") == 0) {return CODETYPE_GPS_L1_CA;}
1151 if (type.compare("1P") == 0) {return CODETYPE_GPS_L1_P;}
1152 if (type.compare("1W") == 0) {return CODETYPE_GPS_L1_Z;}
1153 if (type.compare("2D") == 0) {return CODETYPE_GPS_SEMI_CODELESS;}
1154 if (type.compare("2C") == 0) {return CODETYPE_GPS_L2_CA;}
1155 if (type.compare("2P") == 0) {return CODETYPE_GPS_L2_P;}
1156 if (type.compare("2W") == 0) {return CODETYPE_GPS_L2_Z;}
1157 if (type.compare("2S") == 0) {return CODETYPE_GPS_L2C_M;}
1158 if (type.compare("2L") == 0) {return CODETYPE_GPS_L2C_L;}
1159 if (type.compare("2X") == 0) {return CODETYPE_GPS_L2C_ML;}
1160 if (type.compare("5I") == 0) {return CODETYPE_GPS_L5_I;}
1161 if (type.compare("5Q") == 0) {return CODETYPE_GPS_L5_Q;}
1162 if (type.compare("5X") == 0) {return CODETYPE_GPS_L5_IQ;}
1163 if (type.compare("1S") == 0) {return CODETYPE_GPS_L1C_D;}
1164 if (type.compare("1L") == 0) {return CODETYPE_GPS_L1C_P;}
1165 if (type.compare("1X") == 0) {return CODETYPE_GPS_L1C_DP;}
1166 }
1167 else if (system == 'R') {
1168 if (type.compare("1C") == 0) {return CODETYPE_GLONASS_L1_CA;}
1169 if (type.compare("1P") == 0) {return CODETYPE_GLONASS_L1_P;}
1170 if (type.compare("2C") == 0) {return CODETYPE_GLONASS_L2_CA;}
1171 if (type.compare("2P") == 0) {return CODETYPE_GLONASS_L2_P;}
1172 }
1173 else if (system == 'E') {
1174 if (type.compare("1A") == 0) {return CODETYPE_GALILEO_E1_A;}
1175 if (type.compare("1B") == 0) {return CODETYPE_GALILEO_E1_B;}
1176 if (type.compare("1C") == 0) {return CODETYPE_GALILEO_E1_C;}
1177 if (type.compare("1X") == 0) {return CODETYPE_GALILEO_E1_BC;}
1178 if (type.compare("1Z") == 0) {return CODETYPE_GALILEO_E1_ABC;}
1179 if (type.compare("5I") == 0) {return CODETYPE_GALILEO_E5A_I;}
1180 if (type.compare("5Q") == 0) {return CODETYPE_GALILEO_E5A_Q;}
1181 if (type.compare("5X") == 0) {return CODETYPE_GALILEO_E5A_IQ;}
1182 if (type.compare("7I") == 0) {return CODETYPE_GALILEO_E5B_I;}
1183 if (type.compare("7Q") == 0) {return CODETYPE_GALILEO_E5B_Q;}
1184 if (type.compare("7X") == 0) {return CODETYPE_GALILEO_E5B_IQ;}
1185 if (type.compare("8I") == 0) {return CODETYPE_GALILEO_E5_I;}
1186 if (type.compare("8Q") == 0) {return CODETYPE_GALILEO_E5_Q;}
1187 if (type.compare("8X") == 0) {return CODETYPE_GALILEO_E5_IQ;}
1188 if (type.compare("6A") == 0) {return CODETYPE_GALILEO_E6_A;}
1189 if (type.compare("6B") == 0) {return CODETYPE_GALILEO_E6_B;}
1190 if (type.compare("6C") == 0) {return CODETYPE_GALILEO_E6_C;}
1191 if (type.compare("6X") == 0) {return CODETYPE_GALILEO_E6_BC;}
1192 if (type.compare("6Z") == 0) {return CODETYPE_GALILEO_E6_ABC;}
1193 }
1194 else if (system == 'J') {
1195 if (type.compare("1C") == 0) {return CODETYPE_QZSS_L1_CA;}
1196 if (type.compare("1S") == 0) {return CODETYPE_QZSS_L1C_D;}
1197 if (type.compare("1L") == 0) {return CODETYPE_QZSS_L1C_P;}
1198 if (type.compare("2S") == 0) {return CODETYPE_QZSS_L2C_M;}
1199 if (type.compare("2L") == 0) {return CODETYPE_QZSS_L2C_L;}
1200 if (type.compare("2X") == 0) {return CODETYPE_QZSS_L2C_ML;}
1201 if (type.compare("5I") == 0) {return CODETYPE_QZSS_L5_I;}
1202 if (type.compare("5Q") == 0) {return CODETYPE_QZSS_L5_Q;}
1203 if (type.compare("5X") == 0) {return CODETYPE_QZSS_L5_IQ;}
1204 if (type.compare("6S") == 0) {return CODETYPE_QZSS_L6_D;}
1205 if (type.compare("6L") == 0) {return CODETYPE_QZSS_L6_P;}
1206 if (type.compare("6X") == 0) {return CODETYPE_QZSS_L6_DP;}
1207 if (type.compare("1X") == 0) {return CODETYPE_QZSS_L1C_DP;}
1208 }
1209 else if (system == 'C') {
1210 if (type.compare("2I") == 0) {return CODETYPE_BDS_B1_I;}
1211 if (type.compare("2Q") == 0) {return CODETYPE_BDS_B1_Q;}
1212 if (type.compare("2X") == 0) {return CODETYPE_BDS_B1_IQ;}
1213 if (type.compare("6I") == 0) {return CODETYPE_BDS_B3_I;}
1214 if (type.compare("6Q") == 0) {return CODETYPE_BDS_B3_Q;}
1215 if (type.compare("6X") == 0) {return CODETYPE_BDS_B3_IQ;}
1216 if (type.compare("7I") == 0) {return CODETYPE_BDS_B2_I;}
1217 if (type.compare("7Q") == 0) {return CODETYPE_BDS_B2_Q;}
1218 if (type.compare("7X") == 0) {return CODETYPE_BDS_B2_IQ;}
1219 if (type.compare("1D") == 0) {return CODETYPE_BDS_B1C_D;}
1220 if (type.compare("1P") == 0) {return CODETYPE_BDS_B1C_P;}
1221 if (type.compare("1X") == 0) {return CODETYPE_BDS_B1C_DP;}
1222 if (type.compare("5D") == 0) {return CODETYPE_BDS_B2a_D;}
1223 if (type.compare("5P") == 0) {return CODETYPE_BDS_B2a_P;}
1224 if (type.compare("5X") == 0) {return CODETYPE_BDS_B2a_DP;}
1225 if (type.compare("7D") == 0) {return CODETYPE_BDS_B2b_D;}
1226 }
1227
1228 return CODETYPE_RESERVED;
1229}
1230
Note: See TracBrowser for help on using the repository browser.