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

Last change on this file since 11031 was 11031, checked in by stuerze, 28 hours ago

minor changes
File size: 36.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://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#include <climits>
44
45#include "RTCM3coDecoder.h"
46#include "bncutils.h"
47#include "bncrinex.h"
48#include "bnccore.h"
49#include "bncsettings.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(newMetaData(t_metaData)),
89 BNC_CORE, SLOT(slotNewMetaData(t_metaData)));
90
91 connect(this, SIGNAL(providerIDChanged(QString)),
92 BNC_CORE, SIGNAL(providerIDChanged(QString)));
93
94 connect(this, SIGNAL(newMessage(QByteArray,bool)),
95 BNC_CORE, SLOT(slotMessage(const QByteArray,bool)));
96
97 reset();
98
99 _providerID[0] = -1;
100 _providerID[1] = -1;
101 _providerID[2] = -1;
102
103 _ssrCorr = 0;
104
105}
106
107// Destructor
108////////////////////////////////////////////////////////////////////////////
109RTCM3coDecoder::~RTCM3coDecoder() {
110 delete _out;
111 delete _ssrCorr;
112 _IODs.clear();
113 _orbCorrections.clear();
114 _clkCorrections.clear();
115 _lastClkCorrections.clear();
116 _codeBiases.clear();
117 _phaseBiases.clear();
118 _vTecMap.clear();
119 _metaDataMap.clear();
120}
121
122//
123////////////////////////////////////////////////////////////////////////////
124void RTCM3coDecoder::reset(bool resetPhaseBias) {
125 memset(&_clkOrb, 0, sizeof(_clkOrb));
126 memset(&_codeBias, 0, sizeof(_codeBias));
127 if (resetPhaseBias) {
128 memset(&_phaseBias, 0, sizeof(_phaseBias));
129 for (unsigned s = 0; s < CLOCKORBIT_SATNUM; s++) {
130 _phaseBiasSentEpoch[s] = UINT_MAX; // "never sent"
131 }
132 }
133 memset(&_vTEC, 0, sizeof(_vTEC));
134}
135
136// Reopen Output File
137////////////////////////////////////////////////////////////////////////
138void RTCM3coDecoder::reopen() {
139
140 if (!_fileNameSkl.isEmpty()) {
141
142 bncSettings settings;
143
144 QDateTime datTim = currentDateAndTimeGPS();
145
146 QString hlpStr = bncRinex::nextEpochStr(datTim,
147 settings.value("corrIntr").toString(), 3);
148
149 QString cntStr = (_fileNameSkl.contains("ION")) ? "_ION.ssr" : "_MC.ssr";
150
151 QString fileNameHlp = _fileNameSkl +
152 "_S_" + // stream
153 QString("%1").arg(datTim.date().year()) +
154 QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
155 hlpStr + // HM_period
156 cntStr; // mixed ION or CLK
157
158 if (_fileName == fileNameHlp) {
159 return;
160 }
161 else {
162 _fileName = fileNameHlp;
163 }
164
165 delete _out;
166 if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
167 _out = new ofstream( _fileName.toLatin1().data(), ios_base::out | ios_base::app );
168 }
169 else {
170 _out = new ofstream( _fileName.toLatin1().data() );
171 }
172 }
173}
174
175//
176////////////////////////////////////////////////////////////////////////////
177t_irc RTCM3coDecoder::Decode(char* buffer, int bufLen, vector<string>& errmsg) {
178
179 errmsg.clear();
180
181 _buffer.append(QByteArray(buffer,bufLen));
182
183 t_irc retCode = failure;
184
185 while(_buffer.size()) {
186
187 struct SsrCorr::ClockOrbit clkOrbSav;
188 struct SsrCorr::CodeBias codeBiasSav;
189 struct SsrCorr::PhaseBias phaseBiasSav;
190 struct SsrCorr::VTEC vTECSav;
191 struct SsrCorr::MetaData metaDataSav;
192 struct SsrCorr::Antenna antennaSav;
193 // save state
194 memcpy(&clkOrbSav, &_clkOrb, sizeof(clkOrbSav));
195 memcpy(&codeBiasSav, &_codeBias, sizeof(codeBiasSav));
196 memcpy(&phaseBiasSav, &_phaseBias, sizeof(phaseBiasSav));
197 memcpy(&vTECSav, &_vTEC, sizeof(vTECSav));
198 memcpy(&metaDataSav, &_metaData, sizeof(metaDataSav));
199 memcpy(&antennaSav, &_antenna, sizeof(antennaSav));
200
201 int bytesused = 0;
202
203 GCOB_RETURN irc = _ssrCorr->GetSSR(&_clkOrb, &_codeBias, &_vTEC, &_phaseBias, &_metaData, &_antenna,
204 _buffer.data(), _buffer.size(), &bytesused);
205
206 if (irc <= -30) { // not enough data - restore state and exit loop
207 memcpy(&_clkOrb, &clkOrbSav, sizeof(clkOrbSav));
208 memcpy(&_codeBias, &codeBiasSav, sizeof(codeBiasSav));
209 memcpy(&_phaseBias, &phaseBiasSav, sizeof(phaseBiasSav));
210 memcpy(&_vTEC, &vTECSav, sizeof(vTECSav));
211 memcpy(&_metaData, &metaDataSav, sizeof(metaDataSav));
212 break;
213 }
214
215 else if (irc < 0) { // error - skip this message (or 1 byte if the
216 // frame itself couldn't be recognized) and retry
217 if (irc != GCOBR_UNKNOWNTYPE) {
218 // A recognized-but-unimplemented message (e.g. Tropospheric or
219 // Regional Ionospheric Correction) leaves _clkOrb/_codeBias/
220 // _phaseBias/_vTEC untouched, and bytesused is already reliably set
221 // from its CRC-validated frame length, so there is nothing to
222 // discard. Every other error code may have left inconsistent
223 // partial state (e.g. mid-satellite-loop) or an unreliable frame
224 // boundary, so reset defensively there. Without this, streams with
225 // frequent unimplemented messages (e.g. dense grid-based Regional
226 // Ionospheric traffic) would wipe unrelated, still-valid orbit/
227 // clock/bias/phase-bias state every time one is skipped.
228 reset();
229 }
230 _buffer = _buffer.mid(bytesused ? bytesused : 1);
231 }
232
233 else { // OK or MESSAGEFOLLOWS
234 _buffer = _buffer.mid(bytesused);
235
236 if (irc == GCOBR_OK || irc == GCOBR_MESSAGEFOLLOWS ) {
237 setEpochTime(); // sets _lastTime
238
239 if (_lastTime.valid()) {
240 reopen();
241 checkProviderID();
242 sendResults();
243 retCode = success;
244 }
245 else {
246 emit newMessage("RTCM3coDecoder: _lastTime invalid: " + _staID.toLatin1(), true);
247 retCode = failure;
248 }
249 // Keep _phaseBias intact: an Extended Phase Bias message (COBOFS_PBEXT)
250 // arriving later needs to correlate against the satellite/signal list
251 // just published by this Phase Bias message. clock_orbit_rtcm_new.cpp's
252 // COBOFS_PBIAS handling resets pb->NumberOfSat[s] itself before decoding
253 // a fresh message, so this doesn't cause stale data to accumulate.
254 reset(false);
255 }
256 }
257 }
258
259 return retCode;
260}
261
262//
263////////////////////////////////////////////////////////////////////////////
264void RTCM3coDecoder::sendResults() {
265
266 // Orbit and clock corrections of all satellites
267 // ---------------------------------------------
268 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
269 + CLOCKORBIT_NUMGLONASS
270 + CLOCKORBIT_NUMGALILEO
271 + CLOCKORBIT_NUMQZSS
272 + CLOCKORBIT_NUMSBAS
273 + _clkOrb.NumberOfSat[CLOCKORBIT_SATBDS];
274 ii++) {
275 if (corrIsOutOfRange(_clkOrb.Sat[ii])) {
276 continue;
277 }
278 char sys = ' ';
279 int num = _clkOrb.Sat[ii].ID;
280 int flag = 0; // to force NAV type usage according SSR standard
281 if (ii < _clkOrb.NumberOfSat[CLOCKORBIT_SATGPS]) {
282 sys = 'G';
283 flag = t_eph::LNAV;
284 }
285 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
286 ii < CLOCKORBIT_OFFSETGLONASS + _clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
287 sys = 'R';
288 flag = t_eph::FDMA_M;
289 }
290 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
291 ii < CLOCKORBIT_OFFSETGALILEO + _clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
292 sys = 'E';
293 flag = t_eph::INAV;
294 }
295 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
296 ii < CLOCKORBIT_OFFSETQZSS + _clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS]) {
297 sys = 'J';
298 flag = t_eph::LNAV;
299 }
300 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
301 ii < CLOCKORBIT_OFFSETSBAS + _clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS]) {
302 sys = 'S';
303 flag = t_eph::SBASL1;
304 }
305 else if (ii >= CLOCKORBIT_OFFSETBDS &&
306 ii < CLOCKORBIT_OFFSETBDS + _clkOrb.NumberOfSat[CLOCKORBIT_SATBDS]) {
307 sys = 'C';
308 if (num < 6) {// GEO
309 flag = t_eph::D2;
310 }
311 else if (num > 58 && num < 63) { // GEO
312 flag = t_eph::D2;
313 }
314 else {
315 flag = t_eph::D1;
316 }
317 }
318 else {
319 continue;
320 }
321
322 // Orbit correction
323 // ----------------
324 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED ||
325 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
326 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
327 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
328 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
329 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
330 _clkOrb.messageType == _ssrCorr->COTYPE_GPSORBIT ||
331 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSORBIT ||
332 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOORBIT ||
333 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSORBIT ||
334 _clkOrb.messageType == _ssrCorr->COTYPE_SBASORBIT ||
335 _clkOrb.messageType == _ssrCorr->COTYPE_BDSORBIT ) {
336
337 t_orbCorr orbCorr;
338 orbCorr._prn.set(sys, num, flag);
339 orbCorr._staID = _staID.toStdString();
340 orbCorr._iod = _clkOrb.Sat[ii].IOD;
341 orbCorr._time = _lastTime;
342 orbCorr._updateInt = _clkOrb.UpdateInterval;
343 orbCorr._system = sys;
344 orbCorr._xr[0] = _clkOrb.Sat[ii].Orbit.DeltaRadial;
345 orbCorr._xr[1] = _clkOrb.Sat[ii].Orbit.DeltaAlongTrack;
346 orbCorr._xr[2] = _clkOrb.Sat[ii].Orbit.DeltaCrossTrack;
347 orbCorr._dotXr[0] = _clkOrb.Sat[ii].Orbit.DotDeltaRadial;
348 orbCorr._dotXr[1] = _clkOrb.Sat[ii].Orbit.DotDeltaAlongTrack;
349 orbCorr._dotXr[2] = _clkOrb.Sat[ii].Orbit.DotDeltaCrossTrack;
350 orbCorr._ssrFormat = (_type == RTCMssr) ? ssrRtcmOld :
351 (_type == RTCMnewssr) ? ssrRtcmNew : ssrUnknown;
352
353 _orbCorrections[_lastTime].append(orbCorr);
354
355 _IODs[orbCorr._prn] = _clkOrb.Sat[ii].IOD;
356 }
357
358 // Clock Corrections
359 // -----------------
360 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED ||
361 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
362 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
363 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
364 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
365 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
366 _clkOrb.messageType == _ssrCorr->COTYPE_GPSCLOCK ||
367 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCLOCK ||
368 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCLOCK ||
369 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCLOCK ||
370 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCLOCK ||
371 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCLOCK) {
372
373 t_clkCorr clkCorr;
374 clkCorr._prn.set(sys, _clkOrb.Sat[ii].ID, flag);
375 clkCorr._staID = _staID.toStdString();
376 clkCorr._time = _lastTime;
377 clkCorr._updateInt = _clkOrb.UpdateInterval;
378 clkCorr._dClk = _clkOrb.Sat[ii].Clock.DeltaA0 / t_CST::c;
379 clkCorr._dotDClk = _clkOrb.Sat[ii].Clock.DeltaA1 / t_CST::c;
380 clkCorr._dotDotDClk = _clkOrb.Sat[ii].Clock.DeltaA2 / t_CST::c;
381
382 _lastClkCorrections[clkCorr._prn] = clkCorr;
383
384 if (_IODs.contains(clkCorr._prn)) {
385 clkCorr._iod = _IODs[clkCorr._prn];
386 _clkCorrections[_lastTime].append(clkCorr);
387 }
388 }
389
390 // High-Resolution Clocks
391 // ----------------------
392 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSHR ||
393 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSHR ||
394 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOHR ||
395 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSHR ||
396 _clkOrb.messageType == _ssrCorr->COTYPE_SBASHR ||
397 _clkOrb.messageType == _ssrCorr->COTYPE_BDSHR) {
398 t_prn prn(sys, _clkOrb.Sat[ii].ID, flag);
399 if (_lastClkCorrections.contains(prn)) {
400 t_clkCorr clkCorr;
401 clkCorr = _lastClkCorrections[prn];
402 clkCorr._time = _lastTime;
403 clkCorr._updateInt = _clkOrb.UpdateInterval;
404 clkCorr._dClk += _clkOrb.Sat[ii].hrclock / t_CST::c;
405 if (_IODs.contains(clkCorr._prn)) {
406 clkCorr._iod = _IODs[clkCorr._prn];
407 _clkCorrections[_lastTime].append(clkCorr);
408 }
409 }
410 }
411 }
412
413 // Code Biases
414 // -----------
415 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
416 + CLOCKORBIT_NUMGLONASS
417 + CLOCKORBIT_NUMGALILEO
418 + CLOCKORBIT_NUMQZSS
419 + CLOCKORBIT_NUMSBAS
420 + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS];
421 ii++) {
422 char sys = ' ';
423 int num = _codeBias.Sat[ii].ID;
424 int flag = 0;
425 if (ii < _codeBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
426 sys = 'G';
427 flag = t_eph::LNAV;
428 }
429 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
430 ii < CLOCKORBIT_OFFSETGLONASS + _codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
431 sys = 'R';
432 flag = t_eph::FDMA_M;
433 }
434 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
435 ii < CLOCKORBIT_OFFSETGALILEO + _codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
436 sys = 'E';
437 flag = t_eph::INAV;
438 }
439 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
440 ii < CLOCKORBIT_OFFSETQZSS + _codeBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
441 sys = 'J';
442 flag = t_eph::LNAV;
443 }
444 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
445 ii < CLOCKORBIT_OFFSETSBAS + _codeBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
446 sys = 'S';
447 flag = t_eph::SBASL1;
448 }
449 else if (ii >= CLOCKORBIT_OFFSETBDS &&
450 ii < CLOCKORBIT_OFFSETBDS + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
451 sys = 'C';
452 if (num < 6) {// GEO
453 flag = t_eph::D2;
454 }
455 else if (num > 58 && num < 63) { // GEO
456 flag = t_eph::D2;
457 }
458 else {
459 flag = t_eph::D1;
460 }
461 }
462 else {
463 continue;
464 }
465 t_satCodeBias satCodeBias;
466 satCodeBias._prn.set(sys, num, flag);
467 satCodeBias._staID = _staID.toStdString();
468 satCodeBias._time = _lastTime;
469 satCodeBias._updateInt = _codeBias.UpdateInterval;
470 for (unsigned jj = 0; jj < _codeBias.Sat[ii].NumberOfCodeBiases; jj++) {
471 const SsrCorr::CodeBias::BiasSat::CodeBiasEntry& biasEntry = _codeBias.Sat[ii].Biases[jj];
472 t_frqCodeBias frqCodeBias;
473 frqCodeBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sys, biasEntry.Type));
474 frqCodeBias._value = biasEntry.Bias;
475 if (!frqCodeBias._rnxType2ch.empty()) {
476 satCodeBias._bias.push_back(frqCodeBias);
477 }
478 }
479 _codeBiases[_lastTime].append(satCodeBias);
480 }
481
482 // Phase Biases
483 // -----------
484 // _phaseBias is no longer wiped between messages (kept alive so a later
485 // Extended Phase Bias message can correlate against it - see
486 // COBOFS_PBEXT), so without this guard the block below would re-append
487 // the same system's satellites into the output on every other message
488 // decoded in between two actual phase-bias messages. Only emit a
489 // system's satellites once per epoch, tracked per system by comparing
490 // against the epoch we last actually sent for it.
491 bool phaseBiasFresh[CLOCKORBIT_SATNUM];
492 for (unsigned s = 0; s < CLOCKORBIT_SATNUM; s++) {
493 phaseBiasFresh[s] = _phaseBias.NumberOfSat[s] > 0 &&
494 _phaseBias.EpochTime[s] != _phaseBiasSentEpoch[s];
495 if (phaseBiasFresh[s]) {
496 _phaseBiasSentEpoch[s] = _phaseBias.EpochTime[s];
497 }
498 }
499 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
500 + CLOCKORBIT_NUMGLONASS
501 + CLOCKORBIT_NUMGALILEO
502 + CLOCKORBIT_NUMQZSS
503 + CLOCKORBIT_NUMSBAS
504 + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS];
505 ii++) {
506 char sys = ' ';
507 int num = _phaseBias.Sat[ii].ID;
508 int flag = 0;
509 if (ii < _phaseBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
510 if (!phaseBiasFresh[CLOCKORBIT_SATGPS]) continue;
511 sys = 'G';
512 flag = t_eph::LNAV;
513 }
514 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
515 ii < CLOCKORBIT_OFFSETGLONASS + _phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
516 if (!phaseBiasFresh[CLOCKORBIT_SATGLONASS]) continue;
517 sys = 'R';
518 flag = t_eph::FDMA_M;
519 }
520 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
521 ii < CLOCKORBIT_OFFSETGALILEO + _phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
522 if (!phaseBiasFresh[CLOCKORBIT_SATGALILEO]) continue;
523 sys = 'E';
524 flag = t_eph::INAV;
525 }
526 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
527 ii < CLOCKORBIT_OFFSETQZSS + _phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
528 if (!phaseBiasFresh[CLOCKORBIT_SATQZSS]) continue;
529 sys = 'J';
530 flag = t_eph::LNAV;
531 }
532 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
533 ii < CLOCKORBIT_OFFSETSBAS + _phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
534 if (!phaseBiasFresh[CLOCKORBIT_SATSBAS]) continue;
535 sys = 'S';
536 flag = t_eph::SBASL1;
537 }
538 else if (ii >= CLOCKORBIT_OFFSETBDS &&
539 ii < CLOCKORBIT_OFFSETBDS + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
540 if (!phaseBiasFresh[CLOCKORBIT_SATBDS]) continue;
541 sys = 'C';
542 if (num < 6) {// GEO
543 flag = t_eph::D2;
544 }
545 else if (num > 58 && num < 63) { // GEO
546 flag = t_eph::D2;
547 }
548 else {
549 flag = t_eph::D1;
550 }
551 }
552 else {
553 continue;
554 }
555 t_satPhaseBias satPhaseBias;
556 satPhaseBias._prn.set(sys, num, flag);
557 satPhaseBias._staID = _staID.toStdString();
558 satPhaseBias._time = _lastTime;
559 satPhaseBias._updateInt = _phaseBias.UpdateInterval;
560 satPhaseBias._ssrFormat = (_type == RTCMssr) ? ssrRtcmOld :
561 (_type == RTCMnewssr) ? ssrRtcmNew : ssrUnknown;
562 if (satPhaseBias._ssrFormat == e_ssrFormat::ssrRtcmNew) {
563 satPhaseBias._satYawInfoInd = _phaseBias.SatelliteYawInformationIndicator;
564 satPhaseBias._extPBPhaseInd = _phaseBias.ExtendedPhaseBiasPropertyID;
565 }
566 else {
567 satPhaseBias._dispBiasConsistInd = _phaseBias.DispersiveBiasConsistencyIndicator;
568 satPhaseBias._MelbWuebConsistInd = _phaseBias.MWConsistencyIndicator;
569 }
570 satPhaseBias._yaw = _phaseBias.Sat[ii].YawAngle;
571 satPhaseBias._yawRate = _phaseBias.Sat[ii].YawRate;
572 for (unsigned jj = 0; jj < _phaseBias.Sat[ii].NumberOfPhaseBiases; jj++) {
573 const SsrCorr::PhaseBias::PhaseBiasSat::PhaseBiasEntry& biasEntry = _phaseBias.Sat[ii].Biases[jj];
574 t_frqPhaseBias frqPhaseBias;
575 frqPhaseBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sys, biasEntry.Type));
576 frqPhaseBias._value = biasEntry.Bias;
577 frqPhaseBias._fixIndicator = biasEntry.IntegerIndicator;
578 if (satPhaseBias._ssrFormat == e_ssrFormat::ssrRtcmNew) {
579 if (satPhaseBias._extPBPhaseInd) {
580 frqPhaseBias._fixWideLaneIndicator = biasEntry.WidelaneGroupIndicator;
581 }
582 }
583 else {
584 frqPhaseBias._fixWideLaneIndicator = biasEntry.WidelaneGroupIndicator;
585 }
586 frqPhaseBias._jumpCounter = biasEntry.DiscontinuityCounter;
587 if (!frqPhaseBias._rnxType2ch.empty()) {
588 satPhaseBias._bias.push_back(frqPhaseBias);
589 }
590 }
591 _phaseBiases[_lastTime].append(satPhaseBias);
592 }
593
594 // Ionospheric Model
595 // -----------------
596 if (_vTEC.NumLayers > 0) {
597 _vTecMap[_lastTime]._time = _lastTime;
598 _vTecMap[_lastTime]._updateInt = _vTEC.UpdateInterval;
599 _vTecMap[_lastTime]._staID = _staID.toStdString();
600 for (unsigned ii = 0; ii < _vTEC.NumLayers; ii++) {
601 const SsrCorr::VTEC::IonoLayers& ionoLayer = _vTEC.Layers[ii];
602 t_vTecLayer layer;
603 layer._height = ionoLayer.Height;
604 layer._C.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
605 layer._S.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
606 for (unsigned iDeg = 0; iDeg <= ionoLayer.Degree; iDeg++) {
607 for (unsigned iOrd = 0; iOrd <= ionoLayer.Order; iOrd++) {
608 layer._C[iDeg][iOrd] = ionoLayer.Cosinus[iDeg][iOrd];
609 layer._S[iDeg][iOrd] = ionoLayer.Sinus[iDeg][iOrd];
610 }
611 }
612 _vTecMap[_lastTime]._layers.push_back(layer);
613 }
614 }
615
616 // Metadata (model correction information)
617 // ----------------------------------------
618 if (_metaData.NumEntries > 0) {
619 // Metadata carries no epoch field of its own (it is keyed here by
620 // _lastTime, inherited from whichever other message last set it), so a
621 // fresh, complete message must replace rather than accumulate onto
622 // whatever a previous message at the same _lastTime already stored.
623 _metaDataMap[_lastTime] = t_metaData();
624 _metaDataMap[_lastTime]._time = _lastTime;
625 _metaDataMap[_lastTime]._staID = _staID.toStdString();
626 _metaDataMap[_lastTime]._ssrIOD = _metaData.SSRIOD;
627 _metaDataMap[_lastTime]._providerID = _metaData.SSRProviderID;
628 _metaDataMap[_lastTime]._solutionID = _metaData.SSRSolutionID;
629 for (unsigned ii = 0; ii < _metaData.NumEntries; ii++) {
630 const SsrCorr::MetaData::ModelPart& part = _metaData.Entries[ii];
631 t_metaDataEntry entry;
632 entry._typeIndicator = part.TypeIndicator;
633 entry._applicationIndicator = part.ApplicationIndicator;
634 entry._nonDefaultIndicator = part.nonDefaultIndicator;
635 entry._nonDefaultIdentifier = part.nonDefaultIdentifier;
636 entry._dataIODIndicator = part.DataIODIndicator;
637 entry._dataIOD = part.DataIOD;
638 _metaDataMap[_lastTime]._entries.push_back(entry);
639 }
640 }
641
642 // Dump all older epochs
643 // ---------------------
644 QMutableMapIterator<bncTime, QList<t_orbCorr> > itOrb(_orbCorrections);
645 while (itOrb.hasNext()) {
646 itOrb.next();
647 if (itOrb.key() < _lastTime) {
648 emit newOrbCorrections(itOrb.value());
649 t_orbCorr::writeEpoch(_out, itOrb.value());
650 itOrb.remove();
651 }
652 }
653 QMutableMapIterator<bncTime, QList<t_clkCorr> > itClk(_clkCorrections);
654 while (itClk.hasNext()) {
655 itClk.next();
656 if (itClk.key() < _lastTime) {
657 emit newClkCorrections(itClk.value());
658 t_clkCorr::writeEpoch(_out, itClk.value());
659 itClk.remove();
660 }
661 }
662 QMutableMapIterator<bncTime, QList<t_satCodeBias> > itCB(_codeBiases);
663 while (itCB.hasNext()) {
664 itCB.next();
665 if (itCB.key() < _lastTime) {
666 emit newCodeBiases(itCB.value());
667 t_satCodeBias::writeEpoch(_out, itCB.value());
668 itCB.remove();
669 }
670 }
671 QMutableMapIterator<bncTime, QList<t_satPhaseBias> > itPB(_phaseBiases);
672 while (itPB.hasNext()) {
673 itPB.next();
674 if (itPB.key() < _lastTime) {
675 emit newPhaseBiases(itPB.value());
676 t_satPhaseBias::writeEpoch(_out, itPB.value());
677 itPB.remove();
678 }
679 }
680 QMutableMapIterator<bncTime, t_vTec> itTec(_vTecMap);
681 while (itTec.hasNext()) {
682 itTec.next();
683 if (itTec.key() < _lastTime) {
684 emit newTec(itTec.value());
685 t_vTec::write(_out, itTec.value());
686 itTec.remove();
687 }
688 }
689 QMutableMapIterator<bncTime, t_metaData> itMD(_metaDataMap);
690 while (itMD.hasNext()) {
691 itMD.next();
692 if (itMD.key() < _lastTime) {
693 emit newMetaData(itMD.value());
694 t_metaData::write(_out, itMD.value());
695 itMD.remove();
696 }
697 }
698}
699
700//
701////////////////////////////////////////////////////////////////////////////
702void RTCM3coDecoder::checkProviderID() {
703
704 if (_clkOrb.SSRProviderID == 0 && _clkOrb.SSRSolutionID == 0 && _clkOrb.SSRIOD == 0) {
705 return;
706 }
707
708 int newProviderID[3];
709 newProviderID[0] = _clkOrb.SSRProviderID;
710 newProviderID[1] = _clkOrb.SSRSolutionID;
711 newProviderID[2] = _clkOrb.SSRIOD;
712 QString newProviderIDStr = QString(" [SSR Provider ID: %1 SSR Solution ID: %2 SSR IOD: %3]: ")
713 .arg(newProviderID[0]).arg(newProviderID[1]).arg(newProviderID[2]);
714
715 bool alreadySet = false;
716 bool different = false;
717
718 for (unsigned ii = 0; ii < 3; ii++) {
719 if (_providerID[ii] != -1) {
720 alreadySet = true;
721 }
722 if (_providerID[ii] != newProviderID[ii]) {
723 different = true;
724 }
725 _providerID[ii] = newProviderID[ii];
726 }
727
728 if (alreadySet && different) {
729 emit newMessage("RTCM3coDecoder: SSR Provider or Service changed " + newProviderIDStr.toLatin1() + _staID.toLatin1(), true);
730 emit providerIDChanged(_staID);
731 }
732}
733
734// Check corrections
735////////////////////////////////////////////////////////////////////////////
736bool RTCM3coDecoder::corrIsOutOfRange(const SsrCorr::ClockOrbit::SatData& coSat) {
737
738 QString ssrParStr;
739 QString ssrParValue;
740 bool corrIsOutOfRange = false;
741
742 switch (_type) {
743 // ======== //
744 // IGS SSR //
745 // ======== //
746 case IGSssr:
747 if (coSat.Clock.DeltaA0 < -209.7151 ||
748 coSat.Clock.DeltaA0 > +209.7151) {
749 ssrParStr = "Clock::DeltaA0";
750 ssrParValue = QString::number(coSat.Clock.DeltaA0, 'f', 4);
751 corrIsOutOfRange = true;
752 }
753 if (coSat.Clock.DeltaA1 < -1.048575 ||
754 coSat.Clock.DeltaA1 > +1.048575) {
755 ssrParStr = "Clock::DeltaA1";
756 ssrParValue = QString::number(coSat.Clock.DeltaA1, 'f', 6);
757 corrIsOutOfRange = true;
758 }
759 if (coSat.Clock.DeltaA2 < -1.3421772 ||
760 coSat.Clock.DeltaA2 > +1.3421772) {
761 ssrParStr = "Clock::DeltaA2";
762 ssrParValue = QString::number(coSat.Clock.DeltaA2, 'f', 7);
763 corrIsOutOfRange = true;
764 }
765
766 if (coSat.Orbit.DeltaRadial < -209.7151 ||
767 coSat.Orbit.DeltaRadial > +209.7151) {
768 ssrParStr = "Orbit::DeltaRadial";
769 ssrParValue = QString::number(coSat.Orbit.DeltaRadial, 'f', 4);
770 corrIsOutOfRange = true;
771 }
772
773 if (coSat.Orbit.DeltaAlongTrack < -209.7148 ||
774 coSat.Orbit.DeltaAlongTrack > +209.7148) {
775 ssrParStr = "Orbit::DeltaAlongTrack";
776 ssrParValue = QString::number(coSat.Orbit.DeltaAlongTrack, 'f', 4);
777 corrIsOutOfRange = true;
778 }
779 if (coSat.Orbit.DeltaCrossTrack < -209.7148 ||
780 coSat.Orbit.DeltaCrossTrack > +209.7148) {
781 ssrParStr = "Orbit::DeltaCrossTrack";
782 ssrParValue = QString::number(coSat.Orbit.DeltaCrossTrack, 'f', 4);
783 corrIsOutOfRange = true;
784 }
785
786 if (coSat.Orbit.DotDeltaRadial < -1.048575 ||
787 coSat.Orbit.DotDeltaRadial > +1.048575) {
788 ssrParStr = "Orbit::DotDeltaRadial";
789 ssrParValue = QString::number(coSat.Orbit.DotDeltaRadial, 'f', 6);
790 corrIsOutOfRange = true;
791 }
792 if (coSat.Orbit.DotDeltaAlongTrack < -1.048572 ||
793 coSat.Orbit.DotDeltaAlongTrack > +1.048572) {
794 ssrParStr = "Orbit::DotDeltaAlongTrack";
795 ssrParValue = QString::number(coSat.Orbit.DotDeltaAlongTrack, 'f', 6);
796 corrIsOutOfRange = true;
797 }
798 if (coSat.Orbit.DotDeltaCrossTrack < -1.048572 ||
799 coSat.Orbit.DotDeltaCrossTrack > +1.048572) {
800 ssrParStr = "Orbit::DotDeltaCrossTrack";
801 ssrParValue = QString::number(coSat.Orbit.DotDeltaCrossTrack, 'f', 6);
802 corrIsOutOfRange = true;
803 }
804 break;
805 //==========//
806 // RTCM SSR //
807 // =========//
808 case RTCMssr:
809 case RTCMnewssr:
810 if (coSat.Clock.DeltaA0 < -209.7151 ||
811 coSat.Clock.DeltaA0 > +209.7151) {
812 ssrParStr = "Clock::DeltaA0";
813 ssrParValue = QString::number(coSat.Clock.DeltaA0, 'f', 4);
814 corrIsOutOfRange = true;
815 }
816 if (coSat.Clock.DeltaA1 < -1.048575 ||
817 coSat.Clock.DeltaA1 > +1.048575) {
818 ssrParStr = "Clock::DeltaA1";
819 ssrParValue = QString::number(coSat.Clock.DeltaA1, 'f', 6);
820 corrIsOutOfRange = true;
821 }
822 if (coSat.Clock.DeltaA2 < -1.34217726 ||
823 coSat.Clock.DeltaA2 > +1.34217726) {
824 ssrParStr = "Clock::DeltaA2";
825 ssrParValue = QString::number(coSat.Clock.DeltaA2, 'f', 8);
826 corrIsOutOfRange = true;
827 }
828
829 if (coSat.Orbit.DeltaRadial < -209.7151 ||
830 coSat.Orbit.DeltaRadial > +209.7151) {
831 ssrParStr = "Orbit::DeltaRadial";
832 ssrParValue = QString::number(coSat.Orbit.DeltaRadial, 'f', 4);
833 corrIsOutOfRange = true;
834 }
835
836 if (coSat.Orbit.DeltaAlongTrack < -209.7148 ||
837 coSat.Orbit.DeltaAlongTrack > +209.7148) {
838 ssrParStr = "Orbit::DeltaAlongTrack";
839 ssrParValue = QString::number(coSat.Orbit.DeltaAlongTrack, 'f', 4);
840 corrIsOutOfRange = true;
841 }
842 if (coSat.Orbit.DeltaCrossTrack < -209.7148 ||
843 coSat.Orbit.DeltaCrossTrack > +209.7148) {
844 ssrParStr = "Orbit::DeltaCrossTrack";
845 ssrParValue = QString::number(coSat.Orbit.DeltaCrossTrack, 'f', 4);
846 corrIsOutOfRange = true;
847 }
848
849 if (coSat.Orbit.DotDeltaRadial < -1.048575 ||
850 coSat.Orbit.DotDeltaRadial > +1.048575) {
851 ssrParStr = "Orbit::DotDeltaRadial";
852 ssrParValue = QString::number(coSat.Orbit.DotDeltaRadial, 'f', 6);
853 corrIsOutOfRange = true;
854 }
855 if (coSat.Orbit.DotDeltaAlongTrack < -1.048572 ||
856 coSat.Orbit.DotDeltaAlongTrack > +1.048572) {
857 ssrParStr = "Orbit::DotDeltaAlongTrack";
858 ssrParValue = QString::number(coSat.Orbit.DotDeltaAlongTrack, 'f', 6);
859 corrIsOutOfRange = true;
860 }
861 if (coSat.Orbit.DotDeltaCrossTrack < -1.048572 ||
862 coSat.Orbit.DotDeltaCrossTrack > +1.048572) {
863 ssrParStr = "Orbit::DotDeltaCrossTrack";
864 ssrParValue = QString::number(coSat.Orbit.DotDeltaCrossTrack, 'f', 6);
865 corrIsOutOfRange = true;
866 }
867 break;
868 }
869
870 if (corrIsOutOfRange) {
871 emit newMessage("RTCM3coDecoder: Correction " + ssrParStr.toLatin1()
872 + " (" + ssrParValue.toLatin1() + ") "
873 + "is out of range " + _staID.toLatin1(), true);
874 }
875
876 return corrIsOutOfRange;
877}
878
879//
880////////////////////////////////////////////////////////////////////////////
881void RTCM3coDecoder::setEpochTime() {
882
883 // _phaseBias is no longer wiped between messages (kept alive so a later
884 // Extended Phase Bias message can correlate against it), so
885 // NumberOfSat[s] > 0 alone no longer means "phase bias was just decoded
886 // this cycle" - it can be stale from many messages ago. Gate each
887 // phase-bias fallback below on the same per-system freshness tracking
888 // sendResults() uses (_phaseBiasSentEpoch), so a stale leftover value
889 // never gets picked as this cycle's epoch.
890 bncTime prevTime = _lastTime;
891 _lastTime.reset();
892
893 double epoSecGPS = -1.0;
894 double epoSecGlo = -1.0;
895 double epoSecGal = -1.0;
896 double epoSecQzss = -1.0;
897 double epoSecSbas = -1.0;
898 double epoSecBds = -1.0;
899 if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
900 epoSecGPS = _clkOrb.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
901 }
902 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
903 epoSecGPS = _codeBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
904 }
905 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0 &&
906 _phaseBias.EpochTime[CLOCKORBIT_SATGPS] != _phaseBiasSentEpoch[CLOCKORBIT_SATGPS]) {
907 epoSecGPS = _phaseBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
908 }
909 else if (_vTEC.NumLayers > 0) {
910 epoSecGPS = _vTEC.EpochTime; // 0 .. 604799 s
911 }
912 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
913 epoSecGlo = _clkOrb.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
914 }
915 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
916 epoSecGlo = _codeBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
917 }
918 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0 &&
919 _phaseBias.EpochTime[CLOCKORBIT_SATGLONASS] != _phaseBiasSentEpoch[CLOCKORBIT_SATGLONASS]) {
920 epoSecGlo = _phaseBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
921 }
922 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
923 epoSecGal = _clkOrb.EpochTime[CLOCKORBIT_SATGALILEO];
924 }
925 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
926 epoSecGal = _codeBias.EpochTime[CLOCKORBIT_SATGALILEO];
927 }
928 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0 &&
929 _phaseBias.EpochTime[CLOCKORBIT_SATGALILEO] != _phaseBiasSentEpoch[CLOCKORBIT_SATGALILEO]) {
930 epoSecGal = _phaseBias.EpochTime[CLOCKORBIT_SATGALILEO];
931 }
932 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
933 epoSecQzss = _clkOrb.EpochTime[CLOCKORBIT_SATQZSS];
934 }
935 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
936 epoSecQzss = _codeBias.EpochTime[CLOCKORBIT_SATQZSS];
937 }
938 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0 &&
939 _phaseBias.EpochTime[CLOCKORBIT_SATQZSS] != _phaseBiasSentEpoch[CLOCKORBIT_SATQZSS]) {
940 epoSecQzss = _phaseBias.EpochTime[CLOCKORBIT_SATQZSS];
941 }
942 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
943 epoSecSbas = _clkOrb.EpochTime[CLOCKORBIT_SATSBAS];
944 }
945 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
946 epoSecSbas = _codeBias.EpochTime[CLOCKORBIT_SATSBAS];
947 }
948 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0 &&
949 _phaseBias.EpochTime[CLOCKORBIT_SATSBAS] != _phaseBiasSentEpoch[CLOCKORBIT_SATSBAS]) {
950 epoSecSbas = _phaseBias.EpochTime[CLOCKORBIT_SATSBAS];
951 }
952 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
953 epoSecBds = _clkOrb.EpochTime[CLOCKORBIT_SATBDS];
954 }
955 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
956 epoSecBds = _codeBias.EpochTime[CLOCKORBIT_SATBDS];
957 }
958 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0 &&
959 _phaseBias.EpochTime[CLOCKORBIT_SATBDS] != _phaseBiasSentEpoch[CLOCKORBIT_SATBDS]) {
960 epoSecBds = _phaseBias.EpochTime[CLOCKORBIT_SATBDS];
961 }
962
963 // Retrieve current time
964 // ---------------------
965 int currentWeek = 0;
966 double currentSec = 0.0;
967 currentGPSWeeks(currentWeek, currentSec);
968 bncTime currentTime(currentWeek, currentSec);
969
970 // Set _lastTime close to currentTime
971 // ----------------------------------
972 if (epoSecGPS != -1) {
973 _lastTime.set(currentWeek, epoSecGPS);
974 }
975 else if (epoSecGlo != -1) {
976 QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
977 if (_type == IGSssr) {
978 epoSecGlo = epoSecGlo + gnumleap(date.year(), date.month(), date.day());
979 }
980 if (_type == RTCMssr || _type == RTCMnewssr) {
981 // Same GLONASS epoch wire convention (UTC+3h) as RTCMssr
982 epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
983 }
984 _lastTime.set(currentWeek, epoSecGlo);
985 }
986 else if (epoSecGal != -1) {
987 _lastTime.set(currentWeek, epoSecGal);
988 }
989 else if (epoSecQzss != -1) {
990 _lastTime.set(currentWeek, epoSecQzss);
991 }
992 else if (epoSecSbas != -1) {
993 _lastTime.set(currentWeek, epoSecSbas);
994 }
995 else if (epoSecBds != -1) {
996 epoSecBds += 14.0;
997 if (epoSecBds > 604800.0) {
998 epoSecBds -= 7.0*24.0*60.0*60.0;
999 }
1000 _lastTime.set(currentWeek, epoSecBds);
1001 }
1002 // Some message types (e.g. Metadata) carry no epoch field of their own,
1003 // and none of the above found anything fresh to use either - fall back
1004 // to the last known valid time rather than leaving _lastTime invalid
1005 // (which would silently drop the message's output entirely).
1006 else if (prevTime.valid()) {
1007 _lastTime = prevTime;
1008 }
1009
1010 if (_lastTime.valid()) {
1011 double maxDiff = 12 * 3600.0;
1012 while (_lastTime < currentTime - maxDiff) {
1013 _lastTime = _lastTime + maxDiff;
1014 }
1015 while (_lastTime > currentTime + maxDiff) {
1016 _lastTime = _lastTime - maxDiff;
1017 }
1018 }
1019}
Note: See TracBrowser for help on using the repository browser.