source: ntrip/branches/BNC_2.12/src/bncgetthread.cpp@ 8200

Last change on this file since 8200 was 8200, checked in by stuerze, 4 years ago

receiver type extraction from 1033 RTCM3 messages is added

File size: 30.3 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 delete _query;
696 if (_ntripVersion == "U") {
697 _query = new bncNetQueryUdp();
698 } else if (_ntripVersion == "R") {
699 _query = new bncNetQueryRtp();
700 } else if (_ntripVersion == "S") {
701 _query = new bncNetQueryS();
702 } else if (_ntripVersion == "N") {
703 _query = new bncNetQueryV0();
704 } else if (_ntripVersion == "UN") {
705 _query = new bncNetQueryUdp0();
706 } else if (_ntripVersion == "2") {
707 _query = new bncNetQueryV2(false);
708 } else if (_ntripVersion == "2s") {
709 _query = new bncNetQueryV2(true);
710 } else {
711 _query = new bncNetQueryV1();
712 }
713 if (_nmea == "yes") {
714 if (_serialNMEA == MANUAL_NMEA) {
715 _query->startRequest(_mountPoint, _manualNMEAString);
716 _lastManualNMEA = QDateTime::currentDateTime();
717 } else if (_serialNMEA == AUTO_NMEA) {
718 if (_serialPort) {
719 int nb = _serialPort->bytesAvailable();
720 if (nb > 0) {
721 QByteArray data = _serialPort->read(nb);
722 int i1 = data.indexOf("$GPGGA");
723 if (i1 == -1) {
724 i1 = data.indexOf("$GNGGA");
725 }
726 if (i1 != -1) {
727 int i2 = data.indexOf("*", i1);
728 if (i2 != -1 && data.size() > i2 + 1) {
729 QByteArray gga = data.mid(i1, i2 - i1 + 3);
730 _query->startRequest(_mountPoint, gga);
731 }
732 }
733 }
734 }
735 }
736 } else {
737 _query->startRequest(_mountPoint, "");
738 }
739
740 if (_query->status() != bncNetQuery::running) {
741 return failure;
742 }
743 }
744
745 if (_rawFile) {
746 QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
747 while (itDec.hasNext()) {
748 itDec.next();
749 GPSDecoder* decoder = itDec.value();
750 decoder->setRinexReconnectFlag(false);
751 }
752 } else {
753 _decoder->setRinexReconnectFlag(false);
754 }
755
756 return success;
757}
758
759// RTCM scan output
760//////////////////////////////////////////////////////////////////////////////
761void bncGetThread::miscScanRTCM() {
762
763 if (!decoder()) {
764 return;
765 }
766
767 bncSettings settings;
768 if (Qt::CheckState(settings.value("miscScanRTCM").toInt()) == Qt::Checked) {
769
770 if (_miscMount == _staID || _miscMount == "ALL") {
771 // RTCM message types
772 // ------------------
773 for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
774 QString type = QString("%1 ").arg(decoder()->_typeList[ii]);
775 emit(newMessage(_staID + ": Received message type " + type.toAscii(),
776 true));
777 }
778
779 // Check Observation Types
780 // -----------------------
781 for (int ii = 0; ii < decoder()->_obsList.size(); ii++) {
782 t_satObs& obs = decoder()->_obsList[ii];
783 QVector<QString>& rnxTypes = _rnxTypes[obs._prn.system()];
784 bool allFound = true;
785 for (unsigned iFrq = 0; iFrq < obs._obs.size(); iFrq++) {
786 if (obs._obs[iFrq]->_codeValid) {
787 QString rnxStr('C');
788 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
789 if (_format.indexOf("RTCM_2") != -1
790 || _format.indexOf("RTCM2") != -1
791 || _format.indexOf("RTCM 2") != -1) {
792 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
793 }
794 if (rnxTypes.indexOf(rnxStr) == -1) {
795 rnxTypes.push_back(rnxStr);
796 allFound = false;
797 }
798 }
799 if (obs._obs[iFrq]->_phaseValid) {
800 QString rnxStr('L');
801 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
802 if (_format.indexOf("RTCM_2") != -1
803 || _format.indexOf("RTCM2") != -1
804 || _format.indexOf("RTCM 2") != -1) {
805 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
806 }
807 if (rnxTypes.indexOf(rnxStr) == -1) {
808 rnxTypes.push_back(rnxStr);
809 allFound = false;
810 }
811 }
812 if (obs._obs[iFrq]->_dopplerValid) {
813 QString rnxStr('D');
814 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
815 if (_format.indexOf("RTCM_2") != -1
816 || _format.indexOf("RTCM2") != -1
817 || _format.indexOf("RTCM 2") != -1) {
818 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
819 }
820 if (rnxTypes.indexOf(rnxStr) == -1) {
821 rnxTypes.push_back(rnxStr);
822 allFound = false;
823 }
824 }
825 if (obs._obs[iFrq]->_snrValid) {
826 QString rnxStr('S');
827 rnxStr.append(obs._obs[iFrq]->_rnxType2ch.c_str());
828 if (_format.indexOf("RTCM_2") != -1
829 || _format.indexOf("RTCM2") != -1
830 || _format.indexOf("RTCM 2") != -1) {
831 rnxStr = t_rnxObsFile::type3to2(obs._prn.system(), rnxStr);
832 }
833 if (rnxTypes.indexOf(rnxStr) == -1) {
834 rnxTypes.push_back(rnxStr);
835 allFound = false;
836 }
837 }
838 }
839 if (!allFound) {
840 QString msg;
841 QTextStream str(&msg);
842 QString s;
843 str << obs._prn.system() << " "
844 << s.sprintf("%2d", rnxTypes.size()) << " ";
845 for (int iType = 0; iType < rnxTypes.size(); iType++) {
846 str << " " << rnxTypes[iType];
847 }
848 emit(newMessage(_staID + ": Observation Types: " + msg.toAscii(),
849 true));
850 }
851 }
852
853 // RTCMv3 antenna descriptor
854 // -------------------------
855 for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
856 QString ant1 = QString("%1 ").arg(decoder()->_antType[ii]);
857 emit(newMessage(_staID + ": Antenna descriptor " + ant1.toAscii(), true));
858 }
859
860 // RTCM Antenna Coordinates
861 // ------------------------
862 for (int ii = 0; ii < decoder()->_antList.size(); ii++) {
863 QByteArray antT;
864 if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
865 antT = "ARP";
866 } else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
867 antT = "APC";
868 }
869 QByteArray ant1, ant2, ant3;
870 ant1 =
871 QString("%1 ").arg(decoder()->_antList[ii].xx, 0, 'f', 4).toAscii();
872 ant2 =
873 QString("%1 ").arg(decoder()->_antList[ii].yy, 0, 'f', 4).toAscii();
874 ant3 =
875 QString("%1 ").arg(decoder()->_antList[ii].zz, 0, 'f', 4).toAscii();
876 emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
877 emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
878 emit(newMessage(_staID + ": " + antT + " (ITRF) Z " + ant3 + "m", true));
879 double hh = 0.0;
880 if (decoder()->_antList[ii].height_f) {
881 hh = decoder()->_antList[ii].height;
882 QByteArray ant4 = QString("%1 ").arg(hh, 0, 'f', 4).toAscii();
883 emit(newMessage(
884 _staID + ": Antenna height above marker " + ant4 + "m", true));
885 }
886 emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
887 decoder()->_antList[ii].yy, decoder()->_antList[ii].zz, hh, antT));
888 }
889
890 // RTCMv3 receiver descriptor
891 // --------------------------
892 for (int ii = 0; ii < decoder()->_recType.size(); ii++) {
893 QString rec1 = QString("%1 ").arg(decoder()->_recType[ii]);
894 emit(newMessage(_staID + ": Receiver descriptor " + rec1.toLatin1(), true));
895 }
896
897 // RTCM GLONASS slots
898 // ------------------
899 if (decoder()->_gloFrq.size()) {
900 bool allFound = true;
901 QString slot = decoder()->_gloFrq;
902 slot.replace(" ", " ").replace(" ", ":");
903 if (_gloSlots.indexOf(slot) == -1) {
904 _gloSlots.append(slot);
905 allFound = false;
906 }
907 if (!allFound) {
908 _gloSlots.sort();
909 emit(newMessage(
910 _staID + ": GLONASS Slot:Freq " + _gloSlots.join(" ").toAscii(),
911 true));
912 }
913 }
914 }
915 }
916
917#ifdef MLS_SOFTWARE
918 for (int ii=0; ii <decoder()->_antList.size(); ii++) {
919 QByteArray antT;
920 if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
921 antT = "ARP";
922 }
923 else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
924 antT = "APC";
925 }
926 double hh = 0.0;
927 if (decoder()->_antList[ii].height_f) {
928 hh = decoder()->_antList[ii].height;
929 }
930 emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
931 decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
932 hh, antT));
933 }
934
935 for (int ii = 0; ii <decoder()->_typeList.size(); ii++) {
936 emit(newRTCMMessage(_staID, decoder()->_typeList[ii]));
937 }
938#endif
939
940 decoder()->_gloFrq.clear();
941 decoder()->_typeList.clear();
942 decoder()->_antType.clear();
943 decoder()->_recType.clear();
944 decoder()->_antList.clear();
945}
946
947// Handle Data from Serial Port
948////////////////////////////////////////////////////////////////////////////
949void bncGetThread::slotSerialReadyRead() {
950
951 if (_serialPort) {
952
953 if (_nmea == "yes" && _serialNMEA == MANUAL_NMEA) {
954 if (_manualNMEASampl) {
955 int dt = _lastManualNMEA.secsTo(QDateTime::currentDateTime());
956 if (dt && (fmod(double(dt), double(_manualNMEASampl)) == 0.0)) {
957 _query->sendNMEA(_manualNMEAString);
958 _lastManualNMEA = QDateTime::currentDateTime();
959 }
960 }
961 }
962
963 int nb = _serialPort->bytesAvailable();
964 if (nb > 0) {
965 QByteArray data = _serialPort->read(nb);
966
967 if (_nmea == "yes" && _serialNMEA == AUTO_NMEA) {
968 int i1 = data.indexOf("$GPGGA");
969 if (i1 == -1) {
970 i1 = data.indexOf("$GNGGA");
971 }
972 if (i1 != -1) {
973 int i2 = data.indexOf("*", i1);
974 if (i2 != -1 && data.size() > i2 + 1) {
975 QByteArray gga = data.mid(i1, i2 - i1 + 3);
976 _query->sendNMEA(gga);
977 }
978 }
979 }
980
981 if (_serialOutFile) {
982 _serialOutFile->write(data);
983 _serialOutFile->flush();
984 }
985 }
986 }
987}
988
989void bncGetThread::slotNewNMEAConnection() {
990 _nmeaSockets->push_back(_nmeaServer->nextPendingConnection());
991 emit(newMessage(
992 QString("New PPP client on port: # %1").arg(_nmeaSockets->size()).toAscii(),
993 true));
994}
995
996//
997////////////////////////////////////////////////////////////////////////////
998void bncGetThread::slotNewNMEAstr(QByteArray staID, QByteArray str) {
999 if (_nmeaPortsMap.contains(staID)) {
1000 int nmeaPort = _nmeaPortsMap.value(staID);
1001 QMutableListIterator<QTcpSocket*> is(*_nmeaSockets);
1002 while (is.hasNext()) {
1003 QTcpSocket* sock = is.next();
1004 if (sock->localPort() == nmeaPort) {
1005 if (sock->state() == QAbstractSocket::ConnectedState) {
1006 sock->write(str);
1007 } else if (sock->state() != QAbstractSocket::ConnectingState) {
1008 delete sock;
1009 is.remove();
1010 }
1011 }
1012 }
1013 }
1014}
Note: See TracBrowser for help on using the repository browser.