Context Navigation

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

Last change on this file since 6429 was 6137, checked in by mervart, 10 years ago

File size: 21.5 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
70	using namespace std;
71
72	// Constructor 1
73	////////////////////////////////////////////////////////////////////////////
74	bncGetThread::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	////////////////////////////////////////////////////////////////////////////
87	bncGetThread::bncGetThread(const QUrl& mountPoint,
88	const QByteArray& format,
89	const QByteArray& latitude,
90	const QByteArray& longitude,
91	const QByteArray& nmea,
92	const QByteArray& ntripVersion) {
93	_rawFile = 0;
94	_mountPoint = mountPoint;
95	_staID = mountPoint.path().mid(1).toAscii();
96	_format = format;
97	_latitude = latitude;
98	_longitude = longitude;
99	_nmea = nmea;
100	_ntripVersion = ntripVersion;
101
102	bncSettings settings;
103	if (!settings.value("rawOutFile").toString().isEmpty()) {
104	_rawOutput = true;
105	} else {
106	_rawOutput = false;
107	}
108
109	initialize();
110	initDecoder();
111	}
112
113	// Initialization (common part of the constructor)
114	////////////////////////////////////////////////////////////////////////////
115	void bncGetThread::initialize() {
116
117	bncSettings settings;
118
119	setTerminationEnabled(true);
120
121	connect(this, SIGNAL(newMessage(QByteArray,bool)),
122	BNC_CORE, SLOT(slotMessage(const QByteArray,bool)));
123
124	_isToBeDeleted = false;
125	_query = 0;
126	_nextSleep = 0;
127	_miscMount = settings.value("miscMount").toString();
128	_decoder = 0;
129
130	// Serial Port
131	// -----------
132	_serialNMEA = NO_NMEA;
133	_serialOutFile = 0;
134	_serialPort = 0;
135
136	if (!_staID.isEmpty() &&
137	settings.value("serialMountPoint").toString() == _staID) {
138	_serialPort = new QextSerialPort(settings.value("serialPortName").toString() );
139	_serialPort->setTimeout(0,100);
140
141	// Baud Rate
142	// ---------
143	QString hlp = settings.value("serialBaudRate").toString();
144	if (hlp == "110") {
145	_serialPort->setBaudRate(BAUD110);
146	}
147	else if (hlp == "300") {
148	_serialPort->setBaudRate(BAUD300);
149	}
150	else if (hlp == "600") {
151	_serialPort->setBaudRate(BAUD600);
152	}
153	else if (hlp == "1200") {
154	_serialPort->setBaudRate(BAUD1200);
155	}
156	else if (hlp == "2400") {
157	_serialPort->setBaudRate(BAUD2400);
158	}
159	else if (hlp == "4800") {
160	_serialPort->setBaudRate(BAUD4800);
161	}
162	else if (hlp == "9600") {
163	_serialPort->setBaudRate(BAUD9600);
164	}
165	else if (hlp == "19200") {
166	_serialPort->setBaudRate(BAUD19200);
167	}
168	else if (hlp == "38400") {
169	_serialPort->setBaudRate(BAUD38400);
170	}
171	else if (hlp == "57600") {
172	_serialPort->setBaudRate(BAUD57600);
173	}
174	else if (hlp == "115200") {
175	_serialPort->setBaudRate(BAUD115200);
176	}
177
178	// Parity
179	// ------
180	hlp = settings.value("serialParity").toString();
181	if (hlp == "NONE") {
182	_serialPort->setParity(PAR_NONE);
183	}
184	else if (hlp == "ODD") {
185	_serialPort->setParity(PAR_ODD);
186	}
187	else if (hlp == "EVEN") {
188	_serialPort->setParity(PAR_EVEN);
189	}
190	else if (hlp == "SPACE") {
191	_serialPort->setParity(PAR_SPACE);
192	}
193
194	// Data Bits
195	// ---------
196	hlp = settings.value("serialDataBits").toString();
197	if (hlp == "5") {
198	_serialPort->setDataBits(DATA_5);
199	}
200	else if (hlp == "6") {
201	_serialPort->setDataBits(DATA_6);
202	}
203	else if (hlp == "7") {
204	_serialPort->setDataBits(DATA_7);
205	}
206	else if (hlp == "8") {
207	_serialPort->setDataBits(DATA_8);
208	}
209	hlp = settings.value("serialStopBits").toString();
210	if (hlp == "1") {
211	_serialPort->setStopBits(STOP_1);
212	}
213	else if (hlp == "2") {
214	_serialPort->setStopBits(STOP_2);
215	}
216
217	// Flow Control
218	// ------------
219	hlp = settings.value("serialFlowControl").toString();
220	if (hlp == "XONXOFF") {
221	_serialPort->setFlowControl(FLOW_XONXOFF);
222	}
223	else if (hlp == "HARDWARE") {
224	_serialPort->setFlowControl(FLOW_HARDWARE);
225	}
226	else {
227	_serialPort->setFlowControl(FLOW_OFF);
228	}
229
230	// Open Serial Port
231	// ----------------
232	_serialPort->open(QIODevice::ReadWrite\|QIODevice::Unbuffered);
233	if (!_serialPort->isOpen()) {
234	delete _serialPort;
235	_serialPort = 0;
236	emit(newMessage((_staID + ": Cannot open serial port\n"), true));
237	}
238	connect(_serialPort, SIGNAL(readyRead()),
239	this, SLOT(slotSerialReadyRead()));
240
241	// Automatic NMEA
242	// --------------
243	if (settings.value("serialAutoNMEA").toString() == "Auto") {
244	_serialNMEA = AUTO_NMEA;
245
246	QString fName = settings.value("serialFileNMEA").toString();
247	if (!fName.isEmpty()) {
248	_serialOutFile = new QFile(fName);
249	if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
250	_serialOutFile->open(QIODevice::WriteOnly \| QIODevice::Append);
251	}
252	else {
253	_serialOutFile->open(QIODevice::WriteOnly);
254	}
255	}
256	}
257
258	// Manual NMEA
259	// -----------
260	else {
261	_serialNMEA = MANUAL_NMEA;
262	}
263	}
264
265	if (!_staID.isEmpty()) {
266	_latencyChecker = new latencyChecker(_staID);
267	}
268	else {
269	_latencyChecker = 0;
270	}
271	}
272
273	// Instantiate the decoder
274	//////////////////////////////////////////////////////////////////////////////
275	t_irc bncGetThread::initDecoder() {
276
277	_decoder = 0;
278
279	if (_format.indexOf("RTCM_2") != -1 \|\| _format.indexOf("RTCM2") != -1 \|\|
280	_format.indexOf("RTCM 2") != -1 ) {
281	emit(newMessage(_staID + ": Get data in RTCM 2.x format", true));
282	_decoder = new RTCM2Decoder(_staID.data());
283	}
284	else if (_format.indexOf("RTCM_3") != -1 \|\| _format.indexOf("RTCM3") != -1 \|\|
285	_format.indexOf("RTCM 3") != -1 ) {
286	emit(newMessage(_staID + ": Get data in RTCM 3.x format", true));
287	RTCM3Decoder* newDecoder = new RTCM3Decoder(_staID, _rawFile);
288	_decoder = newDecoder;
289	connect((RTCM3Decoder*) newDecoder, SIGNAL(newMessage(QByteArray,bool)),
290	this, SIGNAL(newMessage(QByteArray,bool)));
291	}
292	else if (_format.indexOf("ZERO") != -1) {
293	emit(newMessage(_staID + ": Get data in original format", true));
294	_decoder = new bncZeroDecoder(_staID);
295	}
296	else if (_format.indexOf("RTNET") != -1) {
297	emit(newMessage(_staID + ": Get data in RTNet format", true));
298	_decoder = new bncRtnetDecoder();
299	}
300	else {
301	emit(newMessage(_staID + ": Unknown data format " + _format, true));
302	_isToBeDeleted = true;
303	return failure;
304	}
305
306	msleep(100); //sleep 0.1 sec
307
308	_decoder->initRinex(_staID, _mountPoint, _latitude, _longitude,
309	_nmea, _ntripVersion);
310
311	if (_rawFile) {
312	_decodersRaw[_staID] = _decoder;
313	}
314
315	return success;
316	}
317
318	// Current decoder in use
319	////////////////////////////////////////////////////////////////////////////
320	GPSDecoder* bncGetThread::decoder() {
321	if (!_rawFile) {
322	return _decoder;
323	}
324	else {
325	if (_decodersRaw.contains(_staID) \|\| initDecoder() == success) {
326	return _decodersRaw[_staID];
327	}
328	}
329	return 0;
330	}
331
332	// Destructor
333	////////////////////////////////////////////////////////////////////////////
334	bncGetThread::~bncGetThread() {
335	if (isRunning()) {
336	wait();
337	}
338	if (_query) {
339	_query->stop();
340	_query->deleteLater();
341	}
342	if (_rawFile) {
343	QMapIterator<QString, GPSDecoder*> it(_decodersRaw);
344	while (it.hasNext()) {
345	it.next();
346	delete it.value();
347	}
348	}
349	else {
350	delete _decoder;
351	}
352	delete _rawFile;
353	delete _serialOutFile;
354	delete _serialPort;
355	delete _latencyChecker;
356	emit getThreadFinished(_staID);
357	}
358
359	//
360	////////////////////////////////////////////////////////////////////////////
361	void bncGetThread::terminate() {
362	_isToBeDeleted = true;
363	if (!isRunning()) {
364	delete this;
365	}
366	}
367
368	// Run
369	////////////////////////////////////////////////////////////////////////////
370	void bncGetThread::run() {
371
372	while (true) {
373	try {
374	if (_isToBeDeleted) {
375	QThread::exit(0);
376	this->deleteLater();
377	return;
378	}
379
380	if (tryReconnect() != success) {
381	if (_latencyChecker) {
382	_latencyChecker->checkReconnect();
383	}
384	continue;
385	}
386
387	// Delete old observations
388	// -----------------------
389	if (_rawFile) {
390	QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
391	while (itDec.hasNext()) {
392	itDec.next();
393	GPSDecoder* decoder = itDec.value();
394	decoder->_obsList.clear();
395	}
396	}
397	else {
398	_decoder->_obsList.clear();
399	}
400
401	// Read Data
402	// ---------
403	QByteArray data;
404	if (_query) {
405	_query->waitForReadyRead(data);
406	}
407	else if (_rawFile) {
408	data = _rawFile->readChunk();
409	_format = _rawFile->format();
410	_staID = _rawFile->staID();
411
412	QCoreApplication::processEvents();
413
414	if (data.isEmpty()) {
415	cout << "no more data" << endl;
416	BNC_CORE->stopCombination();
417	BNC_CORE->stopPPP();
418	::exit(0);
419	}
420	}
421	qint64 nBytes = data.size();
422
423	// Timeout, reconnect
424	// ------------------
425	if (nBytes == 0) {
426	if (_latencyChecker) {
427	_latencyChecker->checkReconnect();
428	}
429	emit(newMessage(_staID + ": Data timeout, reconnecting", true));
430	msleep(10000); //sleep 10 sec, G. Weber
431	continue;
432	}
433	else {
434	emit newBytes(_staID, nBytes);
435	emit newRawData(_staID, data);
436	}
437
438	// Output Data
439	// -----------
440	if (_rawOutput) {
441	BNC_CORE->writeRawData(data, _staID, _format);
442	}
443
444	if (_serialPort) {
445	slotSerialReadyRead();
446	_serialPort->write(data);
447	}
448
449	// Decode Data
450	// -----------
451	vector<string> errmsg;
452	if (!decoder()) {
453	_isToBeDeleted = true;
454	continue;
455	}
456	decoder()->_obsList.clear();
457	t_irc irc = decoder()->Decode(data.data(), data.size(), errmsg);
458
459	// Perform various scans and checks
460	// --------------------------------
461	if (_latencyChecker) {
462	_latencyChecker->checkOutage(irc == success);
463	_latencyChecker->checkObsLatency(decoder()->_obsList);
464	_latencyChecker->checkCorrLatency(decoder()->corrGPSEpochTime());
465
466	emit newLatency(_staID, _latencyChecker->currentLatency());
467	}
468
469	scanRTCM();
470
471	// Loop over all observations (observations output)
472	// ------------------------------------------------
473	QListIterator<t_satObs> it(decoder()->_obsList);
474
475	QList<t_satObs> obsListHlp;
476
477	while (it.hasNext()) {
478	const t_satObs& obs = it.next();
479
480	QString prn(obs._prn.toString().c_str());
481	long iSec = long(floor(obs._time.gpssec()+0.5));
482	long obsTime = obs._time.gpsw()724*3600 + iSec;
483
484	// Check observation epoch
485	// -----------------------
486	if (!_rawFile) {
487	int week;
488	double sec;
489	currentGPSWeeks(week, sec);
490	long currTime = week * 7243600 + long(sec);
491	const double maxDt = 600.0;
492	if (fabs(currTime - obsTime) > maxDt) {
493	emit( newMessage(_staID + ": Wrong observation epoch(s)", false) );
494	continue;
495	}
496	}
497
498	// Check observations coming twice (e.g. KOUR0 Problem)
499	// ----------------------------------------------------
500	if (!_rawFile) {
501	QMap<QString, long>::const_iterator it = _prnLastEpo.find(prn);
502	if (it != _prnLastEpo.end()) {
503	long oldTime = it.value();
504	if (obsTime < oldTime) {
505	emit( newMessage(_staID +
506	": old observation " + prn.toAscii(), false));
507	continue;
508	}
509	else if (obsTime == oldTime) {
510	emit( newMessage(_staID +
511	": observation coming more than once " + prn.toAscii(), false));
512	continue;
513	}
514	}
515	_prnLastEpo[prn] = obsTime;
516	}
517
518	decoder()->dumpRinexEpoch(obs, _format);
519
520	// Save observations
521	// -----------------
522	obsListHlp.append(obs);
523	}
524
525	// Emit signal
526	// -----------
527	if (!_isToBeDeleted && obsListHlp.size() > 0) {
528	emit newObs(_staID, obsListHlp);
529	}
530
531	decoder()->_obsList.clear();
532	}
533	catch (Exception& exc) {
534	emit(newMessage(_staID + " " + exc.what(), true));
535	_isToBeDeleted = true;
536	}
537	catch (...) {
538	emit(newMessage(_staID + " bncGetThread exception", true));
539	_isToBeDeleted = true;
540	}
541	}
542	}
543
544	// Try Re-Connect
545	////////////////////////////////////////////////////////////////////////////
546	t_irc bncGetThread::tryReconnect() {
547
548	// Easy Return
549	// -----------
550	if (_query && _query->status() == bncNetQuery::running) {
551	_nextSleep = 0;
552	if (_rawFile) {
553	QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
554	while (itDec.hasNext()) {
555	itDec.next();
556	GPSDecoder* decoder = itDec.value();
557	decoder->setRinexReconnectFlag(false);
558	}
559	}
560	else {
561	_decoder->setRinexReconnectFlag(false);
562	}
563	return success;
564	}
565
566	// Start a new query
567	// -----------------
568	if (!_rawFile) {
569
570	sleep(_nextSleep);
571	if (_nextSleep == 0) {
572	_nextSleep = 1;
573	}
574	else {
575	_nextSleep = 2 * _nextSleep;
576	if (_nextSleep > 256) {
577	_nextSleep = 256;
578	}
579	#ifdef MLS_SOFTWARE
580	if (_nextSleep > 4) {
581	_nextSleep = 4;
582	}
583	#endif
584	}
585
586	delete _query;
587	if (_ntripVersion == "U") {
588	_query = new bncNetQueryUdp();
589	}
590	else if (_ntripVersion == "R") {
591	_query = new bncNetQueryRtp();
592	}
593	else if (_ntripVersion == "S") {
594	_query = new bncNetQueryS();
595	}
596	else if (_ntripVersion == "N") {
597	_query = new bncNetQueryV0();
598	}
599	else if (_ntripVersion == "UN") {
600	_query = new bncNetQueryUdp0();
601	}
602	else if (_ntripVersion == "2") {
603	_query = new bncNetQueryV2(false);
604	}
605	else if (_ntripVersion == "2s") {
606	_query = new bncNetQueryV2(true);
607	}
608	else {
609	_query = new bncNetQueryV1();
610	}
611	if (_nmea == "yes" && _serialNMEA != AUTO_NMEA) {
612	QByteArray gga = ggaString(_latitude, _longitude, "100.0");
613	_query->startRequest(_mountPoint, gga);
614	}
615	else {
616	_query->startRequest(_mountPoint, "");
617	}
618	if (_query->status() != bncNetQuery::running) {
619	return failure;
620	}
621	}
622
623	if (_rawFile) {
624	QMapIterator<QString, GPSDecoder*> itDec(_decodersRaw);
625	while (itDec.hasNext()) {
626	itDec.next();
627	GPSDecoder* decoder = itDec.value();
628	decoder->setRinexReconnectFlag(false);
629	}
630	}
631	else {
632	_decoder->setRinexReconnectFlag(false);
633	}
634
635	return success;
636	}
637
638	// RTCM scan output
639	//////////////////////////////////////////////////////////////////////////////
640	void bncGetThread::scanRTCM() {
641
642	if ( !decoder() ) {
643	return;
644	}
645
646	bncSettings settings;
647	if ( Qt::CheckState(settings.value("scanRTCM").toInt()) == Qt::Checked ) {
648
649	if ( _miscMount == _staID \|\| _miscMount == "ALL" ) {
650
651	// RTCM message types
652	// ------------------
653	for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
654	QString type = QString("%1 ").arg(decoder()->_typeList[ii]);
655	emit(newMessage(_staID + ": Received message type " + type.toAscii(), true));
656	}
657
658	// Check Observation Types
659	// -----------------------
660	for (int ii = 0; ii < decoder()->_obsList.size(); ii++) {
661	t_satObs& obs = decoder()->_obsList[ii];
662	QVector<QString>& rnxTypes = _rnxTypes[obs._prn.system()];
663	bool allFound = true;
664	for (unsigned iFrq = 0; iFrq < obs._obs.size(); iFrq++) {
665	QString rnxStr(obs._obs[iFrq]->_rnxType2ch.c_str());
666	if (rnxTypes.indexOf(rnxStr) == -1) {
667	allFound = false;
668	rnxTypes << rnxStr;
669	}
670	}
671	if (!allFound) {
672	QString msg;
673	QTextStream str(&msg);
674	str << obs._prn.system() << " " << rnxTypes.size() << " ";
675	for (int iType = 0; iType < rnxTypes.size(); iType++) {
676	str << " " << rnxTypes[iType];
677	}
678	emit(newMessage(_staID + ": Observation Types: " + msg.toAscii(), true));
679	}
680	}
681
682	// RTCMv3 antenna descriptor
683	// -------------------------
684	for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
685	QString ant1 = QString("%1 ").arg(decoder()->_antType[ii]);
686	emit(newMessage(_staID + ": Antenna descriptor " + ant1.toAscii(), true));
687	}
688
689	// RTCM Antenna Coordinates
690	// ------------------------
691	for (int ii=0; ii < decoder()->_antList.size(); ii++) {
692	QByteArray antT;
693	if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
694	antT = "ARP";
695	}
696	else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
697	antT = "APC";
698	}
699	QByteArray ant1, ant2, ant3;
700	ant1 = QString("%1 ").arg(decoder()->_antList[ii].xx,0,'f',4).toAscii();
701	ant2 = QString("%1 ").arg(decoder()->_antList[ii].yy,0,'f',4).toAscii();
702	ant3 = QString("%1 ").arg(decoder()->_antList[ii].zz,0,'f',4).toAscii();
703	emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
704	emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
705	emit(newMessage(_staID + ": " + antT + " (ITRF) Z " + ant3 + "m", true));
706	double hh = 0.0;
707	if (decoder()->_antList[ii].height_f) {
708	hh = decoder()->_antList[ii].height;
709	QByteArray ant4 = QString("%1 ").arg(hh,0,'f',4).toAscii();
710	emit(newMessage(_staID + ": Antenna height above marker " + ant4 + "m", true));
711	}
712	emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
713	decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
714	hh, antT));
715	}
716	}
717	}
718
719	#ifdef MLS_SOFTWARE
720	for (int ii=0; ii <decoder()->_antList.size(); ii++) {
721	QByteArray antT;
722	if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::ARP) {
723	antT = "ARP";
724	}
725	else if (decoder()->_antList[ii].type == GPSDecoder::t_antInfo::APC) {
726	antT = "APC";
727	}
728	double hh = 0.0;
729	if (decoder()->_antList[ii].height_f) {
730	hh = decoder()->_antList[ii].height;
731	}
732	emit(newAntCrd(_staID, decoder()->_antList[ii].xx,
733	decoder()->_antList[ii].yy, decoder()->_antList[ii].zz,
734	hh, antT));
735	}
736
737	for (int ii = 0; ii <decoder()->_typeList.size(); ii++) {
738	emit(newRTCMMessage(_staID, decoder()->_typeList[ii]));
739	}
740	#endif
741
742	decoder()->_typeList.clear();
743	decoder()->_antType.clear();
744	decoder()->_antList.clear();
745	}
746
747	// Handle Data from Serial Port
748	////////////////////////////////////////////////////////////////////////////
749	void bncGetThread::slotSerialReadyRead() {
750	if (_serialPort) {
751	int nb = _serialPort->bytesAvailable();
752	if (nb > 0) {
753	QByteArray data = _serialPort->read(nb);
754
755	if (_serialNMEA == AUTO_NMEA) {
756	int i1 = data.indexOf("$GPGGA");
757	if (i1 != -1) {
758	int i2 = data.indexOf("*", i1);
759	if (i2 != -1 && data.size() > i2 + 1) {
760	QByteArray gga = data.mid(i1,i2-i1+3);
761	_query->sendNMEA(gga);
762	}
763	}
764	}
765
766	if (_serialOutFile) {
767	_serialOutFile->write(data);
768	_serialOutFile->flush();
769	}
770	}
771	}
772	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: