source: ntrip/branches/BNC_2.12/src/bnccore.cpp @ 8216

Last change on this file since 8216 was 8216, checked in by stuerze, 21 months ago

unhealthy satellites are reported within log file but are remainig in stream and file output

File size: 23.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:      t_bncCore
30 *
31 * Purpose:    This class implements the main application
32 *
33 * Author:     L. Mervart
34 *
35 * Created:    29-Aug-2006
36 *
37 * Changes:
38 *
39 * -----------------------------------------------------------------------*/
40
41#include <iostream>
42#include <sstream>
43#include <QMessageBox>
44#include <cmath>
45
46#include "bnccore.h"
47#include "bncutils.h"
48#include "bncrinex.h"
49#include "bncsettings.h"
50#include "bncversion.h"
51#include "ephemeris.h"
52#include "rinex/rnxobsfile.h"
53#include "rinex/rnxnavfile.h"
54#include "pppMain.h"
55#include "combination/bnccomb.h"
56
57using namespace std;
58
59// Singleton
60////////////////////////////////////////////////////////////////////////////
61t_bncCore* t_bncCore::instance() {
62  static t_bncCore _bncCore;
63  return &_bncCore;
64}
65
66// Constructor
67////////////////////////////////////////////////////////////////////////////
68t_bncCore::t_bncCore() : _ephUser(false) {
69  _GUIenabled  = true;
70  _logFileFlag = 0;
71  _logFile     = 0;
72  _logStream   = 0;
73  _rawFile     = 0;
74  _caster      = 0;
75  _bncComb     = 0;
76
77  // Eph file(s)
78  // -----------
79  _rinexVers        = 0;
80  _ephFileGPS       = 0;
81  _ephStreamGPS     = 0;
82  _ephFileGlonass   = 0;
83  _ephStreamGlonass = 0;
84  _ephFileGalileo   = 0;
85  _ephStreamGalileo = 0;
86  _ephFileSBAS      = 0;
87  _ephStreamSBAS    = 0;
88
89  _portEph    = 0;
90  _serverEph  = 0;
91  _socketsEph = 0;
92
93  _portCorr    = 0;
94  _serverCorr  = 0;
95  _socketsCorr = 0;
96
97  _pgmName  = QString(BNCPGMNAME).leftJustified(20, ' ', true);
98#ifdef WIN32
99  _userName = QString("${USERNAME}");
100#else
101  _userName = QString("${USER}");
102#endif
103  expandEnvVar(_userName);
104
105  _userName       = _userName.leftJustified(20, ' ', true);
106  _dateAndTimeGPS = 0;
107  _mainWindow     = 0;
108
109  _pppMain = new BNC_PPP::t_pppMain();
110  qRegisterMetaType< QVector<double> >      ("QVector<double>");
111  qRegisterMetaType<bncTime>                ("bncTime");
112  qRegisterMetaType<t_ephGPS>               ("t_ephGPS");
113  qRegisterMetaType<t_ephGlo>               ("t_ephGlo");
114  qRegisterMetaType<t_ephGal>               ("t_ephGal");
115  qRegisterMetaType<t_ephSBAS>              ("t_ephSBAS");
116  qRegisterMetaType<t_ephBDS>               ("t_ephBDS");
117  qRegisterMetaType<QList<t_orbCorr> >      ("QList<t_orbCorr>");
118  qRegisterMetaType<QList<t_clkCorr> >      ("QList<t_clkCorr>");
119  qRegisterMetaType<QList<t_satCodeBias> >  ("QList<t_satCodeBias>");
120  qRegisterMetaType<QList<t_satPhaseBias> > ("QList<t_satPhaseBias>");
121  qRegisterMetaType<t_vTec>                 ("t_vTec");
122}
123
124// Destructor
125////////////////////////////////////////////////////////////////////////////
126t_bncCore::~t_bncCore() {
127  delete _logStream;
128  delete _logFile;
129  delete _ephStreamGPS;
130  delete _ephFileGPS;
131  delete _serverEph;
132  delete _socketsEph;
133  delete _serverCorr;
134  delete _socketsCorr;
135  if (_rinexVers == 2) {
136    delete _ephStreamGlonass;
137    delete _ephFileGlonass;
138  }
139
140  delete _dateAndTimeGPS;
141  delete _rawFile;
142  delete _bncComb;
143  delete _pppMain;
144}
145
146// Write a Program Message
147////////////////////////////////////////////////////////////////////////////
148void t_bncCore::slotMessage(QByteArray msg, bool showOnScreen) {
149
150  QMutexLocker locker(&_mutexMessage);
151
152  messagePrivate(msg);
153  emit newMessage(msg, showOnScreen);
154}
155
156// Write a Program Message (private, no lock)
157////////////////////////////////////////////////////////////////////////////
158void t_bncCore::messagePrivate(const QByteArray& msg) {
159
160  // First time resolve the log file name
161  // ------------------------------------
162  QDate currDate = currentDateAndTimeGPS().date();
163  if (_logFileFlag == 0 || _fileDate != currDate) {
164    delete _logStream; _logStream = 0;
165    delete _logFile;   _logFile   = 0;
166    _logFileFlag = 1;
167    bncSettings settings;
168    QString logFileName = settings.value("logFile").toString();
169    if ( !logFileName.isEmpty() ) {
170      expandEnvVar(logFileName);
171      _logFile = new QFile(logFileName + "_" +
172                          currDate.toString("yyMMdd").toAscii().data());
173      _fileDate = currDate;
174      if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
175        _logFile->open(QIODevice::WriteOnly | QIODevice::Append);
176      }
177      else {
178        _logFile->open(QIODevice::WriteOnly);
179      }
180      _logStream = new QTextStream();
181      _logStream->setDevice(_logFile);
182    }
183  }
184
185  if (_logStream) {
186    QByteArray msgLocal = msg;
187    if (msg.indexOf('\n') == 0) {
188      *_logStream << endl;
189      msgLocal = msg.mid(1);
190    }
191    *_logStream << currentDateAndTimeGPS().toString("yy-MM-dd hh:mm:ss ").toAscii().data();
192    *_logStream << msgLocal.data() << endl;
193    _logStream->flush();
194    _logFile->flush();
195  }
196}
197
198//
199////////////////////////////////////////////////////////////////////////////
200t_irc t_bncCore::checkPrintEph(t_eph* eph) {
201  QMutexLocker locker(&_mutex);
202  t_irc ircPut = _ephUser.putNewEph(eph, true);
203  if      (eph->checkState() == t_eph::bad) {
204    messagePrivate("WRONG EPHEMERIS\n" + eph->toString(3.0).toAscii());
205    return failure;
206  }
207  else if (eph->checkState() == t_eph::outdated) {
208    messagePrivate("OUTDATED EPHEMERIS\n" + eph->toString(3.0).toAscii());
209    return failure;
210  }
211  else if (eph->checkState() == t_eph::unhealthy) {
212    messagePrivate("UNHEALTHY EPHEMERIS\n" + eph->toString(3.0).toLatin1());
213  }
214  printEphHeader();
215  printEph(*eph, (ircPut == success));
216  return success;
217}
218
219// New GPS Ephemeris
220////////////////////////////////////////////////////////////////////////////
221void t_bncCore::slotNewGPSEph(t_ephGPS eph) {
222  if (checkPrintEph(&eph) == success) {
223    emit newGPSEph(eph);
224  }
225}
226
227// New Glonass Ephemeris
228////////////////////////////////////////////////////////////////////////////
229void t_bncCore::slotNewGlonassEph(t_ephGlo eph) {
230  if (checkPrintEph(&eph) == success) {
231    emit newGlonassEph(eph);
232  }
233}
234
235// New Galileo Ephemeris
236////////////////////////////////////////////////////////////////////////////
237void t_bncCore::slotNewGalileoEph(t_ephGal eph) {
238  if (checkPrintEph(&eph) == success) {
239    emit newGalileoEph(eph);
240  }
241}
242
243// New SBAS Ephemeris
244////////////////////////////////////////////////////////////////////////////
245void t_bncCore::slotNewSBASEph(t_ephSBAS eph) {
246  if (checkPrintEph(&eph) == success) {
247    emit newSBASEph(eph);
248  }
249}
250
251// New BDS Ephemeris
252////////////////////////////////////////////////////////////////////////////
253void t_bncCore::slotNewBDSEph(t_ephBDS eph) {
254  if (checkPrintEph(&eph) == success) {
255    emit newBDSEph(eph);
256  }
257}
258
259// Print Header of the output File(s)
260////////////////////////////////////////////////////////////////////////////
261void t_bncCore::printEphHeader() {
262
263  bncSettings settings;
264    QStringList comments;
265
266  QListIterator<QString> it(settings.value("mountPoints").toStringList());
267  while (it.hasNext()) {
268    QStringList hlp = it.next().split(" ");
269    if (hlp.size() < 7)
270      continue;
271    QUrl url(hlp[0]);
272    QString decoder = hlp[1];
273    comments.append("Source: " + decoder +
274                    " " + url.encodedHost() +
275                    "/" + url.path().mid(1).toAscii());
276  }
277
278  // Initialization
279  // --------------
280  if (_rinexVers == 0) {
281
282    if ( Qt::CheckState(settings.value("ephV3").toInt()) == Qt::Checked) {
283      _rinexVers = 3;
284    }
285    else {
286      _rinexVers = 2;
287    }
288
289    _ephPath = settings.value("ephPath").toString();
290
291    if ( !_ephPath.isEmpty() ) {
292      if ( _ephPath[_ephPath.length()-1] != QDir::separator() ) {
293        _ephPath += QDir::separator();
294      }
295      expandEnvVar(_ephPath);
296    }
297  }
298
299  // (Re-)Open output File(s)
300  // ------------------------
301  if (!_ephPath.isEmpty()) {
302
303    QDateTime datTim = currentDateAndTimeGPS();
304
305    QString ephFileNameGPS = _ephPath + "BRDC";
306
307    bool ephV3filenames = settings.value("ephV3filenames").toBool();
308
309    QString hlpStr = bncRinex::nextEpochStr(datTim,
310                         settings.value("ephIntr").toString(), ephV3filenames);
311
312    if (_rinexVers == 3) {
313      if (ephV3filenames) {
314        QString country = "WRD"; // WORLD
315        QString monNum = "0";
316        QString recNum = "0";
317        ephFileNameGPS += QString("%1").arg(monNum, 1, 10) +
318                          QString("%1").arg(recNum, 1, 10) +
319                          country +
320                          "_S_" +     // stream
321                          QString("%1").arg(datTim.date().year()) +
322                          QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
323                          hlpStr +   // HM_period
324                          "_MN.rnx"; // mixed BRDC
325      }
326      else { // RNX v3 with old filenames
327        ephFileNameGPS +=  QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
328                           hlpStr + datTim.toString(".yyP");
329      }
330    }
331    else { // RNX v2.11
332      ephFileNameGPS += QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
333                        hlpStr + datTim.toString(".yyN");
334    }
335
336    if (_ephFileNameGPS == ephFileNameGPS) {
337      return;
338    }
339    else {
340      _ephFileNameGPS = ephFileNameGPS;
341    }
342
343    delete _ephStreamGPS;
344    delete _ephFileGPS;
345
346    QFlags<QIODevice::OpenModeFlag> appendFlagGPS;
347    QFlags<QIODevice::OpenModeFlag> appendFlagGlonass;
348
349    if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked &&
350         QFile::exists(ephFileNameGPS) ) {
351      appendFlagGPS = QIODevice::Append;
352    }
353
354    _ephFileGPS = new QFile(ephFileNameGPS);
355    _ephFileGPS->open(QIODevice::WriteOnly | appendFlagGPS);
356    _ephStreamGPS = new QTextStream();
357    _ephStreamGPS->setDevice(_ephFileGPS);
358
359    if      (_rinexVers == 3) {
360      _ephFileGlonass   = _ephFileGPS;
361      _ephStreamGlonass = _ephStreamGPS;
362      _ephFileGalileo   = _ephFileGPS;
363      _ephStreamGalileo = _ephStreamGPS;
364      _ephFileSBAS      = _ephFileGPS;
365      _ephStreamSBAS    = _ephStreamGPS;
366    }
367    else if (_rinexVers == 2) {
368      QString ephFileNameGlonass = _ephPath + "BRDC" +
369          QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0')) +
370          hlpStr + datTim.toString(".yyG");
371
372      delete _ephStreamGlonass;
373      delete _ephFileGlonass;
374
375      if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked &&
376           QFile::exists(ephFileNameGlonass) ) {
377        appendFlagGlonass = QIODevice::Append;
378      }
379
380      _ephFileGlonass = new QFile(ephFileNameGlonass);
381      _ephFileGlonass->open(QIODevice::WriteOnly | appendFlagGlonass);
382      _ephStreamGlonass = new QTextStream();
383      _ephStreamGlonass->setDevice(_ephFileGlonass);
384    }
385
386    // Header - RINEX Version 3
387    // ------------------------
388    if (_rinexVers == 3) {
389      if ( ! (appendFlagGPS & QIODevice::Append)) {
390        QString line;
391        line.sprintf(
392          "%9.2f%11sN: GNSS NAV DATA    M: Mixed%12sRINEX VERSION / TYPE\n",
393          t_rnxNavFile::defaultRnxNavVersion3, "", "");
394        *_ephStreamGPS << line;
395
396        QString hlp = currentDateAndTimeGPS().toString("yyyyMMdd hhmmss UTC").leftJustified(20, ' ', true);
397        *_ephStreamGPS << _pgmName.toAscii().data()
398                       << _userName.toAscii().data()
399                       << hlp.toAscii().data()
400                       << "PGM / RUN BY / DATE" << endl;
401
402        QStringListIterator it(comments);
403        while (it.hasNext()) {
404          *_ephStreamGPS << it.next().trimmed().left(60).leftJustified(60) << "COMMENT\n";
405        }
406       
407        line.sprintf("%60sEND OF HEADER\n", "");
408        *_ephStreamGPS << line;
409
410        _ephStreamGPS->flush();
411      }
412    }
413
414    // Headers - RINEX Version 2
415    // -------------------------
416    else if (_rinexVers == 2) {
417      if (! (appendFlagGPS & QIODevice::Append)) {
418        QString line;
419        line.sprintf("%9.2f%11sN: GPS NAV DATA%25sRINEX VERSION / TYPE\n",
420                     t_rnxNavFile::defaultRnxNavVersion2, "", "");
421        *_ephStreamGPS << line;
422
423        QString hlp = currentDateAndTimeGPS().date().toString("dd-MMM-yyyy").leftJustified(20, ' ', true);
424        *_ephStreamGPS << _pgmName.toAscii().data()
425                       << _userName.toAscii().data()
426                       << hlp.toAscii().data()
427                       << "PGM / RUN BY / DATE" << endl;
428
429        QStringListIterator it(comments);
430        while (it.hasNext()) {
431          *_ephStreamGPS << it.next().trimmed().left(60).leftJustified(60) << "COMMENT\n";
432        }
433       
434        line.sprintf("%60sEND OF HEADER\n", "");
435        *_ephStreamGPS << line;
436
437        _ephStreamGPS->flush();
438      }
439      if (! (appendFlagGlonass & QIODevice::Append)) {
440        QString line;
441        line.sprintf("%9.2f%11sG: GLONASS NAV DATA%21sRINEX VERSION / TYPE\n",
442                     t_rnxNavFile::defaultRnxNavVersion2, "", "");
443        *_ephStreamGlonass << line;
444
445        QString hlp = currentDateAndTimeGPS().date().toString("dd-MMM-yyyy").leftJustified(20, ' ', true);
446        *_ephStreamGlonass << _pgmName.toAscii().data()
447                           << _userName.toAscii().data()
448                           << hlp.toAscii().data()
449                           << "PGM / RUN BY / DATE" << endl;
450
451        QStringListIterator it(comments);
452        while (it.hasNext()) {
453          *_ephStreamGlonass << it.next().trimmed().left(60).leftJustified(60) << "COMMENT\n";
454        }
455
456        line.sprintf("%60sEND OF HEADER\n", "");
457        *_ephStreamGlonass << line;
458
459        _ephStreamGlonass->flush();
460      }
461    }
462  }
463}
464
465// Print One Ephemeris
466////////////////////////////////////////////////////////////////////////////
467void t_bncCore::printEph(const t_eph& eph, bool printFile) {
468
469  QString strV2 = eph.toString(t_rnxNavFile::defaultRnxNavVersion2);
470  QString strV3 = eph.toString(t_rnxObsHeader::defaultRnxObsVersion3);
471
472  if     (_rinexVers == 2 && eph.type() == t_eph::GLONASS) {
473    printOutputEph(printFile, _ephStreamGlonass, strV2, strV3);
474  }
475  else if(_rinexVers == 2 && eph.type() == t_eph::GPS)  {
476    printOutputEph(printFile, _ephStreamGPS, strV2, strV3);
477  }
478  else if (_rinexVers == 3) {
479    printOutputEph(printFile, _ephStreamGPS, strV2, strV3);
480  }
481}
482
483// Output
484////////////////////////////////////////////////////////////////////////////
485void t_bncCore::printOutputEph(bool printFile, QTextStream* stream,
486                               const QString& strV2, const QString& strV3) {
487
488  // Output into file
489  // ----------------
490  if (printFile && stream) {
491    if (_rinexVers == 2) {
492      *stream << strV2.toAscii();
493    }
494    else {
495      *stream << strV3.toAscii();
496    }
497    stream->flush();
498  }
499
500  // Output into the socket
501  // ----------------------
502  if (_socketsEph) {
503    QMutableListIterator<QTcpSocket*> is(*_socketsEph);
504    while (is.hasNext()) {
505      QTcpSocket* sock = is.next();
506      if (sock->state() == QAbstractSocket::ConnectedState) {
507        if (sock->write(strV3.toAscii()) == -1) {
508          delete sock;
509          is.remove();
510        }
511      }
512      else if (sock->state() != QAbstractSocket::ConnectingState) {
513        delete sock;
514        is.remove();
515      }
516    }
517  }
518}
519
520// Set Port Number
521////////////////////////////////////////////////////////////////////////////
522void t_bncCore::setPortEph(int port) {
523  _portEph = port;
524  if (_portEph != 0) {
525    delete _serverEph;
526    _serverEph = new QTcpServer;
527    if ( !_serverEph->listen(QHostAddress::Any, _portEph) ) {
528      slotMessage("t_bncCore: Cannot listen on ephemeris port", true);
529    }
530    connect(_serverEph, SIGNAL(newConnection()), this, SLOT(slotNewConnectionEph()));
531    delete _socketsEph;
532    _socketsEph = new QList<QTcpSocket*>;
533  }
534}
535
536// Set Port Number
537////////////////////////////////////////////////////////////////////////////
538void t_bncCore::setPortCorr(int port) {
539  _portCorr = port;
540  if (_portCorr != 0) {
541    delete _serverCorr;
542    _serverCorr = new QTcpServer;
543    if ( !_serverCorr->listen(QHostAddress::Any, _portCorr) ) {
544      slotMessage("t_bncCore: Cannot listen on correction port", true);
545    }
546    connect(_serverCorr, SIGNAL(newConnection()), this, SLOT(slotNewConnectionCorr()));
547    delete _socketsCorr;
548    _socketsCorr = new QList<QTcpSocket*>;
549  }
550}
551
552// New Connection
553////////////////////////////////////////////////////////////////////////////
554void t_bncCore::slotNewConnectionEph() {
555  _socketsEph->push_back( _serverEph->nextPendingConnection() );
556}
557
558// New Connection
559////////////////////////////////////////////////////////////////////////////
560void t_bncCore::slotNewConnectionCorr() {
561  _socketsCorr->push_back( _serverCorr->nextPendingConnection() );
562}
563
564//
565////////////////////////////////////////////////////////////////////////////
566void t_bncCore::slotQuit() {
567  delete _caster; _caster = 0;
568  qApp->quit();
569}
570
571//
572////////////////////////////////////////////////////////////////////////////
573void t_bncCore::slotNewOrbCorrections(QList<t_orbCorr> orbCorrections) {
574  QMutexLocker locker(&_mutex);
575  emit newOrbCorrections(orbCorrections);
576  if (_socketsCorr) {
577    ostringstream out;
578    t_orbCorr::writeEpoch(&out, orbCorrections);
579    QMutableListIterator<QTcpSocket*> is(*_socketsCorr);
580    while (is.hasNext()) {
581      QTcpSocket* sock = is.next();
582      if (sock->state() == QAbstractSocket::ConnectedState) {
583        if (sock->write(out.str().c_str()) == -1) {
584          delete sock;
585          is.remove();
586        }
587      }
588      else if (sock->state() != QAbstractSocket::ConnectingState) {
589        delete sock;
590        is.remove();
591      }
592    }
593  }
594}
595
596//
597////////////////////////////////////////////////////////////////////////////
598void t_bncCore::slotNewClkCorrections(QList<t_clkCorr> clkCorrections) {
599  QMutexLocker locker(&_mutex);
600  emit newClkCorrections(clkCorrections);
601  if (_socketsCorr) {
602    ostringstream out;
603    t_clkCorr::writeEpoch(&out, clkCorrections);
604    QMutableListIterator<QTcpSocket*> is(*_socketsCorr);
605    while (is.hasNext()) {
606      QTcpSocket* sock = is.next();
607      if (sock->state() == QAbstractSocket::ConnectedState) {
608        if (sock->write(out.str().c_str()) == -1) {
609          delete sock;
610          is.remove();
611        }
612      }
613      else if (sock->state() != QAbstractSocket::ConnectingState) {
614        delete sock;
615        is.remove();
616      }
617    }
618  }
619}
620
621//
622////////////////////////////////////////////////////////////////////////////
623void t_bncCore::slotNewCodeBiases(QList<t_satCodeBias> codeBiases) {
624  QMutexLocker locker(&_mutex);
625  emit newCodeBiases(codeBiases);
626  if (_socketsCorr) {
627    ostringstream out;
628    t_satCodeBias::writeEpoch(&out, codeBiases);
629    QMutableListIterator<QTcpSocket*> is(*_socketsCorr);
630    while (is.hasNext()) {
631      QTcpSocket* sock = is.next();
632      if (sock->state() == QAbstractSocket::ConnectedState) {
633        if (sock->write(out.str().c_str()) == -1) {
634          delete sock;
635          is.remove();
636        }
637      }
638      else if (sock->state() != QAbstractSocket::ConnectingState) {
639        delete sock;
640        is.remove();
641      }
642    }
643  }
644}
645
646//
647////////////////////////////////////////////////////////////////////////////
648void t_bncCore::slotNewPhaseBiases(QList<t_satPhaseBias> phaseBiases) {
649  QMutexLocker locker(&_mutex);
650  emit newPhaseBiases(phaseBiases);
651  if (_socketsCorr) {
652    ostringstream out;
653    t_satPhaseBias::writeEpoch(&out, phaseBiases);
654    QMutableListIterator<QTcpSocket*> is(*_socketsCorr);
655    while (is.hasNext()) {
656      QTcpSocket* sock = is.next();
657      if (sock->state() == QAbstractSocket::ConnectedState) {
658        if (sock->write(out.str().c_str()) == -1) {
659          delete sock;
660          is.remove();
661        }
662      }
663      else if (sock->state() != QAbstractSocket::ConnectingState) {
664        delete sock;
665        is.remove();
666      }
667    }
668  }
669}
670
671//
672////////////////////////////////////////////////////////////////////////////
673void t_bncCore::slotNewTec(t_vTec vTec) {
674  QMutexLocker locker(&_mutex);
675  emit newTec(vTec);
676  if (_socketsCorr) {
677    ostringstream out;
678    t_vTec::write(&out, vTec);
679    QMutableListIterator<QTcpSocket*> is(*_socketsCorr);
680    while (is.hasNext()) {
681      QTcpSocket* sock = is.next();
682      if (sock->state() == QAbstractSocket::ConnectedState) {
683        if (sock->write(out.str().c_str()) == -1) {
684          delete sock;
685          is.remove();
686        }
687      }
688      else if (sock->state() != QAbstractSocket::ConnectingState) {
689        delete sock;
690        is.remove();
691      }
692    }
693  }
694}
695
696//
697////////////////////////////////////////////////////////////////////////////
698void t_bncCore::setConfFileName(const QString& confFileName) {
699  if (confFileName.isEmpty()) {
700    _confFileName = QDir::homePath() + QDir::separator()
701                  + ".config" + QDir::separator()
702                  + qApp->organizationName() + QDir::separator()
703                  + qApp->applicationName() + ".bnc";
704  }
705  else {
706    _confFileName = confFileName;
707  }
708}
709
710// Raw Output
711////////////////////////////////////////////////////////////////////////////
712void t_bncCore::writeRawData(const QByteArray& data, const QByteArray& staID,
713                          const QByteArray& format) {
714
715  QMutexLocker locker(&_mutex);
716
717  if (!_rawFile) {
718    bncSettings settings;
719    QByteArray fileName = settings.value("rawOutFile").toByteArray();
720    if (!fileName.isEmpty()) {
721      _rawFile = new bncRawFile(fileName, staID, bncRawFile::output);
722    }
723  }
724
725  if (_rawFile) {
726    _rawFile->writeRawData(data, staID, format);
727  }
728}
729
730//
731////////////////////////////////////////////////////////////////////////////
732void t_bncCore::initCombination() {
733  _bncComb = new bncComb();
734  if (_bncComb->nStreams() < 1) {
735    delete _bncComb;
736    _bncComb = 0;
737  }
738}
739
740//
741////////////////////////////////////////////////////////////////////////////
742void t_bncCore::stopCombination() {
743  delete _bncComb;
744  _bncComb = 0;
745}
746
747//
748////////////////////////////////////////////////////////////////////////////
749bool t_bncCore::dateAndTimeGPSSet() const {
750  QMutexLocker locker(&_mutexDateAndTimeGPS);
751  if (_dateAndTimeGPS) {
752    return true;
753  }
754  else {
755    return false;
756  }
757}
758
759//
760////////////////////////////////////////////////////////////////////////////
761QDateTime t_bncCore::dateAndTimeGPS() const {
762  QMutexLocker locker(&_mutexDateAndTimeGPS);
763  if (_dateAndTimeGPS) {
764    return *_dateAndTimeGPS;
765  }
766  else {
767    return QDateTime();
768  }
769}
770
771//
772////////////////////////////////////////////////////////////////////////////
773void t_bncCore::setDateAndTimeGPS(QDateTime dateTime) {
774  QMutexLocker locker(&_mutexDateAndTimeGPS);
775  delete _dateAndTimeGPS;
776  _dateAndTimeGPS = new QDateTime(dateTime);
777}
778
779//
780////////////////////////////////////////////////////////////////////////////
781void t_bncCore::startPPP() {
782  _pppMain->start();
783}
784
785//
786////////////////////////////////////////////////////////////////////////////
787void t_bncCore::stopPPP() {
788  _pppMain->stop();
789  emit stopRinexPPP();
790}
791
Note: See TracBrowser for help on using the repository browser.