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

Last change on this file since 7005 was 7005, checked in by stuerze, 9 years ago

consideration of the eph flag in order to declare the Galileo clock and orbit corrections as to be valid for I/NAV

File size: 25.9 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 "bnctime.h"
50
51using namespace std;
52
53// Constructor
54////////////////////////////////////////////////////////////////////////////
55RTCM3coDecoder::RTCM3coDecoder(const QString& staID) {
56
57 _staID = staID;
58
59 // File Output
60 // -----------
61 bncSettings settings;
62 QString path = settings.value("corrPath").toString();
63 if (!path.isEmpty()) {
64 expandEnvVar(path);
65 if ( path.length() > 0 && path[path.length()-1] != QDir::separator() ) {
66 path += QDir::separator();
67 }
68 _fileNameSkl = path + staID;
69 }
70 _out = 0;
71
72 connect(this, SIGNAL(newOrbCorrections(QList<t_orbCorr>)),
73 BNC_CORE, SLOT(slotNewOrbCorrections(QList<t_orbCorr>)));
74
75 connect(this, SIGNAL(newClkCorrections(QList<t_clkCorr>)),
76 BNC_CORE, SLOT(slotNewClkCorrections(QList<t_clkCorr>)));
77
78 connect(this, SIGNAL(newCodeBiases(QList<t_satCodeBias>)),
79 BNC_CORE, SLOT(slotNewCodeBiases(QList<t_satCodeBias>)));
80
81 connect(this, SIGNAL(newPhaseBiases(QList<t_satPhaseBias>)),
82 BNC_CORE, SLOT(slotNewPhaseBiases(QList<t_satPhaseBias>)));
83
84 connect(this, SIGNAL(newTec(t_vTec)),
85 BNC_CORE, SLOT(slotNewTec(t_vTec)));
86
87 connect(this, SIGNAL(providerIDChanged(QString)),
88 BNC_CORE, SIGNAL(providerIDChanged(QString)));
89
90 connect(this, SIGNAL(newMessage(QByteArray,bool)),
91 BNC_CORE, SLOT(slotMessage(const QByteArray,bool)));
92
93 reset();
94
95 _providerID[0] = -1;
96 _providerID[1] = -1;
97 _providerID[2] = -1;
98}
99
100// Destructor
101////////////////////////////////////////////////////////////////////////////
102RTCM3coDecoder::~RTCM3coDecoder() {
103 delete _out;
104}
105
106//
107////////////////////////////////////////////////////////////////////////////
108void RTCM3coDecoder::reset() {
109 memset(&_clkOrb, 0, sizeof(_clkOrb));
110 memset(&_codeBias, 0, sizeof(_codeBias));
111 memset(&_phaseBias, 0, sizeof(_phaseBias));
112 memset(&_vTEC, 0, sizeof(_vTEC));
113}
114
115// Reopen Output File
116////////////////////////////////////////////////////////////////////////
117void RTCM3coDecoder::reopen() {
118
119 if (!_fileNameSkl.isEmpty()) {
120
121 bncSettings settings;
122
123 QDateTime datTim = currentDateAndTimeGPS();
124
125 QString hlpStr = bncRinex::nextEpochStr(datTim,
126 settings.value("corrIntr").toString());
127
128 QString fileNameHlp = _fileNameSkl
129 + QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0'))
130 + hlpStr + datTim.toString(".yyC");
131
132 if (_fileName == fileNameHlp) {
133 return;
134 }
135 else {
136 _fileName = fileNameHlp;
137 }
138
139 delete _out;
140 if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
141 _out = new ofstream( _fileName.toAscii().data(), ios_base::out | ios_base::app );
142 }
143 else {
144 _out = new ofstream( _fileName.toAscii().data() );
145 }
146 }
147}
148
149//
150////////////////////////////////////////////////////////////////////////////
151t_irc RTCM3coDecoder::Decode(char* buffer, int bufLen, vector<string>& errmsg) {
152
153 errmsg.clear();
154
155 _buffer.append(QByteArray(buffer,bufLen));
156
157 t_irc retCode = failure;
158
159 while(_buffer.size()) {
160
161 struct ClockOrbit clkOrbSav;
162 struct CodeBias codeBiasSav;
163 struct PhaseBias phaseBiasSav;
164 struct VTEC vTECSav;
165 memcpy(&clkOrbSav, &_clkOrb, sizeof(clkOrbSav)); // save state
166 memcpy(&codeBiasSav, &_codeBias, sizeof(codeBiasSav));
167 memcpy(&phaseBiasSav, &_phaseBias, sizeof(phaseBiasSav));
168 memcpy(&vTECSav, &_vTEC, sizeof(vTECSav));
169
170 int bytesused = 0;
171 GCOB_RETURN irc = GetSSR(&_clkOrb, &_codeBias, &_vTEC, &_phaseBias,
172 _buffer.data(), _buffer.size(), &bytesused);
173
174 if (irc <= -30) { // not enough data - restore state and exit loop
175 memcpy(&_clkOrb, &clkOrbSav, sizeof(clkOrbSav));
176 memcpy(&_codeBias, &codeBiasSav, sizeof(codeBiasSav));
177 memcpy(&_phaseBias, &phaseBiasSav, sizeof(phaseBiasSav));
178 memcpy(&_vTEC, &vTECSav, sizeof(vTECSav));
179 break;
180 }
181
182 else if (irc < 0) { // error - skip 1 byte and retry
183 reset();
184 _buffer = _buffer.mid(bytesused ? bytesused : 1);
185 }
186
187 else { // OK or MESSAGEFOLLOWS
188 _buffer = _buffer.mid(bytesused);
189
190 if (irc == GCOBR_OK || irc == GCOBR_MESSAGEFOLLOWS ) {
191
192 setEpochTime(); // sets _lastTime
193
194 if (_lastTime.valid()) {
195 reopen();
196 checkProviderID();
197 sendResults();
198 retCode = success;
199 }
200 else {
201 retCode = failure;
202 }
203
204 reset();
205 }
206 }
207 }
208
209 return retCode;
210}
211
212//
213////////////////////////////////////////////////////////////////////////////
214void RTCM3coDecoder::sendResults() {
215
216 // Orbit and clock corrections of all satellites
217 // ---------------------------------------------
218 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
219 + CLOCKORBIT_NUMGLONASS
220 + CLOCKORBIT_NUMGALILEO
221 + CLOCKORBIT_NUMQZSS
222 + CLOCKORBIT_NUMSBAS
223 + _clkOrb.NumberOfSat[CLOCKORBIT_SATBDS];
224 ii++) {
225 char sysCh = ' ';
226 int flag = 0;
227 if (ii < _clkOrb.NumberOfSat[CLOCKORBIT_SATGPS]) {
228 sysCh = 'G';
229 }
230 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
231 ii < CLOCKORBIT_OFFSETGLONASS + _clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
232 sysCh = 'R';
233 }
234 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
235 ii < CLOCKORBIT_OFFSETGALILEO + _clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
236 sysCh = 'E';
237 flag = 1; // I/NAV clock has been chosen as reference clock for Galileo SSR corrections
238 }
239 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
240 ii < CLOCKORBIT_OFFSETQZSS + _clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS]) {
241 sysCh = 'J';
242 }
243 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
244 ii < CLOCKORBIT_OFFSETSBAS + _clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS]) {
245 sysCh = 'S';
246 }
247 else if (ii >= CLOCKORBIT_OFFSETBDS &&
248 ii < CLOCKORBIT_OFFSETBDS + _clkOrb.NumberOfSat[CLOCKORBIT_SATBDS]) {
249 sysCh = 'C';
250 }
251 else {
252 continue;
253 }
254 // Orbit correction
255 // ----------------
256 if ( _clkOrb.messageType == COTYPE_GPSCOMBINED ||
257 _clkOrb.messageType == COTYPE_GLONASSCOMBINED ||
258 _clkOrb.messageType == COTYPE_GALILEOCOMBINED ||
259 _clkOrb.messageType == COTYPE_QZSSCOMBINED ||
260 _clkOrb.messageType == COTYPE_SBASCOMBINED ||
261 _clkOrb.messageType == COTYPE_BDSCOMBINED ||
262 _clkOrb.messageType == COTYPE_GPSORBIT ||
263 _clkOrb.messageType == COTYPE_GLONASSORBIT ||
264 _clkOrb.messageType == COTYPE_GALILEOORBIT ||
265 _clkOrb.messageType == COTYPE_QZSSORBIT ||
266 _clkOrb.messageType == COTYPE_SBASORBIT ||
267 _clkOrb.messageType == COTYPE_BDSORBIT ) {
268
269 t_orbCorr orbCorr;
270 orbCorr._prn.set(sysCh, _clkOrb.Sat[ii].ID, flag);
271 orbCorr._staID = _staID.toStdString();
272 orbCorr._iod = _clkOrb.Sat[ii].IOD;
273 orbCorr._time = _lastTime;
274 orbCorr._updateInt = _clkOrb.UpdateInterval;
275 orbCorr._system = sysCh;
276 orbCorr._xr[0] = _clkOrb.Sat[ii].Orbit.DeltaRadial;
277 orbCorr._xr[1] = _clkOrb.Sat[ii].Orbit.DeltaAlongTrack;
278 orbCorr._xr[2] = _clkOrb.Sat[ii].Orbit.DeltaCrossTrack;
279 orbCorr._dotXr[0] = _clkOrb.Sat[ii].Orbit.DotDeltaRadial;
280 orbCorr._dotXr[1] = _clkOrb.Sat[ii].Orbit.DotDeltaAlongTrack;
281 orbCorr._dotXr[2] = _clkOrb.Sat[ii].Orbit.DotDeltaCrossTrack;
282
283 _orbCorrections[_lastTime].push_back(orbCorr);
284
285 _IODs[orbCorr._prn] = _clkOrb.Sat[ii].IOD;
286 }
287
288 // Clock Corrections
289 // -----------------
290 if ( _clkOrb.messageType == COTYPE_GPSCOMBINED ||
291 _clkOrb.messageType == COTYPE_GLONASSCOMBINED ||
292 _clkOrb.messageType == COTYPE_GALILEOCOMBINED ||
293 _clkOrb.messageType == COTYPE_QZSSCOMBINED ||
294 _clkOrb.messageType == COTYPE_SBASCOMBINED ||
295 _clkOrb.messageType == COTYPE_BDSCOMBINED ||
296 _clkOrb.messageType == COTYPE_GPSCLOCK ||
297 _clkOrb.messageType == COTYPE_GLONASSCLOCK ||
298 _clkOrb.messageType == COTYPE_GALILEOCLOCK ||
299 _clkOrb.messageType == COTYPE_QZSSCLOCK ||
300 _clkOrb.messageType == COTYPE_SBASCLOCK ||
301 _clkOrb.messageType == COTYPE_BDSCLOCK) {
302
303 t_clkCorr clkCorr;
304 clkCorr._prn.set(sysCh, _clkOrb.Sat[ii].ID, flag);
305
306 clkCorr._staID = _staID.toStdString();
307 clkCorr._time = _lastTime;
308 clkCorr._updateInt = _clkOrb.UpdateInterval;
309 clkCorr._dClk = _clkOrb.Sat[ii].Clock.DeltaA0 / t_CST::c;
310 clkCorr._dotDClk = _clkOrb.Sat[ii].Clock.DeltaA1 / t_CST::c;
311 clkCorr._dotDotDClk = _clkOrb.Sat[ii].Clock.DeltaA2 / t_CST::c;
312
313 _lastClkCorrections[clkCorr._prn] = clkCorr;
314
315 if (_IODs.contains(clkCorr._prn)) {
316 clkCorr._iod = _IODs[clkCorr._prn];
317 _clkCorrections[_lastTime].push_back(clkCorr);
318 }
319 }
320
321 // High-Resolution Clocks
322 // ----------------------
323 if ( _clkOrb.messageType == COTYPE_GPSHR ||
324 _clkOrb.messageType == COTYPE_GLONASSHR ||
325 _clkOrb.messageType == COTYPE_GALILEOHR ||
326 _clkOrb.messageType == COTYPE_QZSSHR ||
327 _clkOrb.messageType == COTYPE_SBASHR ||
328 _clkOrb.messageType == COTYPE_BDSHR) {
329 t_prn prn(sysCh, _clkOrb.Sat[ii].ID, flag);
330 if (_lastClkCorrections.contains(prn)) {
331 t_clkCorr clkCorr;
332 clkCorr = _lastClkCorrections[prn];
333 clkCorr._time = _lastTime;
334 clkCorr._updateInt = _clkOrb.UpdateInterval;
335 clkCorr._dClk += _clkOrb.Sat[ii].hrclock / t_CST::c;
336 if (_IODs.contains(clkCorr._prn)) {
337 clkCorr._iod = _IODs[clkCorr._prn];
338 _clkCorrections[_lastTime].push_back(clkCorr);
339 }
340 }
341 }
342 }
343
344 // Code Biases
345 // -----------
346 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
347 + CLOCKORBIT_NUMGLONASS
348 + CLOCKORBIT_NUMGALILEO
349 + CLOCKORBIT_NUMQZSS
350 + CLOCKORBIT_NUMSBAS
351 + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS];
352 ii++) {
353 char sysCh = ' ';
354 if (ii < _codeBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
355 sysCh = 'G';
356 }
357 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
358 ii < CLOCKORBIT_OFFSETGLONASS + _codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
359 sysCh = 'R';
360 }
361 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
362 ii < CLOCKORBIT_OFFSETGALILEO + _codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
363 sysCh = 'E';
364 }
365 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
366 ii < CLOCKORBIT_OFFSETQZSS + _codeBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
367 sysCh = 'J';
368 }
369 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
370 ii < CLOCKORBIT_OFFSETSBAS + _codeBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
371 sysCh = 'S';
372 }
373 else if (ii >= CLOCKORBIT_OFFSETBDS &&
374 ii < CLOCKORBIT_OFFSETBDS + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
375 sysCh = 'C';
376 }
377 else {
378 continue;
379 }
380 t_satCodeBias satCodeBias;
381 satCodeBias._prn.set(sysCh, _codeBias.Sat[ii].ID);
382 satCodeBias._staID = _staID.toStdString();
383 satCodeBias._time = _lastTime;
384 satCodeBias._updateInt = _codeBias.UpdateInterval;
385 for (unsigned jj = 0; jj < _codeBias.Sat[ii].NumberOfCodeBiases; jj++) {
386 const CodeBias::BiasSat::CodeBiasEntry& biasEntry = _codeBias.Sat[ii].Biases[jj];
387 t_frqCodeBias frqCodeBias;
388 frqCodeBias._rnxType2ch = codeTypeToRnxType(sysCh, biasEntry.Type);
389 frqCodeBias._value = biasEntry.Bias;
390 if (!frqCodeBias._rnxType2ch.empty()) {
391 satCodeBias._bias.push_back(frqCodeBias);
392 }
393 }
394 _codeBiases[_lastTime].push_back(satCodeBias);
395 }
396
397 // Phase Biases
398 // -----------
399 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
400 + CLOCKORBIT_NUMGLONASS
401 + CLOCKORBIT_NUMGALILEO
402 + CLOCKORBIT_NUMQZSS
403 + CLOCKORBIT_NUMSBAS
404 + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS];
405 ii++) {
406 char sysCh = ' ';
407 if (ii < _phaseBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
408 sysCh = 'G';
409 }
410 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
411 ii < CLOCKORBIT_OFFSETGLONASS + _phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
412 sysCh = 'R';
413 }
414 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
415 ii < CLOCKORBIT_OFFSETGALILEO + _phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
416 sysCh = 'E';
417 }
418 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
419 ii < CLOCKORBIT_OFFSETQZSS + _phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
420 sysCh = 'J';
421 }
422 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
423 ii < CLOCKORBIT_OFFSETSBAS + _phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
424 sysCh = 'S';
425 }
426 else if (ii >= CLOCKORBIT_OFFSETBDS &&
427 ii < CLOCKORBIT_OFFSETBDS + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
428 sysCh = 'C';
429 }
430 else {
431 continue;
432 }
433 t_satPhaseBias satPhaseBias;
434 satPhaseBias._prn.set(sysCh, _phaseBias.Sat[ii].ID);
435 satPhaseBias._staID = _staID.toStdString();
436 satPhaseBias._time = _lastTime;
437 satPhaseBias._updateInt = _phaseBias.UpdateInterval;
438 satPhaseBias._dispBiasConstistInd = _phaseBias.DispersiveBiasConsistencyIndicator;
439 satPhaseBias._MWConsistInd = _phaseBias.MWConsistencyIndicator;
440 satPhaseBias._yawDeg = _phaseBias.Sat[ii].YawAngle * 180.0 / M_PI;
441 satPhaseBias._yawDegRate = _phaseBias.Sat[ii].YawRate * 180.0 / M_PI;
442 for (unsigned jj = 0; jj < _phaseBias.Sat[ii].NumberOfPhaseBiases; jj++) {
443 const PhaseBias::PhaseBiasSat::PhaseBiasEntry& biasEntry = _phaseBias.Sat[ii].Biases[jj];
444 t_frqPhaseBias frqPhaseBias;
445 frqPhaseBias._rnxType2ch = codeTypeToRnxType(sysCh, biasEntry.Type);
446 frqPhaseBias._value = biasEntry.Bias;
447 frqPhaseBias._fixIndicator = biasEntry.SignalIntegerIndicator;
448 frqPhaseBias._fixWideLaneIndicator = biasEntry.SignalsWideLaneIntegerIndicator;
449 frqPhaseBias._jumpCounter = biasEntry.SignalDiscontinuityCounter;
450 if (!frqPhaseBias._rnxType2ch.empty()) {
451 satPhaseBias._bias.push_back(frqPhaseBias);
452 }
453 }
454 _phaseBiases[_lastTime].push_back(satPhaseBias);
455 }
456
457 // Ionospheric Model
458 // -----------------
459 if (_vTEC.NumLayers > 0) {
460 _vTecMap[_lastTime]._time = _lastTime;
461 _vTecMap[_lastTime]._updateInt = _vTEC.UpdateInterval;
462 _vTecMap[_lastTime]._staID = _staID.toStdString();
463 for (unsigned ii = 0; ii < _vTEC.NumLayers; ii++) {
464 const VTEC::IonoLayers& ionoLayer = _vTEC.Layers[ii];
465 t_vTecLayer layer;
466 layer._height = ionoLayer.Height;
467 layer._C.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
468 layer._S.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
469 for (unsigned iDeg = 0; iDeg <= ionoLayer.Degree; iDeg++) {
470 for (unsigned iOrd = 0; iOrd <= ionoLayer.Order; iOrd++) {
471 layer._C[iDeg][iOrd] = ionoLayer.Cosinus[iDeg][iOrd];
472 layer._S[iDeg][iOrd] = ionoLayer.Sinus[iDeg][iOrd];
473 }
474 }
475 _vTecMap[_lastTime]._layers.push_back(layer);
476 }
477 }
478
479 // Dump all older epochs
480 // ---------------------
481 QMutableMapIterator<bncTime, QList<t_orbCorr> > itOrb(_orbCorrections);
482 while (itOrb.hasNext()) {
483 itOrb.next();
484 if (itOrb.key() < _lastTime) {
485 emit newOrbCorrections(itOrb.value());
486 t_orbCorr::writeEpoch(_out, itOrb.value());
487 itOrb.remove();
488 }
489 }
490 QMutableMapIterator<bncTime, QList<t_clkCorr> > itClk(_clkCorrections);
491 while (itClk.hasNext()) {
492 itClk.next();
493 if (itClk.key() < _lastTime) {
494 emit newClkCorrections(itClk.value());
495 t_clkCorr::writeEpoch(_out, itClk.value());
496 itClk.remove();
497 }
498 }
499 QMutableMapIterator<bncTime, QList<t_satCodeBias> > itCB(_codeBiases);
500 while (itCB.hasNext()) {
501 itCB.next();
502 if (itCB.key() < _lastTime) {
503 emit newCodeBiases(itCB.value());
504 t_satCodeBias::writeEpoch(_out, itCB.value());
505 itCB.remove();
506 }
507 }
508 QMutableMapIterator<bncTime, QList<t_satPhaseBias> > itPB(_phaseBiases);
509 while (itPB.hasNext()) {
510 itPB.next();
511 if (itPB.key() < _lastTime) {
512 emit newPhaseBiases(itPB.value());
513 t_satPhaseBias::writeEpoch(_out, itPB.value());
514 itPB.remove();
515 }
516 }
517 QMutableMapIterator<bncTime, t_vTec> itTec(_vTecMap);
518 while (itTec.hasNext()) {
519 itTec.next();
520 if (itTec.key() < _lastTime) {
521 emit newTec(itTec.value());
522 t_vTec::write(_out, itTec.value());
523 itTec.remove();
524 }
525 }
526}
527
528//
529////////////////////////////////////////////////////////////////////////////
530void RTCM3coDecoder::checkProviderID() {
531
532 if (_clkOrb.SSRProviderID == 0 && _clkOrb.SSRSolutionID == 0 && _clkOrb.SSRIOD == 0) {
533 return;
534 }
535
536 int newProviderID[3];
537 newProviderID[0] = _clkOrb.SSRProviderID;
538 newProviderID[1] = _clkOrb.SSRSolutionID;
539 newProviderID[2] = _clkOrb.SSRIOD;
540
541 bool alreadySet = false;
542 bool different = false;
543
544 for (unsigned ii = 0; ii < 3; ii++) {
545 if (_providerID[ii] != -1) {
546 alreadySet = true;
547 }
548 if (_providerID[ii] != newProviderID[ii]) {
549 different = true;
550 }
551 _providerID[ii] = newProviderID[ii];
552 }
553
554 if (alreadySet && different) {
555 emit newMessage("RTCM3coDecoder: Provider Changed " + _staID.toAscii() + "\n", true);
556 emit providerIDChanged(_staID);
557 }
558}
559
560//
561////////////////////////////////////////////////////////////////////////////
562void RTCM3coDecoder::setEpochTime() {
563
564 _lastTime.reset();
565
566 double epoSecGPS = -1.0;
567 double epoSecGlo = -1.0;
568 double epoSecGal = -1.0;
569 double epoSecQzss = -1.0;
570 double epoSecSbas = -1.0;
571 double epoSecBds = -1.0;
572 if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
573 epoSecGPS = _clkOrb.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
574 }
575 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
576 epoSecGPS = _codeBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
577 }
578 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
579 epoSecGPS = _phaseBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
580 }
581 else if (_vTEC.NumLayers > 0) {
582 epoSecGPS = _vTEC.EpochTime; // 0 .. 604799 s
583 }
584 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
585 epoSecGlo = _clkOrb.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
586 }
587 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
588 epoSecGlo = _codeBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
589 }
590 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
591 epoSecGlo = _phaseBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
592 }
593 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
594 epoSecGal = _clkOrb.EpochTime[CLOCKORBIT_SATGALILEO];
595 }
596 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
597 epoSecGal = _codeBias.EpochTime[CLOCKORBIT_SATGALILEO];
598 }
599 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
600 epoSecGal = _phaseBias.EpochTime[CLOCKORBIT_SATGALILEO];
601 }
602 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
603 epoSecQzss = _clkOrb.EpochTime[CLOCKORBIT_SATQZSS];
604 }
605 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
606 epoSecQzss = _codeBias.EpochTime[CLOCKORBIT_SATQZSS];
607 }
608 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
609 epoSecQzss = _phaseBias.EpochTime[CLOCKORBIT_SATQZSS];
610 }
611 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
612 epoSecSbas = _clkOrb.EpochTime[CLOCKORBIT_SATSBAS];
613 }
614 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
615 epoSecSbas = _codeBias.EpochTime[CLOCKORBIT_SATSBAS];
616 }
617 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
618 epoSecSbas = _phaseBias.EpochTime[CLOCKORBIT_SATSBAS];
619 }
620 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
621 epoSecBds = _clkOrb.EpochTime[CLOCKORBIT_SATBDS];
622 }
623 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
624 epoSecBds = _codeBias.EpochTime[CLOCKORBIT_SATBDS];
625 }
626 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
627 epoSecBds = _phaseBias.EpochTime[CLOCKORBIT_SATBDS];
628 }
629
630 // Retrieve current time
631 // ---------------------
632 int currentWeek = 0;
633 double currentSec = 0.0;
634 currentGPSWeeks(currentWeek, currentSec);
635 bncTime currentTime(currentWeek, currentSec);
636
637 // Set _lastTime close to currentTime
638 // ----------------------------------
639 if (epoSecGPS != -1) {
640 _lastTime.set(currentWeek, epoSecGPS);
641 }
642 else if (epoSecGlo != -1) {
643 QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
644 epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
645 _lastTime.set(currentWeek, epoSecGlo);
646 }
647 else if (epoSecGal != -1) {
648 _lastTime.set(currentWeek, epoSecGal);
649 }
650 else if (epoSecQzss != -1) {
651 _lastTime.set(currentWeek, epoSecQzss);
652 }
653 else if (epoSecSbas != -1) {
654 _lastTime.set(currentWeek, epoSecSbas);
655 }
656 else if (epoSecBds != -1) {
657 epoSecBds += 14.0;
658 _lastTime.set(currentWeek, epoSecBds);
659 }
660
661 if (_lastTime.valid()) {
662 double maxDiff = 12 * 3600.0;
663 while (_lastTime < currentTime - maxDiff) {
664 _lastTime = _lastTime + maxDiff;
665 }
666 while (_lastTime > currentTime + maxDiff) {
667 _lastTime = _lastTime - maxDiff;
668 }
669 }
670}
671
672//
673////////////////////////////////////////////////////////////////////////////
674string RTCM3coDecoder::codeTypeToRnxType(char system, CodeType type) const {
675 if (system == 'G') {
676 switch (type) {
677 case CODETYPEGPS_L1_CA: return "1C";
678 case CODETYPEGPS_L1_P: return "1P";
679 case CODETYPEGPS_L1_Z: return "1W";
680 case CODETYPEGPS_L2_CA: return "2C";
681 case CODETYPEGPS_SEMI_CODELESS: return "?N"; // which carrier ?
682 case CODETYPEGPS_L2_CM: return "2S";
683 case CODETYPEGPS_L2_CL: return "2L";
684 case CODETYPEGPS_L2_CML: return "2X";
685 case CODETYPEGPS_L2_P: return "2P";
686 case CODETYPEGPS_L2_Z: return "2W";
687 case CODETYPEGPS_L5_I: return "5I";
688 case CODETYPEGPS_L5_Q: return "5Q";
689 default: return "";
690 }
691 }
692 else if (system == 'R') {
693 switch (type) {
694 case CODETYPEGLONASS_L1_CA: return "1C";
695 case CODETYPEGLONASS_L1_P: return "1P";
696 case CODETYPEGLONASS_L2_CA: return "2C";
697 case CODETYPEGLONASS_L2_P: return "2P";
698 default: return "";
699 }
700 }
701 else if (system == 'E') {
702 switch (type) {
703 case CODETYPEGALILEO_E1_A: return "1A";
704 case CODETYPEGALILEO_E1_B: return "1B";
705 case CODETYPEGALILEO_E1_C: return "1C";
706 case CODETYPEGALILEO_E5A_I: return "5I";
707 case CODETYPEGALILEO_E5A_Q: return "5Q";
708 case CODETYPEGALILEO_E5B_I: return "7I";
709 case CODETYPEGALILEO_E5B_Q: return "7Q";
710 case CODETYPEGALILEO_E5_I: return "8I";
711 case CODETYPEGALILEO_E5_Q: return "8Q";
712 case CODETYPEGALILEO_E6_A: return "6A";
713 case CODETYPEGALILEO_E6_B: return "6B";
714 case CODETYPEGALILEO_E6_C: return "6C";
715 default: return "";
716 }
717 }
718 else if (system == 'J') {
719 switch (type) {
720 case CODETYPEQZSS_L1_CA: return "1C";
721 case CODETYPEQZSS_L1C_D: return "1S";
722 case CODETYPEQZSS_L1C_P: return "1L";
723 case CODETYPEQZSS_L1C_DP: return "1X";
724 case CODETYPEQZSS_L2_CM: return "2S";
725 case CODETYPEQZSS_L2_CL: return "2L";
726 case CODETYPEQZSS_L2_CML: return "2X";
727 case CODETYPEQZSS_L5_I: return "5I";
728 case CODETYPEQZSS_L5_Q: return "5Q";
729 case CODETYPEQZSS_L5_IQ: return "5X";
730 case CODETYPEQZSS_LEX_S: return "6S";
731 case CODETYPEQZSS_LEX_L: return "6L";
732 case CODETYPEQZSS_LEX_SL: return "6X";
733 default: return "";
734 }
735 }
736 else if (system == 'S') {
737 switch (type) {
738 case CODETYPE_SBAS_L1_CA: return "1C";
739 case CODETYPE_SBAS_L5_I: return "5I";
740 case CODETYPE_SBAS_L5_Q: return "5Q";
741 case CODETYPE_SBAS_L5_IQ: return "5X";
742 default: return "";
743 }
744 }
745 else if (system == 'C') {
746 switch (type) {
747 case CODETYPE_BDS_B1_I: return "1I";
748 case CODETYPE_BDS_B1_Q: return "1Q";
749 case CODETYPE_BDS_B1_IQ: return "1X";
750 case CODETYPE_BDS_B2_I: return "7I";
751 case CODETYPE_BDS_B2_Q: return "7Q";
752 case CODETYPE_BDS_B2_IQ: return "7X";
753 case CODETYPE_BDS_B3_I: return "6I";
754 case CODETYPE_BDS_B3_Q: return "6Q";
755 case CODETYPE_BDS_B3_IQ: return "6X";
756 default: return "";
757 }
758 }
759 return "";
760};
Note: See TracBrowser for help on using the repository browser.