source: ntrip/trunk/BNC/src/bncephuser.cpp@ 9332

Last change on this file since 9332 was 9332, checked in by stuerze, 17 months ago

minor changes

File size: 10.8 KB
Line 
1// converting GNSS data streams from NTRIP broadcasters.
2//
3// Copyright (C) 2007
4// German Federal Agency for Cartography and Geodesy (BKG)
5// http://www.bkg.bund.de
6// Czech Technical University Prague, Department of Geodesy
7// http://www.fsv.cvut.cz
8//
9// Email: euref-ip@bkg.bund.de
10//
11// This program is free software; you can redistribute it and/or
12// modify it under the terms of the GNU General Public License
13// as published by the Free Software Foundation, version 2.
14//
15// This program is distributed in the hope that it will be useful,
16// but WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18// GNU General Public License for more details.
19//
20// You should have received a copy of the GNU General Public License
21// along with this program; if not, write to the Free Software
22// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23
24/* -------------------------------------------------------------------------
25 * BKG NTRIP Client
26 * -------------------------------------------------------------------------
27 *
28 * Class: bncEphUser
29 *
30 * Purpose: Base for Classes that use Ephemerides
31 *
32 * Author: L. Mervart
33 *
34 * Created: 27-Jan-2011
35 *
36 * Changes:
37 *
38 * -----------------------------------------------------------------------*/
39
40#include <cmath>
41#include <iostream>
42
43#include "bncephuser.h"
44#include "bnccore.h"
45
46using namespace std;
47
48// Constructor
49////////////////////////////////////////////////////////////////////////////
50bncEphUser::bncEphUser(bool connectSlots) {
51 if (connectSlots) {
52 connect(BNC_CORE, SIGNAL(newGPSEph(t_ephGPS)),
53 this, SLOT(slotNewGPSEph(t_ephGPS)), Qt::DirectConnection);
54
55 connect(BNC_CORE, SIGNAL(newGlonassEph(t_ephGlo)),
56 this, SLOT(slotNewGlonassEph(t_ephGlo)), Qt::DirectConnection);
57
58 connect(BNC_CORE, SIGNAL(newGalileoEph(t_ephGal)),
59 this, SLOT(slotNewGalileoEph(t_ephGal)), Qt::DirectConnection);
60
61 connect(BNC_CORE, SIGNAL(newSBASEph(t_ephSBAS)),
62 this, SLOT(slotNewSBASEph(t_ephSBAS)), Qt::DirectConnection);
63
64 connect(BNC_CORE, SIGNAL(newBDSEph(t_ephBDS)),
65 this, SLOT(slotNewBDSEph(t_ephBDS)), Qt::DirectConnection);
66 }
67}
68
69// Destructor
70////////////////////////////////////////////////////////////////////////////
71bncEphUser::~bncEphUser() {
72 QMapIterator<QString, deque<t_eph*> > it(_eph);
73 while (it.hasNext()) {
74 it.next();
75 const deque<t_eph*>& qq = it.value();
76 for (unsigned ii = 0; ii < qq.size(); ii++) {
77 delete qq[ii];
78 }
79 }
80}
81
82// New GPS Ephemeris
83////////////////////////////////////////////////////////////////////////////
84void bncEphUser::slotNewGPSEph(t_ephGPS eph) {
85 putNewEph(&eph, true);
86}
87
88// New Glonass Ephemeris
89////////////////////////////////////////////////////////////////////////////
90void bncEphUser::slotNewGlonassEph(t_ephGlo eph) {
91 putNewEph(&eph, true);
92}
93
94// New Galileo Ephemeris
95////////////////////////////////////////////////////////////////////////////
96void bncEphUser::slotNewGalileoEph(t_ephGal eph) {
97 putNewEph(&eph, true);
98}
99
100// New SBAS Ephemeris
101////////////////////////////////////////////////////////////////////////////
102void bncEphUser::slotNewSBASEph(t_ephSBAS eph) {
103 putNewEph(&eph, true);
104}
105
106// New BDS Ephemeris
107////////////////////////////////////////////////////////////////////////////
108void bncEphUser::slotNewBDSEph(t_ephBDS eph) {
109 putNewEph(&eph, true);
110}
111
112//
113////////////////////////////////////////////////////////////////////////////
114t_irc bncEphUser::putNewEph(t_eph* eph, bool realTime) {
115
116 QMutexLocker locker(&_mutex);
117
118 if (eph == 0) {
119 return failure;
120 }
121
122 const t_ephGPS* ephGPS = dynamic_cast<const t_ephGPS*>(eph);
123 const t_ephGlo* ephGlo = dynamic_cast<const t_ephGlo*>(eph);
124 const t_ephGal* ephGal = dynamic_cast<const t_ephGal*>(eph);
125 const t_ephSBAS* ephSBAS = dynamic_cast<const t_ephSBAS*>(eph);
126 const t_ephBDS* ephBDS = dynamic_cast<const t_ephBDS*>(eph);
127
128 t_eph* newEph = 0;
129
130 if (ephGPS) {
131 newEph = new t_ephGPS(*ephGPS);
132 }
133 else if (ephGlo) {
134 newEph = new t_ephGlo(*ephGlo);
135 }
136 else if (ephGal) {
137 newEph = new t_ephGal(*ephGal);
138 }
139 else if (ephSBAS) {
140 newEph = new t_ephSBAS(*ephSBAS);
141 }
142 else if (ephBDS) {
143 newEph = new t_ephBDS(*ephBDS);
144 }
145 else {
146 return failure;
147 }
148
149 QString prn(newEph->prn().toInternalString().c_str());
150
151 const t_eph* ephOld = ephLast(prn);
152
153 if (ephOld &&
154 (ephOld->checkState() == t_eph::bad ||
155 ephOld->checkState() == t_eph::outdated ||
156 ephOld->checkState() == t_eph::unhealthy)) {
157 ephOld = 0;
158 }
159
160 if ( (ephOld == 0) || newEph->isNewerThan(ephOld)) {
161 checkEphemeris(newEph, realTime);
162 eph->setCheckState(newEph->checkState());
163 }
164 else {
165 delete newEph;
166 return failure;
167 }
168
169 if (newEph->checkState() != t_eph::bad &&
170 newEph->checkState() != t_eph::outdated) {
171 deque<t_eph*>& qq = _eph[prn];
172 qq.push_back(newEph);
173 if (qq.size() > _maxQueueSize) {
174 delete qq.front();
175 qq.pop_front();
176 }
177 ephBufferChanged();
178 return success;
179 }
180 else {
181 delete newEph;
182 return failure;
183 }
184}
185
186//
187////////////////////////////////////////////////////////////////////////////
188void bncEphUser::checkEphemeris(t_eph* eph, bool realTime) {
189
190 if (!eph) {
191 return;
192 }
193
194 // Check health status
195 // -------------------
196 if (eph->isUnhealthy()) {
197 eph->setCheckState(t_eph::unhealthy);
198 return;
199 }
200
201 // Simple Check - check satellite radial distance
202 // ----------------------------------------------
203 ColumnVector xc(6);
204 ColumnVector vv(3);
205 if (eph->getCrd(eph->TOC(), xc, vv, false) != success) {
206 eph->setCheckState(t_eph::bad);
207 return;
208 }
209 double rr = xc.Rows(1,3).NormFrobenius();
210
211 const double MINDIST = 2.e7;
212 const double MAXDIST = 6.e7;
213 if (rr < MINDIST || rr > MAXDIST || std::isnan(rr)) {
214 eph->setCheckState(t_eph::bad);
215 return;
216 }
217
218 // Check whether the epoch is too far away the current time
219 // --------------------------------------------------------
220 if (realTime) {
221 bncTime toc = eph->TOC();
222 QDateTime now = currentDateAndTimeGPS();
223 bncTime currentTime(now.toString(Qt::ISODate).toStdString());
224 double dt = currentTime - toc;
225
226 // update interval: 2h, data sets are valid for 4 hours
227 if (eph->type() == t_eph::GPS && (dt > 4*3600.0 || dt < -2*3600.0)) {
228 eph->setCheckState(t_eph::outdated);
229 return;
230 }
231 // update interval: 3h, data sets are valid for 4 hours
232 else if (eph->type() == t_eph::Galileo && (dt > 4*3600.0 || dt < 0.0)) {
233 eph->setCheckState(t_eph::outdated);
234 return;
235 }
236 // updated every 30 minutes
237 else if (eph->type() == t_eph::GLONASS && (dt > 1*3600.0 || dt < -1800.0)) {
238 eph->setCheckState(t_eph::outdated);
239 return;
240 }
241 // orbit parameters are valid for 7200 seconds (minimum)
242 else if (eph->type() == t_eph::QZSS && (dt > 2*3600.0 || dt < -1*3600.0)) {
243 eph->setCheckState(t_eph::outdated);
244 return;
245 }
246 // maximum update interval: 300 sec
247 else if (eph->type() == t_eph::SBAS && (dt > 600 || dt < -300.0)) {
248 eph->setCheckState(t_eph::outdated);
249 return;
250 }
251 // updates 1h (GEO) up to 6 hours non-GEO
252 else if (eph->type() == t_eph::BDS && (dt > 6*3600 || dt < 0.0)) {
253 eph->setCheckState(t_eph::outdated);
254 return;
255 }
256 // update interval: up to 24 hours
257 else if (eph->type() == t_eph::IRNSS && fabs(dt > 24*3600.0)) {
258 eph->setCheckState(t_eph::outdated);
259 return;
260 }
261 }
262
263 // Check consistency with older ephemeris
264 // --------------------------------------
265 const double MAXDIFF = 10.0;
266 const double MINDIFF = 0.005;
267 QString prn = QString(eph->prn().toInternalString().c_str());
268 t_eph* ephL = ephLast(prn);
269
270 if (ephL) {
271 ColumnVector xcL(6);
272 ColumnVector vvL(3);
273 ephL->getCrd(eph->TOC(), xcL, vvL, false);
274
275 double diff = (xc.Rows(1,3) - xcL.Rows(1,3)).NormFrobenius();
276 double diffC = fabs(xc(4) - xcL(4)) * t_CST::c;
277
278 if (diff < MAXDIFF && diffC < MAXDIFF) {
279 if (diff < MINDIFF && diffC < MINDIFF &&
280 ephL->checkState() == t_eph::ok) {
281 // to prevent the same data sets with different TOC values
282 eph->setCheckState(t_eph::bad);
283 }
284 else {
285 eph->setCheckState(t_eph::ok);
286 ephL->setCheckState(t_eph::ok);
287 }
288 }
289 else {
290 if (ephL->checkState() == t_eph::ok) {
291 eph->setCheckState(t_eph::bad);
292 }
293 }
294
295 double dt = eph->TOC() - ephL->TOC();
296 // some lines to allow update of ephemeris data sets after an outage
297 // -----------------------------------------------------------------
298 // update interval: 2h,
299 // sometimes corrected BRDC sets are sent with TOC values 16 seconds
300 // before the nominal TOC (integer time)
301 if (eph->type() == t_eph::GPS && dt > (2*3600.0 + 60.0)) {
302 ephL->setCheckState(t_eph::outdated);
303 return;
304 }
305 // update interval: 3h,
306 else if (eph->type() == t_eph::Galileo && dt > (3*3600.0 + 60.0)) {
307 ephL->setCheckState(t_eph::outdated);
308 return;
309 }
310 // updated every 30 minutes
311 else if (eph->type() == t_eph::GLONASS && dt > ( 1800.0 + 60.0)) {
312 ephL->setCheckState(t_eph::outdated);
313 return;
314 }
315 // updated every ?
316 else if (eph->type() == t_eph::QZSS && dt > (2*3600.0 + 60.0)) {
317 ephL->setCheckState(t_eph::outdated);
318 return;
319 }
320 // maximum update interval: 300 sec
321 else if (eph->type() == t_eph::SBAS && dt > ( 300.0)) {
322 ephL->setCheckState(t_eph::outdated);
323 return;
324 }
325 // updates 1h (GEO) up to 6 hours non-GEO
326 else if (eph->type() == t_eph::BDS && dt > 6*3600.0) {
327 ephL->setCheckState(t_eph::outdated);
328 return;
329 }
330 // update interval: up to 24 hours
331 else if (eph->type() == t_eph::IRNSS && dt > 24*3600.0) {
332 ephL->setCheckState(t_eph::outdated);
333 return;
334 }
335 }
336}
337
338/*
339////////////////////////////////////////////////////////////////////////////
340bool bncEphUser::newCorrectedGpsEphSet(const t_eph* eph) {
341
342 if (eph->prn().system() != 'G') {
343 return false;
344 }
345
346 bool correctedGpsEphSet = false;
347 if ((fmod(eph->TOC().daysec()+16.0, 7200) == 0.0)) {
348 // sometimes corrected BRDC sets are sent with TOC values 16 seconds
349 // before the nominal TOC (integer time)
350 correctedGpsEphSet = true;
351 } else {
352 return false;
353 }
354
355 QString prn = QString(eph->prn().toInternalString().c_str());
356 t_eph* ephL = ephLast(prn);
357 if (!ephL) {
358 // first set is a corrected set for GPS
359 if (correctedGpsEphSet) {
360 return true;
361 }
362 else {
363 return false;
364 }
365 }
366 else {
367 double dt = eph->TOC() - ephL->TOC();
368 if (correctedGpsEphSet) {
369 // set already available
370 if (dt == 0.0) {
371 return false;
372 }
373 else {
374 return true;
375 }
376 }
377 }
378
379 return false;
380}*/
Note: See TracBrowser for help on using the repository browser.