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

Last change on this file since 9942 was 9865, checked in by stuerze, 2 years ago

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