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

Last change on this file since 8413 was 8271, checked in by stuerze, 7 years ago

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