source: ntrip/trunk/BNC/src/RTCM3/RTCM3coDecoder.cpp@ 6492

Last change on this file since 6492 was 6492, checked in by mervart, 11 years ago
File size: 20.3 KB
Line 
1// Part of BNC, a utility for retrieving decoding and
2// converting GNSS data streams from NTRIP broadcasters.
3//
4// Copyright (C) 2007
5// German Federal Agency for Cartography and Geodesy (BKG)
6// http://www.bkg.bund.de
7// Czech Technical University Prague, Department of Geodesy
8// http://www.fsv.cvut.cz
9//
10// Email: euref-ip@bkg.bund.de
11//
12// This program is free software; you can redistribute it and/or
13// modify it under the terms of the GNU General Public License
14// as published by the Free Software Foundation, version 2.
15//
16// This program is distributed in the hope that it will be useful,
17// but WITHOUT ANY WARRANTY; without even the implied warranty of
18// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19// GNU General Public License for more details.
20//
21// You should have received a copy of the GNU General Public License
22// along with this program; if not, write to the Free Software
23// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24
25/* -------------------------------------------------------------------------
26 * BKG NTRIP Client
27 * -------------------------------------------------------------------------
28 *
29 * Class: RTCM3coDecoder
30 *
31 * Purpose: RTCM3 Clock Orbit Decoder
32 *
33 * Author: L. Mervart
34 *
35 * Created: 05-May-2008
36 *
37 * Changes:
38 *
39 * -----------------------------------------------------------------------*/
40
41#include <stdio.h>
42#include <math.h>
43
44#include "RTCM3coDecoder.h"
45#include "bncutils.h"
46#include "bncrinex.h"
47#include "bnccore.h"
48#include "bncsettings.h"
49#include "rtcm3torinex.h"
50#include "bnctime.h"
51
52using namespace std;
53
54// Constructor
55////////////////////////////////////////////////////////////////////////////
56RTCM3coDecoder::RTCM3coDecoder(const QString& staID) {
57
58 _staID = staID;
59
60 // File Output
61 // -----------
62 bncSettings settings;
63 QString path = settings.value("corrPath").toString();
64 if (!path.isEmpty()) {
65 expandEnvVar(path);
66 if ( path.length() > 0 && path[path.length()-1] != QDir::separator() ) {
67 path += QDir::separator();
68 }
69 _fileNameSkl = path + staID;
70 }
71 _out = 0;
72
73 connect(this, SIGNAL(newOrbCorrections(QList<t_orbCorr>)),
74 BNC_CORE, SLOT(slotNewOrbCorrections(QList<t_orbCorr>)));
75
76 connect(this, SIGNAL(newClkCorrections(QList<t_clkCorr>)),
77 BNC_CORE, SLOT(slotNewClkCorrections(QList<t_clkCorr>)));
78
79 connect(this, SIGNAL(newCodeBiases(QList<t_satCodeBias>)),
80 BNC_CORE, SLOT(slotNewCodeBiases(QList<t_satCodeBias>)));
81
82 connect(this, SIGNAL(newPhaseBiases(QList<t_satPhaseBias>)),
83 BNC_CORE, SLOT(slotNewPhaseBiases(QList<t_satPhaseBias>)));
84
85 connect(this, SIGNAL(newTec(t_vTec)),
86 BNC_CORE, SLOT(slotNewTec(t_vTec)));
87
88 connect(this, SIGNAL(providerIDChanged(QString)),
89 BNC_CORE, SIGNAL(providerIDChanged(QString)));
90
91 connect(this, SIGNAL(newMessage(QByteArray,bool)),
92 BNC_CORE, SLOT(slotMessage(const QByteArray,bool)));
93
94 reset();
95
96 _providerID[0] = -1;
97 _providerID[1] = -1;
98 _providerID[2] = -1;
99}
100
101// Destructor
102////////////////////////////////////////////////////////////////////////////
103RTCM3coDecoder::~RTCM3coDecoder() {
104 delete _out;
105}
106
107//
108////////////////////////////////////////////////////////////////////////////
109void RTCM3coDecoder::reset() {
110 memset(&_clkOrb, 0, sizeof(_clkOrb));
111 memset(&_codeBias, 0, sizeof(_codeBias));
112 memset(&_phaseBias, 0, sizeof(_phaseBias));
113 memset(&_vTEC, 0, sizeof(_vTEC));
114}
115
116// Reopen Output File
117////////////////////////////////////////////////////////////////////////
118void RTCM3coDecoder::reopen() {
119
120 if (!_fileNameSkl.isEmpty()) {
121
122 bncSettings settings;
123
124 QDateTime datTim = currentDateAndTimeGPS();
125
126 QString hlpStr = bncRinex::nextEpochStr(datTim,
127 settings.value("corrIntr").toString());
128
129 QString fileNameHlp = _fileNameSkl
130 + QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0'))
131 + hlpStr + datTim.toString(".yyC");
132
133 if (_fileName == fileNameHlp) {
134 return;
135 }
136 else {
137 _fileName = fileNameHlp;
138 }
139
140 delete _out;
141 if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
142 _out = new ofstream( _fileName.toAscii().data(), ios_base::out | ios_base::app );
143 }
144 else {
145 _out = new ofstream( _fileName.toAscii().data() );
146 }
147 }
148}
149
150//
151////////////////////////////////////////////////////////////////////////////
152t_irc RTCM3coDecoder::Decode(char* buffer, int bufLen, vector<string>& errmsg) {
153
154 errmsg.clear();
155
156 _buffer.append(QByteArray(buffer,bufLen));
157
158 t_irc retCode = failure;
159
160 while(_buffer.size()) {
161
162 struct ClockOrbit clkOrbSav;
163 struct CodeBias codeBiasSav;
164 struct PhaseBias phaseBiasSav;
165 struct VTEC vTECSav;
166 memcpy(&clkOrbSav, &_clkOrb, sizeof(clkOrbSav)); // save state
167 memcpy(&codeBiasSav, &_codeBias, sizeof(codeBiasSav));
168 memcpy(&phaseBiasSav, &_phaseBias, sizeof(phaseBiasSav));
169 memcpy(&vTECSav, &_vTEC, sizeof(vTECSav));
170
171 int bytesused = 0;
172 GCOB_RETURN irc = GetSSR(&_clkOrb, &_codeBias, &_vTEC, &_phaseBias,
173 _buffer.data(), _buffer.size(), &bytesused);
174
175 if (irc <= -30) { // not enough data - restore state and exit loop
176 memcpy(&_clkOrb, &clkOrbSav, sizeof(clkOrbSav));
177 memcpy(&_codeBias, &codeBiasSav, sizeof(codeBiasSav));
178 memcpy(&_phaseBias, &phaseBiasSav, sizeof(phaseBiasSav));
179 memcpy(&_vTEC, &vTECSav, sizeof(vTECSav));
180 break;
181 }
182
183 else if (irc < 0) { // error - skip 1 byte and retry
184 reset();
185 _buffer = _buffer.mid(bytesused ? bytesused : 1);
186 }
187
188 else { // OK or MESSAGEFOLLOWS
189 _buffer = _buffer.mid(bytesused);
190
191 if (irc == GCOBR_OK || irc == GCOBR_MESSAGEFOLLOWS ) {
192
193 setEpochTime(); // sets _lastTime
194
195 if (_lastTime.valid()) {
196 reopen();
197 checkProviderID();
198 sendResults();
199 retCode = success;
200 }
201 else {
202 retCode = failure;
203 }
204
205 reset();
206 }
207 }
208 }
209
210 return retCode;
211}
212
213//
214////////////////////////////////////////////////////////////////////////////
215void RTCM3coDecoder::sendResults() {
216
217 QList<t_orbCorr>& orbCorrections = _orbCorrections[_lastTime];
218 QList<t_clkCorr>& clkCorrections = _clkCorrections[_lastTime];
219 QList<t_satCodeBias>& codeBiases = _codeBiases[_lastTime];
220 QList<t_satPhaseBias>& phaseBiases = _phaseBiases[_lastTime];
221 t_vTec& vTec = _vTecMap[_lastTime];
222
223 // Orbit and clock corrections of all satellites
224 // ---------------------------------------------
225 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS + _clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS]; ii++) {
226 char sysCh = ' ';
227 if (ii < _clkOrb.NumberOfSat[CLOCKORBIT_SATGPS]) {
228 sysCh = 'G';
229 }
230 else if (ii >= CLOCKORBIT_NUMGPS) {
231 sysCh = 'R';
232 }
233 else {
234 continue;
235 }
236
237 // Orbit correction
238 // ----------------
239 if ( _clkOrb.messageType == COTYPE_GPSCOMBINED ||
240 _clkOrb.messageType == COTYPE_GLONASSCOMBINED ||
241 _clkOrb.messageType == COTYPE_GPSORBIT ||
242 _clkOrb.messageType == COTYPE_GLONASSORBIT ) {
243
244 t_orbCorr orbCorr;
245 orbCorr._prn.set(sysCh, _clkOrb.Sat[ii].ID);
246 orbCorr._staID = _staID.toAscii().data();
247 orbCorr._iod = _clkOrb.Sat[ii].IOD;
248 orbCorr._time = _lastTime;
249 orbCorr._system = 'R';
250 orbCorr._xr[0] = _clkOrb.Sat[ii].Orbit.DeltaRadial;
251 orbCorr._xr[1] = _clkOrb.Sat[ii].Orbit.DeltaAlongTrack;
252 orbCorr._xr[2] = _clkOrb.Sat[ii].Orbit.DeltaCrossTrack;
253 orbCorr._dotXr[0] = _clkOrb.Sat[ii].Orbit.DotDeltaRadial;
254 orbCorr._dotXr[1] = _clkOrb.Sat[ii].Orbit.DotDeltaAlongTrack;
255 orbCorr._dotXr[2] = _clkOrb.Sat[ii].Orbit.DotDeltaCrossTrack;
256
257 orbCorrections.push_back(orbCorr);
258
259 _IODs[orbCorr._prn] = _clkOrb.Sat[ii].IOD;
260 }
261
262 // Clock Corrections
263 // -----------------
264 if ( _clkOrb.messageType == COTYPE_GPSCOMBINED ||
265 _clkOrb.messageType == COTYPE_GLONASSCOMBINED ||
266 _clkOrb.messageType == COTYPE_GPSCLOCK ||
267 _clkOrb.messageType == COTYPE_GLONASSCLOCK ) {
268
269 t_clkCorr clkCorr;
270 clkCorr._prn.set(sysCh, _clkOrb.Sat[ii].ID);
271 clkCorr._staID = _staID.toAscii().data();
272 clkCorr._time = _lastTime;
273 clkCorr._dClk = _clkOrb.Sat[ii].Clock.DeltaA0 / t_CST::c;
274 clkCorr._dotDClk = _clkOrb.Sat[ii].Clock.DeltaA1 / t_CST::c;
275 clkCorr._dotDotDClk = _clkOrb.Sat[ii].Clock.DeltaA2 / t_CST::c;
276
277 _lastClkCorrections[clkCorr._prn] = clkCorr;
278
279 if (_IODs.contains(clkCorr._prn)) {
280 clkCorr._iod = _IODs[clkCorr._prn];
281 clkCorrections.push_back(clkCorr);
282 }
283 }
284
285 // High-Resolution Clocks
286 // ----------------------
287 if ( _clkOrb.messageType == COTYPE_GPSHR ||
288 _clkOrb.messageType == COTYPE_GLONASSHR ) {
289
290 t_prn prn(sysCh, _clkOrb.Sat[ii].ID);
291 if (_lastClkCorrections.contains(prn)) {
292 t_clkCorr clkCorr;
293 clkCorr = _lastClkCorrections[prn];
294 clkCorr._time = _lastTime;
295 clkCorr._dClk +=_clkOrb.Sat[ii].hrclock / t_CST::c;
296 if (_IODs.contains(clkCorr._prn)) {
297 clkCorr._iod = _IODs[clkCorr._prn];
298 clkCorrections.push_back(clkCorr);
299 }
300 }
301 }
302 }
303
304 // Code Biases
305 // -----------
306 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS + _codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS]; ii++) {
307 char sysCh = ' ';
308 if (ii < _codeBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
309 sysCh = 'G';
310 }
311 else if (ii >= CLOCKORBIT_NUMGPS) {
312 sysCh = 'R';
313 }
314 else {
315 continue;
316 }
317 t_satCodeBias satCodeBias;
318 satCodeBias._prn.set(sysCh, _codeBias.Sat[ii].ID);
319 satCodeBias._staID = _staID.toAscii().data();
320 satCodeBias._time = _lastTime;
321 for (unsigned jj = 0; jj < _codeBias.Sat[ii].NumberOfCodeBiases; jj++) {
322 const CodeBias::BiasSat::CodeBiasEntry& biasEntry = _codeBias.Sat[ii].Biases[jj];
323 t_frqCodeBias frqCodeBias;
324 frqCodeBias._rnxType2ch = codeTypeToRnxType(sysCh, biasEntry.Type);
325 frqCodeBias._value = biasEntry.Bias;
326 if (!frqCodeBias._rnxType2ch.empty()) {
327 satCodeBias._bias.push_back(frqCodeBias);
328 }
329 }
330 codeBiases.push_back(satCodeBias);
331 }
332
333 // Phase Biases
334 // -----------
335 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS + _phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS]; ii++) {
336 char sysCh = ' ';
337 if (ii < _phaseBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
338 sysCh = 'G';
339 }
340 else if (ii >= CLOCKORBIT_NUMGPS) {
341 sysCh = 'R';
342 }
343 else {
344 continue;
345 }
346 t_satPhaseBias satPhaseBias;
347 satPhaseBias._prn.set(sysCh, _phaseBias.Sat[ii].ID);
348 satPhaseBias._staID = _staID.toAscii().data();
349 satPhaseBias._time = _lastTime;
350 satPhaseBias._yawDeg = _phaseBias.Sat[ii].YawAngle * 180.0 / M_PI;
351 satPhaseBias._yawDegRate = _phaseBias.Sat[ii].YawRate * 180.0 / M_PI;
352 for (unsigned jj = 0; jj < _phaseBias.Sat[ii].NumberOfPhaseBiases; jj++) {
353 const PhaseBias::PhaseBiasSat::PhaseBiasEntry& biasEntry = _phaseBias.Sat[ii].Biases[jj];
354 t_frqPhaseBias frqPhaseBias;
355 frqPhaseBias._rnxType2ch = codeTypeToRnxType(sysCh, biasEntry.Type);
356 frqPhaseBias._value = biasEntry.Bias;
357 frqPhaseBias._fixIndicator = biasEntry.SignalIntegerIndicator;
358 frqPhaseBias._fixWideLaneIndicator = biasEntry.SignalsWideLaneIntegerIndicator;
359 frqPhaseBias._jumpCounter = biasEntry.SignalDiscontinuityCounter;
360 if (!frqPhaseBias._rnxType2ch.empty()) {
361 satPhaseBias._bias.push_back(frqPhaseBias);
362 }
363 }
364 phaseBiases.push_back(satPhaseBias);
365 }
366
367 // Ionospheric Model
368 // -----------------
369 if (_vTEC.NumLayers > 0) {
370 vTec._time = _lastTime;
371 vTec._staID = _staID.toAscii().data();
372 for (unsigned ii = 0; ii < _vTEC.NumLayers; ii++) {
373 const VTEC::IonoLayers& ionoLayer = _vTEC.Layers[ii];
374 t_vTecLayer layer;
375 layer._height = ionoLayer.Height;
376 layer._C.ReSize(ionoLayer.Degree, ionoLayer.Order);
377 layer._S.ReSize(ionoLayer.Degree, ionoLayer.Order);
378 for (unsigned iDeg = 0; iDeg < ionoLayer.Degree; iDeg++) {
379 for (unsigned iOrd = 0; iOrd < ionoLayer.Order; iOrd++) {
380 layer._C[iDeg][iOrd] = ionoLayer.Cosinus[iDeg][iOrd];
381 layer._S[iDeg][iOrd] = ionoLayer.Sinus[iDeg][iOrd];
382 }
383 }
384 vTec._layers.push_back(layer);
385 }
386 }
387
388 // Remove Empty Lists
389 // ------------------
390 if (orbCorrections.size() == 0) {
391 _orbCorrections.remove(_lastTime);
392 }
393 if (clkCorrections.size() == 0) {
394 _clkCorrections.remove(_lastTime);
395 }
396 if (codeBiases.size() == 0) {
397 _codeBiases.remove(_lastTime);
398 }
399 if (phaseBiases.size() == 0) {
400 _phaseBiases.remove(_lastTime);
401 }
402 if (vTec._layers.size() == 0) {
403 _vTecMap.remove(_lastTime);
404 }
405
406 // Dump all older epochs
407 // ---------------------
408 QMutableMapIterator<bncTime, QList<t_orbCorr> > itOrb(_orbCorrections);
409 while (itOrb.hasNext()) {
410 itOrb.next();
411 if (itOrb.key() < _lastTime) {
412 emit newOrbCorrections(itOrb.value());
413 t_orbCorr::writeEpoch(_out, itOrb.value());
414 itOrb.remove();
415 }
416 }
417 QMutableMapIterator<bncTime, QList<t_clkCorr> > itClk(_clkCorrections);
418 while (itClk.hasNext()) {
419 itClk.next();
420 if (itClk.key() < _lastTime) {
421 emit newClkCorrections(itClk.value());
422 t_clkCorr::writeEpoch(_out, itClk.value());
423 itClk.remove();
424 }
425 }
426 QMutableMapIterator<bncTime, QList<t_satCodeBias> > itCB(_codeBiases);
427 while (itCB.hasNext()) {
428 itCB.next();
429 if (itCB.key() < _lastTime) {
430 emit newCodeBiases(itCB.value());
431 t_satCodeBias::writeEpoch(_out, itCB.value());
432 itCB.remove();
433 }
434 }
435 QMutableMapIterator<bncTime, QList<t_satPhaseBias> > itPB(_phaseBiases);
436 while (itPB.hasNext()) {
437 itPB.next();
438 if (itPB.key() < _lastTime) {
439 emit newPhaseBiases(itPB.value());
440 t_satPhaseBias::writeEpoch(_out, itPB.value());
441 itPB.remove();
442 }
443 }
444 QMutableMapIterator<bncTime, t_vTec> itTec(_vTecMap);
445 while (itTec.hasNext()) {
446 itTec.next();
447 if (itTec.key() < _lastTime) {
448 emit newTec(itTec.value());
449 t_vTec::write(_out, itTec.value());
450 itTec.remove();
451 }
452 }
453}
454
455//
456////////////////////////////////////////////////////////////////////////////
457void RTCM3coDecoder::checkProviderID() {
458
459 if (_clkOrb.SSRProviderID == 0 && _clkOrb.SSRSolutionID == 0 && _clkOrb.SSRIOD == 0) {
460 return;
461 }
462
463 int newProviderID[3];
464 newProviderID[0] = _clkOrb.SSRProviderID;
465 newProviderID[1] = _clkOrb.SSRSolutionID;
466 newProviderID[2] = _clkOrb.SSRIOD;
467
468 bool alreadySet = false;
469 bool different = false;
470
471 for (unsigned ii = 0; ii < 3; ii++) {
472 if (_providerID[ii] != -1) {
473 alreadySet = true;
474 }
475 if (_providerID[ii] != newProviderID[ii]) {
476 different = true;
477 }
478 _providerID[ii] = newProviderID[ii];
479 }
480
481 if (alreadySet && different) {
482 emit newMessage("RTCM3coDecoder: Provider Changed " + _staID.toAscii() + "\n", true);
483 emit providerIDChanged(_staID);
484 }
485}
486
487//
488////////////////////////////////////////////////////////////////////////////
489void RTCM3coDecoder::setEpochTime() {
490
491 _lastTime.reset();
492
493 int epoSecGPS = -1;
494 int epoSecGlo = -1;
495 if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
496 epoSecGPS = _clkOrb.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
497 }
498 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
499 epoSecGPS = _codeBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
500 }
501 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
502 epoSecGPS = _phaseBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
503 }
504 else if (_vTEC.NumLayers > 0) {
505 epoSecGPS = _vTEC.EpochTime; // 0 .. 604799 s
506 }
507 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
508 epoSecGlo = _clkOrb.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
509 }
510 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
511 epoSecGlo = _codeBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
512 }
513 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
514 epoSecGlo = _phaseBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
515 }
516
517 // Retrieve current time
518 // ---------------------
519 int currentWeek = 0;
520 double currentSec = 0.0;
521 currentGPSWeeks(currentWeek, currentSec);
522 bncTime currentTime(currentWeek, currentSec);
523
524 // Set _lastTime close to currentTime
525 // ----------------------------------
526 if (epoSecGPS != -1) {
527 _lastTime.set(currentWeek, epoSecGPS);
528 }
529 else if (epoSecGlo != -1) {
530 QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
531 epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
532 _lastTime.set(currentWeek, epoSecGlo);
533 }
534
535 if (_lastTime.valid()) {
536 double maxDiff = 12 * 3600.0;
537 while (_lastTime < currentTime - maxDiff) {
538 _lastTime = _lastTime + maxDiff;
539 }
540 while (_lastTime > currentTime + maxDiff) {
541 _lastTime = _lastTime - maxDiff;
542 }
543 }
544}
545
546//
547////////////////////////////////////////////////////////////////////////////
548string RTCM3coDecoder::codeTypeToRnxType(char system, CodeType type) const {
549 if (system == 'G') {
550 switch (type) {
551 case CODETYPEGPS_L1_CA: return "1C";
552 case CODETYPEGPS_L1_P: return "1P";
553 case CODETYPEGPS_L1_Z: return "1W";
554 case CODETYPEGPS_L2_CA: return "2C";
555 case CODETYPEGPS_SEMI_CODELESS: return "?N"; // which carrier ?
556 case CODETYPEGPS_L2_CM: return "2S";
557 case CODETYPEGPS_L2_CL: return "2L";
558 case CODETYPEGPS_L2_CML: return "2X";
559 case CODETYPEGPS_L2_P: return "2P";
560 case CODETYPEGPS_L2_Z: return "2W";
561 case CODETYPEGPS_L5_I: return "5I";
562 case CODETYPEGPS_L5_Q: return "5Q";
563 default: return "";
564 }
565 }
566 else if (system == 'R') {
567 switch (type) {
568 case CODETYPEGLONASS_L1_CA: return "1C";
569 case CODETYPEGLONASS_L1_P: return "1P";
570 case CODETYPEGLONASS_L2_CA: return "2C";
571 case CODETYPEGLONASS_L2_P: return "2P";
572 default: return "";
573 }
574 }
575 else if (system == 'E') {
576 switch (type) {
577 case CODETYPEGALILEO_E1_A: return "1A";
578 case CODETYPEGALILEO_E1_B: return "1B";
579 case CODETYPEGALILEO_E1_C: return "1C";
580 case CODETYPEGALILEO_E5A_I: return "5I";
581 case CODETYPEGALILEO_E5A_Q: return "5Q";
582 case CODETYPEGALILEO_E5B_I: return "7I";
583 case CODETYPEGALILEO_E5B_Q: return "7Q";
584 case CODETYPEGALILEO_E5_I: return "8I";
585 case CODETYPEGALILEO_E5_Q: return "8Q";
586 case CODETYPEGALILEO_E6_A: return "6A";
587 case CODETYPEGALILEO_E6_B: return "6B";
588 case CODETYPEGALILEO_E6_C: return "6C";
589 default: return "";
590 }
591 }
592 else if (system == 'J') {
593 switch (type) {
594 case CODETYPEQZSS_L1_CA: return "1C";
595 case CODETYPEQZSS_L1C_D: return "1S";
596 case CODETYPEQZSS_L1C_P: return "1L";
597 case CODETYPEQZSS_L1C_DP: return "1X";
598 case CODETYPEQZSS_L2_CM: return "2S";
599 case CODETYPEQZSS_L2_CL: return "2L";
600 case CODETYPEQZSS_L2_CML: return "2X";
601 case CODETYPEQZSS_L5_I: return "5I";
602 case CODETYPEQZSS_L5_Q: return "5Q";
603 case CODETYPEQZSS_L5_IQ: return "5X";
604 case CODETYPEQZSS_LEX_S: return "6S";
605 case CODETYPEQZSS_LEX_L: return "6L";
606 case CODETYPEQZSS_LEX_SL: return "6X";
607 default: return "";
608 }
609 }
610 else if (system == 'S') {
611 switch (type) {
612 case CODETYPE_SBAS_L1_CA: return "1C";
613 case CODETYPE_SBAS_L5_I: return "5I";
614 case CODETYPE_SBAS_L5_Q: return "5Q";
615 case CODETYPE_SBAS_L5_IQ: return "5X";
616 default: return "";
617 }
618 }
619 else if (system == 'C') {
620 switch (type) {
621 case CODETYPE_BDS_B1_I: return "1I";
622 case CODETYPE_BDS_B1_Q: return "1Q";
623 case CODETYPE_BDS_B1_IQ: return "1X";
624 case CODETYPE_BDS_B2_I: return "7I";
625 case CODETYPE_BDS_B2_Q: return "7Q";
626 case CODETYPE_BDS_B2_IQ: return "7X";
627 case CODETYPE_BDS_B3_I: return "6I";
628 case CODETYPE_BDS_B3_Q: return "6Q";
629 case CODETYPE_BDS_B3_IQ: return "6X";
630 default: return "";
631 }
632 }
633 return "";
634};
Note: See TracBrowser for help on using the repository browser.