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

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

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