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

Last change on this file since 7976 was 7976, checked in by stuerze, 4 years ago

mionor changes to allow programm interruption by Ctrl+C in case of raw file processing

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        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    if (_query) {
644      delete _query;
645    }
646    if      (_ntripVersion == "U") {
647      _query = new bncNetQueryUdp();
648    }
649    else if (_ntripVersion == "R") {
650      _query = new bncNetQueryRtp();
651    }
652    else if (_ntripVersion == "S") {
653      _query = new bncNetQueryS();
654    }
655    else if (_ntripVersion == "N") {
656      _query = new bncNetQueryV0();
657    }
658    else if (_ntripVersion == "UN") {
659      _query = new bncNetQueryUdp0();
660    }
661    else if (_ntripVersion == "2") {
662      _query = new bncNetQueryV2(false);
663    }
664    else if (_ntripVersion == "2s") {
665      _query = new bncNetQueryV2(true);
666    }
667    else {
668      _query = new bncNetQueryV1();
669    }
670    if (_nmea == "yes") {
671      if (_serialNMEA == MANUAL_NMEA) {
672        _query->startRequest(_mountPoint, _manualNMEAString);
673        _lastManualNMEA = QDateTime::currentDateTime();
674      }
675      else if (_serialNMEA == AUTO_NMEA) {
676        if (_serialPort) {
677          int nb = _serialPort->bytesAvailable();
678          if (nb > 0) {
679            QByteArray data = _serialPort->read(nb);
680            int i1 = data.indexOf("$GPGGA");
681            if (i1 == -1) {
682              i1 = data.indexOf("$GNGGA");
683            }
684            if (i1 != -1) {
685              int i2 = data.indexOf("*", i1);
686              if (i2 != -1 && data.size() > i2 + 1) {
687                QByteArray gga = data.mid(i1, i2 - i1 + 3);
688                _query->startRequest(_mountPoint, gga);
689              }
690            }
691          }
692        }
693      }
694    }
695    else {
696      _query->startRequest(_mountPoint, "");
697    }
698
699    if (_query->status() != bncNetQuery::running) {
700      return failure;
701    }
702  }
703
704  if (_rawFile) {
705    QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
706    while (itDec.hasNext()) {
707      itDec.next();
708      GPSDecoder* decoder = itDec.value();
709      decoder->setRinexReconnectFlag(false);
710    }
711  }
712  else {
713   _decoder->setRinexReconnectFlag(false);
714  }
715
716  return success;
717}
718
719// RTCM scan output
720//////////////////////////////////////////////////////////////////////////////
721void bncGetThread::miscScanRTCM() {
722
723  if ( !decoder() ) {
724    return;
725  }
726
727  bncSettings settings;
728  if ( Qt::CheckState(settings.value("miscScanRTCM").toInt()) == Qt::Checked ) {
729
730    if ( _miscMount == _staID || _miscMount == "ALL" ) {
731      // RTCM message types
732      // ------------------
733      for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
734        QString type =  QString("%1 ").arg(decoder()->_typeList[ii]);
735        emit(newMessage(_staID + ": Received message type " + type.toAscii(), true));
736      }
737
738      // Check Observation Types
739      // -----------------------
740      for (int ii = 0; ii < decoder()->_obsList.size(); ii++) {
741        t_satObs& obs = decoder()->_obsList[ii];
742        QVector<QString>& rnxTypes = _rnxTypes[obs._prn.system()];
743        bool allFound = true;
744        for (unsigned iFrq = 0; iFrq < obs._obs.size(); iFrq++) {
745          if (obs._obs[iFrq]->_codeValid) {
746            QString rnxStr('C');
747            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
748            if (_format.indexOf("RTCM_2") != -1 ||
749                _format.indexOf("RTCM2") != -1 ||
750                _format.indexOf("RTCM 2") != -1 ) {
751              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
752            }
753            if (rnxTypes.indexOf(rnxStr) == -1) {
754              rnxTypes.push_back(rnxStr);
755              allFound = false;
756            }
757          }
758          if (obs._obs[iFrq]->_phaseValid) {
759            QString rnxStr('L');
760            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
761            if (_format.indexOf("RTCM_2") != -1 ||
762                _format.indexOf("RTCM2") != -1 ||
763                _format.indexOf("RTCM 2") != -1 ) {
764              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
765            }
766            if (rnxTypes.indexOf(rnxStr) == -1) {
767              rnxTypes.push_back(rnxStr);
768              allFound = false;
769            }
770          }
771          if (obs._obs[iFrq]->_dopplerValid){
772            QString rnxStr('D');
773            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
774            if (_format.indexOf("RTCM_2") != -1 ||
775                _format.indexOf("RTCM2") != -1 ||
776                _format.indexOf("RTCM 2") != -1 ) {
777              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
778            }
779            if (rnxTypes.indexOf(rnxStr) == -1) {
780              rnxTypes.push_back(rnxStr);
781              allFound = false;
782            }
783          }
784          if (obs._obs[iFrq]->_snrValid){
785            QString rnxStr('S');
786            rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
787            if (_format.indexOf("RTCM_2") != -1 ||
788                _format.indexOf("RTCM2") != -1 ||
789                _format.indexOf("RTCM 2") != -1 ) {
790              rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
791            }
792            if (rnxTypes.indexOf(rnxStr) == -1) {
793              rnxTypes.push_back(rnxStr);
794              allFound = false;
795            }
796          }
797        }
798        if (!allFound) {
799          QString msg;
800          QTextStream str(&msg);
801          QString s;
802          str << obs._prn.system() << "    " << s.sprintf("%2d", rnxTypes.size()) << "  ";
803          for (int iType = 0; iType < rnxTypes.size(); iType++) {
804            str << " " << rnxTypes[iType];
805          }
806          emit(newMessage(_staID + ": Observation Types: " + msg.toAscii(), true));
807        }
808      }
809
810      // RTCMv3 antenna descriptor
811      // -------------------------
812      for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
813        QString ant1 =  QString("%1 ").arg(decoder()->_antType[ii]);
814        emit(newMessage(_staID + ": Antenna descriptor " + ant1.toAscii(), true));
815      }
816
817      // RTCM Antenna Coordinates
818      // ------------------------
819      for (int ii=0; ii < decoder()->_antList.size(); ii++) {
820        QByteArray antT;
821        if      (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
822          antT = "ARP";
823        }
824        else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
825          antT = "APC";
826        }
827        QByteArray ant1, ant2, ant3;
828        ant1 = QString("%1 ").arg(decoder()->_antList[ii].xx,0,'f',4).toAscii();
829        ant2 = QString("%1 ").arg(decoder()->_antList[ii].yy,0,'f',4).toAscii();
830        ant3 = QString("%1 ").arg(decoder()->_antList[ii].zz,0,'f',4).toAscii();
831        emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
832        emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
833        emit(newMessage(_staID + ": " + antT + " (ITRF) Z " + ant3 + "m", true));
834        double hh = 0.0;
835        if (decoder()->_antList[ii].height_f) {
836          hh = decoder()->_antList[ii].height;
837          QByteArray ant4 = QString("%1 ").arg(hh,0,'f',4).toAscii();
838          emit(newMessage(_staID + ": Antenna height above marker "  + ant4 + "m", true));
839        }
840        emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
841                       decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
842                       hh, antT));
843      }
844
845      // RTCM GLONASS slots
846      // ------------------
847      if (decoder()->_gloFrq.size()) {
848        bool allFound = true;
849        QString slot = decoder()->_gloFrq;
850        slot.replace("  "," ").replace(" ",":");
851        if (_gloSlots.indexOf(slot) == -1) {
852          _gloSlots.append(slot);
853          allFound = false;
854        }
855        if (!allFound) {
856          _gloSlots.sort();
857          emit(newMessage(_staID + ": GLONASS Slot:Freq "  + _gloSlots.join(" ").toAscii(), true));
858        }
859      }
860    }
861  }
862
863#ifdef MLS_SOFTWARE
864  for (int ii=0; ii <decoder()->_antList.size(); ii++) {
865        QByteArray antT;
866        if      (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
867          antT = "ARP";
868        }
869        else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
870          antT = "APC";
871        }
872        double hh = 0.0;
873        if (decoder()->_antList[ii].height_f) {
874          hh = decoder()->_antList[ii].height;
875        }
876        emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
877                       decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
878                       hh, antT));
879  }
880
881  for (int ii = 0; ii <decoder()->_typeList.size(); ii++) {
882    emit(newRTCMMessage(_staID, decoder()->_typeList[ii]));
883  }
884#endif
885
886  decoder()->_gloFrq.clear();
887  decoder()->_typeList.clear();
888  decoder()->_antType.clear();
889  decoder()->_antList.clear();
890}
891
892// Handle Data from Serial Port
893////////////////////////////////////////////////////////////////////////////
894void bncGetThread::slotSerialReadyRead() {
895
896  if (_serialPort) {
897
898    if (_nmea == "yes" && _serialNMEA == MANUAL_NMEA) {
899      if (_manualNMEASampl) {
900        int dt = _lastManualNMEA.secsTo(QDateTime::currentDateTime());
901        if (dt && (fmod(double(dt), double(_manualNMEASampl)) == 0.0)) {
902          _query->sendNMEA(_manualNMEAString);
903          _lastManualNMEA = QDateTime::currentDateTime();
904        }
905      }
906    }
907
908    int nb = _serialPort->bytesAvailable();
909    if (nb > 0) {
910      QByteArray data = _serialPort->read(nb);
911
912      if (_nmea == "yes" && _serialNMEA == AUTO_NMEA) {
913        int i1 = data.indexOf("$GPGGA");
914        if (i1 == -1) {
915          i1 = data.indexOf("$GNGGA");
916        }
917        if (i1 != -1) {
918          int i2 = data.indexOf("*", i1);
919          if (i2 != -1 && data.size() > i2 + 1) {
920            QByteArray gga = data.mid(i1, i2 - i1 + 3);
921            _query->sendNMEA(gga);
922          }
923        }
924      }
925
926      if (_serialOutFile) {
927        _serialOutFile->write(data);
928        _serialOutFile->flush();
929      }
930    }
931  }
932}
933
934void bncGetThread::slotNewNMEAConnection() {
935  _nmeaSockets->push_back(_nmeaServer->nextPendingConnection());
936  emit( newMessage(QString("New PPP client on port: # %1")
937                   .arg(_nmeaSockets->size()).toAscii(), true) );
938}
939
940//
941////////////////////////////////////////////////////////////////////////////
942void bncGetThread::slotNewNMEAstr(QByteArray staID, QByteArray str) {
943  if (_nmeaPortsMap.contains(staID)) {
944    int nmeaPort = _nmeaPortsMap.value(staID);
945    QMutableListIterator<QTcpSocket*> is(*_nmeaSockets);
946    while (is.hasNext()) {
947      QTcpSocket* sock = is.next();
948      if (sock->localPort() == nmeaPort) {
949        if (sock->state() == QAbstractSocket::ConnectedState) {
950          sock->write(str);
951        }
952        else if (sock->state() != QAbstractSocket::ConnectingState) {
953          delete sock;
954          is.remove();
955        }
956      }
957    }
958  }
959}
Note: See TracBrowser for help on using the repository browser.