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

Last change on this file since 8661 was 8661, checked in by stuerze, 5 months ago

minor changes reagarding skl filenames

File size: 18.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:      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    QString staID;
173    int stIdLength = _mountPoint.path().length()-2;
174    staID = _mountPoint.path().mid(1,stIdLength).toUpper() + ".skl";
175    QUrl url(sklDir  + staID);
176    if (url.port() == -1) {
177      if (sklDir.contains("https", Qt::CaseInsensitive)) {
178        url.setPort(443);
179      }
180      else {
181        url.setPort(80);
182      }
183    }
184
185    bncNetQuery* query = new bncNetQueryV2(true);
186    QByteArray outData;
187    query->waitForRequestResult(url, outData);
188    if (query->status() == bncNetQuery::finished &&
189        outData.contains("END OF HEADER")) {
190      QTextStream in(outData);
191      irc = _sklHeader.read(&in);
192    }
193
194    delete query;
195  }
196
197  return irc;
198}
199
200// Read Skeleton Header File
201////////////////////////////////////////////////////////////////////////////
202bool bncRinex::readSkeleton() {
203
204  bool readDone = false;
205
206  // Read the local file
207  // -------------------
208  QFile skl(_sklName);
209  if ( skl.exists() && skl.open(QIODevice::ReadOnly) ) {
210    QTextStream in(&skl);
211    if (_sklHeader.read(&in) == success) {
212      readDone = true;
213    }
214  }
215
216  // Read downloaded file
217  // --------------------
218  else if ( _ntripVersion != "N" && _ntripVersion != "UN" &&
219            _ntripVersion != "S" ) {
220    QDate currDate = currentDateAndTimeGPS().date();
221    if ( !_skeletonDate.isValid() || _skeletonDate != currDate ) {
222      if (downloadSkeleton() == success) {
223        readDone = true;
224        _skeletonDate = currDate;
225      }
226    } else if (_skeletonDate.isValid()) {
227      readDone = true;
228    }
229  }
230  return readDone;
231}
232
233// Next File Epoch (static)
234////////////////////////////////////////////////////////////////////////////
235QString bncRinex::nextEpochStr(const QDateTime& datTim,
236                               const QString& intStr, bool rnxV3,
237                               QDateTime* nextEpoch) {
238
239  QString epoStr = "";
240
241  QTime nextTime;
242  QDate nextDate;
243
244  int indHlp = intStr.indexOf("min");
245
246  if ( indHlp != -1) {
247    int step = intStr.left(indHlp-1).toInt();
248    if (rnxV3) {
249      epoStr +=  QString("%1").arg(datTim.time().hour(), 2, 10, QChar('0')); // H
250    } else {
251      epoStr +=  'A' + datTim.time().hour();
252    }
253
254    if (datTim.time().minute() >= 60-step) {
255      epoStr += QString("%1").arg(60-step, 2, 10, QChar('0'));               // M
256      if (datTim.time().hour() < 23) {
257        nextTime.setHMS(datTim.time().hour() + 1 , 0, 0);
258        nextDate = datTim.date();
259      }
260      else {
261        nextTime.setHMS(0, 0, 0);
262        nextDate = datTim.date().addDays(1);
263      }
264    }
265    else {
266      for (int limit = step; limit <= 60-step; limit += step) {
267        if (datTim.time().minute() < limit) {
268          epoStr += QString("%1").arg(limit-step, 2, 10, QChar('0'));        // M
269          nextTime.setHMS(datTim.time().hour(), limit, 0);
270          nextDate = datTim.date();
271          break;
272        }
273      }
274    }
275    if (rnxV3) {
276      epoStr += QString("_%1M").arg(step, 2, 10, QChar('0'));                // period
277    }
278  }
279  else if (intStr == "1 hour") {
280    int step = intStr.left(indHlp-1).toInt();
281    if (rnxV3) {
282      epoStr += QString("%1").arg(datTim.time().hour(), 2, 10, QChar('0'));  // H
283      epoStr += QString("%1").arg(0, 2, 10, QChar('0'));                     // M
284      epoStr += QString("_%1H").arg(step+1, 2, 10, QChar('0'));              // period
285    } else {
286      epoStr +=  'A' + datTim.time().hour();
287    }
288    if (datTim.time().hour() < 23) {
289      nextTime.setHMS(datTim.time().hour() + 1 , 0, 0);
290      nextDate = datTim.date();
291    }
292    else {
293      nextTime.setHMS(0, 0, 0);
294      nextDate = datTim.date().addDays(1);
295    }
296  }
297  else {
298    int step = intStr.left(indHlp-1).toInt();
299    if (rnxV3) {
300      epoStr += QString("%1").arg(0, 2, 10, QChar('0'));                    // H
301      epoStr += QString("%1").arg(0, 2, 10, QChar('0'));                    // M
302      epoStr += QString("_%1D").arg(step+1, 2, 10, QChar('0'));             // period
303    } else {
304      epoStr = "0";
305    }
306    nextTime.setHMS(0, 0, 0);
307    nextDate = datTim.date().addDays(1);
308  }
309
310  if (nextEpoch) {
311   *nextEpoch = QDateTime(nextDate, nextTime);
312  }
313
314  return epoStr;
315}
316
317// File Name according to RINEX Standards
318////////////////////////////////////////////////////////////////////////////
319void bncRinex::resolveFileName(const QDateTime& datTim) {
320
321  bncSettings settings;
322  QString path = settings.value("rnxPath").toString();
323  expandEnvVar(path);
324
325  if ( path.length() > 0 && path[path.length()-1] != QDir::separator() ) {
326    path += QDir::separator();
327  }
328
329  QString hlpStr = nextEpochStr(datTim, settings.value("rnxIntr").toString(),
330                                _rnxV3, &_nextCloseEpoch);
331
332  int statIDlength = _statID.size() -1;
333  QString ID = _statID.left(statIDlength);
334  ID = ID.toUpper();
335
336  // Check name conflict
337  // -------------------
338  QString distStr;
339  int num = 0;
340  QListIterator<QString> it(settings.value("mountPoints").toStringList());
341  while (it.hasNext()) {
342    QString mp = it.next();
343    if (mp.indexOf(_statID.left(statIDlength)) != -1) {
344      ++num;
345    }
346  }
347  if (num > 1) {
348    distStr = "_" + _statID.right(1);
349  }
350
351  QString sklExt = settings.value("rnxSkel").toString();
352  if (!sklExt.isEmpty()) {
353    _sklName = path + ID + distStr + "." + sklExt;
354  }
355
356  if (_rnxV3) {
357    QString country;
358    QString monNum = "0";
359    QString recNum = "0";
360    QListIterator<QString> it(settings.value("mountPoints").toStringList());
361    while (it.hasNext()) {
362      QStringList hlp = it.next().split(" ");
363      if (hlp.size() < 7)
364        continue;
365      if (hlp.join(" ").indexOf(_statID, 0) != -1) {
366        country = hlp[2];
367      }
368    }
369
370    path += ID.left(4) +
371            QString("%1").arg(monNum, 1, 10) +
372            QString("%1").arg(recNum, 1, 10) +
373            country +
374            "_S_" + // stream
375            QString("%1").arg(datTim.date().year()) +
376            QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
377            hlpStr + // HMS_period
378            QString("%1").arg(_samplingRateStr) + // sampling rate
379            "_MO" + // mixed OBS
380            distStr +
381            ".rnx";
382  }
383  else {
384    path += ID.left(4) +
385            QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
386            hlpStr + distStr + datTim.toString(".yyO");
387  }
388
389  _fName = path.toLatin1();
390}
391
392// Write RINEX Header
393////////////////////////////////////////////////////////////////////////////
394void bncRinex::writeHeader(const QByteArray& format, const bncTime& firstObsTime) {
395
396  bncSettings settings;
397
398  // Set RINEX Version
399  // -----------------
400  int intHeaderVers = (Qt::CheckState(settings.value("rnxV3").toInt()) == Qt::Checked ? 3 : 2);
401
402  // Open the Output File
403  // --------------------
404  QDateTime datTimNom  = dateAndTimeFromGPSweek(firstObsTime.gpsw(),
405                                                floor(firstObsTime.gpssec()+0.5));
406
407  resolveFileName(datTimNom);
408
409  // Read Skeleton Header
410  // --------------------
411  if (readSkeleton()) {
412    _header.set(_sklHeader, intHeaderVers);
413  }
414  else {
415    if (_writeRinexFileOnlyWithSkl) {
416      return;
417    }
418    _header.setDefault(_statID, intHeaderVers);
419  }
420
421  // Append to existing file and return
422  // ----------------------------------
423  if ( QFile::exists(_fName) &&
424       (_reconnectFlag || Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) ) {
425    _out.open(_fName.data(), ios::app);
426    _out.setf(ios::showpoint | ios::fixed);
427    _headerWritten = true;
428    _reconnectFlag = false;
429  }
430  else {
431    _out.open(_fName.data());
432    _addComments.clear();
433  }
434
435  _out.setf(ios::showpoint | ios::fixed);
436
437  // A Few Additional Comments
438  // -------------------------
439  _addComments << format.left(6) + " " + _mountPoint.host() + _mountPoint.path();
440  if (_nmea == "yes") {
441    _addComments << "NMEA LAT=" + _latitude + " " + "LONG=" + _longitude;
442  }
443
444  // Write the Header
445  // ----------------
446  QByteArray headerLines;
447  QTextStream outHlp(&headerLines);
448
449  QMap<QString, QString> txtMap;
450  txtMap["COMMENT"] = _addComments.join("\\n");
451
452  _header.setStartTime(firstObsTime);
453  _header.write(&outHlp, &txtMap);
454
455  outHlp.flush();
456
457  if (!_headerWritten) {
458    _out << headerLines.data();
459  }
460
461  _headerWritten = true;
462}
463
464// Stores Observation into Internal Array
465////////////////////////////////////////////////////////////////////////////
466void bncRinex::deepCopy(t_satObs obs) {
467  _obs.push_back(obs);
468}
469
470// Write One Epoch into the RINEX File
471////////////////////////////////////////////////////////////////////////////
472void bncRinex::dumpEpoch(const QByteArray& format, const bncTime& maxTime) {
473
474  // Select observations older than maxTime
475  // --------------------------------------
476  QList<t_satObs> obsList;
477  QMutableListIterator<t_satObs> mIt(_obs);
478  while (mIt.hasNext()) {
479    t_satObs obs = mIt.next();
480    if (obs._time < maxTime) {
481      obsList.push_back(obs);
482      mIt.remove();
483    }
484  }
485
486  // Easy Return
487  // -----------
488  if (obsList.isEmpty()) {
489    return;
490  }
491
492  // Time of Epoch
493  // -------------
494  const t_satObs& fObs = obsList.first();
495  QDateTime datTimNom  = dateAndTimeFromGPSweek(fObs._time.gpsw(), fObs._time.gpssec());
496
497  // Close the file
498  // --------------
499  if (_nextCloseEpoch.isValid() && datTimNom >= _nextCloseEpoch) {
500    closeFile();
501    _headerWritten = false;
502  }
503
504  // Write RINEX Header
505  // ------------------
506  if (!_headerWritten) {
507    writeHeader(format, fObs._time);
508  }
509  if (!_headerWritten) {
510    return;
511  }
512
513  // Prepare structure t_rnxEpo
514  // --------------------------
515  t_rnxObsFile::t_rnxEpo rnxEpo;
516  rnxEpo.tt = fObs._time;
517
518  QListIterator<t_satObs> it(obsList);
519  while (it.hasNext()) {
520    const t_satObs& satObs = it.next();
521    t_rnxObsFile::t_rnxSat rnxSat;
522    rnxSat.prn = satObs._prn;
523
524    // Initialize all observations mentioned in skeleton header
525    // --------------------------------------------------------
526    char sys = rnxSat.prn.system();
527    for (int iType = 0; iType < _sklHeader.nTypes(sys); iType++) {
528      QString type = _sklHeader.obsType(sys, iType);
529      t_rnxObsFile::t_rnxObs rnxObs; // create an empty observation
530      rnxSat.obs[type] = rnxObs;
531    }
532
533    for (unsigned ii = 0; ii < satObs._obs.size(); ii++) {
534      const t_frqObs* frqObs = satObs._obs[ii];
535      if (frqObs->_codeValid) {
536        QString type = 'C' + QString(frqObs->_rnxType2ch.c_str());
537        t_rnxObsFile::t_rnxObs rnxObs;
538        rnxObs.value = frqObs->_code;
539        rnxSat.obs[type] = rnxObs;
540      }
541      if (frqObs->_phaseValid) {
542        QString type = 'L' + QString(frqObs->_rnxType2ch.c_str());
543        t_rnxObsFile::t_rnxObs rnxObs;
544        rnxObs.value = frqObs->_phase;
545        if (frqObs->_slip) {
546          rnxObs.lli |= 1;
547        }
548        rnxSat.obs[type] = rnxObs;
549      }
550      if (frqObs->_dopplerValid) {
551        QString type = 'D' + QString(frqObs->_rnxType2ch.c_str());
552        t_rnxObsFile::t_rnxObs rnxObs;
553        rnxObs.value = frqObs->_doppler;
554        rnxSat.obs[type] = rnxObs;
555      }
556      if (frqObs->_snrValid) {
557        QString type = 'S' + QString(frqObs->_rnxType2ch.c_str());
558        t_rnxObsFile::t_rnxObs rnxObs;
559        rnxObs.value = frqObs->_snr;
560        rnxSat.obs[type] = rnxObs;
561      }
562    }
563
564
565    rnxEpo.rnxSat.push_back(rnxSat);
566  }
567
568  // Write the epoch
569  // ---------------
570  QByteArray outLines;
571  QTextStream outStream(&outLines);
572  t_rnxObsFile::writeEpoch(&outStream, _header, &rnxEpo);
573
574  _out << outLines.data();
575  _out.flush();
576}
577
578// Close the Old RINEX File
579////////////////////////////////////////////////////////////////////////////
580void bncRinex::closeFile() {
581
582  if (_header.version() == 3) {
583    _out << ">                              4  1" << endl;
584    _out << "END OF FILE" << endl;
585  }
586  _out.close();
587  if (!_rnxScriptName.isEmpty()) {
588    qApp->thread()->wait(100);
589#ifdef WIN32
590    QProcess::startDetached(_rnxScriptName, QStringList() << _fName) ;
591#else
592    QProcess::startDetached("nohup", QStringList() << _rnxScriptName << _fName) ;
593#endif
594
595  }
596}
597
598// One Line in ASCII (Internal) Format
599////////////////////////////////////////////////////////////////////////////
600string bncRinex::asciiSatLine(const t_satObs& obs, bool outLockTime) {
601
602  ostringstream str;
603  str.setf(ios::showpoint | ios::fixed);
604
605  str << obs._prn.toString();
606
607  for (unsigned ii = 0; ii < obs._obs.size(); ii++) {
608    const t_frqObs* frqObs = obs._obs[ii];
609    if (frqObs->_codeValid) {
610      str << ' '
611          << left  << setw(3)  << "C" + frqObs->_rnxType2ch << ' '
612          << right << setw(14) << setprecision(3) << frqObs->_code;
613    }
614    if (frqObs->_phaseValid) {
615      str << ' '
616          << left  << setw(3) << "L" + frqObs->_rnxType2ch << ' '
617          << right << setw(14) << setprecision(3) << frqObs->_phase << ' '
618          << right << setw(4)                     << frqObs->_slipCounter;
619    }
620    if (frqObs->_dopplerValid) {
621      str << ' '
622          << left  << setw(3) << "D" + frqObs->_rnxType2ch << ' '
623          << right << setw(14) << setprecision(3) << frqObs->_doppler;
624    }
625    if (frqObs->_snrValid) {
626      str << ' '
627          << left  << setw(3) << "S" + frqObs->_rnxType2ch << ' '
628          << right << setw(8) << setprecision(3) << frqObs->_snr;
629    }
630    if (frqObs->_lockTimeValid && outLockTime) {
631      str << ' '
632          << left  << setw(3) << "T" + frqObs->_rnxType2ch << ' '
633          << right << setw(9) << setprecision(3) << frqObs->_lockTime;
634    }
635  }
636
637  return str.str();
638}
Note: See TracBrowser for help on using the repository browser.