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

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

satellite information added to "Wrong observation epoch" message

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() || BNC_CORE->sigintReceived) {
471          cout << "no more data or Ctrl-C received" << 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        // Check observation epoch
540        // -----------------------
541        if (!_rawFile) {
542          bool wrongObservationEpoch = checkForWrongObsEpoch(obs._time);
543          if (wrongObservationEpoch) {
544            QString prn(obs._prn.toString().c_str());
545            emit( newMessage(_staID + " (" + prn.toAscii() + ")" + ": Wrong observation epoch(s)", false) );
546            continue;
547          }
548        }
549
550        // Check observations coming twice (e.g. KOUR0 Problem)
551        // ----------------------------------------------------
552        if (!_rawFile) {
553          QString prn(obs._prn.toString().c_str());
554          long iSec    = long(floor(obs._time.gpssec()+0.5));
555          long obsTime = obs._time.gpsw()*7*24*3600 + iSec;
556          QMap<QString, long>::const_iterator it = _prnLastEpo.find(prn);
557          if (it != _prnLastEpo.end()) {
558            long oldTime = it.value();
559            if      (obsTime <  oldTime) {
560              emit( newMessage(_staID +
561                 ": old observation " + prn.toAscii(), false));
562              continue;
563            }
564            else if (obsTime == oldTime) {
565              emit( newMessage(_staID +
566                 ": observation coming more than once " + prn.toAscii(), false));
567              continue;
568            }
569          }
570          _prnLastEpo[prn] = obsTime;
571        }
572
573        decoder()->dumpRinexEpoch(obs, _format);
574
575        // Save observations
576        // -----------------
577        obsListHlp.append(obs);
578      }
579
580      // Emit signal
581      // -----------
582      if (!_isToBeDeleted && obsListHlp.size() > 0) {
583        emit newObs(_staID, obsListHlp);
584      }
585
586    }
587    catch (Exception& exc) {
588      emit(newMessage(_staID + " " + exc.what(), true));
589      _isToBeDeleted = true;
590    }
591    catch (...) {
592      emit(newMessage(_staID + " bncGetThread exception", true));
593      _isToBeDeleted = true;
594    }
595  }
596}
597
598// Try Re-Connect
599////////////////////////////////////////////////////////////////////////////
600t_irc bncGetThread::tryReconnect() {
601
602  // Easy Return
603  // -----------
604  if (_query && _query->status() == bncNetQuery::running) {
605    _nextSleep = 0;
606    if (_rawFile) {
607      QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
608      while (itDec.hasNext()) {
609        itDec.next();
610        GPSDecoder* decoder = itDec.value();
611        decoder->setRinexReconnectFlag(false);
612      }
613    }
614    else {
615      _decoder->setRinexReconnectFlag(false);
616    }
617    return success;
618  }
619
620  // Start a new query
621  // -----------------
622  if (!_rawFile) {
623
624    sleep(_nextSleep);
625    if (_nextSleep == 0) {
626      _nextSleep = 1;
627    }
628    else {
629      _nextSleep = 2 * _nextSleep;
630      if (_nextSleep > 256) {
631        _nextSleep = 256;
632      }
633#ifdef MLS_SOFTWARE
634      if (_nextSleep > 4) {
635        _nextSleep = 4;
636      }
637#endif
638    }
639    if (_query) {
640      delete _query;
641    }
642    if      (_ntripVersion == "U") {
643      _query = new bncNetQueryUdp();
644    }
645    else if (_ntripVersion == "R") {
646      _query = new bncNetQueryRtp();
647    }
648    else if (_ntripVersion == "S") {
649      _query = new bncNetQueryS();
650    }
651    else if (_ntripVersion == "N") {
652      _query = new bncNetQueryV0();
653    }
654    else if (_ntripVersion == "UN") {
655      _query = new bncNetQueryUdp0();
656    }
657    else if (_ntripVersion == "2") {
658      _query = new bncNetQueryV2(false);
659    }
660    else if (_ntripVersion == "2s") {
661      _query = new bncNetQueryV2(true);
662    }
663    else {
664      _query = new bncNetQueryV1();
665    }
666    if (_nmea == "yes") {
667      if (_serialNMEA == MANUAL_NMEA) {
668        _query->startRequest(_mountPoint, _manualNMEAString);
669        _lastManualNMEA = QDateTime::currentDateTime();
670      }
671      else if (_serialNMEA == AUTO_NMEA) {
672        if (_serialPort) {
673          int nb = _serialPort->bytesAvailable();
674          if (nb > 0) {
675            QByteArray data = _serialPort->read(nb);
676            int i1 = data.indexOf("$GPGGA");
677            if (i1 == -1) {
678              i1 = data.indexOf("$GNGGA");
679            }
680            if (i1 != -1) {
681              int i2 = data.indexOf("*", i1);
682              if (i2 != -1 && data.size() > i2 + 1) {
683                QByteArray gga = data.mid(i1, i2 - i1 + 3);
684                _query->startRequest(_mountPoint, gga);
685              }
686            }
687          }
688        }
689      }
690    }
691    else {
692      _query->startRequest(_mountPoint, "");
693    }
694
695    if (_query->status() != bncNetQuery::running) {
696      return failure;
697    }
698  }
699
700  if (_rawFile) {
701    QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
702    while (itDec.hasNext()) {
703      itDec.next();
704      GPSDecoder* decoder = itDec.value();
705      decoder->setRinexReconnectFlag(false);
706    }
707  }
708  else {
709   _decoder->setRinexReconnectFlag(false);
710  }
711
712  return success;
713}
714
715// RTCM scan output
716//////////////////////////////////////////////////////////////////////////////
717void bncGetThread::miscScanRTCM() {
718
719  if ( !decoder() ) {
720    return;
721  }
722
723  bncSettings settings;
724  if ( Qt::CheckState(settings.value("miscScanRTCM").toInt()) == Qt::Checked ) {
725
726    if ( _miscMount == _staID || _miscMount == "ALL" ) {
727      // RTCM message types
728      // ------------------
729      for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
730        QString type =  QString("%1 ").arg(decoder()->_typeList[ii]);
731        emit(newMessage(_staID + ": Received message type " + type.toAscii(), true));
732      }
733
734      // Check Observation Types
735      // -----------------------
736      for (int ii = 0; ii < decoder()->_obsList.size(); ii++) {
737        t_satObs& obs = decoder()->_obsList[ii];
738        QVector<QString>& rnxTypes = _rnxTypes[obs._prn.system()];
739        bool allFound = true;
740        for (unsigned iFrq = 0; iFrq < obs._obs.size(); iFrq++) {
741          if (obs._obs[iFrq]->_codeValid) {
742            QString rnxStr('C');
743            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
744            if (_format.indexOf("RTCM_2") != -1 ||
745                _format.indexOf("RTCM2") != -1 ||
746                _format.indexOf("RTCM 2") != -1 ) {
747              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
748            }
749            if (rnxTypes.indexOf(rnxStr) == -1) {
750              rnxTypes.push_back(rnxStr);
751              allFound = false;
752            }
753          }
754          if (obs._obs[iFrq]->_phaseValid) {
755            QString rnxStr('L');
756            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
757            if (_format.indexOf("RTCM_2") != -1 ||
758                _format.indexOf("RTCM2") != -1 ||
759                _format.indexOf("RTCM 2") != -1 ) {
760              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
761            }
762            if (rnxTypes.indexOf(rnxStr) == -1) {
763              rnxTypes.push_back(rnxStr);
764              allFound = false;
765            }
766          }
767          if (obs._obs[iFrq]->_dopplerValid){
768            QString rnxStr('D');
769            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
770            if (_format.indexOf("RTCM_2") != -1 ||
771                _format.indexOf("RTCM2") != -1 ||
772                _format.indexOf("RTCM 2") != -1 ) {
773              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
774            }
775            if (rnxTypes.indexOf(rnxStr) == -1) {
776              rnxTypes.push_back(rnxStr);
777              allFound = false;
778            }
779          }
780          if (obs._obs[iFrq]->_snrValid){
781            QString rnxStr('S');
782            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
783            if (_format.indexOf("RTCM_2") != -1 ||
784                _format.indexOf("RTCM2") != -1 ||
785                _format.indexOf("RTCM 2") != -1 ) {
786              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
787            }
788            if (rnxTypes.indexOf(rnxStr) == -1) {
789              rnxTypes.push_back(rnxStr);
790              allFound = false;
791            }
792          }
793        }
794        if (!allFound) {
795          QString msg;
796          QTextStream str(&msg);
797          QString s;
798          str << obs._prn.system() << "    " << s.sprintf("%2d", rnxTypes.size()) << "  ";
799          for (int iType = 0; iType < rnxTypes.size(); iType++) {
800            str << " " << rnxTypes[iType];
801          }
802          emit(newMessage(_staID + ": Observation Types: " + msg.toAscii(), true));
803        }
804      }
805
806      // RTCMv3 antenna descriptor
807      // -------------------------
808      for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
809        QString ant1 =  QString("%1 ").arg(decoder()->_antType[ii]);
810        emit(newMessage(_staID + ": Antenna descriptor " + ant1.toAscii(), true));
811      }
812
813      // RTCM Antenna Coordinates
814      // ------------------------
815      for (int ii=0; ii < decoder()->_antList.size(); ii++) {
816        QByteArray antT;
817        if      (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
818          antT = "ARP";
819        }
820        else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
821          antT = "APC";
822        }
823        QByteArray ant1, ant2, ant3;
824        ant1 = QString("%1 ").arg(decoder()->_antList[ii].xx,0,'f',4).toAscii();
825        ant2 = QString("%1 ").arg(decoder()->_antList[ii].yy,0,'f',4).toAscii();
826        ant3 = QString("%1 ").arg(decoder()->_antList[ii].zz,0,'f',4).toAscii();
827        emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
828        emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
829        emit(newMessage(_staID + ": " + antT + " (ITRF) Z " + ant3 + "m", true));
830        double hh = 0.0;
831        if (decoder()->_antList[ii].height_f) {
832          hh = decoder()->_antList[ii].height;
833          QByteArray ant4 = QString("%1 ").arg(hh,0,'f',4).toAscii();
834          emit(newMessage(_staID + ": Antenna height above marker "  + ant4 + "m", true));
835        }
836        emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
837                       decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
838                       hh, antT));
839      }
840
841      // RTCM GLONASS slots
842      // ------------------
843      if (decoder()->_gloFrq.size()) {
844        bool allFound = true;
845        QString slot = decoder()->_gloFrq;
846        slot.replace("  "," ").replace(" ",":");
847        if (_gloSlots.indexOf(slot) == -1) {
848          _gloSlots.append(slot);
849          allFound = false;
850        }
851        if (!allFound) {
852          _gloSlots.sort();
853          emit(newMessage(_staID + ": GLONASS Slot:Freq "  + _gloSlots.join(" ").toAscii(), true));
854        }
855      }
856    }
857  }
858
859#ifdef MLS_SOFTWARE
860  for (int ii=0; ii <decoder()->_antList.size(); ii++) {
861        QByteArray antT;
862        if      (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
863          antT = "ARP";
864        }
865        else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
866          antT = "APC";
867        }
868        double hh = 0.0;
869        if (decoder()->_antList[ii].height_f) {
870          hh = decoder()->_antList[ii].height;
871        }
872        emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
873                       decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
874                       hh, antT));
875  }
876
877  for (int ii = 0; ii <decoder()->_typeList.size(); ii++) {
878    emit(newRTCMMessage(_staID, decoder()->_typeList[ii]));
879  }
880#endif
881
882  decoder()->_gloFrq.clear();
883  decoder()->_typeList.clear();
884  decoder()->_antType.clear();
885  decoder()->_antList.clear();
886}
887
888// Handle Data from Serial Port
889////////////////////////////////////////////////////////////////////////////
890void bncGetThread::slotSerialReadyRead() {
891
892  if (_serialPort) {
893
894    if (_nmea == "yes" && _serialNMEA == MANUAL_NMEA) {
895      if (_manualNMEASampl) {
896        int dt = _lastManualNMEA.secsTo(QDateTime::currentDateTime());
897        if (dt && (fmod(double(dt), double(_manualNMEASampl)) == 0.0)) {
898          _query->sendNMEA(_manualNMEAString);
899          _lastManualNMEA = QDateTime::currentDateTime();
900        }
901      }
902    }
903
904    int nb = _serialPort->bytesAvailable();
905    if (nb > 0) {
906      QByteArray data = _serialPort->read(nb);
907
908      if (_nmea == "yes" && _serialNMEA == AUTO_NMEA) {
909        int i1 = data.indexOf("$GPGGA");
910        if (i1 == -1) {
911          i1 = data.indexOf("$GNGGA");
912        }
913        if (i1 != -1) {
914          int i2 = data.indexOf("*", i1);
915          if (i2 != -1 && data.size() > i2 + 1) {
916            QByteArray gga = data.mid(i1, i2 - i1 + 3);
917            _query->sendNMEA(gga);
918          }
919        }
920      }
921
922      if (_serialOutFile) {
923        _serialOutFile->write(data);
924        _serialOutFile->flush();
925      }
926    }
927  }
928}
929
930void bncGetThread::slotNewNMEAConnection() {
931  _nmeaSockets->push_back(_nmeaServer->nextPendingConnection());
932  emit( newMessage(QString("New PPP client on port: # %1")
933                   .arg(_nmeaSockets->size()).toAscii(), true) );
934}
935
936//
937////////////////////////////////////////////////////////////////////////////
938void bncGetThread::slotNewNMEAstr(QByteArray staID, QByteArray str) {
939  if (_nmeaPortsMap.contains(staID)) {
940    int nmeaPort = _nmeaPortsMap.value(staID);
941    QMutableListIterator<QTcpSocket*> is(*_nmeaSockets);
942    while (is.hasNext()) {
943      QTcpSocket* sock = is.next();
944      if (sock->localPort() == nmeaPort) {
945        if (sock->state() == QAbstractSocket::ConnectedState) {
946          sock->write(str);
947        }
948        else if (sock->state() != QAbstractSocket::ConnectingState) {
949          delete sock;
950          is.remove();
951        }
952      }
953    }
954  }
955}
Note: See TracBrowser for help on using the repository browser.