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

Last change on this file since 8621 was 8621, checked in by stuerze, 4 months ago

minor changes

File size: 18.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:      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, bool outLockTime) {
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    if (frqObs->_lockTimeValid && outLockTime) {
634      str << ' '
635          << left  << setw(3) << "T" + frqObs->_rnxType2ch << ' '
636          << right << setw(9) << setprecision(3) << frqObs->_lockTime;
637    }
638  }
639
640  return str.str();
641}
Note: See TracBrowser for help on using the repository browser.