Context Navigation

source: ntrip/trunk/BNC/bncgetthread.cpp@ 3301

Last change on this file since 3301 was 3301, checked in by mervart, 13 years ago

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

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

Download in other formats: