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

Last change on this file since 10501 was 10470, checked in by stuerze, 6 months ago

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