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

Last change on this file since 10766 was 10766, checked in by stuerze, 4 weeks ago

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