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

Last change on this file since 8488 was 8417, checked in by stuerze, 6 years ago

some changes to allow 10 Hz observation data real-time processing

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