source: ntrip/trunk/BNC/src/bncrinex.cpp@ 8541

Last change on this file since 8541 was 8500, checked in by stuerze, 6 years ago

minor changes to allow requests of user and password detected sourcetables
File size: 18.1 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: bncRinex
30 *
31 * Purpose: writes RINEX files
32 *
33 * Author: L. Mervart
34 *
35 * Created: 27-Aug-2006
36 *
37 * Changes:
38 *
39 * -----------------------------------------------------------------------*/
40
41#include <stdlib.h>
42#include <iostream>
43#include <iomanip>
44#include <math.h>
45#include <sstream>
46
47#include <QtCore>
48#include <QUrl>
49#include <QString>
50
51#include "bncrinex.h"
52#include "bnccore.h"
53#include "bncutils.h"
54#include "bncconst.h"
55#include "bnctabledlg.h"
56#include "bncgetthread.h"
57#include "bncnetqueryv1.h"
58#include "bncnetqueryv2.h"
59#include "bncsettings.h"
60#include "bncversion.h"
61
62using namespace std;
63
64// Constructor
65////////////////////////////////////////////////////////////////////////////
66bncRinex::bncRinex(const QByteArray& statID, const QUrl& mountPoint,
67 const QByteArray& latitude, const QByteArray& longitude,
68 const QByteArray& nmea, const QByteArray& ntripVersion) {
69
70 _statID = statID;
71 _mountPoint = mountPoint;
72 _latitude = latitude;
73 _longitude = longitude;
74 _nmea = nmea;
75 _ntripVersion = ntripVersion;
76 _headerWritten = false;
77 _reconnectFlag = false;
78
79 bncSettings settings;
80 _rnxScriptName = settings.value("rnxScript").toString();
81 expandEnvVar(_rnxScriptName);
82
83 _pgmName = QString(BNCPGMNAME).leftJustified(20, ' ', true);
84#ifdef WIN32
85 _userName = QString("${USERNAME}");
86#else
87 _userName = QString("${USER}");
88#endif
89 expandEnvVar(_userName);
90 _userName = _userName.leftJustified(20, ' ', true);
91
92 _samplingRateMult10 = int(settings.value("rnxSampl").toString().split("sec").first().toDouble() * 10.0);
93
94 if (settings.value("rnxSampl").toString() == "0.1 sec") {
95 _samplingRateStr = "_10Z";
96 }
97 else if (settings.value("rnxSampl").toString() == "1 sec") {
98 _samplingRateStr = "_01S";
99 }
100 else if (settings.value("rnxSampl").toString() == "5 sec") {
101 _samplingRateStr = "_05S";
102 }
103 else if (settings.value("rnxSampl").toString() == "10 sec") {
104 _samplingRateStr = "_10S";
105 }
106 else if (settings.value("rnxSampl").toString() == "15 sec") {
107 _samplingRateStr = "_15S";
108 }
109 else if (settings.value("rnxSampl").toString() == "30 sec") {
110 _samplingRateStr = "_30S";
111 }
112 else if (settings.value("rnxSampl").toString() == "60 sec") {
113 _samplingRateStr = "_01M";
114 }
115
116 _writeRinexFileOnlyWithSkl = settings.value("rnxOnlyWithSKL").toBool();
117
118 _rnxV3 = (Qt::CheckState(settings.value("rnxV3").toInt()) == Qt::Checked) ? true : false;
119}
120
121// Destructor
122////////////////////////////////////////////////////////////////////////////
123bncRinex::~bncRinex() {
124 bncSettings settings;
125 if ((_header.version() >= 3.0) && ( Qt::CheckState(settings.value("rnxAppend").toInt()) != Qt::Checked) ) {
126 _out << "> 4 1" << endl;
127 _out << "END OF FILE" << endl;
128 }
129 _out.close();
130}
131
132// Download Skeleton Header File
133////////////////////////////////////////////////////////////////////////////
134t_irc bncRinex::downloadSkeleton() {
135
136 t_irc irc = failure;
137
138 QStringList table;
139 bncTableDlg::getFullTable(_ntripVersion, _mountPoint.host(), _mountPoint.port(),
140 _mountPoint.userName(), _mountPoint.password(), table, true);
141 QString net;
142 QStringListIterator it(table);
143 while (it.hasNext()) {
144 QString line = it.next();
145 if (line.indexOf("STR") == 0) {
146 QStringList tags = line.split(";");
147 if (tags.size() > 7) {
148 if (tags.at(1) == _mountPoint.path().mid(1).toLatin1()) {
149 net = tags.at(7);
150 break;
151 }
152 }
153 }
154 }
155 QString sklDir;
156 if (!net.isEmpty()) {
157 it.toFront();
158 while (it.hasNext()) {
159 QString line = it.next();
160 if (line.indexOf("NET") == 0) {
161 QStringList tags = line.split(";");
162 if (tags.size() > 6) {
163 if (tags.at(1) == net) {
164 sklDir = tags.at(6).trimmed();
165 break;
166 }
167 }
168 }
169 }
170 }
171 if (!sklDir.isEmpty() && sklDir != "none") {
172 QUrl url(sklDir + "/" + _mountPoint.path().mid(1,4).toLower() + ".skl");
173 if (url.port() == -1) {
174 if (sklDir.contains("https", Qt::CaseInsensitive)) {
175 url.setPort(443);
176 }
177 else {
178 url.setPort(80);
179 }
180 }
181
182 bncNetQuery* query = new bncNetQueryV2(true);
183 QByteArray outData;
184 query->waitForRequestResult(url, outData);
185 if (query->status() == bncNetQuery::finished &&
186 outData.contains("END OF HEADER")) {
187 QTextStream in(outData);
188 irc = _sklHeader.read(&in);
189 }
190
191 delete query;
192 }
193
194 return irc;
195}
196
197// Read Skeleton Header File
198////////////////////////////////////////////////////////////////////////////
199bool bncRinex::readSkeleton() {
200
201 bool readDone = false;
202
203 // Read the local file
204 // -------------------
205 QFile skl(_sklName);
206 if ( skl.exists() && skl.open(QIODevice::ReadOnly) ) {
207 QTextStream in(&skl);
208 if (_sklHeader.read(&in) == success) {
209 readDone = true;
210 }
211 }
212
213 // Read downloaded file
214 // --------------------
215 else if ( _ntripVersion != "N" && _ntripVersion != "UN" &&
216 _ntripVersion != "S" ) {
217 QDate currDate = currentDateAndTimeGPS().date();
218 if ( !_skeletonDate.isValid() || _skeletonDate != currDate ) {
219 if (downloadSkeleton() == success) {
220 readDone = true;
221 _skeletonDate = currDate;
222 }
223 } else if (_skeletonDate.isValid()) {
224 readDone = true;
225 }
226 }
227 return readDone;
228}
229
230// Next File Epoch (static)
231////////////////////////////////////////////////////////////////////////////
232QString bncRinex::nextEpochStr(const QDateTime& datTim,
233 const QString& intStr, bool rnxV3,
234 QDateTime* nextEpoch) {
235
236 QString epoStr = "";
237
238 QTime nextTime;
239 QDate nextDate;
240
241 int indHlp = intStr.indexOf("min");
242
243 if ( indHlp != -1) {
244 int step = intStr.left(indHlp-1).toInt();
245 if (rnxV3) {
246 epoStr += QString("%1").arg(datTim.time().hour(), 2, 10, QChar('0')); // H
247 } else {
248 epoStr += 'A' + datTim.time().hour();
249 }
250
251 if (datTim.time().minute() >= 60-step) {
252 epoStr += QString("%1").arg(60-step, 2, 10, QChar('0')); // M
253 if (datTim.time().hour() < 23) {
254 nextTime.setHMS(datTim.time().hour() + 1 , 0, 0);
255 nextDate = datTim.date();
256 }
257 else {
258 nextTime.setHMS(0, 0, 0);
259 nextDate = datTim.date().addDays(1);
260 }
261 }
262 else {
263 for (int limit = step; limit <= 60-step; limit += step) {
264 if (datTim.time().minute() < limit) {
265 epoStr += QString("%1").arg(limit-step, 2, 10, QChar('0')); // M
266 nextTime.setHMS(datTim.time().hour(), limit, 0);
267 nextDate = datTim.date();
268 break;
269 }
270 }
271 }
272 if (rnxV3) {
273 epoStr += QString("_%1M").arg(step, 2, 10, QChar('0')); // period
274 }
275 }
276 else if (intStr == "1 hour") {
277 int step = intStr.left(indHlp-1).toInt();
278 if (rnxV3) {
279 epoStr += QString("%1").arg(datTim.time().hour(), 2, 10, QChar('0')); // H
280 epoStr += QString("%1").arg(0, 2, 10, QChar('0')); // M
281 epoStr += QString("_%1H").arg(step+1, 2, 10, QChar('0')); // period
282 } else {
283 epoStr += 'A' + datTim.time().hour();
284 }
285 if (datTim.time().hour() < 23) {
286 nextTime.setHMS(datTim.time().hour() + 1 , 0, 0);
287 nextDate = datTim.date();
288 }
289 else {
290 nextTime.setHMS(0, 0, 0);
291 nextDate = datTim.date().addDays(1);
292 }
293 }
294 else {
295 int step = intStr.left(indHlp-1).toInt();
296 if (rnxV3) {
297 epoStr += QString("%1").arg(0, 2, 10, QChar('0')); // H
298 epoStr += QString("%1").arg(0, 2, 10, QChar('0')); // M
299 epoStr += QString("_%1D").arg(step+1, 2, 10, QChar('0')); // period
300 } else {
301 epoStr = "0";
302 }
303 nextTime.setHMS(0, 0, 0);
304 nextDate = datTim.date().addDays(1);
305 }
306
307 if (nextEpoch) {
308 *nextEpoch = QDateTime(nextDate, nextTime);
309 }
310
311 return epoStr;
312}
313
314// File Name according to RINEX Standards
315////////////////////////////////////////////////////////////////////////////
316void bncRinex::resolveFileName(const QDateTime& datTim) {
317
318 bncSettings settings;
319 QString path = settings.value("rnxPath").toString();
320 expandEnvVar(path);
321
322 if ( path.length() > 0 && path[path.length()-1] != QDir::separator() ) {
323 path += QDir::separator();
324 }
325
326 QString hlpStr = nextEpochStr(datTim, settings.value("rnxIntr").toString(),
327 _rnxV3, &_nextCloseEpoch);
328
329 int statIDlength = _statID.size() -1;
330 QString ID4 = _statID.left(4);
331 ID4 = ID4.toUpper();
332
333 // Check name conflict
334 // -------------------
335 QString distStr;
336 int num = 0;
337 QListIterator<QString> it(settings.value("mountPoints").toStringList());
338 while (it.hasNext()) {
339 QString mp = it.next();
340 if (mp.indexOf(_statID.left(statIDlength)) != -1) {
341 ++num;
342 }
343 }
344 if (num > 1) {
345 distStr = "_" + _statID.right(1);
346 }
347
348 QString sklExt = settings.value("rnxSkel").toString();
349 QString sklPre;
350 if (!sklExt.isEmpty()) {
351 if (sklExt.indexOf("skl",0, Qt::CaseSensitive) != -1) {
352 sklPre = ID4.toLower();
353 } else if (sklExt.indexOf("SKL",0, Qt::CaseSensitive) != -1) {
354 sklPre = ID4.toUpper();
355 }
356 _sklName = path + sklPre + distStr + "." + sklExt;
357 }
358
359 if (_rnxV3) {
360 QString country;
361 QString monNum = "0";
362 QString recNum = "0";
363 QListIterator<QString> it(settings.value("mountPoints").toStringList());
364 while (it.hasNext()) {
365 QStringList hlp = it.next().split(" ");
366 if (hlp.size() < 7)
367 continue;
368 if (hlp.join(" ").indexOf(_statID, 0) != -1) {
369 country = hlp[2];
370 }
371 }
372
373 path += ID4 +
374 QString("%1").arg(monNum, 1, 10) +
375 QString("%1").arg(recNum, 1, 10) +
376 country +
377 "_S_" + // stream
378 QString("%1").arg(datTim.date().year()) +
379 QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
380 hlpStr + // HMS_period
381 QString("%1").arg(_samplingRateStr) + // sampling rate
382 "_MO" + // mixed OBS
383 distStr +
384 ".rnx";
385 }
386 else {
387 path += ID4 +
388 QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
389 hlpStr + distStr + datTim.toString(".yyO");
390 }
391
392 _fName = path.toLatin1();
393}
394
395// Write RINEX Header
396////////////////////////////////////////////////////////////////////////////
397void bncRinex::writeHeader(const QByteArray& format, const bncTime& firstObsTime) {
398
399 bncSettings settings;
400
401 // Set RINEX Version
402 // -----------------
403 int intHeaderVers = (Qt::CheckState(settings.value("rnxV3").toInt()) == Qt::Checked ? 3 : 2);
404
405 // Open the Output File
406 // --------------------
407 QDateTime datTimNom = dateAndTimeFromGPSweek(firstObsTime.gpsw(),
408 floor(firstObsTime.gpssec()+0.5));
409
410 resolveFileName(datTimNom);
411
412 // Read Skeleton Header
413 // --------------------
414 if (readSkeleton()) {
415 _header.set(_sklHeader, intHeaderVers);
416 }
417 else {
418 if (_writeRinexFileOnlyWithSkl) {
419 return;
420 }
421 _header.setDefault(_statID, intHeaderVers);
422 }
423
424 // Append to existing file and return
425 // ----------------------------------
426 if ( QFile::exists(_fName) &&
427 (_reconnectFlag || Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) ) {
428 _out.open(_fName.data(), ios::app);
429 _out.setf(ios::showpoint | ios::fixed);
430 _headerWritten = true;
431 _reconnectFlag = false;
432 }
433 else {
434 _out.open(_fName.data());
435 _addComments.clear();
436 }
437
438 _out.setf(ios::showpoint | ios::fixed);
439
440 // A Few Additional Comments
441 // -------------------------
442 _addComments << format.left(6) + " " + _mountPoint.host() + _mountPoint.path();
443 if (_nmea == "yes") {
444 _addComments << "NMEA LAT=" + _latitude + " " + "LONG=" + _longitude;
445 }
446
447 // Write the Header
448 // ----------------
449 QByteArray headerLines;
450 QTextStream outHlp(&headerLines);
451
452 QMap<QString, QString> txtMap;
453 txtMap["COMMENT"] = _addComments.join("\\n");
454
455 _header.setStartTime(firstObsTime);
456 _header.write(&outHlp, &txtMap);
457
458 outHlp.flush();
459
460 if (!_headerWritten) {
461 _out << headerLines.data();
462 }
463
464 _headerWritten = true;
465}
466
467// Stores Observation into Internal Array
468////////////////////////////////////////////////////////////////////////////
469void bncRinex::deepCopy(t_satObs obs) {
470 _obs.push_back(obs);
471}
472
473// Write One Epoch into the RINEX File
474////////////////////////////////////////////////////////////////////////////
475void bncRinex::dumpEpoch(const QByteArray& format, const bncTime& maxTime) {
476
477 // Select observations older than maxTime
478 // --------------------------------------
479 QList<t_satObs> obsList;
480 QMutableListIterator<t_satObs> mIt(_obs);
481 while (mIt.hasNext()) {
482 t_satObs obs = mIt.next();
483 if (obs._time < maxTime) {
484 obsList.push_back(obs);
485 mIt.remove();
486 }
487 }
488
489 // Easy Return
490 // -----------
491 if (obsList.isEmpty()) {
492 return;
493 }
494
495 // Time of Epoch
496 // -------------
497 const t_satObs& fObs = obsList.first();
498 QDateTime datTimNom = dateAndTimeFromGPSweek(fObs._time.gpsw(), fObs._time.gpssec());
499
500 // Close the file
501 // --------------
502 if (_nextCloseEpoch.isValid() && datTimNom >= _nextCloseEpoch) {
503 closeFile();
504 _headerWritten = false;
505 }
506
507 // Write RINEX Header
508 // ------------------
509 if (!_headerWritten) {
510 writeHeader(format, fObs._time);
511 }
512 if (!_headerWritten) {
513 return;
514 }
515
516 // Prepare structure t_rnxEpo
517 // --------------------------
518 t_rnxObsFile::t_rnxEpo rnxEpo;
519 rnxEpo.tt = fObs._time;
520
521 QListIterator<t_satObs> it(obsList);
522 while (it.hasNext()) {
523 const t_satObs& satObs = it.next();
524 t_rnxObsFile::t_rnxSat rnxSat;
525 rnxSat.prn = satObs._prn;
526
527 // Initialize all observations mentioned in skeleton header
528 // --------------------------------------------------------
529 char sys = rnxSat.prn.system();
530 for (int iType = 0; iType < _sklHeader.nTypes(sys); iType++) {
531 QString type = _sklHeader.obsType(sys, iType);
532 t_rnxObsFile::t_rnxObs rnxObs; // create an empty observation
533 rnxSat.obs[type] = rnxObs;
534 }
535
536 for (unsigned ii = 0; ii < satObs._obs.size(); ii++) {
537 const t_frqObs* frqObs = satObs._obs[ii];
538 if (frqObs->_codeValid) {
539 QString type = 'C' + QString(frqObs->_rnxType2ch.c_str());
540 t_rnxObsFile::t_rnxObs rnxObs;
541 rnxObs.value = frqObs->_code;
542 rnxSat.obs[type] = rnxObs;
543 }
544 if (frqObs->_phaseValid) {
545 QString type = 'L' + QString(frqObs->_rnxType2ch.c_str());
546 t_rnxObsFile::t_rnxObs rnxObs;
547 rnxObs.value = frqObs->_phase;
548 if (frqObs->_slip) {
549 rnxObs.lli |= 1;
550 }
551 rnxSat.obs[type] = rnxObs;
552 }
553 if (frqObs->_dopplerValid) {
554 QString type = 'D' + QString(frqObs->_rnxType2ch.c_str());
555 t_rnxObsFile::t_rnxObs rnxObs;
556 rnxObs.value = frqObs->_doppler;
557 rnxSat.obs[type] = rnxObs;
558 }
559 if (frqObs->_snrValid) {
560 QString type = 'S' + QString(frqObs->_rnxType2ch.c_str());
561 t_rnxObsFile::t_rnxObs rnxObs;
562 rnxObs.value = frqObs->_snr;
563 rnxSat.obs[type] = rnxObs;
564 }
565 }
566
567
568 rnxEpo.rnxSat.push_back(rnxSat);
569 }
570
571 // Write the epoch
572 // ---------------
573 QByteArray outLines;
574 QTextStream outStream(&outLines);
575 t_rnxObsFile::writeEpoch(&outStream, _header, &rnxEpo);
576
577 _out << outLines.data();
578 _out.flush();
579}
580
581// Close the Old RINEX File
582////////////////////////////////////////////////////////////////////////////
583void bncRinex::closeFile() {
584
585 if (_header.version() == 3) {
586 _out << "> 4 1" << endl;
587 _out << "END OF FILE" << endl;
588 }
589 _out.close();
590 if (!_rnxScriptName.isEmpty()) {
591 qApp->thread()->wait(100);
592#ifdef WIN32
593 QProcess::startDetached(_rnxScriptName, QStringList() << _fName) ;
594#else
595 QProcess::startDetached("nohup", QStringList() << _rnxScriptName << _fName) ;
596#endif
597
598 }
599}
600
601// One Line in ASCII (Internal) Format
602////////////////////////////////////////////////////////////////////////////
603string bncRinex::asciiSatLine(const t_satObs& obs) {
604
605 ostringstream str;
606 str.setf(ios::showpoint | ios::fixed);
607
608 str << obs._prn.toString();
609
610 for (unsigned ii = 0; ii < obs._obs.size(); ii++) {
611 const t_frqObs* frqObs = obs._obs[ii];
612 if (frqObs->_codeValid) {
613 str << ' '
614 << left << setw(3) << "C" + frqObs->_rnxType2ch << ' '
615 << right << setw(14) << setprecision(3) << frqObs->_code;
616 }
617 if (frqObs->_phaseValid) {
618 str << ' '
619 << left << setw(3) << "L" + frqObs->_rnxType2ch << ' '
620 << right << setw(14) << setprecision(3) << frqObs->_phase << ' '
621 << right << setw(4) << frqObs->_slipCounter;
622 }
623 if (frqObs->_dopplerValid) {
624 str << ' '
625 << left << setw(3) << "D" + frqObs->_rnxType2ch << ' '
626 << right << setw(14) << setprecision(3) << frqObs->_doppler;
627 }
628 if (frqObs->_snrValid) {
629 str << ' '
630 << left << setw(3) << "S" + frqObs->_rnxType2ch << ' '
631 << right << setw(8) << setprecision(3) << frqObs->_snr;
632 }
633 }
634
635 return str.str();
636}
Note: See TracBrowser for help on using the repository browser.