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

Last change on this file since 8659 was 8659, checked in by stuerze, 15 months ago

minor changes

File size: 18.4 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  QString sklPre;
353  if (!sklExt.isEmpty()) {
354    if (sklExt.indexOf("skl",0, Qt::CaseSensitive) != -1)  {
355      sklPre = ID.toLower();
356    } else if (sklExt.indexOf("SKL",0, Qt::CaseSensitive) != -1) {
357      sklPre = ID;
358    }
359    _sklName = path + sklPre + distStr + "." + sklExt;
360  }
361
362  if (_rnxV3) {
363    QString country;
364    QString monNum = "0";
365    QString recNum = "0";
366    QListIterator<QString> it(settings.value("mountPoints").toStringList());
367    while (it.hasNext()) {
368      QStringList hlp = it.next().split(" ");
369      if (hlp.size() < 7)
370        continue;
371      if (hlp.join(" ").indexOf(_statID, 0) != -1) {
372        country = hlp[2];
373      }
374    }
375
376    path += ID.left(4) +
377            QString("%1").arg(monNum, 1, 10) +
378            QString("%1").arg(recNum, 1, 10) +
379            country +
380            "_S_" + // stream
381            QString("%1").arg(datTim.date().year()) +
382            QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
383            hlpStr + // HMS_period
384            QString("%1").arg(_samplingRateStr) + // sampling rate
385            "_MO" + // mixed OBS
386            distStr +
387            ".rnx";
388  }
389  else {
390    path += ID.left(4) +
391            QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
392            hlpStr + distStr + datTim.toString(".yyO");
393  }
394
395  _fName = path.toLatin1();
396}
397
398// Write RINEX Header
399////////////////////////////////////////////////////////////////////////////
400void bncRinex::writeHeader(const QByteArray& format, const bncTime& firstObsTime) {
401
402  bncSettings settings;
403
404  // Set RINEX Version
405  // -----------------
406  int intHeaderVers = (Qt::CheckState(settings.value("rnxV3").toInt()) == Qt::Checked ? 3 : 2);
407
408  // Open the Output File
409  // --------------------
410  QDateTime datTimNom  = dateAndTimeFromGPSweek(firstObsTime.gpsw(),
411                                                floor(firstObsTime.gpssec()+0.5));
412
413  resolveFileName(datTimNom);
414
415  // Read Skeleton Header
416  // --------------------
417  if (readSkeleton()) {
418    _header.set(_sklHeader, intHeaderVers);
419  }
420  else {
421    if (_writeRinexFileOnlyWithSkl) {
422      return;
423    }
424    _header.setDefault(_statID, intHeaderVers);
425  }
426
427  // Append to existing file and return
428  // ----------------------------------
429  if ( QFile::exists(_fName) &&
430       (_reconnectFlag || Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) ) {
431    _out.open(_fName.data(), ios::app);
432    _out.setf(ios::showpoint | ios::fixed);
433    _headerWritten = true;
434    _reconnectFlag = false;
435  }
436  else {
437    _out.open(_fName.data());
438    _addComments.clear();
439  }
440
441  _out.setf(ios::showpoint | ios::fixed);
442
443  // A Few Additional Comments
444  // -------------------------
445  _addComments << format.left(6) + " " + _mountPoint.host() + _mountPoint.path();
446  if (_nmea == "yes") {
447    _addComments << "NMEA LAT=" + _latitude + " " + "LONG=" + _longitude;
448  }
449
450  // Write the Header
451  // ----------------
452  QByteArray headerLines;
453  QTextStream outHlp(&headerLines);
454
455  QMap<QString, QString> txtMap;
456  txtMap["COMMENT"] = _addComments.join("\\n");
457
458  _header.setStartTime(firstObsTime);
459  _header.write(&outHlp, &txtMap);
460
461  outHlp.flush();
462
463  if (!_headerWritten) {
464    _out << headerLines.data();
465  }
466
467  _headerWritten = true;
468}
469
470// Stores Observation into Internal Array
471////////////////////////////////////////////////////////////////////////////
472void bncRinex::deepCopy(t_satObs obs) {
473  _obs.push_back(obs);
474}
475
476// Write One Epoch into the RINEX File
477////////////////////////////////////////////////////////////////////////////
478void bncRinex::dumpEpoch(const QByteArray& format, const bncTime& maxTime) {
479
480  // Select observations older than maxTime
481  // --------------------------------------
482  QList<t_satObs> obsList;
483  QMutableListIterator<t_satObs> mIt(_obs);
484  while (mIt.hasNext()) {
485    t_satObs obs = mIt.next();
486    if (obs._time < maxTime) {
487      obsList.push_back(obs);
488      mIt.remove();
489    }
490  }
491
492  // Easy Return
493  // -----------
494  if (obsList.isEmpty()) {
495    return;
496  }
497
498  // Time of Epoch
499  // -------------
500  const t_satObs& fObs = obsList.first();
501  QDateTime datTimNom  = dateAndTimeFromGPSweek(fObs._time.gpsw(), fObs._time.gpssec());
502
503  // Close the file
504  // --------------
505  if (_nextCloseEpoch.isValid() && datTimNom >= _nextCloseEpoch) {
506    closeFile();
507    _headerWritten = false;
508  }
509
510  // Write RINEX Header
511  // ------------------
512  if (!_headerWritten) {
513    writeHeader(format, fObs._time);
514  }
515  if (!_headerWritten) {
516    return;
517  }
518
519  // Prepare structure t_rnxEpo
520  // --------------------------
521  t_rnxObsFile::t_rnxEpo rnxEpo;
522  rnxEpo.tt = fObs._time;
523
524  QListIterator<t_satObs> it(obsList);
525  while (it.hasNext()) {
526    const t_satObs& satObs = it.next();
527    t_rnxObsFile::t_rnxSat rnxSat;
528    rnxSat.prn = satObs._prn;
529
530    // Initialize all observations mentioned in skeleton header
531    // --------------------------------------------------------
532    char sys = rnxSat.prn.system();
533    for (int iType = 0; iType < _sklHeader.nTypes(sys); iType++) {
534      QString type = _sklHeader.obsType(sys, iType);
535      t_rnxObsFile::t_rnxObs rnxObs; // create an empty observation
536      rnxSat.obs[type] = rnxObs;
537    }
538
539    for (unsigned ii = 0; ii < satObs._obs.size(); ii++) {
540      const t_frqObs* frqObs = satObs._obs[ii];
541      if (frqObs->_codeValid) {
542        QString type = 'C' + QString(frqObs->_rnxType2ch.c_str());
543        t_rnxObsFile::t_rnxObs rnxObs;
544        rnxObs.value = frqObs->_code;
545        rnxSat.obs[type] = rnxObs;
546      }
547      if (frqObs->_phaseValid) {
548        QString type = 'L' + QString(frqObs->_rnxType2ch.c_str());
549        t_rnxObsFile::t_rnxObs rnxObs;
550        rnxObs.value = frqObs->_phase;
551        if (frqObs->_slip) {
552          rnxObs.lli |= 1;
553        }
554        rnxSat.obs[type] = rnxObs;
555      }
556      if (frqObs->_dopplerValid) {
557        QString type = 'D' + QString(frqObs->_rnxType2ch.c_str());
558        t_rnxObsFile::t_rnxObs rnxObs;
559        rnxObs.value = frqObs->_doppler;
560        rnxSat.obs[type] = rnxObs;
561      }
562      if (frqObs->_snrValid) {
563        QString type = 'S' + QString(frqObs->_rnxType2ch.c_str());
564        t_rnxObsFile::t_rnxObs rnxObs;
565        rnxObs.value = frqObs->_snr;
566        rnxSat.obs[type] = rnxObs;
567      }
568    }
569
570
571    rnxEpo.rnxSat.push_back(rnxSat);
572  }
573
574  // Write the epoch
575  // ---------------
576  QByteArray outLines;
577  QTextStream outStream(&outLines);
578  t_rnxObsFile::writeEpoch(&outStream, _header, &rnxEpo);
579
580  _out << outLines.data();
581  _out.flush();
582}
583
584// Close the Old RINEX File
585////////////////////////////////////////////////////////////////////////////
586void bncRinex::closeFile() {
587
588  if (_header.version() == 3) {
589    _out << ">                              4  1" << endl;
590    _out << "END OF FILE" << endl;
591  }
592  _out.close();
593  if (!_rnxScriptName.isEmpty()) {
594    qApp->thread()->wait(100);
595#ifdef WIN32
596    QProcess::startDetached(_rnxScriptName, QStringList() << _fName) ;
597#else
598    QProcess::startDetached("nohup", QStringList() << _rnxScriptName << _fName) ;
599#endif
600
601  }
602}
603
604// One Line in ASCII (Internal) Format
605////////////////////////////////////////////////////////////////////////////
606string bncRinex::asciiSatLine(const t_satObs& obs, bool outLockTime) {
607
608  ostringstream str;
609  str.setf(ios::showpoint | ios::fixed);
610
611  str << obs._prn.toString();
612
613  for (unsigned ii = 0; ii < obs._obs.size(); ii++) {
614    const t_frqObs* frqObs = obs._obs[ii];
615    if (frqObs->_codeValid) {
616      str << ' '
617          << left  << setw(3)  << "C" + frqObs->_rnxType2ch << ' '
618          << right << setw(14) << setprecision(3) << frqObs->_code;
619    }
620    if (frqObs->_phaseValid) {
621      str << ' '
622          << left  << setw(3) << "L" + frqObs->_rnxType2ch << ' '
623          << right << setw(14) << setprecision(3) << frqObs->_phase << ' '
624          << right << setw(4)                     << frqObs->_slipCounter;
625    }
626    if (frqObs->_dopplerValid) {
627      str << ' '
628          << left  << setw(3) << "D" + frqObs->_rnxType2ch << ' '
629          << right << setw(14) << setprecision(3) << frqObs->_doppler;
630    }
631    if (frqObs->_snrValid) {
632      str << ' '
633          << left  << setw(3) << "S" + frqObs->_rnxType2ch << ' '
634          << right << setw(8) << setprecision(3) << frqObs->_snr;
635    }
636    if (frqObs->_lockTimeValid && outLockTime) {
637      str << ' '
638          << left  << setw(3) << "T" + frqObs->_rnxType2ch << ' '
639          << right << setw(9) << setprecision(3) << frqObs->_lockTime;
640    }
641  }
642
643  return str.str();
644}
Note: See TracBrowser for help on using the repository browser.