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

Last change on this file since 11002 was 11002, checked in by stuerze, 5 weeks ago

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