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

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