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

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

minor changes
  • Property svn:executable set to *
File size: 45.1 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 setCorOffset();
23 setCoType();
24 setCbType();
25 setPbType();
26 setPbExtType();
27 setVtecType();
28 setSatAntType();
29 setGridDefType();
30 setTropoType();
31 setRegIonoType();
32 setMetaDataType();
33 setCodeType();
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_NUM));
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_NUM; ++i) {
56 if (co->NumberOfSat[s] && (type == COTYPE_AUTO || type == corbase[s] + i) &&
57 (co->Supplied[i] || (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(corbase[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(corbase[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(corbase[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(corbase[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(corbase[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 == corbase[s] + COBOFS_CBIAS)) {
314 INITBLOCK
315 E_RTCM_MESSAGE_NUMBER(corbase[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 /* The Widelane Signal Group Indicator shall be releated for every satellite and signal
356 included in the corresponding Satellite Phase Bias Message in the same order. The
357 Extended Satellite Phase Bias Message shall be sent before the corresponding
358 Satellite Phase Bias Message */
359 if (b->NumberOfSat[s] && (type == PBEXTTYPE_AUTO || type == s + PBEXTTYPE_AUTO)) {
360 INITBLOCK
361 E_RTCM_MESSAGE_NUMBER(s + PBEXTTYPE_AUTO)
362 switch (s) {
363 case CLOCKORBIT_SATGPS:
364 case CLOCKORBIT_SATGALILEO:
365 case CLOCKORBIT_SATQZSS:
366 case CLOCKORBIT_SATSBAS:
367 case CLOCKORBIT_SATBDS:
368 E_GPS_EPOCH_TIME(b->EpochTime[s])
369 break;
370 case CLOCKORBIT_SATGLONASS:
371 E_GLONASS_EPOCH_TIME(b->EpochTime[s])
372 break;
373 }
374 E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
375 E_SSR_IOD(b->SSRIOD)
376 E_SSR_PROVIDER_ID(b->SSRProviderID)
377 E_SSR_SOLUTION_ID(b->SSRSolutionID)
378 E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
379 for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
380 for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
381 E_WIDE_LANE_INDICATOR(b->Sat[i].Biases[j].WidelaneGroupIndicator)
382 }
383 }
384 ENDBLOCK
385 }
386 if (b->NumberOfSat[s] && (type == PBTYPE_AUTO || type == s + PBTYPE_BASE)) {
387 INITBLOCK
388 E_RTCM_MESSAGE_NUMBER(s + PBTYPE_BASE)
389 switch (s) {
390 case CLOCKORBIT_SATGPS:
391 case CLOCKORBIT_SATGALILEO:
392 case CLOCKORBIT_SATQZSS:
393 case CLOCKORBIT_SATSBAS:
394 case CLOCKORBIT_SATBDS:
395 E_GPS_EPOCH_TIME(b->EpochTime[s])
396 break;
397 case CLOCKORBIT_SATGLONASS:
398 E_GLONASS_EPOCH_TIME(b->EpochTime[s])
399 break;
400 }
401 E_SSR_UPDATE_INTERVAL(b->UpdateInterval)
402 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
403 E_SSR_IOD(b->SSRIOD)
404 E_SSR_PROVIDER_ID(b->SSRProviderID)
405 E_SSR_SOLUTION_ID(b->SSRSolutionID)
406 E_YAW_INFO_INDICATOR(b->SatelliteYawInformationIndicator)
407 E_EXTENDED_PHASE_BIAS_ID(b->ExtendedPhaseBiasPropertyID)
408 E_NO_OF_SATELLITES(b->NumberOfSat[s])
409 for (i = satoffset[s]; i < satoffset[s] + b->NumberOfSat[s]; ++i) {
410 E_GPS_SATELLITE_ID(b->Sat[i].ID)
411 E_NO_OF_BIASES(b->Sat[i].NumberOfPhaseBiases)
412 E_YAW_ANGLE(b->Sat[i].YawAngle)
413 E_YAW_RATE(b->Sat[i].YawRate)
414 for (j = 0; j < b->Sat[i].NumberOfPhaseBiases; ++j) {
415 E_GNSS_SIGNAL_IDENTIFIER(b->Sat[i].Biases[j].Type)
416 E_INTEGER_INDICATOR(b->Sat[i].Biases[j].IntegerIndicator ? 1 : 0)
417 E_DISCONTINUITY_COUNTER(b->Sat[i].Biases[j].DiscontinuityCounter)
418 E_PHASE_BIAS_CORRECTION(b->Sat[i].Biases[j].Bias)
419 }
420 }
421 ENDBLOCK
422 }
423 }
424 return ressize;
425}
426
427size_t SsrCorrRtcmNew::MakeVTEC(const struct VTEC *v, int moremessagesfollow, char *buffer, size_t size) {
428 unsigned int l, o, d;
429
430 STARTDATA
431 INITBLOCK
432 E_RTCM_MESSAGE_NUMBER(VTEC_BASE)
433 E_GPS_EPOCH_TIME(v->EpochTime)
434 E_SSR_UPDATE_INTERVAL(v->UpdateInterval)
435 E_MULTIPLE_MESSAGE_INDICATOR(moremessagesfollow ? 1 : 0)
436 E_SSR_IOD(v->SSRIOD)
437 E_SSR_PROVIDER_ID(v->SSRProviderID)
438 E_SSR_SOLUTION_ID(v->SSRSolutionID)
439 E_VTEC_QUALITY_INDICATOR(v->Quality)
440 E_NO_IONO_LAYERS(v->NumLayers)
441 for (l = 0; l < v->NumLayers; ++l) {
442 E_IONO_HEIGHT(v->Layers[l].Height)
443 E_IONO_DEGREE(v->Layers[l].Degree)
444 E_IONO_ORDER(v->Layers[l].Order)
445 for (o = 0; o <= v->Layers[l].Order; ++o) {
446 for (d = o; d <= v->Layers[l].Degree; ++d) {
447 E_IONO_COEFF_C(v->Layers[l].Cosinus[d][o])
448 }
449 }
450 for (o = 1; o <= v->Layers[l].Order; ++o) {
451 for (d = o; d <= v->Layers[l].Degree; ++d) {
452 E_IONO_COEFF_S(v->Layers[l].Sinus[d][o])
453 }
454 }
455 }
456 ENDBLOCK
457 return ressize;
458}
459
460enum GCOB_RETURN SsrCorrRtcmNew::GetSSR(struct ClockOrbit *co, struct CodeBias *b,struct VTEC *v,
461 struct PhaseBias *pb, const char *buffer, size_t size, int *bytesused) {
462 int mmi = 0, h, rs;
463 unsigned int type, pos, i, j, s, nums, id;
464 size_t sizeofrtcmblock;
465 const char *blockstart = buffer;
466 DECODESTART
467
468 if (size < 7)
469 return GCOBR_SHORTBUFFER;
470
471#ifdef BNC_DEBUG_SSR
472 fprintf(stderr, "GetSSR-RTCM START: size %d, numbits %d\n",(int)size, numbits);
473#endif
474
475 D_HEADER(h)
476 D_RESERVEDH(rs)
477 D_SIZE(sizeofrtcmblock);
478
479 if ((unsigned char) h != 0xD3 || rs)
480 return GCOBR_UNKNOWNDATA;
481 if (size < sizeofrtcmblock + 3) /* 3 header bytes already removed */
482 return GCOBR_MESSAGEEXCEEDSBUFFER;
483 if (CRC24(sizeofrtcmblock + 3, (const unsigned char *) blockstart) !=
484 (uint32_t) ((((unsigned char) buffer[sizeofrtcmblock]) << 16) |
485 (((unsigned char) buffer[sizeofrtcmblock + 1]) << 8) |
486 (((unsigned char) buffer[sizeofrtcmblock + 2]))))
487 return GCOBR_CRCMISMATCH;
488 size = sizeofrtcmblock; /* reduce size, so overflows are detected */
489
490 D_RTCM_MESSAGE_NUMBER(type)
491#ifdef BNC_DEBUG_SSR
492 fprintf(stderr, "type %d size %d\n",type,(int)sizeofrtcmblock);
493#endif
494 if (bytesused)
495 *bytesused = sizeofrtcmblock + 6;
496 if (type == VTEC_BASE) {
497 unsigned int l, o, d;
498 if (!v)
499 return GCOBR_NOVTECPARAMETER;
500 memset(v, 0, sizeof(*v));
501 D_GPS_EPOCH_TIME(v->EpochTime)
502 D_SSR_UPDATE_INTERVAL(v->UpdateInterval)
503 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
504 D_SSR_IOD(v->SSRIOD)
505 D_SSR_PROVIDER_ID(v->SSRProviderID)
506 D_SSR_SOLUTION_ID(v->SSRSolutionID)
507 D_VTEC_QUALITY_INDICATOR(v->Quality)
508 D_NO_IONO_LAYERS(v->NumLayers)
509#ifdef BNC_DEBUG_SSR
510 fprintf(stderr, "epochTime %d ui %d mmi %d ssrIod %d providerId %d solId %d vtecQ %8.3f numLay %d \n",
511 v->EpochTime, v->UpdateInterval, mmi,
512 v->SSRIOD, v->SSRProviderID, v->SSRSolutionID, v->Quality, v->NumLayers);
513#endif
514 for (l = 0; l < v->NumLayers; ++l) {
515 D_IONO_HEIGHT(v->Layers[l].Height)
516 D_IONO_DEGREE(v->Layers[l].Degree)
517 D_IONO_ORDER(v->Layers[l].Order)
518#ifdef BNC_DEBUG_SSR
519 fprintf(stderr, "h %8.3f deg %d ord %d \n",
520 v->Layers[l].Height, v->Layers[l].Degree, v->Layers[l].Order);
521#endif
522 for (o = 0; o <= v->Layers[l].Order; ++o) {
523 for (d = o; d <= v->Layers[l].Degree; ++d) {
524 D_IONO_COEFF_C(v->Layers[l].Cosinus[d][o])
525#ifdef BNC_DEBUG_SSR
526 fprintf(stderr, "C[%02d][%02d] %8.3f \n",
527 d, o, v->Layers[l].Cosinus[d][o]);
528#endif
529 }
530 }
531 for (o = 1; o <= v->Layers[l].Order; ++o) {
532 for (d = o; d <= v->Layers[l].Degree; ++d) {
533 D_IONO_COEFF_S(v->Layers[l].Sinus[d][o])
534#ifdef BNC_DEBUG_SSR
535 fprintf(stderr, "S[%02d][%02d] %8.3f \n",
536 d, o, v->Layers[l].Sinus[d][o]);
537#endif
538 }
539 }
540 }
541#ifdef BNC_DEBUG_SSR
542 for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
543 numbits += 8;
544 fprintf(stderr, "numbits left %d\n",numbits);
545#endif
546 return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
547 }
548 for (s = CLOCKORBIT_SATNUM; s-- > 0;) {
549 if (type == PBTYPE_BASE + s) {
550 if (!pb)
551 return GCOBR_NOPHASEBIASPARAMETER;
552 pb->messageType = type;
553 switch (s) {
554 case CLOCKORBIT_SATGPS:
555 case CLOCKORBIT_SATGALILEO:
556 case CLOCKORBIT_SATQZSS:
557 case CLOCKORBIT_SATSBAS:
558 case CLOCKORBIT_SATBDS:
559 D_GPS_EPOCH_TIME_CHECK(pb->EpochTime[s], pb->NumberOfSat[s])
560 break;
561 case CLOCKORBIT_SATGLONASS:
562 D_GLONASS_EPOCH_TIME_CHECK(pb->EpochTime[s], pb->NumberOfSat[s])
563 break;
564 }
565 D_SSR_UPDATE_INTERVAL(pb->UpdateInterval)
566 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
567 D_SSR_IOD(pb->SSRIOD)
568 D_SSR_PROVIDER_ID(pb->SSRProviderID)
569 D_SSR_SOLUTION_ID(pb->SSRSolutionID)
570 D_YAW_INFO_INDICATOR(pb->SatelliteYawInformationIndicator)
571 D_EXTENDED_PHASE_BIAS_ID(pb->ExtendedPhaseBiasPropertyID)
572 D_NO_OF_SATELLITES(nums)
573#ifdef BNC_DEBUG_SSR
574 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d dispInd %d mwInd %d\n",
575 pb->EpochTime[s], pb->UpdateInterval,mmi,pb->NumberOfSat[s],nums,
576 pb->SSRIOD, pb->SSRProviderID, pb->SSRSolutionID,
577 pb->DispersiveBiasConsistencyIndicator, pb->MWConsistencyIndicator);
578#endif
579 for (i = 0; i < nums; ++i) {
580 D_GPS_SATELLITE_ID(id)
581 for (pos = satoffset[s];
582 pos < satoffset[s] + pb->NumberOfSat[s] && pb->Sat[pos].ID != id;
583 ++pos)
584 ;
585 if (pos >= satoffset[s + 1])
586 return GCOBR_DATAMISMATCH;
587 else if (pos == pb->NumberOfSat[s] + satoffset[s])
588 ++pb->NumberOfSat[s];
589 pb->Sat[pos].ID = id;
590 D_NO_OF_BIASES(pb->Sat[pos].NumberOfPhaseBiases)
591 D_YAW_ANGLE(pb->Sat[pos].YawAngle)
592 D_YAW_RATE(pb->Sat[pos].YawRate)
593#ifdef BNC_DEBUG_SSR
594 fprintf(stderr, "id %2d #%d y %10.6f yr %10.6f ",
595 pb->Sat[pos].ID, pb->Sat[pos].NumberOfPhaseBiases,
596 pb->Sat[pos].YawAngle/MPI, pb->Sat[pos].YawRate/MPI);
597#endif
598 for (j = 0; j < pb->Sat[pos].NumberOfPhaseBiases; ++j) {
599 D_GNSS_SIGNAL_IDENTIFIER(pb->Sat[pos].Biases[j].Type)
600 D_INTEGER_INDICATOR(pb->Sat[pos].Biases[j].IntegerIndicator)
601 D_WIDE_LANE_INDICATOR(pb->Sat[pos].Biases[j].WidelaneGroupIndicator)
602 D_DISCONTINUITY_COUNTER(pb->Sat[pos].Biases[j].DiscontinuityCounter)
603 D_PHASE_BIAS_CORRECTION(pb->Sat[pos].Biases[j].Bias)
604#ifdef BNC_DEBUG_SSR
605 fprintf(stderr, "t%02d int %d wl %d disc %d b %8.4f ",
606 pb->Sat[pos].Biases[j].Type,
607 pb->Sat[pos].Biases[j].IntegerIndicator,
608 pb->Sat[pos].Biases[j].WidelaneGroupIndicator,
609 pb->Sat[pos].Biases[j].DiscontinuityCounter,
610 pb->Sat[pos].Biases[j].Bias);
611#endif
612 }
613#ifdef BNC_DEBUG_SSR
614 fprintf(stderr, "\n");
615#endif
616 }
617#ifdef BNC_DEBUG_SSR
618 for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
619 numbits += 8;
620 fprintf(stderr, "numbits left %d\n",numbits);
621#endif
622 return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
623 }
624 else if (type >= corbase[s]) {
625 unsigned int corrOffset = type - corbase[s];
626 if (corrOffset == COBOFS_ORBIT) {
627 if (!co)
628 return GCOBR_NOCLOCKORBITPARAMETER;
629 co->messageType = type;
630 switch (s) {
631 case CLOCKORBIT_SATGPS:
632 case CLOCKORBIT_SATGALILEO:
633 case CLOCKORBIT_SATQZSS:
634 case CLOCKORBIT_SATSBAS:
635 case CLOCKORBIT_SATBDS:
636 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
637 break;
638 case CLOCKORBIT_SATGLONASS:
639 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
640 break;
641 }
642 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
643 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
644 D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
645 D_SSR_IOD(co->SSRIOD)
646 D_SSR_PROVIDER_ID(co->SSRProviderID)
647 D_SSR_SOLUTION_ID(co->SSRSolutionID)
648 D_NO_OF_SATELLITES(nums)
649 co->Supplied[COBOFS_ORBIT] |= 1;
650#ifdef BNC_DEBUG_SSR
651 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
652 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
653 co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
654#endif
655 for (i = 0; i < nums; ++i) {
656 D_GPS_SATELLITE_ID(id)
657 for (pos = satoffset[s];
658 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
659 ++pos)
660 ;
661 if (pos >= satoffset[s + 1])
662 return GCOBR_DATAMISMATCH;
663 else if (pos == co->NumberOfSat[s] + satoffset[s])
664 ++co->NumberOfSat[s];
665 co->Sat[pos].ID = id;
666
667 switch (s) {
668 case CLOCKORBIT_SATGPS:
669 case CLOCKORBIT_SATQZSS:
670 D_GPS_IODE(co->Sat[pos].IOD)
671 break;
672 case CLOCKORBIT_SATGLONASS:
673 D_GLONASS_IOD(co->Sat[pos].IOD)
674 break;
675 case CLOCKORBIT_SATGALILEO:
676 D_GALILEO_IOD(co->Sat[pos].IOD)
677 break;
678 case CLOCKORBIT_SATSBAS:
679 D_SBAS_T0MOD(co->Sat[pos].toe)
680 D_SBAS_IODCRC(co->Sat[pos].IOD)
681 break;
682 case CLOCKORBIT_SATBDS:
683 D_BDS_TOEMOD(co->Sat[pos].toe)
684 D_GPS_IODE(co->Sat[pos].IOD)
685 break;
686 }
687 D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
688 D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
689 D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
690 D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
691 D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
692 D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
693#ifdef BNC_DEBUG_SSR
694 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",
695 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
696 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
697 co->Sat[pos].Orbit.DotDeltaRadial,
698 co->Sat[pos].Orbit.DotDeltaAlongTrack,
699 co->Sat[pos].Orbit.DotDeltaCrossTrack);
700#endif
701 }
702 }
703 else if (corrOffset == COBOFS_CLOCK) {
704 if (!co)
705 return GCOBR_NOCLOCKORBITPARAMETER;
706 co->messageType = type;
707 switch (s) {
708 case CLOCKORBIT_SATGPS:
709 case CLOCKORBIT_SATGALILEO:
710 case CLOCKORBIT_SATQZSS:
711 case CLOCKORBIT_SATSBAS:
712 case CLOCKORBIT_SATBDS:
713 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
714 break;
715 case CLOCKORBIT_SATGLONASS:
716 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
717 break;
718 }
719 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
720 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
721 D_SSR_IOD(co->SSRIOD)
722 D_SSR_PROVIDER_ID(co->SSRProviderID)
723 D_SSR_SOLUTION_ID(co->SSRSolutionID)
724 D_NO_OF_SATELLITES(nums)
725 co->Supplied[COBOFS_CLOCK] |= 1;
726#ifdef BNC_DEBUG_SSR
727 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
728 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
729 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
730#endif
731 for (i = 0; i < nums; ++i) {
732 D_GPS_SATELLITE_ID(id)
733 for (pos = satoffset[s];
734 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
735 ++pos)
736 ;
737 if (pos >= satoffset[s + 1])
738 return GCOBR_DATAMISMATCH;
739 else if (pos == co->NumberOfSat[s] + satoffset[s])
740 ++co->NumberOfSat[s];
741 co->Sat[pos].ID = id;
742
743 D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
744 D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
745 D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
746#ifdef BNC_DEBUG_SSR
747 fprintf(stderr, "id %2d c0 %8.3f c1 %8.3f c2 %8.3f\n",
748 co->Sat[pos].ID, co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1,
749 co->Sat[pos].Clock.DeltaA2);
750#endif
751 }
752 }
753 else if (corrOffset == COBOFS_COMBINED) {
754 if (!co)
755 return GCOBR_NOCLOCKORBITPARAMETER;
756 co->messageType = type;
757 switch (s) {
758 case CLOCKORBIT_SATGPS:
759 case CLOCKORBIT_SATGALILEO:
760 case CLOCKORBIT_SATQZSS:
761 case CLOCKORBIT_SATSBAS:
762 case CLOCKORBIT_SATBDS:
763 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
764 break;
765 case CLOCKORBIT_SATGLONASS:
766 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
767 break;
768 }
769 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
770 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
771 D_SATELLITE_REFERENCE_DATUM(co->SatRefDatum)
772 D_SSR_IOD(co->SSRIOD)
773 D_SSR_PROVIDER_ID(co->SSRProviderID)
774 D_SSR_SOLUTION_ID(co->SSRSolutionID)
775 D_NO_OF_SATELLITES(nums)
776 co->Supplied[COBOFS_ORBIT] |= 1;
777 co->Supplied[COBOFS_CLOCK] |= 1;
778#ifdef BNC_DEBUG_SSR
779 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d rd %d ssrIod %d providerId %d solId %d\n",
780 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
781 co->SatRefDatum, co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
782#endif
783 for (i = 0; i < nums; ++i) {
784 D_GPS_SATELLITE_ID(id)
785 for (pos = satoffset[s];
786 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
787 ++pos)
788 ;
789 if (pos >= satoffset[s + 1])
790 return GCOBR_DATAMISMATCH;
791 else if (pos == co->NumberOfSat[s] + satoffset[s])
792 ++co->NumberOfSat[s];
793 co->Sat[pos].ID = id;
794
795 switch (s) {
796 case CLOCKORBIT_SATGPS:
797 case CLOCKORBIT_SATQZSS:
798 D_GPS_IODE(co->Sat[pos].IOD)
799 break;
800 case CLOCKORBIT_SATGLONASS:
801 D_GLONASS_IOD(co->Sat[pos].IOD)
802 break;
803 case CLOCKORBIT_SATGALILEO:
804 D_GALILEO_IOD(co->Sat[pos].IOD)
805 break;
806 case CLOCKORBIT_SATSBAS:
807 D_SBAS_T0MOD(co->Sat[pos].toe)
808 D_SBAS_IODCRC(co->Sat[pos].IOD)
809 break;
810 case CLOCKORBIT_SATBDS:
811 D_BDS_TOEMOD(co->Sat[pos].toe)
812 D_GPS_IODE(co->Sat[pos].IOD)
813 break;
814 }
815 D_DELTA_RADIAL(co->Sat[pos].Orbit.DeltaRadial)
816 D_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DeltaAlongTrack)
817 D_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DeltaCrossTrack)
818 D_DOT_DELTA_RADIAL(co->Sat[pos].Orbit.DotDeltaRadial)
819 D_DOT_DELTA_ALONG_TRACK(co->Sat[pos].Orbit.DotDeltaAlongTrack)
820 D_DOT_DELTA_CROSS_TRACK(co->Sat[pos].Orbit.DotDeltaCrossTrack)
821 D_DELTA_CLOCK_C0(co->Sat[pos].Clock.DeltaA0)
822 D_DELTA_CLOCK_C1(co->Sat[pos].Clock.DeltaA1)
823 D_DELTA_CLOCK_C2(co->Sat[pos].Clock.DeltaA2)
824#ifdef BNC_DEBUG_SSR
825 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",
826 co->Sat[pos].ID,co->Sat[pos].IOD,co->Sat[pos].Orbit.DeltaRadial,
827 co->Sat[pos].Orbit.DeltaAlongTrack,co->Sat[pos].Orbit.DeltaCrossTrack,
828 co->Sat[pos].Orbit.DotDeltaRadial, co->Sat[pos].Orbit.DotDeltaAlongTrack,
829 co->Sat[pos].Orbit.DotDeltaCrossTrack,
830 co->Sat[pos].Clock.DeltaA0, co->Sat[pos].Clock.DeltaA1, co->Sat[pos].Clock.DeltaA2);
831#endif
832 }
833 }
834 else if (corrOffset == COBOFS_URA) {
835 if (!co)
836 return GCOBR_NOCLOCKORBITPARAMETER;
837 co->messageType = type;
838 switch (s) {
839 case CLOCKORBIT_SATGPS:
840 case CLOCKORBIT_SATGALILEO:
841 case CLOCKORBIT_SATQZSS:
842 case CLOCKORBIT_SATSBAS:
843 case CLOCKORBIT_SATBDS:
844 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
845 break;
846 case CLOCKORBIT_SATGLONASS:
847 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
848 break;
849 }
850 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
851 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
852 D_SSR_IOD(co->SSRIOD)
853 D_SSR_PROVIDER_ID(co->SSRProviderID)
854 D_SSR_SOLUTION_ID(co->SSRSolutionID)
855 D_NO_OF_SATELLITES(nums)
856 co->Supplied[COBOFS_URA] |= 1;
857#ifdef BNC_DEBUG_SSR
858 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
859 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
860 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
861#endif
862 for (i = 0; i < nums; ++i) {
863 D_GPS_SATELLITE_ID(id)
864 for (pos = satoffset[s];
865 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
866 ++pos)
867 ;
868 if (pos >= satoffset[s + 1])
869 return GCOBR_DATAMISMATCH;
870 else if (pos == co->NumberOfSat[s] + satoffset[s])
871 ++co->NumberOfSat[s];
872 co->Sat[pos].ID = id;
873 D_SSR_URA(co->Sat[pos].UserRangeAccuracy)
874#ifdef BNC_DEBUG_SSR
875 fprintf(stderr, "id %2d ura %8.3f \n",
876 co->Sat[pos].ID, co->Sat[pos].UserRangeAccuracy);
877#endif
878 }
879 }
880 else if (corrOffset == COBOFS_HR) {
881 if (!co)
882 return GCOBR_NOCLOCKORBITPARAMETER;
883 co->messageType = type;
884 switch (s) {
885 case CLOCKORBIT_SATGPS:/* Phase specific part of GNSS phase bias message */
886 case CLOCKORBIT_SATGALILEO:
887 case CLOCKORBIT_SATQZSS:
888 case CLOCKORBIT_SATSBAS:
889 case CLOCKORBIT_SATBDS:
890 D_GPS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
891 break;
892 case CLOCKORBIT_SATGLONASS:
893 D_GLONASS_EPOCH_TIME_CHECK(co->EpochTime[s], co->NumberOfSat[s])
894 break;
895 }
896 D_SSR_UPDATE_INTERVAL(co->UpdateInterval)
897 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
898 D_SSR_IOD(co->SSRIOD)
899 D_SSR_PROVIDER_ID(co->SSRProviderID)
900 D_SSR_SOLUTION_ID(co->SSRSolutionID)
901 D_NO_OF_SATELLITES(nums)
902 co->Supplied[COBOFS_HR] |= 1;
903#ifdef BNC_DEBUG_SSR
904 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
905 co->EpochTime[s], co->UpdateInterval,mmi,co->NumberOfSat[s],nums,
906 co->SSRIOD, co->SSRProviderID, co->SSRSolutionID);
907#endif
908 for (i = 0; i < nums; ++i) {
909 D_GPS_SATELLITE_ID(id)
910 for (pos = satoffset[s];
911 pos < satoffset[s] + co->NumberOfSat[s] && co->Sat[pos].ID != id;
912 ++pos)
913 ;
914 if (pos >= satoffset[s + 1])
915 return GCOBR_DATAMISMATCH;
916 else if (pos == co->NumberOfSat[s] + satoffset[s])
917 ++co->NumberOfSat[s];
918 co->Sat[pos].ID = id;
919 D_HR_CLOCK_CORRECTION(co->Sat[pos].hrclock)
920#ifdef BNC_DEBUG_SSR
921 fprintf(stderr, "id %2d hrClock %8.3f \n",
922 co->Sat[pos].ID, co->Sat[pos].hrclock);
923#endif
924 }
925 }
926 else if (corrOffset == COBOFS_CBIAS) {
927 if (!b)
928 return GCOBR_NOCODEBIASPARAMETER;
929 b->messageType = type;
930 switch (s) {
931 case CLOCKORBIT_SATGPS:
932 case CLOCKORBIT_SATGALILEO:
933 case CLOCKORBIT_SATQZSS:
934 case CLOCKORBIT_SATSBAS:
935 case CLOCKORBIT_SATBDS:
936 D_GPS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
937 break;
938 case CLOCKORBIT_SATGLONASS:
939 D_GLONASS_EPOCH_TIME_CHECK(b->EpochTime[s], b->NumberOfSat[s])
940 break;
941 }
942 D_SSR_UPDATE_INTERVAL(b->UpdateInterval)
943 D_MULTIPLE_MESSAGE_INDICATOR(mmi)
944 D_SSR_IOD(b->SSRIOD)
945 D_SSR_PROVIDER_ID(b->SSRProviderID)
946 D_SSR_SOLUTION_ID(b->SSRSolutionID)
947 D_NO_OF_SATELLITES(nums)
948#ifdef BNC_DEBUG_SSR
949 fprintf(stderr, "epochTime %d ui %d mmi %d sats %d/%d ssrIod %d providerId %d solId %d\n",
950 b->EpochTime[s], b->UpdateInterval,mmi,b->NumberOfSat[s],nums,
951 b->SSRIOD, b->SSRProviderID, b->SSRSolutionID);
952#endif
953 for (i = 0; i < nums; ++i) {
954 D_GPS_SATELLITE_ID(id)
955 for (pos = satoffset[s];
956 pos < satoffset[s] + b->NumberOfSat[s] && b->Sat[pos].ID != id;
957 ++pos)
958 ;
959 if (pos >= satoffset[s + 1])
960 return GCOBR_DATAMISMATCH;
961 else if (pos == b->NumberOfSat[s] + satoffset[s])
962 ++b->NumberOfSat[s];
963 b->Sat[pos].ID = id;
964 D_NO_OF_BIASES(b->Sat[pos].NumberOfCodeBiases)
965#ifdef BNC_DEBUG_SSR
966 fprintf(stderr, "id %2d #%d ",
967 b->Sat[pos].ID, b->Sat[pos].NumberOfCodeBiases);
968#endif
969 for (j = 0; j < b->Sat[pos].NumberOfCodeBiases; ++j) {
970 D_GNSS_SIGNAL_IDENTIFIER(b->Sat[pos].Biases[j].Type)
971 D_CODE_BIAS(b->Sat[pos].Biases[j].Bias)
972#ifdef BNC_DEBUG_SSR
973 fprintf(stderr, "t%02d b %8.2f ",
974 b->Sat[pos].Biases[j].Type, b->Sat[pos].Biases[j].Bias);
975#endif
976 }
977#ifdef BNC_DEBUG_SSR
978 fprintf(stderr, "\n");
979#endif
980 }
981 }
982 else {
983 continue;
984 }
985#ifdef BNC_DEBUG_SSR
986 for(type = 0; type < (unsigned int)size && (unsigned char)buffer[type] != 0xD3; ++type)
987 numbits += 8;
988 fprintf(stderr, "numbits left %d\n",numbits);
989#endif
990 return mmi ? GCOBR_MESSAGEFOLLOWS : GCOBR_OK;
991 }
992 }
993 return GCOBR_UNKNOWNTYPE;
994}
995
996//
997////////////////////////////////////////////////////////////////////////////
998std::string SsrCorrRtcmNew::codeTypeToRnxType(char system, CodeType type) {
999 if (system == 'G') {
1000 if (type == CODETYPE_GPS_L1_CA) return "1C";
1001 if (type == CODETYPE_GPS_L1_P) return "1P";
1002 if (type == CODETYPE_GPS_L1_Z) return "1W";
1003 if (type == CODETYPE_GPS_SEMI_CODELESS) return "2D";
1004 if (type == CODETYPE_GPS_L2_CA) return "2C";
1005 if (type == CODETYPE_GPS_L2_P) return "2P";
1006 if (type == CODETYPE_GPS_L2_Z) return "2W";
1007 if (type == CODETYPE_GPS_L2C_M) return "2S";
1008 if (type == CODETYPE_GPS_L2C_L) return "2L";
1009 if (type == CODETYPE_GPS_L2C_ML) return "2X";
1010 if (type == CODETYPE_GPS_L5_I) return "5I";
1011 if (type == CODETYPE_GPS_L5_Q) return "5Q";
1012 if (type == CODETYPE_GPS_L5_IQ) return "5X";
1013 if (type == CODETYPE_GPS_L1C_D) return "1S";
1014 if (type == CODETYPE_GPS_L1C_P) return "1L";
1015 if (type == CODETYPE_GPS_L1C_DP) return "1X";
1016 }
1017 else if (system == 'R') {
1018 if (type == CODETYPE_GLONASS_L1_CA) return "1C";
1019 if (type == CODETYPE_GLONASS_L1_P) return "1P";
1020 if (type == CODETYPE_GLONASS_L2_CA) return "2C";
1021 if (type == CODETYPE_GLONASS_L2_P) return "2P";
1022 }
1023 else if (system == 'E') {
1024 if (type == CODETYPE_GALILEO_E1_A) return "1A";
1025 if (type == CODETYPE_GALILEO_E1_B) return "1B";
1026 if (type == CODETYPE_GALILEO_E1_C) return "1C";
1027 if (type == CODETYPE_GALILEO_E1_BC) return "1X";
1028 if (type == CODETYPE_GALILEO_E1_ABC) return "1Z";
1029 if (type == CODETYPE_GALILEO_E5A_I) return "5I";
1030 if (type == CODETYPE_GALILEO_E5A_Q) return "5Q";
1031 if (type == CODETYPE_GALILEO_E5A_IQ) return "5X";
1032 if (type == CODETYPE_GALILEO_E5B_I) return "7I";
1033 if (type == CODETYPE_GALILEO_E5B_Q) return "7Q";
1034 if (type == CODETYPE_GALILEO_E5B_IQ) return "7X";
1035 if (type == CODETYPE_GALILEO_E5_I) return "8I";
1036 if (type == CODETYPE_GALILEO_E5_Q) return "8Q";
1037 if (type == CODETYPE_GALILEO_E5_IQ) return "8X";
1038 if (type == CODETYPE_GALILEO_E6_A) return "6A";
1039 if (type == CODETYPE_GALILEO_E6_B) return "6B";
1040 if (type == CODETYPE_GALILEO_E6_C) return "6C";
1041 if (type == CODETYPE_GALILEO_E6_BC) return "6X";
1042 if (type == CODETYPE_GALILEO_E6_ABC) return "6Z";
1043 }
1044 else if (system == 'J') {
1045 if (type == CODETYPE_QZSS_L1_CA) return "1C";
1046 if (type == CODETYPE_QZSS_L1C_D) return "1S";
1047 if (type == CODETYPE_QZSS_L1C_P) return "1L";
1048 if (type == CODETYPE_QZSS_L2C_M) return "2S";
1049 if (type == CODETYPE_QZSS_L2C_L) return "2L";
1050 if (type == CODETYPE_QZSS_L2C_ML) return "2X";
1051 if (type == CODETYPE_QZSS_L5_I) return "5I";
1052 if (type == CODETYPE_QZSS_L5_Q) return "5Q";
1053 if (type == CODETYPE_QZSS_L5_IQ) return "5X";
1054 if (type == CODETYPE_QZSS_L6_D) return "6S";
1055 if (type == CODETYPE_QZSS_L6_P) return "6L";
1056 if (type == CODETYPE_QZSS_L6_DP) return "6X";
1057 if (type == CODETYPE_QZSS_L1C_DP) return "1X";
1058 }
1059 else if (system == 'C') {
1060 if (type == CODETYPE_BDS_B1_I) return "2I";
1061 if (type == CODETYPE_BDS_B1_Q) return "2Q";
1062 if (type == CODETYPE_BDS_B1_IQ) return "2X";
1063 if (type == CODETYPE_BDS_B3_I) return "6I";
1064 if (type == CODETYPE_BDS_B3_Q) return "6Q";
1065 if (type == CODETYPE_BDS_B3_IQ) return "6X";
1066 if (type == CODETYPE_BDS_B2_I) return "7I";
1067 if (type == CODETYPE_BDS_B2_Q) return "7Q";
1068 if (type == CODETYPE_BDS_B2_IQ) return "7X";
1069 if (type == CODETYPE_BDS_B1C_D) return "1D";
1070 if (type == CODETYPE_BDS_B1C_P) return "1P";
1071 if (type == CODETYPE_BDS_B1C_DP) return "1X";
1072 if (type == CODETYPE_BDS_B2a_D) return "5D";
1073 if (type == CODETYPE_BDS_B2a_P) return "5P";
1074 if (type == CODETYPE_BDS_B2a_DP) return "5X";
1075 if (type == CODETYPE_BDS_B2b_D) return "7D";
1076 }
1077
1078 return "";
1079}
1080
1081//
1082////////////////////////////////////////////////////////////////////////////
1083SsrCorr::CodeType SsrCorrRtcmNew::rnxTypeToCodeType(char system, std::string type) {
1084 if (system == 'G') {
1085 if (type.compare("1C") == 0) {return CODETYPE_GPS_L1_CA;}
1086 if (type.compare("1P") == 0) {return CODETYPE_GPS_L1_P;}
1087 if (type.compare("1W") == 0) {return CODETYPE_GPS_L1_Z;}
1088 if (type.compare("2D") == 0) {return CODETYPE_GPS_SEMI_CODELESS;}
1089 if (type.compare("2C") == 0) {return CODETYPE_GPS_L2_CA;}
1090 if (type.compare("2P") == 0) {return CODETYPE_GPS_L2_P;}
1091 if (type.compare("2W") == 0) {return CODETYPE_GPS_L2_Z;}
1092 if (type.compare("2S") == 0) {return CODETYPE_GPS_L2C_M;}
1093 if (type.compare("2L") == 0) {return CODETYPE_GPS_L2C_L;}
1094 if (type.compare("2X") == 0) {return CODETYPE_GPS_L2C_ML;}
1095 if (type.compare("5I") == 0) {return CODETYPE_GPS_L5_I;}
1096 if (type.compare("5Q") == 0) {return CODETYPE_GPS_L5_Q;}
1097 if (type.compare("5X") == 0) {return CODETYPE_GPS_L5_IQ;}
1098 if (type.compare("1S") == 0) {return CODETYPE_GPS_L1C_D;}
1099 if (type.compare("1L") == 0) {return CODETYPE_GPS_L1C_P;}
1100 if (type.compare("1X") == 0) {return CODETYPE_GPS_L1C_DP;}
1101 }
1102 else if (system == 'R') {
1103 if (type.compare("1C") == 0) {return CODETYPE_GLONASS_L1_CA;}
1104 if (type.compare("1P") == 0) {return CODETYPE_GLONASS_L1_P;}
1105 if (type.compare("2C") == 0) {return CODETYPE_GLONASS_L2_CA;}
1106 if (type.compare("2P") == 0) {return CODETYPE_GLONASS_L2_P;}
1107 }
1108 else if (system == 'E') {
1109 if (type.compare("1A") == 0) {return CODETYPE_GALILEO_E1_A;}
1110 if (type.compare("1B") == 0) {return CODETYPE_GALILEO_E1_B;}
1111 if (type.compare("1C") == 0) {return CODETYPE_GALILEO_E1_C;}
1112 if (type.compare("1X") == 0) {return CODETYPE_GALILEO_E1_BC;}
1113 if (type.compare("1Z") == 0) {return CODETYPE_GALILEO_E1_ABC;}
1114 if (type.compare("5I") == 0) {return CODETYPE_GALILEO_E5A_I;}
1115 if (type.compare("5Q") == 0) {return CODETYPE_GALILEO_E5A_Q;}
1116 if (type.compare("5X") == 0) {return CODETYPE_GALILEO_E5A_IQ;}
1117 if (type.compare("7I") == 0) {return CODETYPE_GALILEO_E5B_I;}
1118 if (type.compare("7Q") == 0) {return CODETYPE_GALILEO_E5B_Q;}
1119 if (type.compare("7X") == 0) {return CODETYPE_GALILEO_E5B_IQ;}
1120 if (type.compare("8I") == 0) {return CODETYPE_GALILEO_E5_I;}
1121 if (type.compare("8Q") == 0) {return CODETYPE_GALILEO_E5_Q;}
1122 if (type.compare("8X") == 0) {return CODETYPE_GALILEO_E5_IQ;}
1123 if (type.compare("6A") == 0) {return CODETYPE_GALILEO_E6_A;}
1124 if (type.compare("6B") == 0) {return CODETYPE_GALILEO_E6_B;}
1125 if (type.compare("6C") == 0) {return CODETYPE_GALILEO_E6_C;}
1126 if (type.compare("6X") == 0) {return CODETYPE_GALILEO_E6_BC;}
1127 if (type.compare("6Z") == 0) {return CODETYPE_GALILEO_E6_ABC;}
1128 }
1129 else if (system == 'J') {
1130 if (type.compare("1C") == 0) {return CODETYPE_QZSS_L1_CA;}
1131 if (type.compare("1S") == 0) {return CODETYPE_QZSS_L1C_D;}
1132 if (type.compare("1L") == 0) {return CODETYPE_QZSS_L1C_P;}
1133 if (type.compare("2S") == 0) {return CODETYPE_QZSS_L2C_M;}
1134 if (type.compare("2L") == 0) {return CODETYPE_QZSS_L2C_L;}
1135 if (type.compare("2X") == 0) {return CODETYPE_QZSS_L2C_ML;}
1136 if (type.compare("5I") == 0) {return CODETYPE_QZSS_L5_I;}
1137 if (type.compare("5Q") == 0) {return CODETYPE_QZSS_L5_Q;}
1138 if (type.compare("5X") == 0) {return CODETYPE_QZSS_L5_IQ;}
1139 if (type.compare("6S") == 0) {return CODETYPE_QZSS_L6_D;}
1140 if (type.compare("6L") == 0) {return CODETYPE_QZSS_L6_P;}
1141 if (type.compare("6X") == 0) {return CODETYPE_QZSS_L6_DP;}
1142 if (type.compare("1X") == 0) {return CODETYPE_QZSS_L1C_DP;}
1143 }
1144 else if (system == 'C') {
1145 if (type.compare("2I") == 0) {return CODETYPE_BDS_B1_I;}
1146 if (type.compare("2Q") == 0) {return CODETYPE_BDS_B1_Q;}
1147 if (type.compare("2X") == 0) {return CODETYPE_BDS_B1_IQ;}
1148 if (type.compare("6I") == 0) {return CODETYPE_BDS_B3_I;}
1149 if (type.compare("6Q") == 0) {return CODETYPE_BDS_B3_Q;}
1150 if (type.compare("6X") == 0) {return CODETYPE_BDS_B3_IQ;}
1151 if (type.compare("7I") == 0) {return CODETYPE_BDS_B2_I;}
1152 if (type.compare("7Q") == 0) {return CODETYPE_BDS_B2_Q;}
1153 if (type.compare("7X") == 0) {return CODETYPE_BDS_B2_IQ;}
1154 if (type.compare("1D") == 0) {return CODETYPE_BDS_B1C_D;}
1155 if (type.compare("1P") == 0) {return CODETYPE_BDS_B1C_P;}
1156 if (type.compare("1X") == 0) {return CODETYPE_BDS_B1C_DP;}
1157 if (type.compare("5D") == 0) {return CODETYPE_BDS_B2a_D;}
1158 if (type.compare("5P") == 0) {return CODETYPE_BDS_B2a_P;}
1159 if (type.compare("5X") == 0) {return CODETYPE_BDS_B2a_DP;}
1160 if (type.compare("7D") == 0) {return CODETYPE_BDS_B2b_D;}
1161 }
1162
1163 return CODETYPE_RESERVED;
1164}
1165
Note: See TracBrowser for help on using the repository browser.