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

Last change on this file since 10270 was 9941, checked in by stuerze, 2 years ago

some renaming off ssr file output
File size: 23.5 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 _ssrCorr = 0;
100}
101
102// Destructor
103////////////////////////////////////////////////////////////////////////////
104RTCM3coDecoder::~RTCM3coDecoder() {
105 delete _out;
106 delete _ssrCorr;
107 _IODs.clear();
108 _orbCorrections.clear();
109 _clkCorrections.clear();
110 _lastClkCorrections.clear();
111 _codeBiases.clear();
112 _phaseBiases.clear();
113 _vTecMap.clear();
114}
115
116//
117////////////////////////////////////////////////////////////////////////////
118void RTCM3coDecoder::reset() {
119 memset(&_clkOrb, 0, sizeof(_clkOrb));
120 memset(&_codeBias, 0, sizeof(_codeBias));
121 memset(&_phaseBias, 0, sizeof(_phaseBias));
122 memset(&_vTEC, 0, sizeof(_vTEC));
123}
124
125// Reopen Output File
126////////////////////////////////////////////////////////////////////////
127void RTCM3coDecoder::reopen() {
128
129 if (!_fileNameSkl.isEmpty()) {
130
131 bncSettings settings;
132
133 QDateTime datTim = currentDateAndTimeGPS();
134
135 QString hlpStr = bncRinex::nextEpochStr(datTim,
136 settings.value("corrIntr").toString(), 3);
137
138 QString cntStr = (_fileNameSkl.contains("ION")) ? "_ION.ssr" : "_MC.ssr";
139
140 QString fileNameHlp = _fileNameSkl +
141 "_S_" + // stream
142 QString("%1").arg(datTim.date().year()) +
143 QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
144 hlpStr + // HM_period
145 cntStr; // mixed ION or CLK
146
147 if (_fileName == fileNameHlp) {
148 return;
149 }
150 else {
151 _fileName = fileNameHlp;
152 }
153
154 delete _out;
155 if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
156 _out = new ofstream( _fileName.toLatin1().data(), ios_base::out | ios_base::app );
157 }
158 else {
159 _out = new ofstream( _fileName.toLatin1().data() );
160 }
161 }
162}
163
164//
165////////////////////////////////////////////////////////////////////////////
166t_irc RTCM3coDecoder::Decode(char* buffer, int bufLen, vector<string>& errmsg) {
167
168 errmsg.clear();
169
170 _buffer.append(QByteArray(buffer,bufLen));
171
172 t_irc retCode = failure;
173
174 while(_buffer.size()) {
175
176 struct SsrCorr::ClockOrbit clkOrbSav;
177 struct SsrCorr::CodeBias codeBiasSav;
178 struct SsrCorr::PhaseBias phaseBiasSav;
179 struct SsrCorr::VTEC vTECSav;
180 memcpy(&clkOrbSav, &_clkOrb, sizeof(clkOrbSav)); // save state
181 memcpy(&codeBiasSav, &_codeBias, sizeof(codeBiasSav));
182 memcpy(&phaseBiasSav, &_phaseBias, sizeof(phaseBiasSav));
183 memcpy(&vTECSav, &_vTEC, sizeof(vTECSav));
184
185 int bytesused = 0;
186
187 GCOB_RETURN irc = _ssrCorr->GetSSR(&_clkOrb, &_codeBias, &_vTEC, &_phaseBias,
188 _buffer.data(), _buffer.size(), &bytesused);
189
190 if (irc <= -30) { // not enough data - restore state and exit loop
191 memcpy(&_clkOrb, &clkOrbSav, sizeof(clkOrbSav));
192 memcpy(&_codeBias, &codeBiasSav, sizeof(codeBiasSav));
193 memcpy(&_phaseBias, &phaseBiasSav, sizeof(phaseBiasSav));
194 memcpy(&_vTEC, &vTECSav, sizeof(vTECSav));
195 break;
196 }
197
198 else if (irc < 0) { // error - skip 1 byte and retry
199 reset();
200 _buffer = _buffer.mid(bytesused ? bytesused : 1);
201 }
202
203 else { // OK or MESSAGEFOLLOWS
204 _buffer = _buffer.mid(bytesused);
205
206 if (irc == GCOBR_OK || irc == GCOBR_MESSAGEFOLLOWS ) {
207
208 setEpochTime(); // sets _lastTime
209
210 if (_lastTime.valid()) {
211 reopen();
212 checkProviderID();
213 sendResults();
214 retCode = success;
215 }
216 else {
217 retCode = failure;
218 }
219
220 reset();
221 }
222 }
223 }
224
225 return retCode;
226}
227
228//
229////////////////////////////////////////////////////////////////////////////
230void RTCM3coDecoder::sendResults() {
231
232 // Orbit and clock corrections of all satellites
233 // ---------------------------------------------
234 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
235 + CLOCKORBIT_NUMGLONASS
236 + CLOCKORBIT_NUMGALILEO
237 + CLOCKORBIT_NUMQZSS
238 + CLOCKORBIT_NUMSBAS
239 + _clkOrb.NumberOfSat[CLOCKORBIT_SATBDS];
240 ii++) {
241 char sysCh = ' ';
242 int flag = 0;
243 if (ii < _clkOrb.NumberOfSat[CLOCKORBIT_SATGPS]) {
244 sysCh = 'G';
245 }
246 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
247 ii < CLOCKORBIT_OFFSETGLONASS + _clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
248 sysCh = 'R';
249 }
250 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
251 ii < CLOCKORBIT_OFFSETGALILEO + _clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
252 sysCh = 'E';
253 flag = 1; // I/NAV clock has been chosen as reference clock for Galileo SSR corrections
254 }
255 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
256 ii < CLOCKORBIT_OFFSETQZSS + _clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS]) {
257 sysCh = 'J';
258 }
259 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
260 ii < CLOCKORBIT_OFFSETSBAS + _clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS]) {
261 sysCh = 'S';
262 }
263 else if (ii >= CLOCKORBIT_OFFSETBDS &&
264 ii < CLOCKORBIT_OFFSETBDS + _clkOrb.NumberOfSat[CLOCKORBIT_SATBDS]) {
265 sysCh = 'C';
266 }
267 else {
268 continue;
269 }
270
271 // Orbit correction
272 // ----------------
273 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED ||
274 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
275 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
276 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
277 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
278 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
279 _clkOrb.messageType == _ssrCorr->COTYPE_GPSORBIT ||
280 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSORBIT ||
281 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOORBIT ||
282 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSORBIT ||
283 _clkOrb.messageType == _ssrCorr->COTYPE_SBASORBIT ||
284 _clkOrb.messageType == _ssrCorr->COTYPE_BDSORBIT ) {
285
286 t_orbCorr orbCorr;
287 orbCorr._prn.set(sysCh, _clkOrb.Sat[ii].ID, flag);
288 orbCorr._staID = _staID.toStdString();
289 orbCorr._iod = _clkOrb.Sat[ii].IOD;
290 orbCorr._time = _lastTime;
291 orbCorr._updateInt = _clkOrb.UpdateInterval;
292 orbCorr._system = sysCh;
293 orbCorr._xr[0] = _clkOrb.Sat[ii].Orbit.DeltaRadial;
294 orbCorr._xr[1] = _clkOrb.Sat[ii].Orbit.DeltaAlongTrack;
295 orbCorr._xr[2] = _clkOrb.Sat[ii].Orbit.DeltaCrossTrack;
296 orbCorr._dotXr[0] = _clkOrb.Sat[ii].Orbit.DotDeltaRadial;
297 orbCorr._dotXr[1] = _clkOrb.Sat[ii].Orbit.DotDeltaAlongTrack;
298 orbCorr._dotXr[2] = _clkOrb.Sat[ii].Orbit.DotDeltaCrossTrack;
299
300 _orbCorrections[_lastTime].append(orbCorr);
301
302 _IODs[orbCorr._prn] = _clkOrb.Sat[ii].IOD;
303 }
304
305 // Clock Corrections
306 // -----------------
307 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED ||
308 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
309 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
310 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
311 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
312 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
313 _clkOrb.messageType == _ssrCorr->COTYPE_GPSCLOCK ||
314 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCLOCK ||
315 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCLOCK ||
316 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCLOCK ||
317 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCLOCK ||
318 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCLOCK) {
319
320 t_clkCorr clkCorr;
321 clkCorr._prn.set(sysCh, _clkOrb.Sat[ii].ID, flag);
322 clkCorr._staID = _staID.toStdString();
323 clkCorr._time = _lastTime;
324 clkCorr._updateInt = _clkOrb.UpdateInterval;
325 clkCorr._dClk = _clkOrb.Sat[ii].Clock.DeltaA0 / t_CST::c;
326 clkCorr._dotDClk = _clkOrb.Sat[ii].Clock.DeltaA1 / t_CST::c;
327 clkCorr._dotDotDClk = _clkOrb.Sat[ii].Clock.DeltaA2 / t_CST::c;
328
329 _lastClkCorrections[clkCorr._prn] = clkCorr;
330
331 if (_IODs.contains(clkCorr._prn)) {
332 clkCorr._iod = _IODs[clkCorr._prn];
333 _clkCorrections[_lastTime].append(clkCorr);
334 }
335 }
336
337 // High-Resolution Clocks
338 // ----------------------
339 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSHR ||
340 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSHR ||
341 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOHR ||
342 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSHR ||
343 _clkOrb.messageType == _ssrCorr->COTYPE_SBASHR ||
344 _clkOrb.messageType == _ssrCorr->COTYPE_BDSHR) {
345 t_prn prn(sysCh, _clkOrb.Sat[ii].ID, flag);
346 if (_lastClkCorrections.contains(prn)) {
347 t_clkCorr clkCorr;
348 clkCorr = _lastClkCorrections[prn];
349 clkCorr._time = _lastTime;
350 clkCorr._updateInt = _clkOrb.UpdateInterval;
351 clkCorr._dClk += _clkOrb.Sat[ii].hrclock / t_CST::c;
352 if (_IODs.contains(clkCorr._prn)) {
353 clkCorr._iod = _IODs[clkCorr._prn];
354 _clkCorrections[_lastTime].push_back(clkCorr);
355 }
356 }
357 }
358 }
359
360 // Code Biases
361 // -----------
362 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
363 + CLOCKORBIT_NUMGLONASS
364 + CLOCKORBIT_NUMGALILEO
365 + CLOCKORBIT_NUMQZSS
366 + CLOCKORBIT_NUMSBAS
367 + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS];
368 ii++) {
369 char sysCh = ' ';
370 if (ii < _codeBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
371 sysCh = 'G';
372 }
373 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
374 ii < CLOCKORBIT_OFFSETGLONASS + _codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
375 sysCh = 'R';
376 }
377 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
378 ii < CLOCKORBIT_OFFSETGALILEO + _codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
379 sysCh = 'E';
380 }
381 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
382 ii < CLOCKORBIT_OFFSETQZSS + _codeBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
383 sysCh = 'J';
384 }
385 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
386 ii < CLOCKORBIT_OFFSETSBAS + _codeBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
387 sysCh = 'S';
388 }
389 else if (ii >= CLOCKORBIT_OFFSETBDS &&
390 ii < CLOCKORBIT_OFFSETBDS + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
391 sysCh = 'C';
392 }
393 else {
394 continue;
395 }
396 t_satCodeBias satCodeBias;
397 satCodeBias._prn.set(sysCh, _codeBias.Sat[ii].ID);
398 satCodeBias._staID = _staID.toStdString();
399 satCodeBias._time = _lastTime;
400 satCodeBias._updateInt = _codeBias.UpdateInterval;
401 for (unsigned jj = 0; jj < _codeBias.Sat[ii].NumberOfCodeBiases; jj++) {
402 const SsrCorr::CodeBias::BiasSat::CodeBiasEntry& biasEntry = _codeBias.Sat[ii].Biases[jj];
403 t_frqCodeBias frqCodeBias;
404 frqCodeBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sysCh, biasEntry.Type));
405 frqCodeBias._value = biasEntry.Bias;
406 if (!frqCodeBias._rnxType2ch.empty()) {
407 satCodeBias._bias.push_back(frqCodeBias);
408 }
409 }
410 _codeBiases[_lastTime].append(satCodeBias);
411 }
412
413 // Phase Biases
414 // -----------
415 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
416 + CLOCKORBIT_NUMGLONASS
417 + CLOCKORBIT_NUMGALILEO
418 + CLOCKORBIT_NUMQZSS
419 + CLOCKORBIT_NUMSBAS
420 + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS];
421 ii++) {
422 char sysCh = ' ';
423 if (ii < _phaseBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
424 sysCh = 'G';
425 }
426 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
427 ii < CLOCKORBIT_OFFSETGLONASS + _phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
428 sysCh = 'R';
429 }
430 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
431 ii < CLOCKORBIT_OFFSETGALILEO + _phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
432 sysCh = 'E';
433 }
434 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
435 ii < CLOCKORBIT_OFFSETQZSS + _phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
436 sysCh = 'J';
437 }
438 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
439 ii < CLOCKORBIT_OFFSETSBAS + _phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
440 sysCh = 'S';
441 }
442 else if (ii >= CLOCKORBIT_OFFSETBDS &&
443 ii < CLOCKORBIT_OFFSETBDS + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
444 sysCh = 'C';
445 }
446 else {
447 continue;
448 }
449 t_satPhaseBias satPhaseBias;
450 satPhaseBias._prn.set(sysCh, _phaseBias.Sat[ii].ID);
451 satPhaseBias._staID = _staID.toStdString();
452 satPhaseBias._time = _lastTime;
453 satPhaseBias._updateInt = _phaseBias.UpdateInterval;
454 satPhaseBias._dispBiasConstistInd = _phaseBias.DispersiveBiasConsistencyIndicator;
455 satPhaseBias._MWConsistInd = _phaseBias.MWConsistencyIndicator;
456 satPhaseBias._yaw = _phaseBias.Sat[ii].YawAngle;
457 satPhaseBias._yawRate = _phaseBias.Sat[ii].YawRate;
458 for (unsigned jj = 0; jj < _phaseBias.Sat[ii].NumberOfPhaseBiases; jj++) {
459 const SsrCorr::PhaseBias::PhaseBiasSat::PhaseBiasEntry& biasEntry = _phaseBias.Sat[ii].Biases[jj];
460 t_frqPhaseBias frqPhaseBias;
461 frqPhaseBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sysCh, biasEntry.Type));
462 frqPhaseBias._value = biasEntry.Bias;
463 frqPhaseBias._fixIndicator = biasEntry.SignalIntegerIndicator;
464 frqPhaseBias._fixWideLaneIndicator = biasEntry.SignalsWideLaneIntegerIndicator;
465 frqPhaseBias._jumpCounter = biasEntry.SignalDiscontinuityCounter;
466 if (!frqPhaseBias._rnxType2ch.empty()) {
467 satPhaseBias._bias.push_back(frqPhaseBias);
468 }
469 }
470 _phaseBiases[_lastTime].append(satPhaseBias);
471 }
472
473 // Ionospheric Model
474 // -----------------
475 if (_vTEC.NumLayers > 0) {
476 _vTecMap[_lastTime]._time = _lastTime;
477 _vTecMap[_lastTime]._updateInt = _vTEC.UpdateInterval;
478 _vTecMap[_lastTime]._staID = _staID.toStdString();
479 for (unsigned ii = 0; ii < _vTEC.NumLayers; ii++) {
480 const SsrCorr::VTEC::IonoLayers& ionoLayer = _vTEC.Layers[ii];
481 t_vTecLayer layer;
482 layer._height = ionoLayer.Height;
483 layer._C.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
484 layer._S.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
485 for (unsigned iDeg = 0; iDeg <= ionoLayer.Degree; iDeg++) {
486 for (unsigned iOrd = 0; iOrd <= ionoLayer.Order; iOrd++) {
487 layer._C[iDeg][iOrd] = ionoLayer.Cosinus[iDeg][iOrd];
488 layer._S[iDeg][iOrd] = ionoLayer.Sinus[iDeg][iOrd];
489 }
490 }
491 _vTecMap[_lastTime]._layers.push_back(layer);
492 }
493 }
494
495 // Dump all older epochs
496 // ---------------------
497 QMutableMapIterator<bncTime, QList<t_orbCorr> > itOrb(_orbCorrections);
498 while (itOrb.hasNext()) {
499 itOrb.next();
500 if (itOrb.key() < _lastTime) {
501 emit newOrbCorrections(itOrb.value());
502 t_orbCorr::writeEpoch(_out, itOrb.value());
503 itOrb.remove();
504 }
505 }
506 QMutableMapIterator<bncTime, QList<t_clkCorr> > itClk(_clkCorrections);
507 while (itClk.hasNext()) {
508 itClk.next();
509 if (itClk.key() < _lastTime) {
510 emit newClkCorrections(itClk.value());
511 t_clkCorr::writeEpoch(_out, itClk.value());
512 itClk.remove();
513 }
514 }
515 QMutableMapIterator<bncTime, QList<t_satCodeBias> > itCB(_codeBiases);
516 while (itCB.hasNext()) {
517 itCB.next();
518 if (itCB.key() < _lastTime) {
519 emit newCodeBiases(itCB.value());
520 t_satCodeBias::writeEpoch(_out, itCB.value());
521 itCB.remove();
522 }
523 }
524 QMutableMapIterator<bncTime, QList<t_satPhaseBias> > itPB(_phaseBiases);
525 while (itPB.hasNext()) {
526 itPB.next();
527 if (itPB.key() < _lastTime) {
528 emit newPhaseBiases(itPB.value());
529 t_satPhaseBias::writeEpoch(_out, itPB.value());
530 itPB.remove();
531 }
532 }
533 QMutableMapIterator<bncTime, t_vTec> itTec(_vTecMap);
534 while (itTec.hasNext()) {
535 itTec.next();
536 if (itTec.key() < _lastTime) {
537 emit newTec(itTec.value());
538 t_vTec::write(_out, itTec.value());
539 itTec.remove();
540 }
541 }
542}
543
544//
545////////////////////////////////////////////////////////////////////////////
546void RTCM3coDecoder::checkProviderID() {
547
548 if (_clkOrb.SSRProviderID == 0 && _clkOrb.SSRSolutionID == 0 && _clkOrb.SSRIOD == 0) {
549 return;
550 }
551
552 int newProviderID[3];
553 newProviderID[0] = _clkOrb.SSRProviderID;
554 newProviderID[1] = _clkOrb.SSRSolutionID;
555 newProviderID[2] = _clkOrb.SSRIOD;
556
557 bool alreadySet = false;
558 bool different = false;
559
560 for (unsigned ii = 0; ii < 3; ii++) {
561 if (_providerID[ii] != -1) {
562 alreadySet = true;
563 }
564 if (_providerID[ii] != newProviderID[ii]) {
565 different = true;
566 }
567 _providerID[ii] = newProviderID[ii];
568 }
569
570 if (alreadySet && different) {
571 emit newMessage("RTCM3coDecoder: Provider Changed: " + _staID.toLatin1(), true);
572 emit providerIDChanged(_staID);
573 }
574}
575
576//
577////////////////////////////////////////////////////////////////////////////
578void RTCM3coDecoder::setEpochTime() {
579
580 _lastTime.reset();
581
582 double epoSecGPS = -1.0;
583 double epoSecGlo = -1.0;
584 double epoSecGal = -1.0;
585 double epoSecQzss = -1.0;
586 double epoSecSbas = -1.0;
587 double epoSecBds = -1.0;
588 if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
589 epoSecGPS = _clkOrb.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
590 }
591 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
592 epoSecGPS = _codeBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
593 }
594 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
595 epoSecGPS = _phaseBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
596 }
597 else if (_vTEC.NumLayers > 0) {
598 epoSecGPS = _vTEC.EpochTime; // 0 .. 604799 s
599 }
600 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
601 epoSecGlo = _clkOrb.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
602 }
603 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
604 epoSecGlo = _codeBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
605 }
606 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
607 epoSecGlo = _phaseBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
608 }
609 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
610 epoSecGal = _clkOrb.EpochTime[CLOCKORBIT_SATGALILEO];
611 }
612 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
613 epoSecGal = _codeBias.EpochTime[CLOCKORBIT_SATGALILEO];
614 }
615 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
616 epoSecGal = _phaseBias.EpochTime[CLOCKORBIT_SATGALILEO];
617 }
618 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
619 epoSecQzss = _clkOrb.EpochTime[CLOCKORBIT_SATQZSS];
620 }
621 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
622 epoSecQzss = _codeBias.EpochTime[CLOCKORBIT_SATQZSS];
623 }
624 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
625 epoSecQzss = _phaseBias.EpochTime[CLOCKORBIT_SATQZSS];
626 }
627 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
628 epoSecSbas = _clkOrb.EpochTime[CLOCKORBIT_SATSBAS];
629 }
630 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
631 epoSecSbas = _codeBias.EpochTime[CLOCKORBIT_SATSBAS];
632 }
633 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
634 epoSecSbas = _phaseBias.EpochTime[CLOCKORBIT_SATSBAS];
635 }
636 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
637 epoSecBds = _clkOrb.EpochTime[CLOCKORBIT_SATBDS];
638 }
639 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
640 epoSecBds = _codeBias.EpochTime[CLOCKORBIT_SATBDS];
641 }
642 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
643 epoSecBds = _phaseBias.EpochTime[CLOCKORBIT_SATBDS];
644 }
645
646 // Retrieve current time
647 // ---------------------
648 int currentWeek = 0;
649 double currentSec = 0.0;
650 currentGPSWeeks(currentWeek, currentSec);
651 bncTime currentTime(currentWeek, currentSec);
652
653 // Set _lastTime close to currentTime
654 // ----------------------------------
655 if (epoSecGPS != -1) {
656 _lastTime.set(currentWeek, epoSecGPS);
657 }
658 else if (epoSecGlo != -1) {
659 if (_type == RTCMssr) {
660 QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
661 epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
662 }
663 _lastTime.set(currentWeek, epoSecGlo);
664 }
665 else if (epoSecGal != -1) {
666 _lastTime.set(currentWeek, epoSecGal);
667 }
668 else if (epoSecQzss != -1) {
669 _lastTime.set(currentWeek, epoSecQzss);
670 }
671 else if (epoSecSbas != -1) {
672 _lastTime.set(currentWeek, epoSecSbas);
673 }
674 else if (epoSecBds != -1) {
675 if (_type == RTCMssr) {
676 epoSecBds += 14.0;
677 if (epoSecBds > 604800.0) {
678 epoSecBds -= 7.0*24.0*60.0*60.0;
679 }
680 }
681 _lastTime.set(currentWeek, epoSecBds);
682 }
683
684 if (_lastTime.valid()) {
685 double maxDiff = 12 * 3600.0;
686 while (_lastTime < currentTime - maxDiff) {
687 _lastTime = _lastTime + maxDiff;
688 }
689 while (_lastTime > currentTime + maxDiff) {
690 _lastTime = _lastTime - maxDiff;
691 }
692 }
693}
Note: See TracBrowser for help on using the repository browser.