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

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

minor changes
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
465 qint64 nBytes = data.size();
466
467 // Timeout, reconnect
468 // ------------------
469 if (nBytes == 0) {
470 if (_latencyChecker) {
471 _latencyChecker->checkReconnect();
472 }
473 emit(newMessage(_staID + ": Data timeout, reconnecting", true));
474 msleep(10000); //sleep 10 sec, G. Weber
475 continue;
476 } else {
477 emit newBytes(_staID, nBytes);
478 emit newRawData(_staID, data);
479 }
480
481 // Output Data
482 // -----------
483 if (_rawOutput) {
484 BNC_CORE->writeRawData(data, _staID, _format);
485 }
486
487 if (_serialPort) {
488 slotSerialReadyRead();
489 _serialPort->write(data);
490 }
491
492 // Decode Data
493 // -----------
494 vector<string> errmsg;
495 if (!decoder()) {
496 _isToBeDeleted = true;
497 continue;
498 }
499
500 t_irc irc = decoder()->Decode(data.data(), data.size(), errmsg);
501
502 if (irc != success) {
503 continue;
504 }
505 // Perform various scans and checks
506 // --------------------------------
507 if (_latencyChecker) {
508 _latencyChecker->checkOutage(irc == success);
509 QListIterator<int> it(decoder()->_typeList);
510 _ssrEpoch = decoder()->corrGPSEpochTime();
511 if (_oldSsrEpoch > 0 && _ssrEpoch && _ssrEpoch > _oldSsrEpoch) {
512 if (ssrOrb) {
513 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1057);
514 ssrOrb = false;
515 }
516 if (ssrClk) {
517 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1058);
518 ssrClk = false;
519 }
520 if (ssrOrbClk) {
521 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1060);
522 ssrOrbClk = false;
523 }
524 if (ssrCbi) {
525 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1059);
526 ssrCbi = false;
527 }
528 if (ssrPbi) {
529 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1265);
530 ssrPbi = false;
531 }
532 if (ssrVtec) {
533 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1264);
534 ssrVtec = false;
535 }
536 if (ssrUra) {
537 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1061);
538 ssrUra = false;
539 }
540 if (ssrHr) {
541 _latencyChecker->checkCorrLatency(_oldSsrEpoch, 1062);
542 ssrHr = false;
543 }
544 }
545 while (it.hasNext()) {
546 int rtcmType = it.next();
547 if ((rtcmType >= 1001 && rtcmType <= 1004) || // legacy RTCM OBS
548 (rtcmType >= 1009 && rtcmType <= 1012) || // legacy RTCM OBS
549 (rtcmType >= 1071 && rtcmType <= 1127)) { // MSM RTCM OBS
550 obs = true;
551 } else if ((rtcmType >= 1057 && rtcmType <= 1068) ||
552 (rtcmType >= 1240 && rtcmType <= 1270)) {
553 switch (rtcmType) {
554 case 1057: case 1063: case 1240: case 1246: case 1252: case 1258:
555 ssrOrb = true;
556 break;
557 case 1058: case 1064: case 1241: case 1247: case 1253: case 1259:
558 ssrClk = true;
559 break;
560 case 1060: case 1066: case 1243: case 1249: case 1255: case 1261:
561 ssrOrbClk = true;
562 break;
563 case 1059: case 1065: case 1242: case 1248: case 1254: case 1260:
564 ssrCbi = true;
565 break;
566 case 1265: case 1266: case 1267: case 1268: case 1269: case 1270:
567 ssrPbi = true;
568 break;
569 case 1264:
570 ssrVtec = true;
571 break;
572 case 1061: case 1067: case 1244: case 1250: case 1256: case 1262:
573 ssrUra = true;
574 break;
575 case 1062: case 1068: case 1245: case 1251: case 1257: case 1263:
576 ssrHr = true;
577 break;
578 }
579 }
580 }
581 if (obs) {
582 _latencyChecker->checkObsLatency(decoder()->_obsList);
583 }
584 _oldSsrEpoch = _ssrEpoch;
585 emit newLatency(_staID, _latencyChecker->currentLatency());
586 }
587 miscScanRTCM();
588
589 // Loop over all observations (observations output)
590 // ------------------------------------------------
591 QListIterator<t_satObs> it(decoder()->_obsList);
592
593 QList<t_satObs> obsListHlp;
594
595 while (it.hasNext()) {
596 const t_satObs& obs = it.next();
597
598 // Check observation epoch
599 // -----------------------
600 if (!_rawFile) {
601 bool wrongObservationEpoch = checkForWrongObsEpoch(obs._time);
602 if (wrongObservationEpoch) {
603 QString prn(obs._prn.toString().c_str());
604 emit(newMessage(
605 _staID + " (" + prn.toAscii() + ")"
606 + ": Wrong observation epoch(s)", false));
607 continue;
608 }
609 }
610
611 // Check observations coming twice (e.g. KOUR0 Problem)
612 // ----------------------------------------------------
613 if (!_rawFile) {
614 QString prn(obs._prn.toString().c_str());
615 long iSec = long(floor(obs._time.gpssec() + 0.5));
616 long obsTime = obs._time.gpsw() * 7 * 24 * 3600 + iSec;
617 QMap<QString, long>::const_iterator it = _prnLastEpo.find(prn);
618 if (it != _prnLastEpo.end()) {
619 long oldTime = it.value();
620 if (obsTime < oldTime) {
621 emit(newMessage(_staID + ": old observation " + prn.toAscii(),
622 false));
623 continue;
624 } else if (obsTime == oldTime) {
625 emit(newMessage(
626 _staID + ": observation coming more than once "
627 + prn.toAscii(), false));
628 continue;
629 }
630 }
631 _prnLastEpo[prn] = obsTime;
632 }
633
634 decoder()->dumpRinexEpoch(obs, _format);
635
636 // Save observations
637 // -----------------
638 obsListHlp.append(obs);
639 }
640
641 // Emit signal
642 // -----------
643 if (!_isToBeDeleted && obsListHlp.size() > 0) {
644 emit newObs(_staID, obsListHlp);
645 }
646
647 } catch (Exception& exc) {
648 emit(newMessage(_staID + " " + exc.what(), true));
649 _isToBeDeleted = true;
650 } catch (...) {
651 emit(newMessage(_staID + " bncGetThread exception", true));
652 _isToBeDeleted = true;
653 }
654 }
655}
656
657// Try Re-Connect
658////////////////////////////////////////////////////////////////////////////
659t_irc bncGetThread::tryReconnect() {
660
661 // Easy Return
662 // -----------
663 if (_query && _query->status() == bncNetQuery::running) {
664 _nextSleep = 0;
665 if (_rawFile) {
666 QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
667 while (itDec.hasNext()) {
668 itDec.next();
669 GPSDecoder* decoder = itDec.value();
670 decoder->setRinexReconnectFlag(false);
671 }
672 } else {
673 _decoder->setRinexReconnectFlag(false);
674 }
675 return success;
676 }
677
678 // Start a new query
679 // -----------------
680 if (!_rawFile) {
681
682 sleep(_nextSleep);
683 if (_nextSleep == 0) {
684 _nextSleep = 1;
685 } else {
686 _nextSleep = 2 * _nextSleep;
687 if (_nextSleep > 256) {
688 _nextSleep = 256;
689 }
690#ifdef MLS_SOFTWARE
691 if (_nextSleep > 4) {
692 _nextSleep = 4;
693 }
694#endif
695 }
696 delete _query;
697 if (_ntripVersion == "U") {
698 _query = new bncNetQueryUdp();
699 } else if (_ntripVersion == "R") {
700 _query = new bncNetQueryRtp();
701 } else if (_ntripVersion == "S") {
702 _query = new bncNetQueryS();
703 } else if (_ntripVersion == "N") {
704 _query = new bncNetQueryV0();
705 } else if (_ntripVersion == "UN") {
706 _query = new bncNetQueryUdp0();
707 } else if (_ntripVersion == "2") {
708 _query = new bncNetQueryV2(false);
709 } else if (_ntripVersion == "2s") {
710 _query = new bncNetQueryV2(true);
711 } else {
712 _query = new bncNetQueryV1();
713 }
714 if (_nmea == "yes") {
715 if (_serialNMEA == MANUAL_NMEA) {
716 _query->startRequest(_mountPoint, _manualNMEAString);
717 _lastManualNMEA = QDateTime::currentDateTime();
718 } else if (_serialNMEA == AUTO_NMEA) {
719 if (_serialPort) {
720 int nb = _serialPort->bytesAvailable();
721 if (nb > 0) {
722 QByteArray data = _serialPort->read(nb);
723 int i1 = data.indexOf("$GPGGA");
724 if (i1 == -1) {
725 i1 = data.indexOf("$GNGGA");
726 }
727 if (i1 != -1) {
728 int i2 = data.indexOf("*", i1);
729 if (i2 != -1 && data.size() > i2 + 1) {
730 QByteArray gga = data.mid(i1, i2 - i1 + 3);
731 _query->startRequest(_mountPoint, gga);
732 }
733 }
734 }
735 }
736 }
737 } else {
738 _query->startRequest(_mountPoint, "");
739 }
740
741 if (_query->status() != bncNetQuery::running) {
742 return failure;
743 }
744 }
745
746 if (_rawFile) {
747 QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
748 while (itDec.hasNext()) {
749 itDec.next();
750 GPSDecoder* decoder = itDec.value();
751 decoder->setRinexReconnectFlag(false);
752 }
753 } else {
754 _decoder->setRinexReconnectFlag(false);
755 }
756
757 return success;
758}
759
760// RTCM scan output
761//////////////////////////////////////////////////////////////////////////////
762void bncGetThread::miscScanRTCM() {
763
764 if (!decoder()) {
765 return;
766 }
767
768 bncSettings settings;
769 if (Qt::CheckState(settings.value("miscScanRTCM").toInt()) == Qt::Checked) {
770
771 if (_miscMount == _staID || _miscMount == "ALL") {
772 // RTCM message types
773 // ------------------
774 for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
775 QString type = QString("%1 ").arg(decoder()->_typeList[ii]);
776 emit(newMessage(_staID + ": Received message type " + type.toAscii(),
777 true));
778 }
779
780 // Check Observation Types
781 // -----------------------
782 for (int ii = 0; ii < decoder()->_obsList.size(); ii++) {
783 t_satObs& obs = decoder()->_obsList[ii];
784 QVector<QString>& rnxTypes = _rnxTypes[obs._prn.system()];
785 bool allFound = true;
786 for (unsigned iFrq = 0; iFrq < obs._obs.size(); iFrq++) {
787 if (obs._obs[iFrq]->_codeValid) {
788 QString rnxStr('C');
789 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
790 if (_format.indexOf("RTCM_2") != -1
791 || _format.indexOf("RTCM2") != -1
792 || _format.indexOf("RTCM 2") != -1) {
793 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
794 }
795 if (rnxTypes.indexOf(rnxStr) == -1) {
796 rnxTypes.push_back(rnxStr);
797 allFound = false;
798 }
799 }
800 if (obs._obs[iFrq]->_phaseValid) {
801 QString rnxStr('L');
802 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
803 if (_format.indexOf("RTCM_2") != -1
804 || _format.indexOf("RTCM2") != -1
805 || _format.indexOf("RTCM 2") != -1) {
806 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
807 }
808 if (rnxTypes.indexOf(rnxStr) == -1) {
809 rnxTypes.push_back(rnxStr);
810 allFound = false;
811 }
812 }
813 if (obs._obs[iFrq]->_dopplerValid) {
814 QString rnxStr('D');
815 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
816 if (_format.indexOf("RTCM_2") != -1
817 || _format.indexOf("RTCM2") != -1
818 || _format.indexOf("RTCM 2") != -1) {
819 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
820 }
821 if (rnxTypes.indexOf(rnxStr) == -1) {
822 rnxTypes.push_back(rnxStr);
823 allFound = false;
824 }
825 }
826 if (obs._obs[iFrq]->_snrValid) {
827 QString rnxStr('S');
828 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
829 if (_format.indexOf("RTCM_2") != -1
830 || _format.indexOf("RTCM2") != -1
831 || _format.indexOf("RTCM 2") != -1) {
832 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
833 }
834 if (rnxTypes.indexOf(rnxStr) == -1) {
835 rnxTypes.push_back(rnxStr);
836 allFound = false;
837 }
838 }
839 }
840 if (!allFound) {
841 QString msg;
842 QTextStream str(&msg);
843 QString s;
844 str << obs._prn.system() << " "
845 << s.sprintf("%2d", rnxTypes.size()) << " ";
846 for (int iType = 0; iType < rnxTypes.size(); iType++) {
847 str << " " << rnxTypes[iType];
848 }
849 emit(newMessage(_staID + ": Observation Types: " + msg.toAscii(),
850 true));
851 }
852 }
853
854 // RTCMv3 antenna descriptor
855 // -------------------------
856 for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
857 QString ant1 = QString("%1 ").arg(decoder()->_antType[ii]);
858 emit(newMessage(_staID + ": Antenna descriptor " + ant1.toAscii(), true));
859 }
860
861 // RTCM Antenna Coordinates
862 // ------------------------
863 for (int ii = 0; ii < decoder()->_antList.size(); ii++) {
864 QByteArray antT;
865 if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
866 antT = "ARP";
867 } else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
868 antT = "APC";
869 }
870 QByteArray ant1, ant2, ant3;
871 ant1 =
872 QString("%1 ").arg(decoder()->_antList[ii].xx, 0, 'f', 4).toAscii();
873 ant2 =
874 QString("%1 ").arg(decoder()->_antList[ii].yy, 0, 'f', 4).toAscii();
875 ant3 =
876 QString("%1 ").arg(decoder()->_antList[ii].zz, 0, 'f', 4).toAscii();
877 emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
878 emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
879 emit(newMessage(_staID + ": " + antT + " (ITRF) Z " + ant3 + "m", true));
880 double hh = 0.0;
881 if (decoder()->_antList[ii].height_f) {
882 hh = decoder()->_antList[ii].height;
883 QByteArray ant4 = QString("%1 ").arg(hh, 0, 'f', 4).toAscii();
884 emit(newMessage(
885 _staID + ": Antenna height above marker " + ant4 + "m", true));
886 }
887 emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
888 decoder()->_antList[ii].yy, decoder()->_antList[ii].zz, hh, antT));
889 }
890
891 // RTCM GLONASS slots
892 // ------------------
893 if (decoder()->_gloFrq.size()) {
894 bool allFound = true;
895 QString slot = decoder()->_gloFrq;
896 slot.replace(" ", " ").replace(" ", ":");
897 if (_gloSlots.indexOf(slot) == -1) {
898 _gloSlots.append(slot);
899 allFound = false;
900 }
901 if (!allFound) {
902 _gloSlots.sort();
903 emit(newMessage(
904 _staID + ": GLONASS Slot:Freq " + _gloSlots.join(" ").toAscii(),
905 true));
906 }
907 }
908 }
909 }
910
911#ifdef MLS_SOFTWARE
912 for (int ii=0; ii <decoder()->_antList.size(); ii++) {
913 QByteArray antT;
914 if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
915 antT = "ARP";
916 }
917 else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
918 antT = "APC";
919 }
920 double hh = 0.0;
921 if (decoder()->_antList[ii].height_f) {
922 hh = decoder()->_antList[ii].height;
923 }
924 emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
925 decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
926 hh, antT));
927 }
928
929 for (int ii = 0; ii <decoder()->_typeList.size(); ii++) {
930 emit(newRTCMMessage(_staID, decoder()->_typeList[ii]));
931 }
932#endif
933
934 decoder()->_gloFrq.clear();
935 decoder()->_typeList.clear();
936 decoder()->_antType.clear();
937 decoder()->_antList.clear();
938}
939
940// Handle Data from Serial Port
941////////////////////////////////////////////////////////////////////////////
942void bncGetThread::slotSerialReadyRead() {
943
944 if (_serialPort) {
945
946 if (_nmea == "yes" && _serialNMEA == MANUAL_NMEA) {
947 if (_manualNMEASampl) {
948 int dt = _lastManualNMEA.secsTo(QDateTime::currentDateTime());
949 if (dt && (fmod(double(dt), double(_manualNMEASampl)) == 0.0)) {
950 _query->sendNMEA(_manualNMEAString);
951 _lastManualNMEA = QDateTime::currentDateTime();
952 }
953 }
954 }
955
956 int nb = _serialPort->bytesAvailable();
957 if (nb > 0) {
958 QByteArray data = _serialPort->read(nb);
959
960 if (_nmea == "yes" && _serialNMEA == AUTO_NMEA) {
961 int i1 = data.indexOf("$GPGGA");
962 if (i1 == -1) {
963 i1 = data.indexOf("$GNGGA");
964 }
965 if (i1 != -1) {
966 int i2 = data.indexOf("*", i1);
967 if (i2 != -1 && data.size() > i2 + 1) {
968 QByteArray gga = data.mid(i1, i2 - i1 + 3);
969 _query->sendNMEA(gga);
970 }
971 }
972 }
973
974 if (_serialOutFile) {
975 _serialOutFile->write(data);
976 _serialOutFile->flush();
977 }
978 }
979 }
980}
981
982void bncGetThread::slotNewNMEAConnection() {
983 _nmeaSockets->push_back(_nmeaServer->nextPendingConnection());
984 emit(newMessage(
985 QString("New PPP client on port: # %1").arg(_nmeaSockets->size()).toAscii(),
986 true));
987}
988
989//
990////////////////////////////////////////////////////////////////////////////
991void bncGetThread::slotNewNMEAstr(QByteArray staID, QByteArray str) {
992 if (_nmeaPortsMap.contains(staID)) {
993 int nmeaPort = _nmeaPortsMap.value(staID);
994 QMutableListIterator<QTcpSocket*> is(*_nmeaSockets);
995 while (is.hasNext()) {
996 QTcpSocket* sock = is.next();
997 if (sock->localPort() == nmeaPort) {
998 if (sock->state() == QAbstractSocket::ConnectedState) {
999 sock->write(str);
1000 } else if (sock->state() != QAbstractSocket::ConnectingState) {
1001 delete sock;
1002 is.remove();
1003 }
1004 }
1005 }
1006 }
1007}
Note: See TracBrowser for help on using the repository browser.