source: ntrip/trunk/BNC/RTCM3/RTCM3Decoder.cpp@ 1210

Last change on this file since 1210 was 1185, checked in by weber, 16 years ago

* empty log message *
File size: 13.2 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: RTCM3Decoder
30 *
31 * Purpose: RTCM3 Decoder
32 *
33 * Author: L. Mervart
34 *
35 * Created: 24-Aug-2006
36 *
37 * Changes:
38 *
39 * -----------------------------------------------------------------------*/
40
41#include <iostream>
42#include <math.h>
43#include <string.h>
44
45#include "RTCM3Decoder.h"
46#include "RTCM3coDecoder.h"
47#include "bncconst.h"
48#include "bncapp.h"
49#include "bncutils.h" /* Weber, for latencies */
50
51using namespace std;
52
53#ifndef isinf
54# define isinf(x) 0
55#endif
56
57// Error Handling
58////////////////////////////////////////////////////////////////////////////
59void RTCM3Error(const char*, ...) {
60}
61
62// Constructor
63////////////////////////////////////////////////////////////////////////////
64RTCM3Decoder::RTCM3Decoder(const QString& staID) : GPSDecoder() {
65
66 QSettings settings;
67 _checkMountPoint = settings.value("messTypes").toString();
68 _staID = staID;
69
70 // Latency
71 _numLat = 0;
72 _minLat = 1000.;
73 _maxLat = -1000.;
74 _sumLat = 0.;
75 _sumLatQ = 0.;
76 _followSec = false;
77 _meanDiff = 0.;
78 _diffSecGPS= 0.;
79 _numGaps = 0;
80 _oldSecGPS = 0.;
81 _newSecGPS = 0.;
82 _curLat = 0.;
83 _perfIntr = 86400;
84 if ( settings.value("perfIntr").toString().isEmpty() ) { _perfIntr = 0; }
85 if ( settings.value("perfIntr").toString().indexOf("1 min") != -1 ) { _perfIntr = 60; }
86 if ( settings.value("perfIntr").toString().indexOf("5 min") != -1 ) { _perfIntr = 300; }
87 if ( settings.value("perfIntr").toString().indexOf("15 min") != -1 ) { _perfIntr = 900; }
88 if ( settings.value("perfIntr").toString().indexOf("1 hour") != -1 ) { _perfIntr = 3600; }
89 if ( settings.value("perfIntr").toString().indexOf("6 hours") != -1 ) { _perfIntr = 21600; }
90 if ( settings.value("perfIntr").toString().indexOf("1 day") != -1 ) { _perfIntr = 86400; }
91
92 // Ensure, that the Decoder uses the "old" convention for the data structure for Rinex2. Perlt
93 _Parser.rinex3 = 0;
94
95 memset(&_Parser, 0, sizeof(_Parser));
96
97 double secGPS;
98 currentGPSWeeks(_Parser.GPSWeek, secGPS);
99 _Parser.GPSTOW = int(secGPS);
100
101 connect(this, SIGNAL(newGPSEph(gpsephemeris*)),
102 (bncApp*) qApp, SLOT(slotNewGPSEph(gpsephemeris*)));
103 connect(this, SIGNAL(newGlonassEph(glonassephemeris*)),
104 (bncApp*) qApp, SLOT(slotNewGlonassEph(glonassephemeris*)));
105
106 // Sub-Decoder for Clock and Orbit Corrections
107 // -------------------------------------------
108 _coDecoder = new RTCM3coDecoder(staID);
109
110 // Mode can be either observations or corrections
111 // ----------------------------------------------
112 _mode = unknown;
113}
114
115// Destructor
116////////////////////////////////////////////////////////////////////////////
117RTCM3Decoder::~RTCM3Decoder() {
118 delete _coDecoder;
119}
120
121//
122////////////////////////////////////////////////////////////////////////////
123t_irc RTCM3Decoder::Decode(char* buffer, int bufLen) {
124
125 bool decoded = false;
126
127 // Try to decode Clock and Orbit Corrections
128 // -----------------------------------------
129 if (_mode == unknown || _mode == corrections) {
130 if ( _coDecoder->Decode(buffer, bufLen) == success ) {
131 decoded = true;
132
133 // Latency
134 // -------
135 if (_perfIntr>0) {
136 if (0<_coDecoder->_epochList.size()) {
137 for (int ii=0;ii<_coDecoder->_epochList.size();ii++) {
138 int week;
139 double sec;
140 _newSecGPS = _coDecoder->_epochList[ii];
141 currentGPSWeeks(week, sec);
142 double dt = fabs(sec - _newSecGPS);
143 const double secPerWeek = 7.0 * 24.0 * 3600.0;
144 if (dt > 0.5 * secPerWeek) {
145 if (sec > _newSecGPS) {
146 sec -= secPerWeek;
147 } else {
148 sec += secPerWeek;
149 }
150 }
151 if (_newSecGPS != _oldSecGPS) {
152 if (int(_newSecGPS) % _perfIntr < int(_oldSecGPS) % _perfIntr) {
153 if (_numLat>0) {
154 QString late;
155 if (_meanDiff>0.) {
156 late = QString(": Mean latency %1 sec, min %2, max %3, rms %4, %5 epochs, %6 gaps")
157 .arg(int(_sumLat/_numLat*100)/100.)
158 .arg(int(_minLat*100)/100.)
159 .arg(int(_maxLat*100)/100.)
160 .arg(int((sqrt((_sumLatQ - _sumLat * _sumLat / _numLat)/_numLat))*100)/100.)
161 .arg(_numLat)
162 .arg(_numGaps);
163 emit(newMessage(QString(_staID + late ).toAscii() ) );
164 } else {
165 late = QString(": Mean latency %1 sec, min %2, max %3, rms %4, %5 epochs")
166 .arg(int(_sumLat/_numLat*100)/100.)
167 .arg(int(_minLat*100)/100.)
168 .arg(int(_maxLat*100)/100.)
169 .arg(int((sqrt((_sumLatQ - _sumLat * _sumLat / _numLat)/_numLat))*100)/100.)
170 .arg(_numLat);
171 emit(newMessage(QString(_staID + late ).toAscii() ) );
172 }
173 }
174 _meanDiff = int(_diffSecGPS)/_numLat;
175 _diffSecGPS = 0.;
176 _numGaps = 0;
177 _sumLat = 0.;
178 _sumLatQ = 0.;
179 _numLat = 0;
180 _minLat = 1000.;
181 _maxLat = -1000.;
182 }
183 if (_followSec) {
184 _diffSecGPS += _newSecGPS - _oldSecGPS;
185 if (_meanDiff>0.) {
186 if (_newSecGPS - _oldSecGPS > 1.5 * _meanDiff) {
187 _numGaps += 1;
188 }
189 }
190 }
191 _curLat = sec - _newSecGPS;
192 _sumLat += _curLat;
193 _sumLatQ += _curLat * _curLat;
194 if (_curLat < _minLat) {_minLat = _curLat;}
195 if (_curLat >= _maxLat) {_maxLat = _curLat;}
196 _numLat += 1;
197 _oldSecGPS = _newSecGPS;
198 _followSec = true;
199 }
200 }
201 }
202 }
203 _coDecoder->_epochList.clear();
204
205 if (_mode == unknown) {
206 _mode = corrections;
207 }
208 }
209 }
210
211 // Remaining part decodes the Observations
212 // ---------------------------------------
213 if (_mode == unknown || _mode == observations || _checkMountPoint == _staID || _checkMountPoint == "ALL") {
214
215 for (int ii = 0; ii < bufLen; ii++) {
216 _Parser.Message[_Parser.MessageSize++] = buffer[ii];
217
218 if (_Parser.MessageSize >= _Parser.NeedBytes) {
219
220 // RTCMv3 message types
221 // --------------------
222 for (int kk = 0; kk < _Parser.typeSize; kk++) {
223 _typeList.push_back(_Parser.typeList[kk]);
224 }
225 _Parser.typeSize = 0;
226
227 // RTCMv3 antenna descriptor
228 // -------------------------
229 for (int kk = 0; kk < _Parser.antSize; kk++) {
230 _antType.push_back(_Parser.antType[kk]);
231 }
232 _Parser.antSize = 0;
233
234 // RTCMv3 antenna XYZ
235 // ------------------
236 for (int kk = 0; kk < _Parser.antSize5; kk += 3) {
237 _antList5.push_back(_Parser.antList5[kk + 0]);
238 _antList5.push_back(_Parser.antList5[kk + 1]);
239 _antList5.push_back(_Parser.antList5[kk + 2]);
240 }
241 _Parser.antSize5 = 0;
242
243 // RTCMv3 antenna XYZ-H
244 // --------------------
245 for (int kk = 0; kk < _Parser.antSize6; kk += 4) {
246 _antList6.push_back(_Parser.antList6[kk + 0]);
247 _antList6.push_back(_Parser.antList6[kk + 1]);
248 _antList6.push_back(_Parser.antList6[kk + 2]);
249 _antList6.push_back(_Parser.antList6[kk + 3]);
250 }
251 _Parser.antSize6 = 0;
252
253 while(int rr = RTCM3Parser(&_Parser)) {
254
255 // GNSS Observations
256 // -----------------
257 if (rr == 1 || rr == 2) {
258 decoded = true;
259
260 if (!_Parser.init) {
261 HandleHeader(&_Parser);
262 _Parser.init = 1;
263 }
264
265 if (rr == 2) {
266 emit(newMessage( (_staID + ": No valid RINEX! All values are modulo 299792.458!").toAscii() ));
267 }
268
269 for (int ii = 0; ii < _Parser.Data.numsats; ii++) {
270 p_obs obs = new t_obs();
271 _obsList.push_back(obs);
272 if (_Parser.Data.satellites[ii] <= PRN_GPS_END) {
273 obs->_o.satSys = 'G';
274 obs->_o.satNum = _Parser.Data.satellites[ii];
275 }
276 else if (_Parser.Data.satellites[ii] <= PRN_GLONASS_END) {
277 obs->_o.satSys = 'R';
278 obs->_o.satNum = _Parser.Data.satellites[ii] - PRN_GLONASS_START + 1;
279 }
280 else {
281 obs->_o.satSys = 'S';
282 obs->_o.satNum = _Parser.Data.satellites[ii] - PRN_WAAS_START + 20;
283 }
284 obs->_o.GPSWeek = _Parser.Data.week;
285 obs->_o.GPSWeeks = _Parser.Data.timeofweek / 1000.0;
286
287 for (int jj = 0; jj < _Parser.numdatatypesGPS; jj++) {
288 int v = 0;
289 // sepearated declaration and initalization of df and pos. Perlt
290 int df;
291 int pos;
292 df = _Parser.dataflag[jj];
293 pos = _Parser.datapos[jj];
294 if ( (_Parser.Data.dataflags[ii] & df)
295 && !isnan(_Parser.Data.measdata[ii][pos])
296 && !isinf(_Parser.Data.measdata[ii][pos])) {
297 v = 1;
298 }
299 else {
300 df = _Parser.dataflagGPS[jj];
301 pos = _Parser.dataposGPS[jj];
302 if ( (_Parser.Data.dataflags[ii] & df)
303 && !isnan(_Parser.Data.measdata[ii][pos])
304 && !isinf(_Parser.Data.measdata[ii][pos])) {
305 v = 1;
306 }
307 }
308 if (!v) {
309 continue;
310 }
311 else
312 {
313 int isat = (_Parser.Data.satellites[ii] < 120
314 ? _Parser.Data.satellites[ii]
315 : _Parser.Data.satellites[ii] - 80);
316
317 // variables df and pos are used consequently. Perlt
318 if (df & GNSSDF_C1DATA) {
319 obs->_o.C1 = _Parser.Data.measdata[ii][pos];
320 }
321 else if (df & GNSSDF_C2DATA) {
322 obs->_o.C2 = _Parser.Data.measdata[ii][pos];
323 }
324 else if (df & GNSSDF_P1DATA) {
325 obs->_o.P1 = _Parser.Data.measdata[ii][pos];
326 }
327 else if (df & GNSSDF_P2DATA) {
328 obs->_o.P2 = _Parser.Data.measdata[ii][pos];
329 }
330 else if (df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA)) {
331 obs->_o.L1 = _Parser.Data.measdata[ii][pos];
332 obs->_o.SNR1 = _Parser.Data.snrL1[ii];
333 obs->_o.lock_timei_L1 = _Parser.lastlockl1[isat];
334 }
335 else if (df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA)) {
336 obs->_o.L2 = _Parser.Data.measdata[ii][pos];
337 obs->_o.SNR2 = _Parser.Data.snrL2[ii];
338 obs->_o.lock_timei_L2 = _Parser.lastlockl2[isat];
339 }
340 else if (df & (GNSSDF_S1CDATA|GNSSDF_S1PDATA)) {
341 obs->_o.S1 = _Parser.Data.measdata[ii][pos];
342 }
343 else if (df & (GNSSDF_S2CDATA|GNSSDF_S2PDATA)) {
344 obs->_o.S2 = _Parser.Data.measdata[ii][pos];
345 }
346 }
347 }
348 }
349 }
350
351 // GPS Ephemeris
352 // -------------
353 else if (rr == 1019) {
354 decoded = true;
355 gpsephemeris* ep = new gpsephemeris(_Parser.ephemerisGPS);
356 emit newGPSEph(ep);
357 }
358
359 // GLONASS Ephemeris
360 // -----------------
361 else if (rr == 1020) {
362 decoded = true;
363 glonassephemeris* ep = new glonassephemeris(_Parser.ephemerisGLONASS);
364 emit newGlonassEph(ep);
365 }
366 }
367 }
368 }
369 if (_mode == unknown && decoded) {
370 _mode = observations;
371 }
372 }
373
374 if (decoded) {
375 return success;
376 }
377 else {
378 return failure;
379 }
380}
Note: See TracBrowser for help on using the repository browser.