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

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

#BNC_DEBUG added

File size: 27.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:      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  while (!isFinished()) {
412    wait();
413  }
414  delete this;
415#else
416    if (!isRunning()) {
417      delete this;
418    }
419#endif
420
421}
422
423// Run
424////////////////////////////////////////////////////////////////////////////
425void bncGetThread::run() {
426
427  while (true) {
428    try {
429      if (_isToBeDeleted) {
430        QThread::exit(0);
431        this->deleteLater();
432        return;
433      }
434
435      if (tryReconnect() != success) {
436        if (_latencyChecker) {
437          _latencyChecker->checkReconnect();
438        }
439        continue;
440      }
441
442      // Delete old observations
443      // -----------------------
444      if (_rawFile) {
445        QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
446        while (itDec.hasNext()) {
447          itDec.next();
448          GPSDecoder* decoder = itDec.value();
449          decoder->_obsList.clear();
450        }
451      }
452      else {
453        _decoder->_obsList.clear();
454      }
455
456      // Read Data
457      // ---------
458      QByteArray data;
459      if      (_query) {
460        _query->waitForReadyRead(data);
461      }
462      else if (_rawFile) {
463        data = _rawFile->readChunk();
464        _format = _rawFile->format();
465        _staID  = _rawFile->staID();
466
467        QCoreApplication::processEvents();
468
469        if (data.isEmpty()) {
470          cout << "no more data" << endl;
471          BNC_CORE->stopCombination();
472          BNC_CORE->stopPPP();
473          ::exit(0);
474        }
475      }
476      qint64 nBytes = data.size();
477
478      // Timeout, reconnect
479      // ------------------
480      if (nBytes == 0) {
481        if (_latencyChecker) {
482          _latencyChecker->checkReconnect();
483        }
484        emit(newMessage(_staID + ": Data timeout, reconnecting", true));
485        msleep(10000); //sleep 10 sec, G. Weber
486        continue;
487      }
488      else {
489        emit newBytes(_staID, nBytes);
490        emit newRawData(_staID, data);
491      }
492
493      // Output Data
494      // -----------
495      if (_rawOutput) {
496        BNC_CORE->writeRawData(data, _staID, _format);
497      }
498
499      if (_serialPort) {
500        slotSerialReadyRead();
501        _serialPort->write(data);
502      }
503
504      // Decode Data
505      // -----------
506      vector<string> errmsg;
507      if (!decoder()) {
508        _isToBeDeleted = true;
509        continue;
510      }
511
512      t_irc irc = decoder()->Decode(data.data(), data.size(), errmsg);
513
514      if (irc != success) {
515        continue;
516      }
517      // Perform various scans and checks
518      // --------------------------------
519      if (_latencyChecker) {
520        _latencyChecker->checkOutage(irc == success);
521        _latencyChecker->checkObsLatency(decoder()->_obsList);
522        _latencyChecker->checkCorrLatency(decoder()->corrGPSEpochTime());
523
524        emit newLatency(_staID, _latencyChecker->currentLatency());
525      }
526
527      miscScanRTCM();
528
529      // Loop over all observations (observations output)
530      // ------------------------------------------------
531      QListIterator<t_satObs> it(decoder()->_obsList);
532
533      QList<t_satObs> obsListHlp;
534
535      while (it.hasNext()) {
536        const t_satObs& obs = it.next();
537
538        QString prn(obs._prn.toString().c_str());
539        long iSec    = long(floor(obs._time.gpssec()+0.5));
540        long obsTime = obs._time.gpsw()*7*24*3600 + iSec;
541
542        // Check observation epoch
543        // -----------------------
544        if (!_rawFile) {
545          int    week;
546          double sec;
547          currentGPSWeeks(week, sec);
548          long currTime = week * 7*24*3600 + long(sec);
549          const double maxDt = 600.0;
550          if (fabs(currTime - obsTime) > maxDt) {
551              emit( newMessage(_staID + ": Wrong observation epoch(s)", false) );
552            continue;
553          }
554        }
555
556        // Check observations coming twice (e.g. KOUR0 Problem)
557        // ----------------------------------------------------
558        if (!_rawFile) {
559          QMap<QString, long>::const_iterator it = _prnLastEpo.find(prn);
560          if (it != _prnLastEpo.end()) {
561            long oldTime = it.value();
562            if      (obsTime <  oldTime) {
563              emit( newMessage(_staID +
564                 ": old observation " + prn.toAscii(), false));
565              continue;
566            }
567            else if (obsTime == oldTime) {
568              emit( newMessage(_staID +
569                 ": observation coming more than once " + prn.toAscii(), false));
570              continue;
571            }
572          }
573          _prnLastEpo[prn] = obsTime;
574        }
575
576        decoder()->dumpRinexEpoch(obs, _format);
577
578        // Save observations
579        // -----------------
580        obsListHlp.append(obs);
581      }
582
583      // Emit signal
584      // -----------
585      if (!_isToBeDeleted && obsListHlp.size() > 0) {
586        emit newObs(_staID, obsListHlp);
587      }
588
589    }
590    catch (Exception& exc) {
591      emit(newMessage(_staID + " " + exc.what(), true));
592      _isToBeDeleted = true;
593    }
594    catch (...) {
595      emit(newMessage(_staID + " bncGetThread exception", true));
596      _isToBeDeleted = true;
597    }
598  }
599}
600
601// Try Re-Connect
602////////////////////////////////////////////////////////////////////////////
603t_irc bncGetThread::tryReconnect() {
604
605  // Easy Return
606  // -----------
607  if (_query && _query->status() == bncNetQuery::running) {
608    _nextSleep = 0;
609    if (_rawFile) {
610      QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
611      while (itDec.hasNext()) {
612        itDec.next();
613        GPSDecoder* decoder = itDec.value();
614        decoder->setRinexReconnectFlag(false);
615      }
616    }
617    else {
618      _decoder->setRinexReconnectFlag(false);
619    }
620    return success;
621  }
622
623  // Start a new query
624  // -----------------
625  if (!_rawFile) {
626
627    sleep(_nextSleep);
628    if (_nextSleep == 0) {
629      _nextSleep = 1;
630    }
631    else {
632      _nextSleep = 2 * _nextSleep;
633      if (_nextSleep > 256) {
634        _nextSleep = 256;
635      }
636#ifdef MLS_SOFTWARE
637      if (_nextSleep > 4) {
638        _nextSleep = 4;
639      }
640#endif
641    }
642
643    delete _query;
644    if      (_ntripVersion == "U") {
645      _query = new bncNetQueryUdp();
646    }
647    else if (_ntripVersion == "R") {
648      _query = new bncNetQueryRtp();
649    }
650    else if (_ntripVersion == "S") {
651      _query = new bncNetQueryS();
652    }
653    else if (_ntripVersion == "N") {
654      _query = new bncNetQueryV0();
655    }
656    else if (_ntripVersion == "UN") {
657      _query = new bncNetQueryUdp0();
658    }
659    else if (_ntripVersion == "2") {
660      _query = new bncNetQueryV2(false);
661    }
662    else if (_ntripVersion == "2s") {
663      _query = new bncNetQueryV2(true);
664    }
665    else {
666      _query = new bncNetQueryV1();
667    }
668    if (_nmea == "yes") {
669      if (_serialNMEA == MANUAL_NMEA) {
670        _query->startRequest(_mountPoint, _manualNMEAString);
671        _lastManualNMEA = QDateTime::currentDateTime();
672      }
673      else if (_serialNMEA == AUTO_NMEA) {
674        if (_serialPort) {
675          int nb = _serialPort->bytesAvailable();
676          if (nb > 0) {
677            QByteArray data = _serialPort->read(nb);
678            int i1 = data.indexOf("$GPGGA");
679            if (i1 == -1) {
680              i1 = data.indexOf("$GNGGA");
681            }
682            if (i1 != -1) {
683              int i2 = data.indexOf("*", i1);
684              if (i2 != -1 && data.size() > i2 + 1) {
685                QByteArray gga = data.mid(i1, i2 - i1 + 3);
686                _query->startRequest(_mountPoint, gga);
687              }
688            }
689          }
690        }
691      }
692    }
693    else {
694      _query->startRequest(_mountPoint, "");
695    }
696
697    if (_query->status() != bncNetQuery::running) {
698      return failure;
699    }
700  }
701
702  if (_rawFile) {
703    QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
704    while (itDec.hasNext()) {
705      itDec.next();
706      GPSDecoder* decoder = itDec.value();
707      decoder->setRinexReconnectFlag(false);
708    }
709  }
710  else {
711   _decoder->setRinexReconnectFlag(false);
712  }
713
714  return success;
715}
716
717// RTCM scan output
718//////////////////////////////////////////////////////////////////////////////
719void bncGetThread::miscScanRTCM() {
720
721  if ( !decoder() ) {
722    return;
723  }
724
725  bncSettings settings;
726  if ( Qt::CheckState(settings.value("miscScanRTCM").toInt()) == Qt::Checked ) {
727
728    if ( _miscMount == _staID || _miscMount == "ALL" ) {
729      // RTCM message types
730      // ------------------
731      for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
732        QString type =  QString("%1 ").arg(decoder()->_typeList[ii]);
733        emit(newMessage(_staID + ": Received message type " + type.toAscii(), true));
734      }
735
736      // Check Observation Types
737      // -----------------------
738      for (int ii = 0; ii < decoder()->_obsList.size(); ii++) {
739        t_satObs& obs = decoder()->_obsList[ii];
740        QVector<QString>& rnxTypes = _rnxTypes[obs._prn.system()];
741        bool allFound = true;
742        for (unsigned iFrq = 0; iFrq < obs._obs.size(); iFrq++) {
743          if (obs._obs[iFrq]->_codeValid) {
744            QString rnxStr('C');
745            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
746            if (_format.indexOf("RTCM_2") != -1 ||
747                _format.indexOf("RTCM2") != -1 ||
748                _format.indexOf("RTCM 2") != -1 ) {
749              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
750            }
751            if (rnxTypes.indexOf(rnxStr) == -1) {
752              rnxTypes.push_back(rnxStr);
753              allFound = false;
754            }
755          }
756          if (obs._obs[iFrq]->_phaseValid) {
757            QString rnxStr('L');
758            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
759            if (_format.indexOf("RTCM_2") != -1 ||
760                _format.indexOf("RTCM2") != -1 ||
761                _format.indexOf("RTCM 2") != -1 ) {
762              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
763            }
764            if (rnxTypes.indexOf(rnxStr) == -1) {
765              rnxTypes.push_back(rnxStr);
766              allFound = false;
767            }
768          }
769          if (obs._obs[iFrq]->_dopplerValid){
770            QString rnxStr('D');
771            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
772            if (_format.indexOf("RTCM_2") != -1 ||
773                _format.indexOf("RTCM2") != -1 ||
774                _format.indexOf("RTCM 2") != -1 ) {
775              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
776            }
777            if (rnxTypes.indexOf(rnxStr) == -1) {
778              rnxTypes.push_back(rnxStr);
779              allFound = false;
780            }
781          }
782          if (obs._obs[iFrq]->_snrValid){
783            QString rnxStr('S');
784            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
785            if (_format.indexOf("RTCM_2") != -1 ||
786                _format.indexOf("RTCM2") != -1 ||
787                _format.indexOf("RTCM 2") != -1 ) {
788              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
789            }
790            if (rnxTypes.indexOf(rnxStr) == -1) {
791              rnxTypes.push_back(rnxStr);
792              allFound = false;
793            }
794          }
795        }
796        if (!allFound) {
797          QString msg;
798          QTextStream str(&msg);
799          QString s;
800          str << obs._prn.system() << "    " << s.sprintf("%2d", rnxTypes.size()) << "  ";
801          for (int iType = 0; iType < rnxTypes.size(); iType++) {
802            str << " " << rnxTypes[iType];
803          }
804          emit(newMessage(_staID + ": Observation Types: " + msg.toAscii(), true));
805        }
806      }
807
808      // RTCMv3 antenna descriptor
809      // -------------------------
810      for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
811        QString ant1 =  QString("%1 ").arg(decoder()->_antType[ii]);
812        emit(newMessage(_staID + ": Antenna descriptor " + ant1.toAscii(), true));
813      }
814
815      // RTCM Antenna Coordinates
816      // ------------------------
817      for (int ii=0; ii < decoder()->_antList.size(); ii++) {
818        QByteArray antT;
819        if      (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
820          antT = "ARP";
821        }
822        else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
823          antT = "APC";
824        }
825        QByteArray ant1, ant2, ant3;
826        ant1 = QString("%1 ").arg(decoder()->_antList[ii].xx,0,'f',4).toAscii();
827        ant2 = QString("%1 ").arg(decoder()->_antList[ii].yy,0,'f',4).toAscii();
828        ant3 = QString("%1 ").arg(decoder()->_antList[ii].zz,0,'f',4).toAscii();
829        emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
830        emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
831        emit(newMessage(_staID + ": " + antT + " (ITRF) Z " + ant3 + "m", true));
832        double hh = 0.0;
833        if (decoder()->_antList[ii].height_f) {
834          hh = decoder()->_antList[ii].height;
835          QByteArray ant4 = QString("%1 ").arg(hh,0,'f',4).toAscii();
836          emit(newMessage(_staID + ": Antenna height above marker "  + ant4 + "m", true));
837        }
838        emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
839                       decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
840                       hh, antT));
841      }
842
843      // RTCM GLONASS slots
844      // ------------------
845      if (decoder()->_gloFrq.size()) {
846        bool allFound = true;
847        QString slot = decoder()->_gloFrq;
848        slot.replace("  "," ").replace(" ",":");
849        if (_gloSlots.indexOf(slot) == -1) {
850          _gloSlots.append(slot);
851          allFound = false;
852        }
853        if (!allFound) {
854          _gloSlots.sort();
855          emit(newMessage(_staID + ": GLONASS Slot:Freq "  + _gloSlots.join(" ").toAscii(), true));
856        }
857      }
858    }
859  }
860
861#ifdef MLS_SOFTWARE
862  for (int ii=0; ii <decoder()->_antList.size(); ii++) {
863        QByteArray antT;
864        if      (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
865          antT = "ARP";
866        }
867        else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
868          antT = "APC";
869        }
870        double hh = 0.0;
871        if (decoder()->_antList[ii].height_f) {
872          hh = decoder()->_antList[ii].height;
873        }
874        emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
875                       decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
876                       hh, antT));
877  }
878
879  for (int ii = 0; ii <decoder()->_typeList.size(); ii++) {
880    emit(newRTCMMessage(_staID, decoder()->_typeList[ii]));
881  }
882#endif
883
884  decoder()->_gloFrq.clear();
885  decoder()->_typeList.clear();
886  decoder()->_antType.clear();
887  decoder()->_antList.clear();
888}
889
890// Handle Data from Serial Port
891////////////////////////////////////////////////////////////////////////////
892void bncGetThread::slotSerialReadyRead() {
893
894  if (_serialPort) {
895
896    if (_nmea == "yes" && _serialNMEA == MANUAL_NMEA) {
897      if (_manualNMEASampl) {
898        int dt = _lastManualNMEA.secsTo(QDateTime::currentDateTime());
899        if (dt && (fmod(double(dt), double(_manualNMEASampl)) == 0.0)) {
900          _query->sendNMEA(_manualNMEAString);
901          _lastManualNMEA = QDateTime::currentDateTime();
902        }
903      }
904    }
905
906    int nb = _serialPort->bytesAvailable();
907    if (nb > 0) {
908      QByteArray data = _serialPort->read(nb);
909
910      if (_nmea == "yes" && _serialNMEA == AUTO_NMEA) {
911        int i1 = data.indexOf("$GPGGA");
912        if (i1 == -1) {
913          i1 = data.indexOf("$GNGGA");
914        }
915        if (i1 != -1) {
916          int i2 = data.indexOf("*", i1);
917          if (i2 != -1 && data.size() > i2 + 1) {
918            QByteArray gga = data.mid(i1, i2 - i1 + 3);
919            _query->sendNMEA(gga);
920          }
921        }
922      }
923
924      if (_serialOutFile) {
925        _serialOutFile->write(data);
926        _serialOutFile->flush();
927      }
928    }
929  }
930}
931
932void bncGetThread::slotNewNMEAConnection() {
933  _nmeaSockets->push_back(_nmeaServer->nextPendingConnection());
934  emit( newMessage(QString("New PPP client on port: # %1")
935                   .arg(_nmeaSockets->size()).toAscii(), true) );
936}
937
938//
939////////////////////////////////////////////////////////////////////////////
940void bncGetThread::slotNewNMEAstr(QByteArray staID, QByteArray str) {
941  if (_nmeaPortsMap.contains(staID)) {
942    int nmeaPort = _nmeaPortsMap.value(staID);
943    QMutableListIterator<QTcpSocket*> is(*_nmeaSockets);
944    while (is.hasNext()) {
945      QTcpSocket* sock = is.next();
946      if (sock->localPort() == nmeaPort) {
947        if (sock->state() == QAbstractSocket::ConnectedState) {
948          sock->write(str);
949        }
950        else if (sock->state() != QAbstractSocket::ConnectingState) {
951          delete sock;
952          is.remove();
953        }
954      }
955    }
956  }
957}
Note: See TracBrowser for help on using the repository browser.