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

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

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