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

Last change on this file since 10999 was 10999, checked in by stuerze, 15 hours ago

minor changes regarding RTCM-SSR
File size: 30.4 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
103// Destructor
104////////////////////////////////////////////////////////////////////////////
105RTCM3coDecoder::~RTCM3coDecoder() {
106 delete _out;
107 delete _ssrCorr;
108 _IODs.clear();
109 _orbCorrections.clear();
110 _clkCorrections.clear();
111 _lastClkCorrections.clear();
112 _codeBiases.clear();
113 _phaseBiases.clear();
114 _vTecMap.clear();
115}
116
117//
118////////////////////////////////////////////////////////////////////////////
119void RTCM3coDecoder::reset() {
120 memset(&_clkOrb, 0, sizeof(_clkOrb));
121 memset(&_codeBias, 0, sizeof(_codeBias));
122 memset(&_phaseBias, 0, sizeof(_phaseBias));
123 memset(&_vTEC, 0, sizeof(_vTEC));
124}
125
126// Reopen Output File
127////////////////////////////////////////////////////////////////////////
128void RTCM3coDecoder::reopen() {
129
130 if (!_fileNameSkl.isEmpty()) {
131
132 bncSettings settings;
133
134 QDateTime datTim = currentDateAndTimeGPS();
135
136 QString hlpStr = bncRinex::nextEpochStr(datTim,
137 settings.value("corrIntr").toString(), 3);
138
139 QString cntStr = (_fileNameSkl.contains("ION")) ? "_ION.ssr" : "_MC.ssr";
140
141 QString fileNameHlp = _fileNameSkl +
142 "_S_" + // stream
143 QString("%1").arg(datTim.date().year()) +
144 QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
145 hlpStr + // HM_period
146 cntStr; // mixed ION or CLK
147
148 if (_fileName == fileNameHlp) {
149 return;
150 }
151 else {
152 _fileName = fileNameHlp;
153 }
154
155 delete _out;
156 if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
157 _out = new ofstream( _fileName.toLatin1().data(), ios_base::out | ios_base::app );
158 }
159 else {
160 _out = new ofstream( _fileName.toLatin1().data() );
161 }
162 }
163}
164
165//
166////////////////////////////////////////////////////////////////////////////
167t_irc RTCM3coDecoder::Decode(char* buffer, int bufLen, vector<string>& errmsg) {
168
169 errmsg.clear();
170
171 _buffer.append(QByteArray(buffer,bufLen));
172
173 t_irc retCode = failure;
174
175 while(_buffer.size()) {
176
177 struct SsrCorr::ClockOrbit clkOrbSav;
178 struct SsrCorr::CodeBias codeBiasSav;
179 struct SsrCorr::PhaseBias phaseBiasSav;
180 struct SsrCorr::VTEC vTECSav;
181 memcpy(&clkOrbSav, &_clkOrb, sizeof(clkOrbSav)); // save state
182 memcpy(&codeBiasSav, &_codeBias, sizeof(codeBiasSav));
183 memcpy(&phaseBiasSav, &_phaseBias, sizeof(phaseBiasSav));
184 memcpy(&vTECSav, &_vTEC, sizeof(vTECSav));
185
186 int bytesused = 0;
187
188 GCOB_RETURN irc = _ssrCorr->GetSSR(&_clkOrb, &_codeBias, &_vTEC, &_phaseBias,
189 _buffer.data(), _buffer.size(), &bytesused);
190
191 if (irc <= -30) { // not enough data - restore state and exit loop
192 memcpy(&_clkOrb, &clkOrbSav, sizeof(clkOrbSav));
193 memcpy(&_codeBias, &codeBiasSav, sizeof(codeBiasSav));
194 memcpy(&_phaseBias, &phaseBiasSav, sizeof(phaseBiasSav));
195 memcpy(&_vTEC, &vTECSav, sizeof(vTECSav));
196 break;
197 }
198
199 else if (irc < 0) { // error - skip 1 byte and retry
200 reset();
201 _buffer = _buffer.mid(bytesused ? bytesused : 1);
202 }
203
204 else { // OK or MESSAGEFOLLOWS
205 _buffer = _buffer.mid(bytesused);
206
207 if (irc == GCOBR_OK || irc == GCOBR_MESSAGEFOLLOWS ) {
208 setEpochTime(); // sets _lastTime
209
210 if (_lastTime.valid()) {
211 reopen();
212 checkProviderID();
213 sendResults();
214 retCode = success;
215 }
216 else {
217 emit newMessage("RTCM3coDecoder: _lastTime invalid: " + _staID.toLatin1(), true);
218 retCode = failure;
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 if (corrIsOutOfRange(_clkOrb.Sat[ii])) {
242 continue;
243 }
244 char sys = ' ';
245 int num = _clkOrb.Sat[ii].ID;
246 int flag = 0; // to force NAV type usage according SSR standard
247 if (ii < _clkOrb.NumberOfSat[CLOCKORBIT_SATGPS]) {
248 sys = 'G';
249 flag = t_eph::LNAV;
250 }
251 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
252 ii < CLOCKORBIT_OFFSETGLONASS + _clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
253 sys = 'R';
254 flag = t_eph::FDMA_M;
255 }
256 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
257 ii < CLOCKORBIT_OFFSETGALILEO + _clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
258 sys = 'E';
259 flag = t_eph::INAV;
260 }
261 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
262 ii < CLOCKORBIT_OFFSETQZSS + _clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS]) {
263 sys = 'J';
264 flag = t_eph::LNAV;
265 }
266 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
267 ii < CLOCKORBIT_OFFSETSBAS + _clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS]) {
268 sys = 'S';
269 flag = t_eph::SBASL1;
270 }
271 else if (ii >= CLOCKORBIT_OFFSETBDS &&
272 ii < CLOCKORBIT_OFFSETBDS + _clkOrb.NumberOfSat[CLOCKORBIT_SATBDS]) {
273 sys = 'C';
274 if (num < 6) {// GEO
275 flag = t_eph::D2;
276 }
277 else if (num > 58 && num < 63) { // GEO
278 flag = t_eph::D2;
279 }
280 else {
281 flag = t_eph::D1;
282 }
283 }
284 else {
285 continue;
286 }
287
288 // Orbit correction
289 // ----------------
290 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED ||
291 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
292 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
293 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
294 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
295 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
296 _clkOrb.messageType == _ssrCorr->COTYPE_GPSORBIT ||
297 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSORBIT ||
298 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOORBIT ||
299 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSORBIT ||
300 _clkOrb.messageType == _ssrCorr->COTYPE_SBASORBIT ||
301 _clkOrb.messageType == _ssrCorr->COTYPE_BDSORBIT ) {
302
303 t_orbCorr orbCorr;
304 orbCorr._prn.set(sys, num, flag);
305 orbCorr._staID = _staID.toStdString();
306 orbCorr._iod = _clkOrb.Sat[ii].IOD;
307 orbCorr._time = _lastTime;
308 orbCorr._updateInt = _clkOrb.UpdateInterval;
309 orbCorr._system = sys;
310 orbCorr._xr[0] = _clkOrb.Sat[ii].Orbit.DeltaRadial;
311 orbCorr._xr[1] = _clkOrb.Sat[ii].Orbit.DeltaAlongTrack;
312 orbCorr._xr[2] = _clkOrb.Sat[ii].Orbit.DeltaCrossTrack;
313 orbCorr._dotXr[0] = _clkOrb.Sat[ii].Orbit.DotDeltaRadial;
314 orbCorr._dotXr[1] = _clkOrb.Sat[ii].Orbit.DotDeltaAlongTrack;
315 orbCorr._dotXr[2] = _clkOrb.Sat[ii].Orbit.DotDeltaCrossTrack;
316 orbCorr._ssrFormat = (_type == RTCMssr) ? ssrRtcmOld :
317 (_type == RTCMnewssr) ? ssrRtcmNew : ssrUnknown;
318
319 _orbCorrections[_lastTime].append(orbCorr);
320
321 _IODs[orbCorr._prn] = _clkOrb.Sat[ii].IOD;
322 }
323
324 // Clock Corrections
325 // -----------------
326 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSCOMBINED ||
327 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCOMBINED ||
328 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCOMBINED ||
329 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCOMBINED ||
330 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCOMBINED ||
331 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCOMBINED ||
332 _clkOrb.messageType == _ssrCorr->COTYPE_GPSCLOCK ||
333 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSCLOCK ||
334 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOCLOCK ||
335 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSCLOCK ||
336 _clkOrb.messageType == _ssrCorr->COTYPE_SBASCLOCK ||
337 _clkOrb.messageType == _ssrCorr->COTYPE_BDSCLOCK) {
338
339 t_clkCorr clkCorr;
340 clkCorr._prn.set(sys, _clkOrb.Sat[ii].ID, flag);
341 clkCorr._staID = _staID.toStdString();
342 clkCorr._time = _lastTime;
343 clkCorr._updateInt = _clkOrb.UpdateInterval;
344 clkCorr._dClk = _clkOrb.Sat[ii].Clock.DeltaA0 / t_CST::c;
345 clkCorr._dotDClk = _clkOrb.Sat[ii].Clock.DeltaA1 / t_CST::c;
346 clkCorr._dotDotDClk = _clkOrb.Sat[ii].Clock.DeltaA2 / t_CST::c;
347
348 _lastClkCorrections[clkCorr._prn] = clkCorr;
349
350 if (_IODs.contains(clkCorr._prn)) {
351 clkCorr._iod = _IODs[clkCorr._prn];
352 _clkCorrections[_lastTime].append(clkCorr);
353 }
354 }
355
356 // High-Resolution Clocks
357 // ----------------------
358 if ( _clkOrb.messageType == _ssrCorr->COTYPE_GPSHR ||
359 _clkOrb.messageType == _ssrCorr->COTYPE_GLONASSHR ||
360 _clkOrb.messageType == _ssrCorr->COTYPE_GALILEOHR ||
361 _clkOrb.messageType == _ssrCorr->COTYPE_QZSSHR ||
362 _clkOrb.messageType == _ssrCorr->COTYPE_SBASHR ||
363 _clkOrb.messageType == _ssrCorr->COTYPE_BDSHR) {
364 t_prn prn(sys, _clkOrb.Sat[ii].ID, flag);
365 if (_lastClkCorrections.contains(prn)) {
366 t_clkCorr clkCorr;
367 clkCorr = _lastClkCorrections[prn];
368 clkCorr._time = _lastTime;
369 clkCorr._updateInt = _clkOrb.UpdateInterval;
370 clkCorr._dClk += _clkOrb.Sat[ii].hrclock / t_CST::c;
371 if (_IODs.contains(clkCorr._prn)) {
372 clkCorr._iod = _IODs[clkCorr._prn];
373 _clkCorrections[_lastTime].append(clkCorr);
374 }
375 }
376 }
377 }
378
379 // Code Biases
380 // -----------
381 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
382 + CLOCKORBIT_NUMGLONASS
383 + CLOCKORBIT_NUMGALILEO
384 + CLOCKORBIT_NUMQZSS
385 + CLOCKORBIT_NUMSBAS
386 + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS];
387 ii++) {
388 char sys = ' ';
389 int num = _codeBias.Sat[ii].ID;
390 int flag = 0;
391 if (ii < _codeBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
392 sys = 'G';
393 flag = t_eph::LNAV;
394 }
395 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
396 ii < CLOCKORBIT_OFFSETGLONASS + _codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
397 sys = 'R';
398 flag = t_eph::FDMA_M;
399 }
400 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
401 ii < CLOCKORBIT_OFFSETGALILEO + _codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
402 sys = 'E';
403 flag = t_eph::INAV;
404 }
405 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
406 ii < CLOCKORBIT_OFFSETQZSS + _codeBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
407 sys = 'J';
408 flag = t_eph::LNAV;
409 }
410 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
411 ii < CLOCKORBIT_OFFSETSBAS + _codeBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
412 sys = 'S';
413 flag = t_eph::SBASL1;
414 }
415 else if (ii >= CLOCKORBIT_OFFSETBDS &&
416 ii < CLOCKORBIT_OFFSETBDS + _codeBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
417 sys = 'C';
418 if (num < 6) {// GEO
419 flag = t_eph::D2;
420 }
421 else if (num > 58 && num < 63) { // GEO
422 flag = t_eph::D2;
423 }
424 else {
425 flag = t_eph::D1;
426 }
427 }
428 else {
429 continue;
430 }
431 t_satCodeBias satCodeBias;
432 satCodeBias._prn.set(sys, num, flag);
433 satCodeBias._staID = _staID.toStdString();
434 satCodeBias._time = _lastTime;
435 satCodeBias._updateInt = _codeBias.UpdateInterval;
436 for (unsigned jj = 0; jj < _codeBias.Sat[ii].NumberOfCodeBiases; jj++) {
437 const SsrCorr::CodeBias::BiasSat::CodeBiasEntry& biasEntry = _codeBias.Sat[ii].Biases[jj];
438 t_frqCodeBias frqCodeBias;
439 frqCodeBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sys, biasEntry.Type));
440 frqCodeBias._value = biasEntry.Bias;
441 if (!frqCodeBias._rnxType2ch.empty()) {
442 satCodeBias._bias.push_back(frqCodeBias);
443 }
444 }
445 _codeBiases[_lastTime].append(satCodeBias);
446 }
447
448 // Phase Biases
449 // -----------
450 for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS
451 + CLOCKORBIT_NUMGLONASS
452 + CLOCKORBIT_NUMGALILEO
453 + CLOCKORBIT_NUMQZSS
454 + CLOCKORBIT_NUMSBAS
455 + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS];
456 ii++) {
457 char sys = ' ';
458 int num = _phaseBias.Sat[ii].ID;
459 int flag = 0;
460 if (ii < _phaseBias.NumberOfSat[CLOCKORBIT_SATGPS]) {
461 sys = 'G';
462 flag = t_eph::LNAV;
463 }
464 else if (ii >= CLOCKORBIT_OFFSETGLONASS &&
465 ii < CLOCKORBIT_OFFSETGLONASS + _phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS]) {
466 sys = 'R';
467 flag = t_eph::FDMA_M;
468 }
469 else if (ii >= CLOCKORBIT_OFFSETGALILEO &&
470 ii < CLOCKORBIT_OFFSETGALILEO + _phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO]) {
471 sys = 'E';
472 flag = t_eph::INAV;
473 }
474 else if (ii >= CLOCKORBIT_OFFSETQZSS &&
475 ii < CLOCKORBIT_OFFSETQZSS + _phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS]) {
476 sys = 'J';
477 flag = t_eph::LNAV;
478 }
479 else if (ii >= CLOCKORBIT_OFFSETSBAS &&
480 ii < CLOCKORBIT_OFFSETSBAS + _phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS]) {
481 sys = 'S';
482 flag = t_eph::SBASL1;
483 }
484 else if (ii >= CLOCKORBIT_OFFSETBDS &&
485 ii < CLOCKORBIT_OFFSETBDS + _phaseBias.NumberOfSat[CLOCKORBIT_SATBDS]) {
486 sys = 'C';
487 if (num < 6) {// GEO
488 flag = t_eph::D2;
489 }
490 else if (num > 58 && num < 63) { // GEO
491 flag = t_eph::D2;
492 }
493 else {
494 flag = t_eph::D1;
495 }
496 }
497 else {
498 continue;
499 }
500 t_satPhaseBias satPhaseBias;
501 satPhaseBias._prn.set(sys, num, flag);
502 satPhaseBias._staID = _staID.toStdString();
503 satPhaseBias._time = _lastTime;
504 satPhaseBias._updateInt = _phaseBias.UpdateInterval;
505 satPhaseBias._ssrFormat = (_type == RTCMssr) ? ssrRtcmOld :
506 (_type == RTCMnewssr) ? ssrRtcmNew : ssrUnknown;
507 satPhaseBias._dispBiasConsistInd = _phaseBias.DispersiveBiasConsistencyIndicator;
508 satPhaseBias._MelbWuebConsistInd = _phaseBias.MWConsistencyIndicator;
509 satPhaseBias._yaw = _phaseBias.Sat[ii].YawAngle;
510 satPhaseBias._yawRate = _phaseBias.Sat[ii].YawRate;
511 for (unsigned jj = 0; jj < _phaseBias.Sat[ii].NumberOfPhaseBiases; jj++) {
512 const SsrCorr::PhaseBias::PhaseBiasSat::PhaseBiasEntry& biasEntry = _phaseBias.Sat[ii].Biases[jj];
513 t_frqPhaseBias frqPhaseBias;
514 frqPhaseBias._rnxType2ch.assign(_ssrCorr->codeTypeToRnxType(sys, biasEntry.Type));
515 frqPhaseBias._value = biasEntry.Bias;
516 frqPhaseBias._fixIndicator = biasEntry.IntegerIndicator;
517 frqPhaseBias._fixWideLaneIndicator = biasEntry.WidelaneGroupIndicator;
518 frqPhaseBias._jumpCounter = biasEntry.DiscontinuityCounter;
519 if (!frqPhaseBias._rnxType2ch.empty()) {
520 satPhaseBias._bias.push_back(frqPhaseBias);
521 }
522 }
523 _phaseBiases[_lastTime].append(satPhaseBias);
524 }
525
526 // Ionospheric Model
527 // -----------------
528 if (_vTEC.NumLayers > 0) {
529 _vTecMap[_lastTime]._time = _lastTime;
530 _vTecMap[_lastTime]._updateInt = _vTEC.UpdateInterval;
531 _vTecMap[_lastTime]._staID = _staID.toStdString();
532 for (unsigned ii = 0; ii < _vTEC.NumLayers; ii++) {
533 const SsrCorr::VTEC::IonoLayers& ionoLayer = _vTEC.Layers[ii];
534 t_vTecLayer layer;
535 layer._height = ionoLayer.Height;
536 layer._C.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
537 layer._S.ReSize(ionoLayer.Degree+1, ionoLayer.Order+1);
538 for (unsigned iDeg = 0; iDeg <= ionoLayer.Degree; iDeg++) {
539 for (unsigned iOrd = 0; iOrd <= ionoLayer.Order; iOrd++) {
540 layer._C[iDeg][iOrd] = ionoLayer.Cosinus[iDeg][iOrd];
541 layer._S[iDeg][iOrd] = ionoLayer.Sinus[iDeg][iOrd];
542 }
543 }
544 _vTecMap[_lastTime]._layers.push_back(layer);
545 }
546 }
547
548 // Dump all older epochs
549 // ---------------------
550 QMutableMapIterator<bncTime, QList<t_orbCorr> > itOrb(_orbCorrections);
551 while (itOrb.hasNext()) {
552 itOrb.next();
553 if (itOrb.key() < _lastTime) {
554 emit newOrbCorrections(itOrb.value());
555 t_orbCorr::writeEpoch(_out, itOrb.value());
556 itOrb.remove();
557 }
558 }
559 QMutableMapIterator<bncTime, QList<t_clkCorr> > itClk(_clkCorrections);
560 while (itClk.hasNext()) {
561 itClk.next();
562 if (itClk.key() < _lastTime) {
563 emit newClkCorrections(itClk.value());
564 t_clkCorr::writeEpoch(_out, itClk.value());
565 itClk.remove();
566 }
567 }
568 QMutableMapIterator<bncTime, QList<t_satCodeBias> > itCB(_codeBiases);
569 while (itCB.hasNext()) {
570 itCB.next();
571 if (itCB.key() < _lastTime) {
572 emit newCodeBiases(itCB.value());
573 t_satCodeBias::writeEpoch(_out, itCB.value());
574 itCB.remove();
575 }
576 }
577 QMutableMapIterator<bncTime, QList<t_satPhaseBias> > itPB(_phaseBiases);
578 while (itPB.hasNext()) {
579 itPB.next();
580 if (itPB.key() < _lastTime) {
581 emit newPhaseBiases(itPB.value());
582 t_satPhaseBias::writeEpoch(_out, itPB.value());
583 itPB.remove();
584 }
585 }
586 QMutableMapIterator<bncTime, t_vTec> itTec(_vTecMap);
587 while (itTec.hasNext()) {
588 itTec.next();
589 if (itTec.key() < _lastTime) {
590 emit newTec(itTec.value());
591 t_vTec::write(_out, itTec.value());
592 itTec.remove();
593 }
594 }
595}
596
597//
598////////////////////////////////////////////////////////////////////////////
599void RTCM3coDecoder::checkProviderID() {
600
601 if (_clkOrb.SSRProviderID == 0 && _clkOrb.SSRSolutionID == 0 && _clkOrb.SSRIOD == 0) {
602 return;
603 }
604
605 int newProviderID[3];
606 newProviderID[0] = _clkOrb.SSRProviderID;
607 newProviderID[1] = _clkOrb.SSRSolutionID;
608 newProviderID[2] = _clkOrb.SSRIOD;
609 QString newProviderIDStr = QString(" [SSR Provider ID: %1 SSR Solution ID: %2 SSR IOD: %3]: ")
610 .arg(newProviderID[0]).arg(newProviderID[1]).arg(newProviderID[2]);
611
612 bool alreadySet = false;
613 bool different = false;
614
615 for (unsigned ii = 0; ii < 3; ii++) {
616 if (_providerID[ii] != -1) {
617 alreadySet = true;
618 }
619 if (_providerID[ii] != newProviderID[ii]) {
620 different = true;
621 }
622 _providerID[ii] = newProviderID[ii];
623 }
624
625 if (alreadySet && different) {
626 emit newMessage("RTCM3coDecoder: SSR Provider or Service changed " + newProviderIDStr.toLatin1() + _staID.toLatin1(), true);
627 emit providerIDChanged(_staID);
628 }
629}
630
631// Check corrections
632////////////////////////////////////////////////////////////////////////////
633bool RTCM3coDecoder::corrIsOutOfRange(const SsrCorr::ClockOrbit::SatData& coSat) {
634
635 QString ssrParStr;
636 QString ssrParValue;
637 bool corrIsOutOfRange = false;
638
639 switch (_type) {
640 // ======== //
641 // IGS SSR //
642 // ======== //
643 case IGSssr:
644 if (coSat.Clock.DeltaA0 < -209.7151 ||
645 coSat.Clock.DeltaA0 > +209.7151) {
646 ssrParStr = "Clock::DeltaA0";
647 ssrParValue = QString::number(coSat.Clock.DeltaA0, 'f', 4);
648 corrIsOutOfRange = true;
649 }
650 if (coSat.Clock.DeltaA1 < -1.048575 ||
651 coSat.Clock.DeltaA1 > +1.048575) {
652 ssrParStr = "Clock::DeltaA1";
653 ssrParValue = QString::number(coSat.Clock.DeltaA1, 'f', 6);
654 corrIsOutOfRange = true;
655 }
656 if (coSat.Clock.DeltaA2 < -1.3421772 ||
657 coSat.Clock.DeltaA2 > +1.3421772) {
658 ssrParStr = "Clock::DeltaA2";
659 ssrParValue = QString::number(coSat.Clock.DeltaA2, 'f', 7);
660 corrIsOutOfRange = true;
661 }
662
663 if (coSat.Orbit.DeltaRadial < -209.7151 ||
664 coSat.Orbit.DeltaRadial > +209.7151) {
665 ssrParStr = "Orbit::DeltaRadial";
666 ssrParValue = QString::number(coSat.Orbit.DeltaRadial, 'f', 4);
667 corrIsOutOfRange = true;
668 }
669
670 if (coSat.Orbit.DeltaAlongTrack < -209.7148 ||
671 coSat.Orbit.DeltaAlongTrack > +209.7148) {
672 ssrParStr = "Orbit::DeltaAlongTrack";
673 ssrParValue = QString::number(coSat.Orbit.DeltaAlongTrack, 'f', 4);
674 corrIsOutOfRange = true;
675 }
676 if (coSat.Orbit.DeltaCrossTrack < -209.7148 ||
677 coSat.Orbit.DeltaCrossTrack > +209.7148) {
678 ssrParStr = "Orbit::DeltaCrossTrack";
679 ssrParValue = QString::number(coSat.Orbit.DeltaCrossTrack, 'f', 4);
680 corrIsOutOfRange = true;
681 }
682
683 if (coSat.Orbit.DotDeltaRadial < -1.048575 ||
684 coSat.Orbit.DotDeltaRadial > +1.048575) {
685 ssrParStr = "Orbit::DotDeltaRadial";
686 ssrParValue = QString::number(coSat.Orbit.DotDeltaRadial, 'f', 6);
687 corrIsOutOfRange = true;
688 }
689 if (coSat.Orbit.DotDeltaAlongTrack < -1.048572 ||
690 coSat.Orbit.DotDeltaAlongTrack > +1.048572) {
691 ssrParStr = "Orbit::DotDeltaAlongTrack";
692 ssrParValue = QString::number(coSat.Orbit.DotDeltaAlongTrack, 'f', 6);
693 corrIsOutOfRange = true;
694 }
695 if (coSat.Orbit.DotDeltaCrossTrack < -1.048572 ||
696 coSat.Orbit.DotDeltaCrossTrack > +1.048572) {
697 ssrParStr = "Orbit::DotDeltaCrossTrack";
698 ssrParValue = QString::number(coSat.Orbit.DotDeltaCrossTrack, 'f', 6);
699 corrIsOutOfRange = true;
700 }
701 break;
702 //==========//
703 // RTCM SSR //
704 // =========//
705 case RTCMssr:
706 case RTCMnewssr:
707 if (coSat.Clock.DeltaA0 < -209.7151 ||
708 coSat.Clock.DeltaA0 > +209.7151) {
709 ssrParStr = "Clock::DeltaA0";
710 ssrParValue = QString::number(coSat.Clock.DeltaA0, 'f', 4);
711 corrIsOutOfRange = true;
712 }
713 if (coSat.Clock.DeltaA1 < -1.048575 ||
714 coSat.Clock.DeltaA1 > +1.048575) {
715 ssrParStr = "Clock::DeltaA1";
716 ssrParValue = QString::number(coSat.Clock.DeltaA1, 'f', 6);
717 corrIsOutOfRange = true;
718 }
719 if (coSat.Clock.DeltaA2 < -1.34217726 ||
720 coSat.Clock.DeltaA2 > +1.34217726) {
721 ssrParStr = "Clock::DeltaA2";
722 ssrParValue = QString::number(coSat.Clock.DeltaA2, 'f', 8);
723 corrIsOutOfRange = true;
724 }
725
726 if (coSat.Orbit.DeltaRadial < -209.7151 ||
727 coSat.Orbit.DeltaRadial > +209.7151) {
728 ssrParStr = "Orbit::DeltaRadial";
729 ssrParValue = QString::number(coSat.Orbit.DeltaRadial, 'f', 4);
730 corrIsOutOfRange = true;
731 }
732
733 if (coSat.Orbit.DeltaAlongTrack < -209.7148 ||
734 coSat.Orbit.DeltaAlongTrack > +209.7148) {
735 ssrParStr = "Orbit::DeltaAlongTrack";
736 ssrParValue = QString::number(coSat.Orbit.DeltaAlongTrack, 'f', 4);
737 corrIsOutOfRange = true;
738 }
739 if (coSat.Orbit.DeltaCrossTrack < -209.7148 ||
740 coSat.Orbit.DeltaCrossTrack > +209.7148) {
741 ssrParStr = "Orbit::DeltaCrossTrack";
742 ssrParValue = QString::number(coSat.Orbit.DeltaCrossTrack, 'f', 4);
743 corrIsOutOfRange = true;
744 }
745
746 if (coSat.Orbit.DotDeltaRadial < -1.048575 ||
747 coSat.Orbit.DotDeltaRadial > +1.048575) {
748 ssrParStr = "Orbit::DotDeltaRadial";
749 ssrParValue = QString::number(coSat.Orbit.DotDeltaRadial, 'f', 6);
750 corrIsOutOfRange = true;
751 }
752 if (coSat.Orbit.DotDeltaAlongTrack < -1.048572 ||
753 coSat.Orbit.DotDeltaAlongTrack > +1.048572) {
754 ssrParStr = "Orbit::DotDeltaAlongTrack";
755 ssrParValue = QString::number(coSat.Orbit.DotDeltaAlongTrack, 'f', 6);
756 corrIsOutOfRange = true;
757 }
758 if (coSat.Orbit.DotDeltaCrossTrack < -1.048572 ||
759 coSat.Orbit.DotDeltaCrossTrack > +1.048572) {
760 ssrParStr = "Orbit::DotDeltaCrossTrack";
761 ssrParValue = QString::number(coSat.Orbit.DotDeltaCrossTrack, 'f', 6);
762 corrIsOutOfRange = true;
763 }
764 break;
765 }
766
767 if (corrIsOutOfRange) {
768 emit newMessage("RTCM3coDecoder: Correction " + ssrParStr.toLatin1()
769 + " (" + ssrParValue.toLatin1() + ") "
770 + "is out of range " + _staID.toLatin1(), true);
771 }
772
773 return corrIsOutOfRange;
774}
775
776//
777////////////////////////////////////////////////////////////////////////////
778void RTCM3coDecoder::setEpochTime() {
779
780 _lastTime.reset();
781
782 double epoSecGPS = -1.0;
783 double epoSecGlo = -1.0;
784 double epoSecGal = -1.0;
785 double epoSecQzss = -1.0;
786 double epoSecSbas = -1.0;
787 double epoSecBds = -1.0;
788 if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
789 epoSecGPS = _clkOrb.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
790 }
791 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
792 epoSecGPS = _codeBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
793 }
794 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGPS] > 0) {
795 epoSecGPS = _phaseBias.EpochTime[CLOCKORBIT_SATGPS]; // 0 .. 604799 s
796 }
797 else if (_vTEC.NumLayers > 0) {
798 epoSecGPS = _vTEC.EpochTime; // 0 .. 604799 s
799 }
800 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
801 epoSecGlo = _clkOrb.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
802 }
803 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
804 epoSecGlo = _codeBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
805 }
806 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
807 epoSecGlo = _phaseBias.EpochTime[CLOCKORBIT_SATGLONASS]; // 0 .. 86399 s
808 }
809 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
810 epoSecGal = _clkOrb.EpochTime[CLOCKORBIT_SATGALILEO];
811 }
812 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
813 epoSecGal = _codeBias.EpochTime[CLOCKORBIT_SATGALILEO];
814 }
815 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATGALILEO] > 0) {
816 epoSecGal = _phaseBias.EpochTime[CLOCKORBIT_SATGALILEO];
817 }
818 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
819 epoSecQzss = _clkOrb.EpochTime[CLOCKORBIT_SATQZSS];
820 }
821 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
822 epoSecQzss = _codeBias.EpochTime[CLOCKORBIT_SATQZSS];
823 }
824 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATQZSS] > 0) {
825 epoSecQzss = _phaseBias.EpochTime[CLOCKORBIT_SATQZSS];
826 }
827 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
828 epoSecSbas = _clkOrb.EpochTime[CLOCKORBIT_SATSBAS];
829 }
830 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
831 epoSecSbas = _codeBias.EpochTime[CLOCKORBIT_SATSBAS];
832 }
833 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATSBAS] > 0) {
834 epoSecSbas = _phaseBias.EpochTime[CLOCKORBIT_SATSBAS];
835 }
836 else if (_clkOrb.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
837 epoSecBds = _clkOrb.EpochTime[CLOCKORBIT_SATBDS];
838 }
839 else if (_codeBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
840 epoSecBds = _codeBias.EpochTime[CLOCKORBIT_SATBDS];
841 }
842 else if (_phaseBias.NumberOfSat[CLOCKORBIT_SATBDS] > 0) {
843 epoSecBds = _phaseBias.EpochTime[CLOCKORBIT_SATBDS];
844 }
845
846 // Retrieve current time
847 // ---------------------
848 int currentWeek = 0;
849 double currentSec = 0.0;
850 currentGPSWeeks(currentWeek, currentSec);
851 bncTime currentTime(currentWeek, currentSec);
852
853 // Set _lastTime close to currentTime
854 // ----------------------------------
855 if (epoSecGPS != -1) {
856 _lastTime.set(currentWeek, epoSecGPS);
857 }
858 else if (epoSecGlo != -1) {
859 QDate date = dateAndTimeFromGPSweek(currentTime.gpsw(), currentTime.gpssec()).date();
860 if (_type == IGSssr) {
861 epoSecGlo = epoSecGlo + gnumleap(date.year(), date.month(), date.day());
862 }
863 if (_type == RTCMssr) {
864 epoSecGlo = epoSecGlo - 3 * 3600 + gnumleap(date.year(), date.month(), date.day());
865 }
866 _lastTime.set(currentWeek, epoSecGlo);
867 }
868 else if (epoSecGal != -1) {
869 _lastTime.set(currentWeek, epoSecGal);
870 }
871 else if (epoSecQzss != -1) {
872 _lastTime.set(currentWeek, epoSecQzss);
873 }
874 else if (epoSecSbas != -1) {
875 _lastTime.set(currentWeek, epoSecSbas);
876 }
877 else if (epoSecBds != -1) {
878 epoSecBds += 14.0;
879 if (epoSecBds > 604800.0) {
880 epoSecBds -= 7.0*24.0*60.0*60.0;
881 }
882 _lastTime.set(currentWeek, epoSecBds);
883 }
884
885 if (_lastTime.valid()) {
886 double maxDiff = 12 * 3600.0;
887 while (_lastTime < currentTime - maxDiff) {
888 _lastTime = _lastTime + maxDiff;
889 }
890 while (_lastTime > currentTime + maxDiff) {
891 _lastTime = _lastTime - maxDiff;
892 }
893 }
894}
Note: See TracBrowser for help on using the repository browser.