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

Last change on this file since 10998 was 10998, checked in by stuerze, 7 weeks ago

minor changes 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 E_YAW_ANGLE(b->Sat[i].YawAngle)
383 E_YAW_RATE(b->Sat[i].YawRate)
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 D_YAW_ANGLE(pb->Sat[pos].YawAngle)
608 D_YAW_RATE(pb->Sat[pos].YawRate)
609#ifdef BNC_DEBUG_SSR
610 fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ",
611 pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases,
612 pb->Sat[pos].YawAngle/MPI, pb->Sat[pos].YawRate/MPI);
613#endif
614 /* Signal Specific Part */
615 for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
616 D_GNSS_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type)
617 D_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].IntegerIndicator)
618 D_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].DiscontinuityCounter)
619 D_PHASE_BIAS_CORRECTION(pb->Sat[pos].Biases[j].Bias)
620#ifdef BNC_DEBUG_SSR
621 fprintf(stderr, "t%02d int %d disc %d b %8.4f ",
622 pb->Sat[pos].Biases[j].Type,
623 pb->Sat[pos].Biases[j].IntegerIndicator,
624 pb->Sat[pos].Biases[j].DiscontinuityCounter,
625 pb->Sat[pos].Biases[j].Bias);
626#endif
627 }
628#ifdef BNC_DEBUG_SSR
629 fprintf(stderr, "\n");
630#endif
631 }
632 }
633 else if (kind == COBOFS_PBEXT) {
634 unsigned int EpochTime, SSRIOD, SSRProviderID, SSRSolutionID, ExtendedPhaseBiasPropertyID;
635 if (!pb)
636 return GCOBR_NOPHASEBIASPARAMETER;
637 pb->messageExtType = type;
638 switch (s) {
639 case CLOCKORBIT_SATGPS:
640 case CLOCKORBIT_SATGALILEO:
641 case CLOCKORBIT_SATQZSS:
642 case CLOCKORBIT_SATSBAS:
643 case CLOCKORBIT_SATBDS:
644 D_GPS_EPOCH_TIME(EpochTime)
645 break;
646 case CLOCKORBIT_SATGLONASS:
647 D_GLONASS_EPOCH_TIME(EpochTime)
648 break;
649 }
650 D_SSR_IOD(SSRIOD)
651 D_SSR_PROVIDER_ID(SSRProviderID)
652 D_SSR_SOLUTION_ID(SSRSolutionID)
653 D_EXTENDED_PHASE_BIAS_ID(ExtendedPhaseBiasPropertyID)
654#ifdef BNC_DEBUG_SSR
655 fprintf(stderr, "epochTime %d/%d ssrIod %d/%d providerId %d/%d solId %d/%d extpbInd %d/%d \n",
656 EpochTime, pb->EpochTime[s],
657 SSRIOD, pb->SSRIOD,
658 SSRProviderID, pb->SSRProviderID,
659 SSRSolutionID, pb->SSRSolutionID,
660 ExtendedPhaseBiasPropertyID, pb->ExtendedPhaseBiasPropertyID);
661#endif
662 if (EpochTime == pb->EpochTime[s] &&
663 ExtendedPhaseBiasPropertyID == pb->ExtendedPhaseBiasPropertyID) {
664 for (i = 0; i < pb->NumberOfSat[s]; ++i) {
665 for (pos = satoffset[s];
666 pos < satoffset[s] + pb->NumberOfSat[s];
667 ++pos)
668 ;
669 if (pos >= satoffset[s + 1])
670 return GCOBR_DATAMISMATCH;
671 else if (pos == pb->NumberOfSat[s] + satoffset[s])
672 ++pb->NumberOfSat[s];
673#ifdef BNC_DEBUG_SSR
674 fprintf(stderr, "id %2d ", pb->Sat[pos].ID);
675#endif
676 for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
677 D_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].WidelaneGroupIndicator)
678#ifdef BNC_DEBUG_SSR
679 fprintf(stderr, "t%02d int %d /*wl %d*/ disc %d b %8.4f ",
680 pb->Sat[pos].Biases[j].Type,
681 pb->Sat[pos].Biases[j].IntegerIndicator,
682 pb->Sat[pos].Biases[j].WidelaneGroupIndicator,
683 pb->Sat[pos].Biases[j].DiscontinuityCounter,
684 pb->Sat[pos].Biases[j].Bias);
685#endif
686 }
687#ifdef BNC_DEBUG_SSR
688 fprintf(stderr, "\n");
689#endif
690 }
691 }
692 }
693 else if (kind == COBOFS_ORBIT) {
694 if (!co)
695 return GCOBR_NOCLOCKORBITPARAMETER;
696 co->messageType = type;
697 switch (s) {
698 case CLOCKORBIT_SATGPS:
699 case CLOCKORBIT_SATGALILEO:
700 case CLOCKORBIT_SATQZSS:
701 case CLOCKORBIT_SATSBAS:
702 case CLOCKORBIT_SATBDS:
703 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
704 break;
705 case CLOCKORBIT_SATGLONASS:
706 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
707 break;
708 }
709 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
710 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
711 D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
712 D_SSR_IOD(co->SSRIOD)
713 D_SSR_PROVIDER_ID(co->SSRProviderID)
714 D_SSR_SOLUTION_ID(co->SSRSolutionID)
715 D_NO_OF_SATELLITES(nums)
716 co->Supplied[COBOFS_ORBIT] |= 1;
717#ifdef BNC_DEBUG_SSR
718 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
719 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
720 co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
721#endif
722 for (i = 0; i < nums; ++i) {
723 D_GPS_SATELLITE_ID(id)
724 for (pos = satoffset[s];
725 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
726 ++pos)
727 ;
728 if (pos >= satoffset[s + 1])
729 return GCOBR_DATAMISMATCH;
730 else if (pos == co->NumberOfSat[s] + satoffset[s])
731 ++co->NumberOfSat[s];
732 co->Sat[pos].ID = id;
733
734 switch (s) {
735 case CLOCKORBIT_SATGPS:
736 case CLOCKORBIT_SATQZSS:
737 D_GPS_IODE(co->Sat[pos].IOD)
738 break;
739 case CLOCKORBIT_SATGLONASS:
740 D_GLONASS_IOD(co->Sat[pos].IOD)
741 break;
742 case CLOCKORBIT_SATGALILEO:
743 D_GALILEO_IOD(co->Sat[pos].IOD)
744 break;
745 case CLOCKORBIT_SATSBAS:
746 D_SBAS_T0MOD(co->Sat[pos].toe)
747 D_SBAS_IODCRC(co->Sat[pos].IOD)
748 break;
749 case CLOCKORBIT_SATBDS:
750 D_BDS_TOEMOD(co->Sat[pos].toe)
751 D_GPS_IODE(co->Sat[pos].IOD)
752 break;
753 }
754 D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
755 D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
756 D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
757 D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
758 D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
759 D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
760#ifdef BNC_DEBUG_SSR
761 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",
762 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
763 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
764 co->Sat[pos].Orbit.DotDeltaRadial,
765 co->Sat[pos].Orbit.DotDeltaAlongTrack,
766 co->Sat[pos].Orbit.DotDeltaCrossTrack);
767#endif
768 }
769 }
770 else if (kind == COBOFS_CLOCK) {
771 if (!co)
772 return GCOBR_NOCLOCKORBITPARAMETER;
773 co->messageType = type;
774 switch (s) {
775 case CLOCKORBIT_SATGPS:
776 case CLOCKORBIT_SATGALILEO:
777 case CLOCKORBIT_SATQZSS:
778 case CLOCKORBIT_SATSBAS:
779 case CLOCKORBIT_SATBDS:
780 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
781 break;
782 case CLOCKORBIT_SATGLONASS:
783 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
784 break;
785 }
786 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
787 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
788 D_SSR_IOD(co->SSRIOD)
789 D_SSR_PROVIDER_ID(co->SSRProviderID)
790 D_SSR_SOLUTION_ID(co->SSRSolutionID)
791 D_NO_OF_SATELLITES(nums)
792 co->Supplied[COBOFS_CLOCK] |= 1;
793#ifdef BNC_DEBUG_SSR
794 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
795 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
796 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
797#endif
798 for (i = 0; i < nums; ++i) {
799 D_GPS_SATELLITE_ID(id)
800 for (pos = satoffset[s];
801 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
802 ++pos)
803 ;
804 if (pos >= satoffset[s + 1])
805 return GCOBR_DATAMISMATCH;
806 else if (pos == co->NumberOfSat[s] + satoffset[s])
807 ++co->NumberOfSat[s];
808 co->Sat[pos].ID = id;
809
810 D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
811 D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
812 D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
813#ifdef BNC_DEBUG_SSR
814 fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n",
815 co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1,
816 co->Sat[pos].Clock.DeltaA2);
817#endif
818 }
819 }
820 else if (kind == COBOFS_COMBINED) {
821 if (!co)
822 return GCOBR_NOCLOCKORBITPARAMETER;
823 co->messageType = type;
824 switch (s) {
825 case CLOCKORBIT_SATGPS:
826 case CLOCKORBIT_SATGALILEO:
827 case CLOCKORBIT_SATQZSS:
828 case CLOCKORBIT_SATSBAS:
829 case CLOCKORBIT_SATBDS:
830 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
831 break;
832 case CLOCKORBIT_SATGLONASS:
833 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
834 break;
835 }
836 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
837 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
838 D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
839 D_SSR_IOD(co->SSRIOD)
840 D_SSR_PROVIDER_ID(co->SSRProviderID)
841 D_SSR_SOLUTION_ID(co->SSRSolutionID)
842 D_NO_OF_SATELLITES(nums)
843 co->Supplied[COBOFS_ORBIT] |= 1;
844 co->Supplied[COBOFS_CLOCK] |= 1;
845#ifdef BNC_DEBUG_SSR
846 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
847 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
848 co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
849#endif
850 for (i = 0; i < nums; ++i) {
851 D_GPS_SATELLITE_ID(id)
852 for (pos = satoffset[s];
853 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
854 ++pos)
855 ;
856 if (pos >= satoffset[s + 1])
857 return GCOBR_DATAMISMATCH;
858 else if (pos == co->NumberOfSat[s] + satoffset[s])
859 ++co->NumberOfSat[s];
860 co->Sat[pos].ID = id;
861
862 switch (s) {
863 case CLOCKORBIT_SATGPS:
864 case CLOCKORBIT_SATQZSS:
865 D_GPS_IODE(co->Sat[pos].IOD)
866 break;
867 case CLOCKORBIT_SATGLONASS:
868 D_GLONASS_IOD(co->Sat[pos].IOD)
869 break;
870 case CLOCKORBIT_SATGALILEO:
871 D_GALILEO_IOD(co->Sat[pos].IOD)
872 break;
873 case CLOCKORBIT_SATSBAS:
874 D_SBAS_T0MOD(co->Sat[pos].toe)
875 D_SBAS_IODCRC(co->Sat[pos].IOD)
876 break;
877 case CLOCKORBIT_SATBDS:
878 D_BDS_TOEMOD(co->Sat[pos].toe)
879 D_GPS_IODE(co->Sat[pos].IOD)
880 break;
881 }
882 D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
883 D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
884 D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
885 D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
886 D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
887 D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
888 D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
889 D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
890 D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
891#ifdef BNC_DEBUG_SSR
892 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",
893 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
894 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
895 co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack,
896 co->Sat[pos].Orbit.DotDeltaCrossTrack,
897 co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2);
898#endif
899 }
900 }
901 else if (kind == COBOFS_URA) {
902 if (!co)
903 return GCOBR_NOCLOCKORBITPARAMETER;
904 co->messageType = type;
905 switch (s) {
906 case CLOCKORBIT_SATGPS:
907 case CLOCKORBIT_SATGALILEO:
908 case CLOCKORBIT_SATQZSS:
909 case CLOCKORBIT_SATSBAS:
910 case CLOCKORBIT_SATBDS:
911 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
912 break;
913 case CLOCKORBIT_SATGLONASS:
914 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
915 break;
916 }
917 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
918 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
919 D_SSR_IOD(co->SSRIOD)
920 D_SSR_PROVIDER_ID(co->SSRProviderID)
921 D_SSR_SOLUTION_ID(co->SSRSolutionID)
922 D_NO_OF_SATELLITES(nums)
923 co->Supplied[COBOFS_URA] |= 1;
924#ifdef BNC_DEBUG_SSR
925 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
926 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
927 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
928#endif
929 for (i = 0; i < nums; ++i) {
930 D_GPS_SATELLITE_ID(id)
931 for (pos = satoffset[s];
932 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
933 ++pos)
934 ;
935 if (pos >= satoffset[s + 1])
936 return GCOBR_DATAMISMATCH;
937 else if (pos == co->NumberOfSat[s] + satoffset[s])
938 ++co->NumberOfSat[s];
939 co->Sat[pos].ID = id;
940 D_SSR_URA(co->Sat[pos].UserRangeAccuracy)
941#ifdef BNC_DEBUG_SSR
942 fprintf(stderr, "id %2d ura %8.3f \n",
943 co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy);
944#endif
945 }
946 }
947 else if (kind == COBOFS_HR) {
948 if (!co)
949 return GCOBR_NOCLOCKORBITPARAMETER;
950 co->messageType = type;
951 switch (s) {
952 case CLOCKORBIT_SATGPS:/* Phase specific part of GNSS phase bias message */
953 case CLOCKORBIT_SATGALILEO:
954 case CLOCKORBIT_SATQZSS:
955 case CLOCKORBIT_SATSBAS:
956 case CLOCKORBIT_SATBDS:
957 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
958 break;
959 case CLOCKORBIT_SATGLONASS:
960 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
961 break;
962 }
963 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
964 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
965 D_SSR_IOD(co->SSRIOD)
966 D_SSR_PROVIDER_ID(co->SSRProviderID)
967 D_SSR_SOLUTION_ID(co->SSRSolutionID)
968 D_NO_OF_SATELLITES(nums)
969 co->Supplied[COBOFS_HR] |= 1;
970#ifdef BNC_DEBUG_SSR
971 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
972 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
973 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
974#endif
975 for (i = 0; i < nums; ++i) {
976 D_GPS_SATELLITE_ID(id)
977 for (pos = satoffset[s];
978 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
979 ++pos)
980 ;
981 if (pos >= satoffset[s + 1])
982 return GCOBR_DATAMISMATCH;
983 else if (pos == co->NumberOfSat[s] + satoffset[s])
984 ++co->NumberOfSat[s];
985 co->Sat[pos].ID = id;
986 D_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock)
987#ifdef BNC_DEBUG_SSR
988 fprintf(stderr, "id %2d hrClock %8.3f \n",
989 co->Sat[pos].ID, co->Sat[pos].hrclock);
990#endif
991 }
992 }
993 else if (kind == COBOFS_CBIAS) {
994 if (!b)
995 return GCOBR_NOCODEBIASPARAMETER;
996 b->messageType = type;
997 switch (s) {
998 case CLOCKORBIT_SATGPS:
999 case CLOCKORBIT_SATGALILEO:
1000 case CLOCKORBIT_SATQZSS:
1001 case CLOCKORBIT_SATSBAS:
1002 case CLOCKORBIT_SATBDS:
1003 D_GPS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
1004 break;
1005 case CLOCKORBIT_SATGLONASS:
1006 D_GLONASS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
1007 break;
1008 }
1009 D_SSR_UPDATE_INTERVAL(b->UpdateInterval)
1010 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
1011 D_SSR_IOD(b->SSRIOD)
1012 D_SSR_PROVIDER_ID(b->SSRProviderID)
1013 D_SSR_SOLUTION_ID(b->SSRSolutionID)
1014 D_NO_OF_SATELLITES(nums)
1015#ifdef BNC_DEBUG_SSR
1016 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
1017 b->EpochTime[s], b->UpdateInterval,mmi,b->NumberOfSat[s],nums,
1018 b->SSRIOD, b->SSRProviderID, b->SSRSolutionID);
1019#endif
1020 for (i = 0; i < nums; ++i) {
1021 D_GPS_SATELLITE_ID(id)
1022 for (pos = satoffset[s];
1023 pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id;
1024 ++pos)
1025 ;
1026 if (pos >= satoffset[s + 1])
1027 return GCOBR_DATAMISMATCH;
1028 else if (pos == b->NumberOfSat[s] + satoffset[s])
1029 ++b->NumberOfSat[s];
1030 b->Sat[pos].ID = id;
1031 D_NO_OF_BIASES(b->Sat[pos].NumberOfCodeBiases)
1032#ifdef BNC_DEBUG_SSR
1033 fprintf(stderr, "id %2d #%d ",
1034 b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases);
1035#endif
1036 for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) {
1037 D_GNSS_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type)
1038 D_CODE_BIAS(b->Sat[pos].Biases[j].Bias)
1039#ifdef BNC_DEBUG_SSR
1040 fprintf(stderr, "t%02d b %8.2f ",
1041 b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias);
1042#endif
1043 }
1044#ifdef BNC_DEBUG_SSR
1045 fprintf(stderr, "\n");
1046#endif
1047 }
1048 }
1049 else {
1050 /* COBOFS_PBEXT / COBOFS_SATANT / COBOFS_REGIONO: message numbers are
1051 recognized (see setCorType()) but decoding is not implemented yet */
1052 return GCOBR_UNKNOWNTYPE;
1053 }
1054
1055#ifdef BNC_DEBUG_SSR
1056 for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
1057 numbits += 8;
1058 fprintf(stderr, "numbits left %d\n",numbits);
1059#endif
1060 return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
1061 }
1062}
1063
1064//
1065////////////////////////////////////////////////////////////////////////////
1066std::string SsrCorrRtcmNew::codeTypeToRnxType(char system, CodeType type) {
1067 if (system == 'G') {
1068 if (type == CODETYPE_GPS_L1_CA) return "1C";
1069 if (type == CODETYPE_GPS_L1_P) return "1P";
1070 if (type == CODETYPE_GPS_L1_Z) return "1W";
1071 if (type == CODETYPE_GPS_SEMI_CODELESS) return "2D";
1072 if (type == CODETYPE_GPS_L2_CA) return "2C";
1073 if (type == CODETYPE_GPS_L2_P) return "2P";
1074 if (type == CODETYPE_GPS_L2_Z) return "2W";
1075 if (type == CODETYPE_GPS_L2C_M) return "2S";
1076 if (type == CODETYPE_GPS_L2C_L) return "2L";
1077 if (type == CODETYPE_GPS_L2C_ML) return "2X";
1078 if (type == CODETYPE_GPS_L5_I) return "5I";
1079 if (type == CODETYPE_GPS_L5_Q) return "5Q";
1080 if (type == CODETYPE_GPS_L5_IQ) return "5X";
1081 if (type == CODETYPE_GPS_L1C_D) return "1S";
1082 if (type == CODETYPE_GPS_L1C_P) return "1L";
1083 if (type == CODETYPE_GPS_L1C_DP) return "1X";
1084 }
1085 else if (system == 'R') {
1086 if (type == CODETYPE_GLONASS_L1_CA) return "1C";
1087 if (type == CODETYPE_GLONASS_L1_P) return "1P";
1088 if (type == CODETYPE_GLONASS_L2_CA) return "2C";
1089 if (type == CODETYPE_GLONASS_L2_P) return "2P";
1090 }
1091 else if (system == 'E') {
1092 if (type == CODETYPE_GALILEO_E1_A) return "1A";
1093 if (type == CODETYPE_GALILEO_E1_B) return "1B";
1094 if (type == CODETYPE_GALILEO_E1_C) return "1C";
1095 if (type == CODETYPE_GALILEO_E1_BC) return "1X";
1096 if (type == CODETYPE_GALILEO_E1_ABC) return "1Z";
1097 if (type == CODETYPE_GALILEO_E5A_I) return "5I";
1098 if (type == CODETYPE_GALILEO_E5A_Q) return "5Q";
1099 if (type == CODETYPE_GALILEO_E5A_IQ) return "5X";
1100 if (type == CODETYPE_GALILEO_E5B_I) return "7I";
1101 if (type == CODETYPE_GALILEO_E5B_Q) return "7Q";
1102 if (type == CODETYPE_GALILEO_E5B_IQ) return "7X";
1103 if (type == CODETYPE_GALILEO_E5_I) return "8I";
1104 if (type == CODETYPE_GALILEO_E5_Q) return "8Q";
1105 if (type == CODETYPE_GALILEO_E5_IQ) return "8X";
1106 if (type == CODETYPE_GALILEO_E6_A) return "6A";
1107 if (type == CODETYPE_GALILEO_E6_B) return "6B";
1108 if (type == CODETYPE_GALILEO_E6_C) return "6C";
1109 if (type == CODETYPE_GALILEO_E6_BC) return "6X";
1110 if (type == CODETYPE_GALILEO_E6_ABC) return "6Z";
1111 }
1112 else if (system == 'J') {
1113 if (type == CODETYPE_QZSS_L1_CA) return "1C";
1114 if (type == CODETYPE_QZSS_L1C_D) return "1S";
1115 if (type == CODETYPE_QZSS_L1C_P) return "1L";
1116 if (type == CODETYPE_QZSS_L2C_M) return "2S";
1117 if (type == CODETYPE_QZSS_L2C_L) return "2L";
1118 if (type == CODETYPE_QZSS_L2C_ML) return "2X";
1119 if (type == CODETYPE_QZSS_L5_I) return "5I";
1120 if (type == CODETYPE_QZSS_L5_Q) return "5Q";
1121 if (type == CODETYPE_QZSS_L5_IQ) return "5X";
1122 if (type == CODETYPE_QZSS_L6_D) return "6S";
1123 if (type == CODETYPE_QZSS_L6_P) return "6L";
1124 if (type == CODETYPE_QZSS_L6_DP) return "6X";
1125 if (type == CODETYPE_QZSS_L1C_DP) return "1X";
1126 }
1127 else if (system == 'C') {
1128 if (type == CODETYPE_BDS_B1_I) return "2I";
1129 if (type == CODETYPE_BDS_B1_Q) return "2Q";
1130 if (type == CODETYPE_BDS_B1_IQ) return "2X";
1131 if (type == CODETYPE_BDS_B3_I) return "6I";
1132 if (type == CODETYPE_BDS_B3_Q) return "6Q";
1133 if (type == CODETYPE_BDS_B3_IQ) return "6X";
1134 if (type == CODETYPE_BDS_B2_I) return "7I";
1135 if (type == CODETYPE_BDS_B2_Q) return "7Q";
1136 if (type == CODETYPE_BDS_B2_IQ) return "7X";
1137 if (type == CODETYPE_BDS_B1C_D) return "1D";
1138 if (type == CODETYPE_BDS_B1C_P) return "1P";
1139 if (type == CODETYPE_BDS_B1C_DP) return "1X";
1140 if (type == CODETYPE_BDS_B2a_D) return "5D";
1141 if (type == CODETYPE_BDS_B2a_P) return "5P";
1142 if (type == CODETYPE_BDS_B2a_DP) return "5X";
1143 if (type == CODETYPE_BDS_B2b_D) return "7D";
1144 }
1145
1146 return "";
1147}
1148
1149//
1150////////////////////////////////////////////////////////////////////////////
1151SsrCorr::CodeType SsrCorrRtcmNew::rnxTypeToCodeType(char system, std::string type) {
1152 if (system == 'G') {
1153 if (type.compare("1C") == 0) {return CODETYPE_GPS_L1_CA;}
1154 if (type.compare("1P") == 0) {return CODETYPE_GPS_L1_P;}
1155 if (type.compare("1W") == 0) {return CODETYPE_GPS_L1_Z;}
1156 if (type.compare("2D") == 0) {return CODETYPE_GPS_SEMI_CODELESS;}
1157 if (type.compare("2C") == 0) {return CODETYPE_GPS_L2_CA;}
1158 if (type.compare("2P") == 0) {return CODETYPE_GPS_L2_P;}
1159 if (type.compare("2W") == 0) {return CODETYPE_GPS_L2_Z;}
1160 if (type.compare("2S") == 0) {return CODETYPE_GPS_L2C_M;}
1161 if (type.compare("2L") == 0) {return CODETYPE_GPS_L2C_L;}
1162 if (type.compare("2X") == 0) {return CODETYPE_GPS_L2C_ML;}
1163 if (type.compare("5I") == 0) {return CODETYPE_GPS_L5_I;}
1164 if (type.compare("5Q") == 0) {return CODETYPE_GPS_L5_Q;}
1165 if (type.compare("5X") == 0) {return CODETYPE_GPS_L5_IQ;}
1166 if (type.compare("1S") == 0) {return CODETYPE_GPS_L1C_D;}
1167 if (type.compare("1L") == 0) {return CODETYPE_GPS_L1C_P;}
1168 if (type.compare("1X") == 0) {return CODETYPE_GPS_L1C_DP;}
1169 }
1170 else if (system == 'R') {
1171 if (type.compare("1C") == 0) {return CODETYPE_GLONASS_L1_CA;}
1172 if (type.compare("1P") == 0) {return CODETYPE_GLONASS_L1_P;}
1173 if (type.compare("2C") == 0) {return CODETYPE_GLONASS_L2_CA;}
1174 if (type.compare("2P") == 0) {return CODETYPE_GLONASS_L2_P;}
1175 }
1176 else if (system == 'E') {
1177 if (type.compare("1A") == 0) {return CODETYPE_GALILEO_E1_A;}
1178 if (type.compare("1B") == 0) {return CODETYPE_GALILEO_E1_B;}
1179 if (type.compare("1C") == 0) {return CODETYPE_GALILEO_E1_C;}
1180 if (type.compare("1X") == 0) {return CODETYPE_GALILEO_E1_BC;}
1181 if (type.compare("1Z") == 0) {return CODETYPE_GALILEO_E1_ABC;}
1182 if (type.compare("5I") == 0) {return CODETYPE_GALILEO_E5A_I;}
1183 if (type.compare("5Q") == 0) {return CODETYPE_GALILEO_E5A_Q;}
1184 if (type.compare("5X") == 0) {return CODETYPE_GALILEO_E5A_IQ;}
1185 if (type.compare("7I") == 0) {return CODETYPE_GALILEO_E5B_I;}
1186 if (type.compare("7Q") == 0) {return CODETYPE_GALILEO_E5B_Q;}
1187 if (type.compare("7X") == 0) {return CODETYPE_GALILEO_E5B_IQ;}
1188 if (type.compare("8I") == 0) {return CODETYPE_GALILEO_E5_I;}
1189 if (type.compare("8Q") == 0) {return CODETYPE_GALILEO_E5_Q;}
1190 if (type.compare("8X") == 0) {return CODETYPE_GALILEO_E5_IQ;}
1191 if (type.compare("6A") == 0) {return CODETYPE_GALILEO_E6_A;}
1192 if (type.compare("6B") == 0) {return CODETYPE_GALILEO_E6_B;}
1193 if (type.compare("6C") == 0) {return CODETYPE_GALILEO_E6_C;}
1194 if (type.compare("6X") == 0) {return CODETYPE_GALILEO_E6_BC;}
1195 if (type.compare("6Z") == 0) {return CODETYPE_GALILEO_E6_ABC;}
1196 }
1197 else if (system == 'J') {
1198 if (type.compare("1C") == 0) {return CODETYPE_QZSS_L1_CA;}
1199 if (type.compare("1S") == 0) {return CODETYPE_QZSS_L1C_D;}
1200 if (type.compare("1L") == 0) {return CODETYPE_QZSS_L1C_P;}
1201 if (type.compare("2S") == 0) {return CODETYPE_QZSS_L2C_M;}
1202 if (type.compare("2L") == 0) {return CODETYPE_QZSS_L2C_L;}
1203 if (type.compare("2X") == 0) {return CODETYPE_QZSS_L2C_ML;}
1204 if (type.compare("5I") == 0) {return CODETYPE_QZSS_L5_I;}
1205 if (type.compare("5Q") == 0) {return CODETYPE_QZSS_L5_Q;}
1206 if (type.compare("5X") == 0) {return CODETYPE_QZSS_L5_IQ;}
1207 if (type.compare("6S") == 0) {return CODETYPE_QZSS_L6_D;}
1208 if (type.compare("6L") == 0) {return CODETYPE_QZSS_L6_P;}
1209 if (type.compare("6X") == 0) {return CODETYPE_QZSS_L6_DP;}
1210 if (type.compare("1X") == 0) {return CODETYPE_QZSS_L1C_DP;}
1211 }
1212 else if (system == 'C') {
1213 if (type.compare("2I") == 0) {return CODETYPE_BDS_B1_I;}
1214 if (type.compare("2Q") == 0) {return CODETYPE_BDS_B1_Q;}
1215 if (type.compare("2X") == 0) {return CODETYPE_BDS_B1_IQ;}
1216 if (type.compare("6I") == 0) {return CODETYPE_BDS_B3_I;}
1217 if (type.compare("6Q") == 0) {return CODETYPE_BDS_B3_Q;}
1218 if (type.compare("6X") == 0) {return CODETYPE_BDS_B3_IQ;}
1219 if (type.compare("7I") == 0) {return CODETYPE_BDS_B2_I;}
1220 if (type.compare("7Q") == 0) {return CODETYPE_BDS_B2_Q;}
1221 if (type.compare("7X") == 0) {return CODETYPE_BDS_B2_IQ;}
1222 if (type.compare("1D") == 0) {return CODETYPE_BDS_B1C_D;}
1223 if (type.compare("1P") == 0) {return CODETYPE_BDS_B1C_P;}
1224 if (type.compare("1X") == 0) {return CODETYPE_BDS_B1C_DP;}
1225 if (type.compare("5D") == 0) {return CODETYPE_BDS_B2a_D;}
1226 if (type.compare("5P") == 0) {return CODETYPE_BDS_B2a_P;}
1227 if (type.compare("5X") == 0) {return CODETYPE_BDS_B2a_DP;}
1228 if (type.compare("7D") == 0) {return CODETYPE_BDS_B2b_D;}
1229 }
1230
1231 return CODETYPE_RESERVED;
1232}
1233
Note: See TracBrowser for help on using the repository browser.