source: ntrip/trunk/BNC/src/bncgetthread.cpp @ 9211

Last change on this file since 9211 was 9211, checked in by stuerze, 9 months ago

minor changes

File size: 31.5 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:      bncGetThread
30 *
31 * Purpose:    Thread that retrieves data from NTRIP caster
32 *
33 * Author:     L. Mervart
34 *
35 * Created:    24-Dec-2005
36 *
37 * Changes:
38 *
39 * -----------------------------------------------------------------------*/
40
41#include <stdlib.h>
42#include <iomanip>
43#include <sstream>
44
45#include <QComboBox>
46#include <QDialog>
47#include <QFile>
48#include <QTextStream>
49#include <QMutex>
50#include <QPushButton>
51#include <QTableWidget>
52#include <QTime>
53
54#include "bncgetthread.h"
55#include "bnctabledlg.h"
56#include "bnccore.h"
57#include "bncutils.h"
58#include "bnctime.h"
59#include "bnczerodecoder.h"
60#include "bncnetqueryv0.h"
61#include "bncnetqueryv1.h"
62#include "bncnetqueryv2.h"
63#include "bncnetqueryrtp.h"
64#include "bncnetqueryudp.h"
65#include "bncnetqueryudp0.h"
66#include "bncnetquerys.h"
67#include "bncsettings.h"
68#include "latencychecker.h"
69#include "upload/bncrtnetdecoder.h"
70#include "RTCM/RTCM2Decoder.h"
71#include "RTCM3/RTCM3Decoder.h"
72#include "serial/qextserialport.h"
73
74using namespace std;
75
76// Constructor 1
77////////////////////////////////////////////////////////////////////////////
78bncGetThread::bncGetThread(bncRawFile* rawFile) {
79
80  _rawFile = rawFile;
81  _format = rawFile->format();
82  _staID = rawFile->staID();
83  _rawOutput = false;
84  _ntripVersion = "N";
85
86  initialize();
87}
88
89// Constructor 2
90////////////////////////////////////////////////////////////////////////////
91bncGetThread::bncGetThread(const QUrl& mountPoint, const QByteArray& format,
92    const QByteArray& latitude, const QByteArray& longitude,
93    const QByteArray& nmea, const QByteArray& ntripVersion) {
94  _rawFile = 0;
95  _mountPoint = mountPoint;
96  _staID = mountPoint.path().mid(1).toLatin1();
97  _format = format;
98  _latitude = latitude;
99  _longitude = longitude;
100  _nmea = nmea;
101  _ntripVersion = ntripVersion;
102
103  bncSettings settings;
104  if (!settings.value("rawOutFile").toString().isEmpty()) {
105    _rawOutput = true;
106  }
107  else {
108    _rawOutput = false;
109  }
110  if  (!settings.value("miscMount").toString().isEmpty()) {
111    _latencycheck = true;
112  }
113  else {
114    _latencycheck = false;
115  }
116  initialize();
117  initDecoder();
118}
119
120// Initialization (common part of the constructor)
121////////////////////////////////////////////////////////////////////////////
122void bncGetThread::initialize() {
123
124  bncSettings settings;
125
126  setTerminationEnabled(true);
127
128  connect(this, SIGNAL(newMessage(QByteArray,bool)),
129  BNC_CORE, SLOT(slotMessage(const QByteArray,bool)));
130
131  _isToBeDeleted = false;
132  _query = 0;
133  _nextSleep = 0;
134  _miscMount = settings.value("miscMount").toString();
135  _decoder = 0;
136
137  // NMEA Port
138  // -----------
139  QListIterator<QString> iSta(settings.value("PPP/staTable").toStringList());
140  int nmeaPort = 0;
141  while (iSta.hasNext()) {
142    QStringList hlp = iSta.next().split(",");
143    if (hlp.size() < 10) {
144      continue;
145    }
146    QByteArray mp = hlp[0].toLatin1();
147    if (_staID == mp) {
148      nmeaPort = hlp[9].toInt();
149    }
150  }
151  if (nmeaPort != 0) {
152    _nmeaServer = new QTcpServer;
153    _nmeaServer->setProxy(QNetworkProxy::NoProxy);
154    if (!_nmeaServer->listen(QHostAddress::Any, nmeaPort)) {
155      QString message = "bncCaster: Cannot listen on port "
156                      + QByteArray::number(nmeaPort) + ": "
157                      + _nmeaServer->errorString();
158      emit newMessage(message.toLatin1(), true);
159    } else {
160      connect(_nmeaServer, SIGNAL(newConnection()), this,
161          SLOT(slotNewNMEAConnection()));
162      connect(BNC_CORE, SIGNAL(newNMEAstr(QByteArray, QByteArray)), this,
163          SLOT(slotNewNMEAstr(QByteArray, QByteArray)));
164      _nmeaSockets = new QList<QTcpSocket*>;
165      _nmeaPortsMap[_staID] = nmeaPort;
166    }
167  } else {
168    _nmeaServer = 0;
169    _nmeaSockets = 0;
170  }
171
172  // Serial Port
173  // -----------
174  _serialNMEA = NO_NMEA;
175  _serialOutFile = 0;
176  _serialPort = 0;
177
178  if (!_staID.isEmpty()
179      && settings.value("serialMountPoint").toString() == _staID) {
180    _serialPort = new QextSerialPort(
181        settings.value("serialPortName").toString());
182    _serialPort->setTimeout(0, 100);
183
184    // Baud Rate
185    // ---------
186    QString hlp = settings.value("serialBaudRate").toString();
187    if (hlp == "110") {
188      _serialPort->setBaudRate(BAUD110);
189    } else if (hlp == "300") {
190      _serialPort->setBaudRate(BAUD300);
191    } else if (hlp == "600") {
192      _serialPort->setBaudRate(BAUD600);
193    } else if (hlp == "1200") {
194      _serialPort->setBaudRate(BAUD1200);
195    } else if (hlp == "2400") {
196      _serialPort->setBaudRate(BAUD2400);
197    } else if (hlp == "4800") {
198      _serialPort->setBaudRate(BAUD4800);
199    } else if (hlp == "9600") {
200      _serialPort->setBaudRate(BAUD9600);
201    } else if (hlp == "19200") {
202      _serialPort->setBaudRate(BAUD19200);
203    } else if (hlp == "38400") {
204      _serialPort->setBaudRate(BAUD38400);
205    } else if (hlp == "57600") {
206      _serialPort->setBaudRate(BAUD57600);
207    } else if (hlp == "115200") {
208      _serialPort->setBaudRate(BAUD115200);
209    }
210
211    // Parity
212    // ------
213    hlp = settings.value("serialParity").toString();
214    if (hlp == "NONE") {
215      _serialPort->setParity(PAR_NONE);
216    } else if (hlp == "ODD") {
217      _serialPort->setParity(PAR_ODD);
218    } else if (hlp == "EVEN") {
219      _serialPort->setParity(PAR_EVEN);
220    } else if (hlp == "SPACE") {
221      _serialPort->setParity(PAR_SPACE);
222    }
223
224    // Data Bits
225    // ---------
226    hlp = settings.value("serialDataBits").toString();
227    if (hlp == "5") {
228      _serialPort->setDataBits(DATA_5);
229    } else if (hlp == "6") {
230      _serialPort->setDataBits(DATA_6);
231    } else if (hlp == "7") {
232      _serialPort->setDataBits(DATA_7);
233    } else if (hlp == "8") {
234      _serialPort->setDataBits(DATA_8);
235    }
236    hlp = settings.value("serialStopBits").toString();
237    if (hlp == "1") {
238      _serialPort->setStopBits(STOP_1);
239    } else if (hlp == "2") {
240      _serialPort->setStopBits(STOP_2);
241    }
242
243    // Flow Control
244    // ------------
245    hlp = settings.value("serialFlowControl").toString();
246    if (hlp == "XONXOFF") {
247      _serialPort->setFlowControl(FLOW_XONXOFF);
248    } else if (hlp == "HARDWARE") {
249      _serialPort->setFlowControl(FLOW_HARDWARE);
250    } else {
251      _serialPort->setFlowControl(FLOW_OFF);
252    }
253
254    // Open Serial Port
255    // ----------------
256    _serialPort->open(QIODevice::ReadWrite | QIODevice::Unbuffered);
257    if (!_serialPort->isOpen()) {
258      delete _serialPort;
259      _serialPort = 0;
260      emit(newMessage((_staID + ": Cannot open serial port\n"), true));
261    }
262    connect(_serialPort, SIGNAL(readyRead()), this,
263        SLOT(slotSerialReadyRead()));
264
265    // Automatic NMEA
266    // --------------
267    QString nmeaMode = settings.value("serialAutoNMEA").toString();
268    if (nmeaMode == "Auto") {
269      _serialNMEA = AUTO_NMEA;
270      QString fName = settings.value("serialFileNMEA").toString();
271      if (!fName.isEmpty()) {
272        _serialOutFile = new QFile(fName);
273        if (Qt::CheckState(settings.value("rnxAppend").toInt())
274            == Qt::Checked) {
275          _serialOutFile->open(QIODevice::WriteOnly | QIODevice::Append);
276        } else {
277          _serialOutFile->open(QIODevice::WriteOnly);
278        }
279      }
280    }
281    // Manual NMEA
282    // -----------
283    if ((nmeaMode == "Manual GPGGA") || (nmeaMode == "Manual GNGGA")) {
284      _serialNMEA = MANUAL_NMEA;
285      bncSettings settings;
286      _manualNMEASampl = settings.value("serialManualNMEASampling").toInt();
287      QString hlp = settings.value("serialHeightNMEA").toString();
288      if (hlp.isEmpty()) {
289        hlp = "0.0";
290      }
291      QByteArray _serialHeightNMEA = hlp.toLatin1();
292      _manualNMEAString = ggaString(_latitude, _longitude, _serialHeightNMEA,
293          nmeaMode);
294    }
295  }
296
297  if (!_staID.isEmpty() && _latencycheck) {
298    _latencyChecker = new latencyChecker(_staID);
299    _rtcmObs       = false;
300    _rtcmSsrOrb    = false;
301    _rtcmSsrClk    = false;
302    _rtcmSsrOrbClk = false;
303    _rtcmSsrCbi    = false;
304    _rtcmSsrPbi    = false;
305    _rtcmSsrVtec   = false;
306    _rtcmSsrUra    = false;
307    _rtcmSsrHr     = false;
308    _rtcmSsrIgs    = false;
309    _ssrEpoch      = 0;
310  } else {
311    _latencyChecker = 0;
312  }
313}
314
315// Instantiate the decoder
316//////////////////////////////////////////////////////////////////////////////
317t_irc bncGetThread::initDecoder() {
318
319
320
321  _decoder = 0;
322
323  if (_format.indexOf("RTCM_2") != -1 ||
324      _format.indexOf("RTCM2")  != -1 ||
325      _format.indexOf("RTCM 2") != -1) {
326    emit(newMessage(_staID + ": Get data in RTCM 2.x format", true));
327    _decoder = new RTCM2Decoder(_staID.data());
328  } else if (_format.indexOf("RTCM_3") != -1 ||
329      _format.indexOf("RTCM3")  != -1 ||
330      _format.indexOf("RTCM 3") != -1) {
331    emit(newMessage(_staID + ": Get data in RTCM 3.x format", true));
332    RTCM3Decoder* newDecoder = new RTCM3Decoder(_staID, _rawFile);
333    _decoder = newDecoder;
334    connect((RTCM3Decoder*) newDecoder, SIGNAL(newMessage(QByteArray,bool)),
335        this, SIGNAL(newMessage(QByteArray,bool)));
336  } else if (_format.indexOf("ZERO") != -1) {
337    emit(newMessage(_staID + ": Get data in original format", true));
338    _decoder = new bncZeroDecoder(_staID);
339  } else if (_format.indexOf("RTNET") != -1) {
340    emit(newMessage(_staID + ": Get data in RTNet format", true));
341    _decoder = new bncRtnetDecoder();
342  } else {
343    emit(newMessage(_staID + ": Unknown data format " + _format, true));
344    _isToBeDeleted = true;
345    return failure;
346  }
347
348  msleep(100); //sleep 0.1 sec
349
350  _decoder->initRinex(_staID, _mountPoint, _latitude, _longitude, _nmea,
351      _ntripVersion);
352
353  if (_rawFile) {
354    _decodersRaw[_staID] = _decoder;
355  }
356
357  return success;
358}
359
360// Current decoder in use
361////////////////////////////////////////////////////////////////////////////
362GPSDecoder* bncGetThread::decoder() {
363  if (!_rawFile) {
364    return _decoder;
365  } else {
366    if (_decodersRaw.contains(_staID) || initDecoder() == success) {
367      return _decodersRaw[_staID];
368    }
369  }
370  return 0;
371}
372
373// Destructor
374////////////////////////////////////////////////////////////////////////////
375bncGetThread::~bncGetThread() {
376  if (isRunning()) {
377    wait();
378  }
379  if (_query) {
380    _query->stop();
381    _query->deleteLater();
382  }
383  if (_rawFile) {
384    QMapIterator<QString, GPSDecoder*> it(_decodersRaw);
385    while (it.hasNext()) {
386      it.next();
387      delete it.value();
388    }
389  } else {
390    delete _decoder;
391  }
392  delete _rawFile;
393  delete _serialOutFile;
394  delete _serialPort;
395  delete _latencyChecker;
396  emit getThreadFinished(_staID);
397}
398
399//
400////////////////////////////////////////////////////////////////////////////
401void bncGetThread::terminate() {
402  _isToBeDeleted = true;
403
404  if (_nmeaPortsMap.contains(_staID)) {
405    _nmeaPortsMap.remove(_staID);
406  }
407  if (_nmeaServer) {
408    delete _nmeaServer;
409  }
410  if (_nmeaSockets) {
411    delete _nmeaSockets;
412  }
413
414//#ifdef BNC_DEBUG
415  if (BNC_CORE->mode() != t_bncCore::interactive) {
416    while (!isFinished()) {
417      wait();
418    }
419    delete this;
420  } else {
421    if (!isRunning()) {
422      delete this;
423    }
424  }
425//#else
426//  if (!isRunning()) {delete this;}
427//#endif
428
429}
430
431// Run
432////////////////////////////////////////////////////////////////////////////
433void bncGetThread::run() {
434
435  while (true) {
436    try {
437      if (_isToBeDeleted) {
438        QThread::exit(0);
439        this->deleteLater();
440        return;
441      }
442
443      if (tryReconnect() != success) {
444        if (_latencyChecker) {
445          _latencyChecker->checkReconnect();
446        }
447        continue;
448      }
449
450      // Delete old observations
451      // -----------------------
452      if (_rawFile) {
453        QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
454        while (itDec.hasNext()) {
455          itDec.next();
456          GPSDecoder* decoder = itDec.value();
457          decoder->_obsList.clear();
458        }
459      } else {
460        _decoder->_obsList.clear();
461      }
462
463      // Read Data
464      // ---------
465      QByteArray data;
466      if (_query) {
467        _query->waitForReadyRead(data);
468      } else if (_rawFile) {
469        data = _rawFile->readChunk();
470        _format = _rawFile->format();
471        _staID = _rawFile->staID();
472
473        QCoreApplication::processEvents();
474
475        if (data.isEmpty() || BNC_CORE->sigintReceived) {
476          cout << "no more data or Ctrl-C received" << endl;
477          BNC_CORE->stopCombination();
478          BNC_CORE->stopPPP();
479          sleep(2);
480          ::exit(0);
481        }
482      }
483
484      qint64 nBytes = data.size();
485
486      // Timeout, reconnect
487      // ------------------
488      if (nBytes == 0) {
489        if (_latencyChecker) {
490          _latencyChecker->checkReconnect();
491        }
492        emit(newMessage(_staID + ": Data timeout, reconnecting", true));
493        msleep(10000); //sleep 10 sec, G. Weber
494        continue;
495      } else {
496        emit newBytes(_staID, nBytes);
497        emit newRawData(_staID, data);
498      }
499
500      // Output Data
501      // -----------
502      if (_rawOutput) {
503        BNC_CORE->writeRawData(data, _staID, _format);
504      }
505
506      if (_serialPort) {
507        slotSerialReadyRead();
508        _serialPort->write(data);
509      }
510
511      // Decode Data
512      // -----------
513      vector<string> errmsg;
514      if (!decoder()) {
515        _isToBeDeleted = true;
516        continue;
517      }
518
519      t_irc irc = decoder()->Decode(data.data(), data.size(), errmsg);
520
521      if (irc != success) {
522        continue;
523      }
524      // Perform various scans and checks
525      // --------------------------------
526      if (_latencyChecker) {
527        _latencyChecker->checkOutage(irc);
528        QListIterator<int> it(decoder()->_typeList);
529        _ssrEpoch = static_cast<int>(decoder()->corrGPSEpochTime());
530        if (_ssrEpoch != -1) {
531          if (_rtcmSsrOrb) {
532            _latencyChecker->checkCorrLatency(_ssrEpoch, 1057);
533            _rtcmSsrOrb = false;
534          }
535          if (_rtcmSsrClk) {
536            _latencyChecker->checkCorrLatency(_ssrEpoch, 1058);
537            _rtcmSsrClk = false;
538          }
539          if (_rtcmSsrOrbClk) {
540            _latencyChecker->checkCorrLatency(_ssrEpoch, 1060);
541            _rtcmSsrOrbClk = false;
542          }
543          if (_rtcmSsrCbi) {
544            _latencyChecker->checkCorrLatency(_ssrEpoch, 1059);
545            _rtcmSsrCbi = false;
546          }
547          if (_rtcmSsrPbi) {
548            _latencyChecker->checkCorrLatency(_ssrEpoch, 1265);
549            _rtcmSsrPbi = false;
550          }
551          if (_rtcmSsrVtec) {
552            _latencyChecker->checkCorrLatency(_ssrEpoch, 1264);
553            _rtcmSsrVtec = false;
554          }
555          if (_rtcmSsrUra) {
556            _latencyChecker->checkCorrLatency(_ssrEpoch, 1061);
557            _rtcmSsrUra = false;
558          }
559          if (_rtcmSsrHr) {
560            _latencyChecker->checkCorrLatency(_ssrEpoch, 1062);
561            _rtcmSsrHr = false;
562          }
563          if (_rtcmSsrIgs) {
564            _latencyChecker->checkCorrLatency(_ssrEpoch, 4076);
565            _rtcmSsrIgs = false;
566          }
567        }
568        while (it.hasNext()) {
569          int rtcmType = it.next();
570          if ((rtcmType >= 1001 && rtcmType <= 1004) || // legacy RTCM OBS
571              (rtcmType >= 1009 && rtcmType <= 1012) || // legacy RTCM OBS
572              (rtcmType >= 1071 && rtcmType <= 1137)) { // MSM RTCM OBS
573            _rtcmObs = true;
574          } else if ((rtcmType >= 1057 && rtcmType <= 1068) ||
575                     (rtcmType >= 1240 && rtcmType <= 1270) ||
576                                         (rtcmType == 4076)) {
577            switch (rtcmType) {
578              case 1057: case 1063: case 1240: case 1246: case 1252: case 1258:
579                _rtcmSsrOrb = true;
580                break;
581              case 1058: case 1064: case 1241: case 1247: case 1253: case 1259:
582                _rtcmSsrClk = true;
583                break;
584              case 1060: case 1066: case 1243: case 1249: case 1255: case 1261:
585                _rtcmSsrOrbClk = true;
586                break;
587              case 1059: case 1065: case 1242: case 1248: case 1254: case 1260:
588                _rtcmSsrCbi = true;
589                break;
590              case 1265: case 1266: case 1267: case 1268: case 1269: case 1270:
591                _rtcmSsrPbi = true;
592                break;
593              case 1264:
594                _rtcmSsrVtec = true;
595                break;
596              case 1061: case 1067: case 1244: case 1250: case 1256: case 1262:
597                _rtcmSsrUra = true;
598                break;
599              case 1062: case 1068: case 1245: case 1251: case 1257: case 1263:
600                _rtcmSsrHr = true;
601                break;
602              case 4076:
603                _rtcmSsrIgs = true;
604                break;
605            }
606          }
607        }
608        if (_rtcmObs) {
609          _latencyChecker->checkObsLatency(decoder()->_obsList);
610        }
611        emit newLatency(_staID, _latencyChecker->currentLatency());
612      }
613      miscScanRTCM();
614
615      // Loop over all observations (observations output)
616      // ------------------------------------------------
617      QListIterator<t_satObs> it(decoder()->_obsList);
618
619      QList<t_satObs> obsListHlp;
620
621      while (it.hasNext()) {
622        const t_satObs& obs = it.next();
623
624        // Check observation epoch
625        // -----------------------
626        if (!_rawFile) {
627          bool wrongObservationEpoch = checkForWrongObsEpoch(obs._time);
628          if (wrongObservationEpoch) {
629            QString prn(obs._prn.toString().c_str());
630            emit(newMessage(_staID + " (" + prn.toLatin1() + ")" + ": Wrong observation epoch(s)", false));
631            continue;
632          }
633        }
634
635        // Check observations coming twice (e.g. KOUR0 Problem)
636        // ----------------------------------------------------
637        if (!_rawFile) {
638          QString prn(obs._prn.toString().c_str());
639          bncTime obsTime = obs._time;
640          QMap<QString, bncTime>::const_iterator it = _prnLastEpo.find(prn);
641          if (it != _prnLastEpo.end()) {
642            bncTime oldTime = it.value();
643            if (obsTime < oldTime) {
644              emit(newMessage(_staID + ": old observation " + prn.toLatin1(), false));
645              continue;
646            } else if (obsTime == oldTime) {
647              emit(newMessage(_staID + ": observation coming more than once " + prn.toLatin1(), false));
648              continue;
649            }
650          }
651          _prnLastEpo[prn] = obsTime;
652        }
653
654        decoder()->dumpRinexEpoch(obs, _format);
655
656        // Save observations
657        // -----------------
658        obsListHlp.append(obs);
659      }
660
661      // Emit signal
662      // -----------
663      if (!_isToBeDeleted && obsListHlp.size() > 0) {
664        emit newObs(_staID, obsListHlp);
665      }
666
667    } catch (Exception& exc) {
668      emit(newMessage(_staID + " " + exc.what(), true));
669      _isToBeDeleted = true;
670    } catch (...) {
671      emit(newMessage(_staID + " bncGetThread exception", true));
672      _isToBeDeleted = true;
673    }
674  }
675}
676
677// Try Re-Connect
678////////////////////////////////////////////////////////////////////////////
679t_irc bncGetThread::tryReconnect() {
680
681  // Easy Return
682  // -----------
683  if (_query && _query->status() == bncNetQuery::running) {
684    _nextSleep = 0;
685    if (_rawFile) {
686      QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
687      while (itDec.hasNext()) {
688        itDec.next();
689        GPSDecoder* decoder = itDec.value();
690        decoder->setRinexReconnectFlag(false);
691      }
692    } else {
693      _decoder->setRinexReconnectFlag(false);
694    }
695    return success;
696  }
697
698  // Start a new query
699  // -----------------
700  if (!_rawFile) {
701
702    sleep(_nextSleep);
703    if (_nextSleep == 0) {
704      _nextSleep = 1;
705    } else {
706      _nextSleep = 2 * _nextSleep;
707      if (_nextSleep > 256) {
708        _nextSleep = 256;
709      }
710#ifdef MLS_SOFTWARE
711      if (_nextSleep > 4) {
712        _nextSleep = 4;
713      }
714#endif
715    }
716    delete _query;
717    if (_ntripVersion == "U") {
718      _query = new bncNetQueryUdp();
719    } else if (_ntripVersion == "R") {
720      _query = new bncNetQueryRtp();
721    } else if (_ntripVersion == "S") {
722      _query = new bncNetQueryS();
723    } else if (_ntripVersion == "N") {
724      _query = new bncNetQueryV0();
725    } else if (_ntripVersion == "UN") {
726      _query = new bncNetQueryUdp0();
727    } else if (_ntripVersion == "2") {
728      _query = new bncNetQueryV2(false);
729    } else if (_ntripVersion == "2s") {
730      _query = new bncNetQueryV2(true);
731    } else {
732      _query = new bncNetQueryV1();
733    }
734    if (_nmea == "yes") {
735      if (_serialNMEA == MANUAL_NMEA) {
736        _query->startRequest(_mountPoint, _manualNMEAString);
737        _lastManualNMEA = QDateTime::currentDateTime();
738      } else if (_serialNMEA == AUTO_NMEA) {
739        if (_serialPort) {
740          int nb = _serialPort->bytesAvailable();
741          if (nb > 0) {
742            QByteArray data = _serialPort->read(nb);
743            int i1 = data.indexOf("$GPGGA");
744            if (i1 == -1) {
745              i1 = data.indexOf("$GNGGA");
746            }
747            if (i1 != -1) {
748              int i2 = data.indexOf("*", i1);
749              if (i2 != -1 && data.size() > i2 + 1) {
750                QByteArray gga = data.mid(i1, i2 - i1 + 3);
751                _query->startRequest(_mountPoint, gga);
752              }
753            }
754          }
755        }
756      }
757    } else {
758      _query->startRequest(_mountPoint, "");
759    }
760
761    if (_query->status() != bncNetQuery::running) {
762      return failure;
763    }
764  }
765
766  if (_rawFile) {
767    QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
768    while (itDec.hasNext()) {
769      itDec.next();
770      GPSDecoder* decoder = itDec.value();
771      decoder->setRinexReconnectFlag(false);
772    }
773  } else {
774    _decoder->setRinexReconnectFlag(false);
775  }
776
777  return success;
778}
779
780// RTCM scan output
781//////////////////////////////////////////////////////////////////////////////
782void bncGetThread::miscScanRTCM() {
783
784  if (!decoder()) {
785    return;
786  }
787
788  bncSettings settings;
789  if (Qt::CheckState(settings.value("miscScanRTCM").toInt()) == Qt::Checked) {
790
791    if (_miscMount == _staID || _miscMount == "ALL") {
792      // RTCM message types
793      // ------------------
794      for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
795        QString type = QString("%1 ").arg(decoder()->_typeList[ii]);
796        emit(newMessage(_staID + ": Received message type " + type.toLatin1(),
797            true));
798      }
799
800      // Check Observation Types
801      // -----------------------
802      for (int ii = 0; ii < decoder()->_obsList.size(); ii++) {
803        t_satObs& obs = decoder()->_obsList[ii];
804        QVector<QString>& rnxTypes = _rnxTypes[obs._prn.system()];
805        bool allFound = true;
806        for (unsigned iFrq = 0; iFrq < obs._obs.size(); iFrq++) {
807          if (obs._obs[iFrq]->_codeValid) {
808            QString rnxStr('C');
809            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
810            if (_format.indexOf("RTCM_2") != -1
811                || _format.indexOf("RTCM2") != -1
812                || _format.indexOf("RTCM 2") != -1) {
813              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
814            }
815            if (rnxTypes.indexOf(rnxStr) == -1) {
816              rnxTypes.push_back(rnxStr);
817              allFound = false;
818            }
819          }
820          if (obs._obs[iFrq]->_phaseValid) {
821            QString rnxStr('L');
822            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
823            if (_format.indexOf("RTCM_2") != -1
824                || _format.indexOf("RTCM2") != -1
825                || _format.indexOf("RTCM 2") != -1) {
826              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
827            }
828            if (rnxTypes.indexOf(rnxStr) == -1) {
829              rnxTypes.push_back(rnxStr);
830              allFound = false;
831            }
832          }
833          if (obs._obs[iFrq]->_dopplerValid) {
834            QString rnxStr('D');
835            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
836            if (_format.indexOf("RTCM_2") != -1
837                || _format.indexOf("RTCM2") != -1
838                || _format.indexOf("RTCM 2") != -1) {
839              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
840            }
841            if (rnxTypes.indexOf(rnxStr) == -1) {
842              rnxTypes.push_back(rnxStr);
843              allFound = false;
844            }
845          }
846          if (obs._obs[iFrq]->_snrValid) {
847            QString rnxStr('S');
848            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
849            if (_format.indexOf("RTCM_2") != -1
850                || _format.indexOf("RTCM2") != -1
851                || _format.indexOf("RTCM 2") != -1) {
852              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
853            }
854            if (rnxTypes.indexOf(rnxStr) == -1) {
855              rnxTypes.push_back(rnxStr);
856              allFound = false;
857            }
858          }
859        }
860        if (!allFound) {
861          QString msg;
862          QTextStream str(&msg);
863          QString s;
864          str << obs._prn.system() << "    "
865              << s.sprintf("%2d", rnxTypes.size()) << "  ";
866          for (int iType = 0; iType < rnxTypes.size(); iType++) {
867            str << " " << rnxTypes[iType];
868          }
869          emit(newMessage(_staID + ": Observation Types: " + msg.toLatin1(),
870              true));
871        }
872      }
873
874      // RTCMv3 antenna descriptor
875      // -------------------------
876      for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
877        QString ant1 = QString(": Antenna Descriptor: %1 ").arg(decoder()->_antType[ii].descriptor);
878        emit(newMessage(_staID + ant1.toLatin1(), true));
879        if (strlen(decoder()->_antType[ii].serialnumber)) {
880          QString ant2 = QString(": Antenna Serial Number: %1 ").arg(decoder()->_antType[ii].serialnumber);
881          emit(newMessage(_staID + ant2.toLatin1(), true));
882        }
883      }
884
885      // RTCM Antenna Coordinates
886      // ------------------------
887      for (int ii = 0; ii < decoder()->_antList.size(); ii++) {
888        QByteArray antT;
889        if (decoder()->_antList[ii].type == GPSDecoder::t_antRefPoint::ARP) {
890          antT = "ARP";
891        } else if (decoder()->_antList[ii].type == GPSDecoder::t_antRefPoint::APC) {
892          antT = "APC";
893        }
894        QByteArray ant1, ant2, ant3;
895        ant1 = QString("%1 ").arg(decoder()->_antList[ii].xx, 0, 'f', 4).toLatin1();
896        ant2 = QString("%1 ").arg(decoder()->_antList[ii].yy, 0, 'f', 4).toLatin1();
897        ant3 = QString("%1 ").arg(decoder()->_antList[ii].zz, 0, 'f', 4).toLatin1();
898        emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
899        emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
900        emit(newMessage(_staID + ": " + antT + " (ITRF) Z " + ant3 + "m", true));
901        double hh = 0.0;
902        if (decoder()->_antList[ii].height_f) {
903          hh = decoder()->_antList[ii].height;
904          QByteArray ant4 = QString("%1 ").arg(hh, 0, 'f', 4).toLatin1();
905          emit(newMessage(
906              _staID + ": Antenna height above marker " + ant4 + "m", true));
907        }
908        emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
909            decoder()->_antList[ii].yy, decoder()->_antList[ii].zz, hh, antT));
910      }
911
912      // RTCMv3 receiver descriptor
913      // --------------------------
914      for (int ii = 0; ii < decoder()->_recType.size(); ii++) {
915        QString rec1 = QString(": Receiver Descriptor: %1 ").arg(decoder()->_recType[ii].descriptor);
916        QString rec2 = QString(": Receiver Firmware Version: %1 ").arg(decoder()->_recType[ii].firmware);
917        QString rec3 = QString(": Receiver Serial Number: %1 ").arg(decoder()->_recType[ii].serialnumber);
918        emit(newMessage(_staID + rec1.toLatin1(), true));
919        emit(newMessage(_staID + rec2.toLatin1(), true));
920        emit(newMessage(_staID + rec3.toLatin1(), true));
921      }
922
923      // RTCM GLONASS slots
924      // ------------------
925      if (decoder()->_gloFrq.size()) {
926        bool allFound = true;
927        QString slot = decoder()->_gloFrq;
928        slot.replace("  ", " ").replace(" ", ":");
929        if (_gloSlots.indexOf(slot) == -1) {
930          _gloSlots.append(slot);
931          allFound = false;
932        }
933        if (!allFound) {
934          _gloSlots.sort();
935          emit(newMessage(
936              _staID + ": GLONASS Slot:Freq " + _gloSlots.join(" ").toLatin1(),
937              true));
938        }
939      }
940    }
941  }
942
943#ifdef MLS_SOFTWARE
944  for (int ii=0; ii <decoder()->_antList.size(); ii++) {
945    QByteArray antT;
946    if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
947      antT = "ARP";
948    }
949    else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
950      antT = "APC";
951    }
952    double hh = 0.0;
953    if (decoder()->_antList[ii].height_f) {
954      hh = decoder()->_antList[ii].height;
955    }
956    emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
957            decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
958            hh, antT));
959  }
960
961  for (int ii = 0; ii <decoder()->_typeList.size(); ii++) {
962    emit(newRTCMMessage(_staID, decoder()->_typeList[ii]));
963  }
964#endif
965
966  decoder()->_gloFrq.clear();
967  decoder()->_typeList.clear();
968  decoder()->_antType.clear();
969  decoder()->_recType.clear();
970  decoder()->_antList.clear();
971}
972
973// Handle Data from Serial Port
974////////////////////////////////////////////////////////////////////////////
975void bncGetThread::slotSerialReadyRead() {
976
977  if (_serialPort) {
978
979    if (_nmea == "yes" && _serialNMEA == MANUAL_NMEA) {
980      if (_manualNMEASampl) {
981        int dt = _lastManualNMEA.secsTo(QDateTime::currentDateTime());
982        if (dt && (fmod(double(dt), double(_manualNMEASampl)) == 0.0)) {
983          _query->sendNMEA(_manualNMEAString);
984          _lastManualNMEA = QDateTime::currentDateTime();
985        }
986      }
987    }
988
989    int nb = _serialPort->bytesAvailable();
990    if (nb > 0) {
991      QByteArray data = _serialPort->read(nb);
992
993      if (_nmea == "yes" && _serialNMEA == AUTO_NMEA) {
994        int i1 = data.indexOf("$GPGGA");
995        if (i1 == -1) {
996          i1 = data.indexOf("$GNGGA");
997        }
998        if (i1 != -1) {
999          int i2 = data.indexOf("*", i1);
1000          if (i2 != -1 && data.size() > i2 + 1) {
1001            QByteArray gga = data.mid(i1, i2 - i1 + 3);
1002            _query->sendNMEA(gga);
1003          }
1004        }
1005      }
1006
1007      if (_serialOutFile) {
1008        _serialOutFile->write(data);
1009        _serialOutFile->flush();
1010      }
1011    }
1012  }
1013}
1014
1015void bncGetThread::slotNewNMEAConnection() {
1016  _nmeaSockets->push_back(_nmeaServer->nextPendingConnection());
1017  emit(newMessage(
1018      QString("New PPP client on port: # %1").arg(_nmeaSockets->size()).toLatin1(),
1019      true));
1020}
1021
1022//
1023////////////////////////////////////////////////////////////////////////////
1024void bncGetThread::slotNewNMEAstr(QByteArray staID, QByteArray str) {
1025  if (_nmeaPortsMap.contains(staID)) {
1026    int nmeaPort = _nmeaPortsMap.value(staID);
1027    QMutableListIterator<QTcpSocket*> is(*_nmeaSockets);
1028    while (is.hasNext()) {
1029      QTcpSocket* sock = is.next();
1030      if (sock->localPort() == nmeaPort) {
1031        if (sock->state() == QAbstractSocket::ConnectedState) {
1032          sock->write(str);
1033        } else if (sock->state() != QAbstractSocket::ConnectingState) {
1034          delete sock;
1035          is.remove();
1036        }
1037      }
1038    }
1039  }
1040}
Note: See TracBrowser for help on using the repository browser.