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

Last change on this file since 7859 was 7859, checked in by stuerze, 3 years ago

minor changes to allow a complete end of program only in debug + command line mode

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