WebSVN - Projects - Blame - /QMK-Groundstation/trunk/Forms/mktool.cpp

Rev	Author	Line No.	Line
158	KeyOz	1	/***************************************************************************
		2	* Copyright (C) 2008 by Manuel Schrape *
		3	* manuel.schrape@gmx.de *
		4	* *
		5	* This program is free software; you can redistribute it and/or modify *
		6	* it under the terms of the GNU General Public License as published by *
		7	* the Free Software Foundation; either version 2 of the License. *
		8	* *
		9	* This program is distributed in the hope that it will be useful, *
		10	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
		11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
		12	* GNU General Public License for more details. *
		13	* *
		14	* You should have received a copy of the GNU General Public License *
		15	* along with this program; if not, write to the *
		16	* Free Software Foundation, Inc., *
		17	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
		18	***************************************************************************/
		19
250	KeyOz	20	// TODO: Wiederholungssenden wieder einbauen
		21
158	KeyOz	22	#include <QtGui>
		23
		24	#include <QLineEdit>
		25	#include <QString>
		26	#include <QTimer>
		27	#include <QIcon>
		28	#include <QToolButton>
		29	#include <QSpinBox>
199	KeyOz	30	#include <QAction>
227	KeyOz	31	#include <QPalette>
158	KeyOz	32
		33	#include "mktool.h"
		34	#include "dlg_Config.h"
		35	#include "dlg_Motortest.h"
159	KeyOz	36	#include "dlg_Preferences.h"
158	KeyOz	37	#include "../global.h"
227	KeyOz	38	#include "../Classes/ToolBox.h"
158	KeyOz	39
		40	#include <stdlib.h>
		41
		42	MKTool::MKTool()
		43	{
		44	setupUi(this);
		45
		46	Settings = new cSettings;
		47
		48	init_Arrays();
		49	init_GUI();
		50
		51	init_Objects();
		52	init_Connections();
		53
		54	init_Plot();
		55	}
		56
		57	void MKTool::init_GUI()
		58	{
		59	setWindowTitle(QA_NAME + " v" + QA_VERSION);
		60
167	KeyOz	61	// Tab mit Debug-Elementen verbergen
227	KeyOz	62	tab_Main->removeTab(6);
167	KeyOz	63
227	KeyOz	64	// Tab mit Wegpunkte-Elementen verbergen
250	KeyOz	65	// tab_Main->removeTab(5);
227	KeyOz	66
167	KeyOz	67	// Settings-Tab hinzufügen.
		68	f_Settings = new wdg_Settings( this );
227	KeyOz	69	f_Settings->set_Config(Settings);
		70	tab_Main->insertTab ( 2, f_Settings, ac_View2->icon(), "FC-Settings");
167	KeyOz	71	tab_Main->widget(2)->setObjectName("Tab_2");
		72
		73	// Develop - Nicht gebrauchte sachen abschalten.
		74	pb_SettingsReset->hide();
		75	pb_Flash->hide();
		76	rb_NC->hide();
		77
		78	// Zusätzliche Widgets in die Toolbar.
227	KeyOz	79	tb_TTY->addWidget(lb_Port);
		80	tb_TTY->addWidget(le_Port);
166	KeyOz	81
227	KeyOz	82	tb_Hardware->addWidget(rb_SelFC);
		83	tb_Hardware->addWidget(rb_SelNC);
		84	tb_Hardware->addWidget(rb_SelMag);
166	KeyOz	85
227	KeyOz	86	tb_Allgemein->setVisible(Settings->GUI.ToolViews[0]);
		87	tb_Werkzeuge->setVisible(Settings->GUI.ToolViews[1]);
		88	tb_Debug->setVisible(Settings->GUI.ToolViews[2]);
		89	tb_TTY->setVisible(Settings->GUI.ToolViews[3]);
		90	tb_Hardware->setVisible(Settings->GUI.ToolViews[4]);
		91
199	KeyOz	92	lb_Status->setText(tr("Hallo bei QMK-Groundstation...!!!"));
		93
227	KeyOz	94	QPalette newPalette;
199	KeyOz	95
227	KeyOz	96	newPalette.setColor(QPalette::Base, Qt::darkBlue);
		97	newPalette.setColor(QPalette::Foreground, QColor(Qt::darkBlue).dark(120));
		98	newPalette.setColor(QPalette::Text, Qt::white);
		99
		100	Compass->setScaleOptions(QwtDial::ScaleTicks \| QwtDial::ScaleLabel);
		101	Compass->setScaleTicks(0, 0, 3);
		102	Compass->setScale(36, 5, 0);
		103
		104	Compass->setNeedle(new QwtDialSimpleNeedle(QwtDialSimpleNeedle::Arrow, true, Qt::red, QColor(Qt::gray).light(130)));
		105	Compass->setPalette(newPalette);
		106	Compass->setMaximumSize(QSize(MeterSize, MeterSize));
		107	Compass->setMinimumSize(QSize(MeterSize, MeterSize));
		108
		109	QPalette newPalette1;
		110
		111	newPalette1.setColor(QPalette::Base, Qt::darkBlue);
		112	newPalette1.setColor(QPalette::Foreground, QColor(255,128,0).dark(120));
		113	newPalette1.setColor(QPalette::Text, Qt::white);
		114
		115	Attitude = new AttitudeIndicator(this);
		116	Attitude->setMaximumSize(QSize(MeterSize, MeterSize));
		117	Attitude->setMinimumSize(QSize(MeterSize, MeterSize));
		118	Attitude->setPalette(newPalette1);
		119
		120	verticalLayout->addWidget(Attitude);
		121
		122	qwt_Rate->setRange(-10.0, 10.0, 0.1, 0);
		123
		124	newPalette1.setColor(QPalette::Foreground, QColor(Qt::darkBlue).dark(120));
		125
		126	SpeedMeter = new cSpeedMeter(this);
		127	SpeedMeter->setMaximumSize(QSize(MeterSize, MeterSize));
		128	SpeedMeter->setMinimumSize(QSize(MeterSize, MeterSize));
		129	SpeedMeter->setPalette(newPalette1);
		130	SpeedMeter->setRange(0.0, 5.0);
		131	SpeedMeter->setScale(1, 2, 0.5);
		132	SpeedMeter->setProperty("END", 5);
		133
		134	LayOut_Speed->addWidget(SpeedMeter);
		135
158	KeyOz	136	#ifdef _EEEPC_
166	KeyOz	137	lb_Status->hide();
158	KeyOz	138	#endif
		139
		140	resize(Settings->GUI.Size);
		141	move(Settings->GUI.Point);
		142
		143	if (Settings->GUI.isMax)
		144	{
		145	showMaximized();
		146	}
		147
199	KeyOz	148	// Analoglabels anzeigen
158	KeyOz	149	for (int a = 0; a < MaxAnalog; a++)
		150	{
162	KeyOz	151	lb_Analog[a]->setText(Settings->Analog1.Label[a]);
158	KeyOz	152	}
		153
199	KeyOz	154	// Kopie der Tabs anlegen
227	KeyOz	155	// for (int b = 0; b < 7; b++)
158	KeyOz	156	for (int b = 0; b < 6; b++)
		157	{
		158	TabWidgets[b] = tab_Main->widget(b);
		159	}
		160
199	KeyOz	161	// Ausgeblendete Tabs ausblenden
227	KeyOz	162	// for (int c = 0; c < 7; c++)
158	KeyOz	163	for (int c = 0; c < 6; c++)
		164	{
		165	if (Settings->GUI.TabViews[c] == false)
		166	{
		167	QString TabName = QString("Tab_%1").arg(c);
		168
		169	for (int d = 0; d < tab_Main->count(); d++)
		170	{
		171	if (tab_Main->widget(d)->objectName() == TabName)
		172	{
		173	tab_Main->removeTab(d);
		174	}
		175	}
		176	}
		177	}
		178
		179	ac_View0->setChecked(Settings->GUI.TabViews[0]);
		180	ac_View1->setChecked(Settings->GUI.TabViews[1]);
		181	ac_View2->setChecked(Settings->GUI.TabViews[2]);
		182	ac_View3->setChecked(Settings->GUI.TabViews[3]);
		183	ac_View4->setChecked(Settings->GUI.TabViews[4]);
		184	ac_View5->setChecked(Settings->GUI.TabViews[5]);
227	KeyOz	185	// ac_View6->setChecked(Settings->GUI.TabViews[6]);
158	KeyOz	186
		187	le_Port->setText(Settings->TTY.Port);
162	KeyOz	188
		189	cb_ShowMSG->setChecked(Settings->GUI.Term_Info);
		190	cb_ShowData->setChecked(Settings->GUI.Term_Data);
		191	cb_ShowAlways->setChecked(Settings->GUI.Term_Always);
158	KeyOz	192	}
		193
		194	void MKTool::init_Objects()
		195	{
		196	// QTimer-Instanzen
199	KeyOz	197	Ticker = new QTimer(this);
158	KeyOz	198
		199	// Seriell-Port
250	KeyOz	200	// serialPort = new ManageSerialPort;
158	KeyOz	201
250	KeyOz	202	Conn = new cConnection();
		203
239	Brean	204	// neuer Logger
240	Brean	205	logger = new Logger(Settings, &Mode);
159	KeyOz	206
227	KeyOz	207	// LCD-Dialog
		208	f_LCD = new dlg_LCD(this);
		209
199	KeyOz	210	// Senden erlauben (Warum auch immer)
250	KeyOz	211	// AllowSend = true;
199	KeyOz	212
		213	Server = new cServer();
		214
227	KeyOz	215	MyServer = new cQMK_Server();
		216	MyServer->setProperty("Connect", false);
		217
		218
199	KeyOz	219	if (Settings->Server.StartServer)
		220	{
		221	ac_StartServer->setChecked(true);
		222	Server->start_Server(Settings->Server.Port.toInt(), Settings);
		223	}
158	KeyOz	224	}
		225
		226	void MKTool::init_Connections()
		227	{
250	KeyOz	228	connect(Dec, SIGNAL(clicked()), this, SLOT(slot_Test()));
199	KeyOz	229
250	KeyOz	230	// Daten Senden / Empfangen
		231	connect(Conn, SIGNAL(newData(sRxData)), this, SLOT(slot_newData(sRxData)));
		232	connect(Conn, SIGNAL(showTerminal(int, QString)), this, SLOT(slot_showTerminal(int, QString)));
158	KeyOz	233
199	KeyOz	234	// Serielle Verbundung öffnen / schließen
		235	connect(ac_ConnectTTY, SIGNAL(triggered()), this, SLOT(slot_OpenPort()));
		236
227	KeyOz	237	// TCP-Connection verbinden / trennen
		238	connect(ac_QMKServer, SIGNAL(triggered()), this, SLOT(slot_QMKS_Connect()));
		239
167	KeyOz	240	// Buttons Settings lesen / schreiben
199	KeyOz	241	connect(f_Settings->pb_Read, SIGNAL(clicked()), this, SLOT(slot_GetFCSettings()));
		242	connect(f_Settings->pb_Write, SIGNAL(clicked()), this, SLOT(slot_SetFCSettings()));
158	KeyOz	243
		244	// Actions
		245	connect(ac_Config, SIGNAL(triggered()), this, SLOT(slot_ac_Config()));
159	KeyOz	246	connect(ac_Preferences, SIGNAL(triggered()), this, SLOT(slot_ac_Preferences()));
158	KeyOz	247	connect(ac_Motortest, SIGNAL(triggered()), this, SLOT(slot_ac_Motortest()));
227	KeyOz	248	connect(ac_LCD, SIGNAL(triggered()), this, SLOT(slot_ac_LCD()));
199	KeyOz	249	connect(ac_FastDebug, SIGNAL(triggered()), this, SLOT(slot_ac_FastDebug()));
		250	connect(ac_NoDebug, SIGNAL(triggered()), this, SLOT(slot_ac_NoDebug()));
		251	connect(ac_FastNavi, SIGNAL(triggered()), this, SLOT(slot_ac_FastNavi()));
		252	connect(ac_NoNavi, SIGNAL(triggered()), this, SLOT(slot_ac_NoNavi()));
158	KeyOz	253	connect(ac_GetLabels, SIGNAL(triggered()), this, SLOT(slot_ac_GetLabels()));
		254
167	KeyOz	255	// Plotter starten / scrollen
		256	connect(scroll_plot, SIGNAL(valueChanged(int)), this, SLOT(slot_ScrollPlot(int)));
		257	connect(ac_StartPlotter, SIGNAL(triggered()), this, SLOT(slot_ac_StartPlotter()));
199	KeyOz	258	connect(ac_StartServer, SIGNAL(triggered()), this, SLOT(slot_ac_StartServer()));
167	KeyOz	259
158	KeyOz	260	// Tabs ein & ausblenden
		261	connect(ac_View0, SIGNAL(triggered()), this, SLOT(slot_ac_View()));
		262	connect(ac_View1, SIGNAL(triggered()), this, SLOT(slot_ac_View()));
		263	connect(ac_View2, SIGNAL(triggered()), this, SLOT(slot_ac_View()));
		264	connect(ac_View3, SIGNAL(triggered()), this, SLOT(slot_ac_View()));
		265	connect(ac_View4, SIGNAL(triggered()), this, SLOT(slot_ac_View()));
		266	connect(ac_View5, SIGNAL(triggered()), this, SLOT(slot_ac_View()));
227	KeyOz	267	connect(ac_View6, SIGNAL(triggered()), this, SLOT(slot_ac_View()));
158	KeyOz	268
199	KeyOz	269	connect(ac_SelNC, SIGNAL(triggered()), this, SLOT(slot_ac_Hardware()));
		270	connect(ac_SelFC, SIGNAL(triggered()), this, SLOT(slot_ac_Hardware()));
		271	connect(ac_SelMag, SIGNAL(triggered()), this, SLOT(slot_ac_Hardware()));
		272
		273	connect(rb_SelNC, SIGNAL(clicked()), this, SLOT(slot_rb_Hardware()));
		274	connect(rb_SelFC, SIGNAL(clicked()), this, SLOT(slot_rb_Hardware()));
		275	connect(rb_SelMag, SIGNAL(clicked()), this, SLOT(slot_rb_Hardware()));
		276
167	KeyOz	277	// firmeware Updateen / flashen
199	KeyOz	278	connect(pb_Update, SIGNAL(clicked()), this, SLOT(slot_pb_Update()));
166	KeyOz	279	connect(pb_HexFile, SIGNAL(clicked()), this, SLOT(slot_pb_HexFile()));
158	KeyOz	280
250	KeyOz	281	// Wegpunkt-Befehl
		282	connect(pb_FlyTo, SIGNAL(clicked()), this, SLOT(slot_pb_SendWaypoint()));
		283
167	KeyOz	284	// CVS-Record starten / stoppen
239	Brean	285	connect(ac_RecordCSV, SIGNAL(triggered()), this, SLOT(slot_RecordLog()));
158	KeyOz	286
		287	// Timer-Events
		288	connect(Ticker, SIGNAL(timeout()), SLOT(slot_Ticker()));
		289
167	KeyOz	290	// Seitenwechsel
199	KeyOz	291	connect(tab_Main, SIGNAL(currentChanged(int)), this, SLOT(slot_TabChanged(int)));
167	KeyOz	292	connect(f_Settings->tab_Par, SIGNAL(currentChanged(int)), this, SLOT(slot_TabChanged(int)));
158	KeyOz	293
167	KeyOz	294	// About QMK & About-QT Dialog einfügen
		295	connect(ac_About, SIGNAL(triggered()), this, SLOT(slot_ac_About()));
158	KeyOz	296	menu_Help->addAction(trUtf8("Über &Qt"), qApp, SLOT(aboutQt()));
		297	}
		298
		299	void MKTool::init_Arrays()
		300	{
		301	lb_Analog[0] = lb_A_0;
		302	lb_Analog[1] = lb_A_1;
		303	lb_Analog[2] = lb_A_2;
		304	lb_Analog[3] = lb_A_3;
		305	lb_Analog[4] = lb_A_4;
		306	lb_Analog[5] = lb_A_5;
		307	lb_Analog[6] = lb_A_6;
		308	lb_Analog[7] = lb_A_7;
		309	lb_Analog[8] = lb_A_8;
		310	lb_Analog[9] = lb_A_9;
		311	lb_Analog[10] = lb_A_10;
		312	lb_Analog[11] = lb_A_11;
		313	lb_Analog[12] = lb_A_12;
		314	lb_Analog[13] = lb_A_13;
		315	lb_Analog[14] = lb_A_14;
		316	lb_Analog[15] = lb_A_15;
		317	lb_Analog[16] = lb_A_16;
		318	lb_Analog[17] = lb_A_17;
		319	lb_Analog[18] = lb_A_18;
		320	lb_Analog[19] = lb_A_19;
		321	lb_Analog[20] = lb_A_20;
		322	lb_Analog[21] = lb_A_21;
		323	lb_Analog[22] = lb_A_22;
		324	lb_Analog[23] = lb_A_23;
		325	lb_Analog[24] = lb_A_24;
		326	lb_Analog[25] = lb_A_25;
		327	lb_Analog[26] = lb_A_26;
		328	lb_Analog[27] = lb_A_27;
		329	lb_Analog[28] = lb_A_28;
		330	lb_Analog[29] = lb_A_29;
		331	lb_Analog[30] = lb_A_30;
		332	lb_Analog[31] = lb_A_31;
		333	}
		334
		335	void MKTool::init_Plot()
		336	{
		337	NextPlot = 0;
		338
		339	qwtPlot->setCanvasBackground(QColor(QRgb(0x00000000)));
		340
		341	qwtPlot->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
		342
		343	QwtPlotGrid *Grid = new QwtPlotGrid();
		344	Grid->setMajPen(QPen(Qt::gray, 0, Qt::DotLine));
		345
		346	Grid->attach(qwtPlot);
		347
166	KeyOz	348	qwtPlot->setAxisScale(QwtPlot::xBottom,0,Settings->Data.Plotter_Count,0);
158	KeyOz	349
		350	for (int a = 0; a < MaxAnalog; a++)
		351	{
162	KeyOz	352	Plot[a] = new QwtPlotCurve(Settings->Analog1.Label[a]);
		353	Plot[a]->setPen(QPen(QColor(Def_Colors[a])));
250	KeyOz	354	// Plot[a]->setRenderHint(QwtPlotItem::RenderAntialiased);
158	KeyOz	355
162	KeyOz	356	if (Settings->Analog1.PlotView[a])
158	KeyOz	357	Plot[a]->attach(qwtPlot);
		358	}
		359	qwtPlot->replot();
		360	}
		361
199	KeyOz	362	void MKTool::slot_Test()
158	KeyOz	363	{
250	KeyOz	364	}
158	KeyOz	365
250	KeyOz	366	void MKTool::parse_TargetKML()
		367	{
		368	QString Tmp = te_KML->toPlainText().simplified();
		369	QStringList List;
158	KeyOz	370
250	KeyOz	371	if ((Tmp.contains("<kml xmlns=\"http://earth.google.com/kml/2.2\">")) && (Tmp.contains("<coordinates>")))
		372	{
		373	List = Tmp.split("<coordinates>");
		374	List = List[1].split(",");
		375
		376	le_TarLong->setText(ToolBox::get_Float((List[0].toDouble() * 10000000), 10000000));
		377	le_TarLat->setText(ToolBox::get_Float((List[1].toDouble() * 10000000), 10000000));
		378	}
158	KeyOz	379	}
		380
250	KeyOz	381	void MKTool::slot_pb_SendWaypoint()
		382	{
		383	if ((Navi.Current.Longitude == 0) && (Navi.Current.Latitude == 0))
		384	{
		385	QMessageBox msgB;
		386	QString msg;
		387	msgB.setText("Fehler: Es konnten keine GPS-Daten vom Mikrokopter empfangen werden");
		388	msgB.exec();
		389	return;
		390	}
		391	//erstelle einen Wegpunkt, den die NaviCtrl auswerten kann
		392
		393	Waypoint_t desired_pos;
		394	bool ok_lat, ok_lon;
		395
		396	//eingegebene Daten holen
		397	double desired_long, desired_lat;
		398
		399	desired_long = le_TarLong->text().toDouble(&ok_lon);
		400	desired_lat = le_TarLat->text().toDouble(&ok_lat);
		401
		402	if (ok_lon && desired_long < 100)
		403	desired_long *= 10000000+0.5;
		404
		405	if (ok_lat && desired_lat < 100)
		406	desired_lat *= 10000000+0.5;
		407
		408	//fülle Wegpunkt-Daten
		409	desired_pos.Position.Altitude = 0;
		410	desired_pos.Position.Longitude = int32_t(desired_long);
		411	desired_pos.Position.Latitude = int32_t(desired_lat);
		412	desired_pos.Position.Status = NEWDATA;
		413	desired_pos.Heading = -1;
		414	desired_pos.ToleranceRadius = 1;
		415	desired_pos.HoldTime = 60;
		416	desired_pos.Event_Flag = 0;
		417	desired_pos.reserve[0] = 0; // reserve
		418	desired_pos.reserve[1] = 0; // reserve
		419	desired_pos.reserve[2] = 0; // reserve
		420	desired_pos.reserve[3] = 0; // reserve
		421
		422	//...und sende ihn an die NaviCtrl
		423	int max_radius = 10000;
		424	if (ok_lat && ok_lon &&
		425	abs(Navi.Current.Longitude - desired_pos.Position.Longitude) < max_radius &&
		426	abs(Navi.Current.Latitude - desired_pos.Position.Latitude) < max_radius)
		427	{
		428	Conn->send_Cmd('s', ADDRESS_NC, (char *)&desired_pos, sizeof(desired_pos), false);
		429	}
		430	else
		431	{
		432	QMessageBox msgB;
		433	QString msg;
		434	msg += "Bitte die Eingabe ueberpruefen!\n";
		435	msg += "Die Werte muessen sich in der Naehe der aktuellen Koordinaten befinden\n";
		436	msg += "(Lon: ";
		437	msg += ToolBox::get_Float(Navi.Current.Longitude,10000000);
		438	msg += ", ";
		439	msg += "Lat: ";
		440	msg += ToolBox::get_Float(Navi.Current.Latitude,10000000);
		441	msg += ")";
		442	msgB.setText(msg);
		443	msgB.exec();
		444	}
		445	}
		446
199	KeyOz	447	void MKTool::slot_ac_Hardware()
		448	{
		449	QAction Action = (QAction)sender();
158	KeyOz	450
199	KeyOz	451	if (Action->isChecked() == false)
		452	{
		453	Action->setChecked(true);
		454	}
		455
		456	slot_rb_Hardware();
		457	}
		458
		459	void MKTool::slot_rb_Hardware()
		460	{
		461	if ((rb_SelNC->isChecked() == false) && (Mode.ID != ADDRESS_NC))
		462	{
		463	lb_Status->setText(tr("Schalte um auf NaviCtrl."));
		464	TX_Data[0] = 0x1B;
		465	TX_Data[1] = 0x1B;
		466	TX_Data[2] = 0x55;
		467	TX_Data[3] = 0xAA;
		468	TX_Data[4] = 0x00;
		469	TX_Data[5] = '\r';
250	KeyOz	470	Conn->send_Cmd('#', ADDRESS_NC, TX_Data, 6, false);
227	KeyOz	471	ToolBox::Wait(SLEEP);
199	KeyOz	472	}
		473
		474	if (rb_SelFC->isChecked())
		475	{
		476	lb_Status->setText(tr("Schalte um auf FlightCtrl."));
		477	TX_Data[0] = 0;
250	KeyOz	478	Conn->send_Cmd('u', ADDRESS_NC, TX_Data, 1, false);
199	KeyOz	479	}
		480	else
		481	if (rb_SelMag->isChecked())
		482	{
		483	lb_Status->setText(tr("Schalte um auf MK3MAG."));
		484	TX_Data[0] = 1;
250	KeyOz	485	Conn->send_Cmd('u', ADDRESS_NC, TX_Data, 1, false);
199	KeyOz	486	}
		487	else
		488	if (rb_SelNC->isChecked())
		489	{
		490	lb_Status->setText(tr("Schalte um auf NaviCtrl."));
		491	TX_Data[0] = 0x1B;
		492	TX_Data[1] = 0x1B;
		493	TX_Data[2] = 0x55;
		494	TX_Data[3] = 0xAA;
		495	TX_Data[4] = 0x00;
		496	TX_Data[5] = '\r';
250	KeyOz	497	Conn->send_Cmd('#', ADDRESS_NC, TX_Data, 6, false);
199	KeyOz	498	}
227	KeyOz	499	ToolBox::Wait(SLEEP);
199	KeyOz	500
		501	// qDebug("Select RB Hardware");
250	KeyOz	502	Conn->send_Cmd('v', ADDRESS_ALL, TX_Data, 0, true);
199	KeyOz	503	}
		504
158	KeyOz	505	// Ticker-Event
		506	///////////////
		507	void MKTool::slot_Ticker()
		508	{
		509	if (TickerDiv)
		510	TickerDiv = false;
		511	else
		512	TickerDiv = true;
		513
250	KeyOz	514	if (cb_ClipBoard->isChecked())
		515	{
		516	QString s_OLD = te_KML->toPlainText();
		517	te_KML->clear();
		518	te_KML->paste();
		519	if (s_OLD != te_KML->toPlainText())
		520	{
		521	parse_TargetKML();
		522	}
		523	}
		524
158	KeyOz	525	for (int a = 0; a < MaxTickerEvents; a++)
		526	{
		527	if (TickerEvent[a] == true)
		528	{
		529	switch(a)
		530	{
		531	case 0 :
		532	if (TickerDiv)
		533	{
		534	QByteArray Temp(LastSend.toUtf8());
250	KeyOz	535	// serialPort->sendData(Temp);
158	KeyOz	536	}
		537	break;
		538	case 1 :
159	KeyOz	539	TX_Data[0] = 0;
250	KeyOz	540	Conn->send_Cmd('p', ADDRESS_FC, TX_Data, 0, false);
158	KeyOz	541	break;
159	KeyOz	542	case 2 :
227	KeyOz	543	if (f_LCD->cb_LCD->isChecked())
167	KeyOz	544	{
227	KeyOz	545	if (!f_LCD->isVisible())
		546	{
		547	Ticker->setInterval(2000);
		548	TickerEvent[2] = false;
		549	}
167	KeyOz	550	TX_Data[0] = LCD_Page;
		551	TX_Data[1] = 0;
250	KeyOz	552	Conn->send_Cmd('l', ADDRESS_ALL, TX_Data, 1, true);
167	KeyOz	553	}
159	KeyOz	554	break;
167	KeyOz	555	case 3 :
199	KeyOz	556	if (ac_FastDebug->isChecked())
167	KeyOz	557	{
		558	TX_Data[0] = Settings->Data.Debug_Fast / 10;
250	KeyOz	559	Conn->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
167	KeyOz	560	}
		561	else
		562	{
		563	TX_Data[0] = Settings->Data.Debug_Slow / 10;
250	KeyOz	564	Conn->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
167	KeyOz	565	}
		566	break;
158	KeyOz	567	}
		568	}
		569	}
		570	}
		571
227	KeyOz	572	void MKTool::slot_QMKS_Connect()
		573	{
		574	if (ac_QMKServer->isChecked())
		575	{
		576	lb_Status->setText(tr("Verbinde zum QMK-Datenserver."));
158	KeyOz	577
227	KeyOz	578	MyServer->Connect("nimari.de", 16441, Settings->Server.QMKS_Login, Settings->Server.QMKS_Password);
		579	connect(MyServer, SIGNAL(sig_Connected()), this, SLOT(slot_QMKS_Connected()));
		580	connect(MyServer, SIGNAL(sig_Disconnected(int)), this, SLOT(slot_QMKS_Disconnected(int)));
		581
		582	}
		583	else
		584	{
		585	if ((MyServer->property("Connect")) == true)
		586	{
		587	disconnect(MyServer, SIGNAL(sig_Disconnected(int)), 0, 0);
		588	lb_Status->setText(tr("Trenne vom QMK-Datenserver."));
		589
		590	MyServer->Disconnect();
		591	MyServer->setProperty("Connect", false);
		592	ac_QMKServer->setText("QMK-Server Verbinden");
		593	}
		594	}
		595	}
		596
		597	void MKTool::slot_QMKS_Connected()
		598	{
		599	MyServer->setProperty("Connect", true);
		600	ac_QMKServer->setText("QMK-Server Trennnen");
		601	lb_Status->setText(tr("Verbunden mit QMK-Datenserver."));
		602	}
		603
		604	void MKTool::slot_QMKS_Disconnected(int Error)
		605	{
		606	MyServer->setProperty("Connect", false);
		607	ac_QMKServer->setText("QMK-Server Verbinden");
		608	ac_QMKServer->setChecked(false);
		609
		610	disconnect(MyServer, SIGNAL(sig_Disconnected(int)), 0, 0);
		611
		612	switch (Error)
		613	{
		614	case 1 :
		615	{
		616	lb_Status->setText(tr("Verbindung vom Server beendet."));
		617	QMessageBox::warning(this, QA_NAME,"QMK-Datenserver: Verbindung wurde vom Server beendet.", QMessageBox::Ok);
		618	}
		619	break;
		620	case 2 :
		621	{
		622	lb_Status->setText(tr("Server nicht gefunden."));
		623	QMessageBox::warning(this, QA_NAME,"QMK-Datenserver: Kann nicht zum Server verbinden.", QMessageBox::Ok);
		624	}
		625	break;
		626	case 3 :
		627	{
		628	lb_Status->setText(tr("Serververbindung getrennt. Logindaten falsch."));
		629	QMessageBox::warning(this, QA_NAME,"QMK-Datenserver: Loginname oder Password falsch.", QMessageBox::Ok);
		630	}
		631	break;
		632	default :
		633	{
		634	lb_Status->setText(tr("Getrennt vom QMK-Datenserver."));
		635	}
		636	break;
		637	}
		638	}
		639
158	KeyOz	640	// Slots der Actions (Menüpunkte, Buttons)
		641	//////////////////////////////////////////
		642	void MKTool::slot_ac_Motortest()
		643	{
		644	dlg_Motortest *f_Motortest = new dlg_Motortest(this);
		645
		646	connect(f_Motortest, SIGNAL(updateMotor(int, int, int, int)), this, SLOT(slot_Motortest(int, int, int, int)));
		647
		648	if (f_Motortest->exec()==QDialog::Accepted)
		649	{
		650	}
		651
		652	disconnect(f_Motortest, 0,0,0);
		653	slot_Motortest(0,0,0,0);
		654	}
		655
227	KeyOz	656	void MKTool::slot_ac_LCD()
		657	{
		658	if (!f_LCD->isVisible())
		659	{
		660	f_LCD = new dlg_LCD(this);
		661
		662	// LCD auf / ab
		663	connect(f_LCD->pb_LCDup, SIGNAL(clicked()), this, SLOT(slot_LCD_UP()));
		664	connect(f_LCD->pb_LCDdown, SIGNAL(clicked()), this, SLOT(slot_LCD_DOWN()));
		665
		666	f_LCD->show();
		667	TX_Data[0] = 0;
		668	TX_Data[1] = 0;
250	KeyOz	669	Conn->send_Cmd('l', ADDRESS_ALL, TX_Data, 1, true);
227	KeyOz	670
		671	Ticker->setInterval(500);
		672	TickerEvent[2] = true;
		673	}
		674	}
		675
158	KeyOz	676	void MKTool::slot_Motortest(int Motor1, int Motor2, int Motor3, int Motor4)
		677	{
		678	TX_Data[0] = Motor1;
		679	TX_Data[1] = Motor2;
		680	TX_Data[2] = Motor3;
		681	TX_Data[3] = Motor4;
250	KeyOz	682	Conn->send_Cmd('t', ADDRESS_FC, TX_Data, 4, false);
158	KeyOz	683	}
		684
		685	void MKTool::slot_ac_Config()
		686	{
162	KeyOz	687	set_Analog Old_Analog1;
158	KeyOz	688
162	KeyOz	689	Old_Analog1 = Settings->Analog1;
		690
158	KeyOz	691	dlg_Config *f_Config = new dlg_Config(this);
162	KeyOz	692	f_Config->set_Settings(Settings, Mode.ID);
158	KeyOz	693
		694	if (f_Config->exec()==QDialog::Accepted)
		695	{
		696	Settings = f_Config->get_Settings();
162	KeyOz	697	Settings->write_Settings_Analog(Mode.ID);
158	KeyOz	698
163	KeyOz	699	// Plotter neu einrichten
		700	if (Old_Analog1.PlotView != Settings->Analog1.PlotView)
158	KeyOz	701	{
163	KeyOz	702	config_Plot();
158	KeyOz	703	}
		704
163	KeyOz	705	// CVS-Datei neu anlegen.
241	KeyOz	706	if ((logger->is_active()) && (Old_Analog1.LogView != Settings->Analog1.LogView))
158	KeyOz	707	{
239	Brean	708	logger->close();
240	Brean	709	logger->start_Log();
241	KeyOz	710	// update_Log();
158	KeyOz	711	}
		712
		713	}
		714	}
		715
239	Brean	716	//aktualisiere Logging-Status
241	KeyOz	717	void MKTool::update_Log()
		718	{
239	Brean	719	if (logger->is_active())
		720	{
241	KeyOz	721	// logger->write(AnalogData);
		722	// pb_Record->setText("Log Stop");
239	Brean	723	ac_RecordCSV->setText("Log Stop");
		724	lb_Status->setText(tr("Log-Record gestartet."));
		725	}
		726	else
		727	{
241	KeyOz	728	// pb_Record->setText("Log Aufzeichnen");
		729	ac_RecordCSV->setText("Log Aufzeichnen");
239	Brean	730	lb_Status->setText(tr("Log-Record gestopt."));
		731	}
		732	}
		733
		734	//starte/stoppe Logging, wenn auf den entsprechenden Button gedrückt wurde
		735	void MKTool::slot_RecordLog()
		736	{
		737	if (!logger->is_active())
		738	logger->start_Log();
		739	else
		740	logger->close();
241	KeyOz	741
239	Brean	742	update_Log();
		743	}
		744
159	KeyOz	745	void MKTool::slot_ac_Preferences()
		746	{
		747	dlg_Preferences *f_Preferences = new dlg_Preferences(this);
		748
166	KeyOz	749	Settings->TTY.Port = le_Port->text();
163	KeyOz	750	f_Preferences->set_Settings(Settings);
		751
159	KeyOz	752	if (f_Preferences->exec()==QDialog::Accepted)
		753	{
163	KeyOz	754	Settings = f_Preferences->get_Settings();
		755	Settings->write_Settings();
166	KeyOz	756	le_Port->setText(Settings->TTY.Port);
		757	config_Plot();
159	KeyOz	758	}
		759	}
		760
158	KeyOz	761	void MKTool::slot_ac_StartPlotter()
		762	{
		763	if (ac_StartPlotter->isChecked())
		764	{
199	KeyOz	765	lb_Status->setText(tr("Datenplotter gestartet."));
158	KeyOz	766	ac_StartPlotter->setText("Stop Plotter");
		767	pb_StartPlotter->setText("Stop Plotter");
		768	}
		769	else
		770	{
199	KeyOz	771	lb_Status->setText(tr("Datenplotter gestopt."));
158	KeyOz	772	ac_StartPlotter->setText("Start Plotter");
		773	pb_StartPlotter->setText("Start Plotter");
		774	}
		775	}
		776
		777	void MKTool::slot_ac_View()
		778	{
227	KeyOz	779	int Aktive = -1;
158	KeyOz	780
		781	QAction Action = (QAction)sender();
		782
		783	if (Action->objectName() == QString("ac_View0"))
		784	Aktive = 0;
		785	if (Action->objectName() == QString("ac_View1"))
		786	Aktive = 1;
		787	if (Action->objectName() == QString("ac_View2"))
		788	Aktive = 2;
		789	if (Action->objectName() == QString("ac_View3"))
		790	Aktive = 3;
		791	if (Action->objectName() == QString("ac_View4"))
		792	Aktive = 4;
		793	if (Action->objectName() == QString("ac_View5"))
		794	Aktive = 5;
227	KeyOz	795	// if (Action->objectName() == QString("ac_View6"))
		796	// Aktive = 6;
158	KeyOz	797
		798	QString TabName = QString("Tab_%1").arg(Aktive);
		799
		800	if (!Action->isChecked())
		801	{
		802	for (int a = 0; a < tab_Main->count(); a++)
		803	{
		804	if (tab_Main->widget(a)->objectName() == TabName)
		805	{
		806	tab_Main->removeTab(a);
		807	}
		808	}
		809	}
		810	else
		811	{
227	KeyOz	812	tab_Main->insertTab(Aktive, TabWidgets[Aktive], Action->icon(), Action->text());
158	KeyOz	813	}
		814	}
		815
199	KeyOz	816	void MKTool::slot_ac_FastNavi() // DONE NC 0.12i
158	KeyOz	817	{
199	KeyOz	818	if (!ac_NoNavi->isChecked())
158	KeyOz	819	{
199	KeyOz	820	if (ac_FastNavi->isChecked())
166	KeyOz	821	{
199	KeyOz	822	lb_Status->setText(tr("Fordere schnelle NaviDaten an."));
		823	TX_Data[0] = Settings->Data.Navi_Fast / 10;
		824	}
		825	else
		826	{
		827	lb_Status->setText(tr("Fordere langsame NaviDaten an."));
		828	TX_Data[0] = Settings->Data.Navi_Slow / 10;
		829	}
250	KeyOz	830	Conn->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
199	KeyOz	831	}
		832	}
		833
		834	void MKTool::slot_ac_NoNavi() // DONE NC 0.12i
		835	{
		836	if (ac_NoNavi->isChecked())
		837	{
		838	lb_Status->setText(tr("NaviDaten abstellen."));
		839	TX_Data[0] = 0;
		840	}
		841	else
		842	{
		843	if (ac_FastNavi->isChecked())
		844	{
		845	lb_Status->setText(tr("Fordere schnelle NaviDaten an."));
		846	TX_Data[0] = Settings->Data.Navi_Fast / 10;
		847	}
		848	else
		849	{
		850	lb_Status->setText(tr("Fordere langsame NaviDaten an."));
		851	TX_Data[0] = Settings->Data.Navi_Slow / 10;
		852	}
		853	}
250	KeyOz	854	Conn->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
199	KeyOz	855	}
		856
		857	void MKTool::slot_ac_FastDebug() // DONE 0.71g
		858	{
		859	if (!ac_NoDebug->isChecked())
		860	{
		861	if (ac_FastDebug->isChecked())
		862	{
		863	lb_Status->setText(tr("Fordere schnelle DebugDaten an."));
166	KeyOz	864	TX_Data[0] = Settings->Data.Debug_Fast / 10;
		865	}
		866	else
		867	{
199	KeyOz	868	lb_Status->setText(tr("Fordere langsame DebugDaten an."));
166	KeyOz	869	TX_Data[0] = Settings->Data.Debug_Slow / 10;
		870	}
250	KeyOz	871	Conn->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
166	KeyOz	872	}
		873	}
		874
199	KeyOz	875	void MKTool::slot_ac_NoDebug() // DONE 0.71g
166	KeyOz	876	{
199	KeyOz	877	if (ac_NoDebug->isChecked())
166	KeyOz	878	{
199	KeyOz	879	lb_Status->setText(tr("DebugDaten abstellen."));
167	KeyOz	880	TickerEvent[3] = false;
166	KeyOz	881	TX_Data[0] = 0;
		882	}
158	KeyOz	883	else
		884	{
167	KeyOz	885	// Wenn MK3MAG dann andauernd Daten neu anfragen.
		886	if (Mode.ID == ADDRESS_MK3MAG)
		887	TickerEvent[3] = true;
		888
199	KeyOz	889	if (ac_FastDebug->isChecked())
166	KeyOz	890	{
199	KeyOz	891	lb_Status->setText(tr("Fordere schnelle DebugDaten an."));
166	KeyOz	892	TX_Data[0] = Settings->Data.Debug_Fast / 10;
		893	}
		894	else
		895	{
199	KeyOz	896	lb_Status->setText(tr("Fordere langsame DebugDaten an."));
166	KeyOz	897	TX_Data[0] = Settings->Data.Debug_Slow / 10;
		898	}
		899	}
250	KeyOz	900	Conn->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
158	KeyOz	901	}
		902
		903	void MKTool::slot_ac_About()
		904	{
		905	QMessageBox::about(this, trUtf8(("Über ")) + QA_NAME, QA_ABOUT);
		906	}
		907
159	KeyOz	908	void MKTool::slot_ac_GetLabels() // DONE 0.71g
158	KeyOz	909	{
199	KeyOz	910	lb_Status->setText(tr("Analoglabels auslesen."));
158	KeyOz	911	TX_Data[0] = 0;
250	KeyOz	912	Conn->send_Cmd('a', ADDRESS_ALL, TX_Data, 1, true);
158	KeyOz	913	}
		914
199	KeyOz	915	void MKTool::slot_ac_StartServer()
		916	{
		917	if (ac_StartServer->isChecked())
		918	{
		919	lb_Status->setText(tr("GoogleEarth-Server gestartet."));
		920	Server->start_Server(Settings->Server.Port.toInt(), Settings);
		921	}
		922	else
		923	{
		924	lb_Status->setText(tr("GoogleEarth-Server gestopt."));
		925	Server->stop_Server();
		926	}
		927	}
159	KeyOz	928
227	KeyOz	929
158	KeyOz	930	// Daten-Plotter
		931	/////////////////
		932	void MKTool::update_Plot()
		933	{
		934	for (int a = 0; a < MaxAnalog; a++)
		935	{
		936	Plot[a]->setData(aID,aData[a],NextPlot - 1);
		937	}
		938
166	KeyOz	939	if ((NextPlot > Settings->Data.Plotter_Count))
158	KeyOz	940	{
166	KeyOz	941	scroll_plot->setMaximum(NextPlot - Settings->Data.Plotter_Count);
158	KeyOz	942	}
		943
166	KeyOz	944	if ((scroll_plot->value() == NextPlot - (Settings->Data.Plotter_Count + 1)))
158	KeyOz	945	{
166	KeyOz	946	qwtPlot->setAxisScale(QwtPlot::xBottom,NextPlot - Settings->Data.Plotter_Count,NextPlot,0);
		947	scroll_plot->setValue(NextPlot - Settings->Data.Plotter_Count);
158	KeyOz	948	}
		949
		950	qwtPlot->replot();
		951	}
		952
		953	void MKTool::config_Plot()
		954	{
166	KeyOz	955	// qDebug("Plotter rekonfiguriert..!!");
		956	qwtPlot->setAxisScale(QwtPlot::xBottom,0,Settings->Data.Plotter_Count,0);
		957
158	KeyOz	958	for (int a = 0; a < MaxAnalog; a++)
		959	{
		960	Plot[a]->detach();
162	KeyOz	961	Plot[a]->setPen(QPen(QColor(Def_Colors[a])));
158	KeyOz	962
162	KeyOz	963	if (Settings->Analog1.PlotView[a])
		964	{
		965	Plot[a]->setTitle(Settings->Analog1.Label[a]);
158	KeyOz	966	Plot[a]->attach(qwtPlot);
162	KeyOz	967	}
158	KeyOz	968	}
166	KeyOz	969	qwtPlot->replot();
158	KeyOz	970	}
		971
		972	void MKTool::slot_ScrollPlot(int Pos)
		973	{
166	KeyOz	974	qwtPlot->setAxisScale(QwtPlot::xBottom,Pos,Pos + Settings->Data.Plotter_Count,0);
158	KeyOz	975	qwtPlot->replot();
		976	}
		977
		978
		979	// Firmeware-Update
		980	///////////////////
		981	void MKTool::slot_pb_Update()
		982	{
167	KeyOz	983	QString Device;
		984	QString Hardware;
158	KeyOz	985
167	KeyOz	986	if (rb_FC->isChecked())
		987	{
		988	Device = "m644";
		989	Hardware = "FlightCtrl";
		990	}
		991	else if (rb_MK3MAG->isChecked())
		992	{
		993	Device = "m168";
		994	Hardware = "MK3MAG";
		995	}
		996	else if (rb_BL->isChecked())
		997	{
		998	Device = "m8";
		999	Hardware = "BL-Ctrl";
		1000	}
166	KeyOz	1001
		1002	QString Message = "Firmeware-Datei \n\n";
		1003	Message = Message + le_HexFile->text() + "\n\n";
167	KeyOz	1004	Message = Message + "an " + Hardware + trUtf8(" mit AVRDUDE - Seriel & Bootloader über ") + le_Port->text() + trUtf8(" übertragen?\n");
166	KeyOz	1005
		1006	if (le_HexFile->text() == "")
162	KeyOz	1007	{
166	KeyOz	1008	QMessageBox::warning(this, QA_NAME, trUtf8("Bitte Firmeware-Datei wählen."), QMessageBox::Ok);
162	KeyOz	1009	}
166	KeyOz	1010	else if (QMessageBox::warning(this, QA_NAME, Message, QMessageBox::Yes \| QMessageBox::No) == QMessageBox::Yes)
		1011	{
		1012	QString Programm = "avrdude" ;
162	KeyOz	1013
166	KeyOz	1014	QStringList Argumente;
162	KeyOz	1015
166	KeyOz	1016	Update = new QProcess();
162	KeyOz	1017
250	KeyOz	1018	if (Conn->isOpen())
166	KeyOz	1019	{
		1020	slot_OpenPort();
		1021	}
		1022
		1023	Argumente << "-P";
		1024	Argumente << le_Port->text();
		1025	Argumente << "-p";
		1026	Argumente << Device;
		1027	Argumente << "-c";
		1028	Argumente << "butterfly";
		1029	Argumente << "-b";
		1030	Argumente << "57600";
		1031	Argumente << "-U";
		1032	Argumente << "flash:w:" + le_HexFile->text();
		1033
		1034	// QString Programm = "/home/Manuel/bin/avrdude -p m644 -P /dev/ttyS0 -c butterfly -b 57600 -U flash:w:/home/Manuel/Documents/Mikrokopter/Firmeware/FlightCtrl/Flight-Ctrl_MEGA644_V0_71h.hex";
		1035
		1036	te_Shell->setText(""); // Ausgabefenster säubern
		1037
		1038	connect(Update, SIGNAL(readyReadStandardOutput()), this, SLOT(slot_UpdateShell()) );
		1039	connect(Update, SIGNAL(readyReadStandardError()), this, SLOT(slot_UpdateShell()) );
		1040
		1041	Update->start(Programm, Argumente); // Programmaufruf
		1042	}
158	KeyOz	1043	}
		1044
		1045	void MKTool::slot_UpdateShell()
		1046	{
162	KeyOz	1047	QByteArray Output;
158	KeyOz	1048
166	KeyOz	1049	Output = Update->readAllStandardError(); // Shellausgabe an Variable
162	KeyOz	1050	te_Shell->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor);
		1051	te_Shell->insertPlainText(QString::fromUtf8(Output));
158	KeyOz	1052
166	KeyOz	1053	Output = Update->readAll();
		1054	te_Shell->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor);
		1055	te_Shell->insertPlainText(QString::fromUtf8(Output));
158	KeyOz	1056	}
		1057
166	KeyOz	1058	void MKTool::slot_pb_HexFile()
		1059	{
		1060	QString FileName = QFileDialog::getOpenFileName(this,trUtf8(("Firmeware-Datei wählen")),"",
		1061	tr("Intel Hex(.hex);;Alle Dateien ()"));
		1062	if (!FileName.isEmpty())
		1063	{
		1064	le_HexFile->setText(FileName);
		1065	}
		1066	}
158	KeyOz	1067
		1068
167	KeyOz	1069	// Wechsel der Tabs erkennen
159	KeyOz	1070	void MKTool::slot_TabChanged(int Tab) // DONE 0.71g
158	KeyOz	1071	{
		1072	Tab = Tab;
162	KeyOz	1073	if (tab_Main->count() != 0)
158	KeyOz	1074	{
167	KeyOz	1075	if ((tab_Main->currentWidget()->objectName() == QString("Tab_2")) && (f_Settings->tab_Par->currentIndex() == 1))
162	KeyOz	1076	{
		1077	TX_Data[0] = 0;
250	KeyOz	1078	Conn->send_Cmd('p', ADDRESS_FC, TX_Data, 0, true);
159	KeyOz	1079
162	KeyOz	1080	Ticker->setInterval(500);
		1081	TickerEvent[1] = true;
		1082	}
		1083	else
		1084	{
		1085	Ticker->setInterval(2000);
		1086	TickerEvent[1] = false;
		1087	}
227	KeyOz	1088	/*
162	KeyOz	1089	if ((tab_Main->currentWidget()->objectName() == QString("Tab_4")))
		1090	{
		1091	TX_Data[0] = 0;
		1092	TX_Data[1] = 0;
		1093	send_Data('l', ADDRESS_ALL, TX_Data, 1, true);
159	KeyOz	1094
162	KeyOz	1095	Ticker->setInterval(500);
		1096	TickerEvent[2] = true;
		1097	}
		1098	else
		1099	{
		1100	Ticker->setInterval(2000);
		1101	TickerEvent[2] = false;
		1102	}
227	KeyOz	1103	*/
159	KeyOz	1104	}
158	KeyOz	1105	}
		1106
167	KeyOz	1107	// LCD-Seiten weiterschalten
159	KeyOz	1108	void MKTool::slot_LCD_UP() // DONE 0.71g
158	KeyOz	1109	{
159	KeyOz	1110	if (LCD_Page == LCD_MAX_Page)
		1111	TX_Data[0] = 0;
		1112	else
		1113	TX_Data[0] = LCD_Page + 1;
		1114
		1115	TX_Data[1] = 0;
250	KeyOz	1116	Conn->send_Cmd('l', ADDRESS_ALL, TX_Data, 1, true);
159	KeyOz	1117	}
		1118
		1119	void MKTool::slot_LCD_DOWN() // DONE 0.71g
		1120	{
		1121	if (LCD_Page == 0)
		1122	TX_Data[0] = LCD_MAX_Page;
		1123	else
		1124	TX_Data[0] = LCD_Page - 1;
		1125
		1126	TX_Data[1] = 0;
250	KeyOz	1127	Conn->send_Cmd('l', ADDRESS_ALL, TX_Data, 1, true);
159	KeyOz	1128	}
		1129
167	KeyOz	1130	// Settings aus MK lesen / in MK schreiben
199	KeyOz	1131	void MKTool::slot_GetFCSettings() // DONE 0.71g
159	KeyOz	1132	{
199	KeyOz	1133	lb_Status->setText(tr("Lese FlightCtrl-Settings aus."));
167	KeyOz	1134	TX_Data[0] = f_Settings->sb_Set->value();
158	KeyOz	1135	TX_Data[1] = 0;
250	KeyOz	1136	Conn->send_Cmd('q', ADDRESS_FC, TX_Data, 1);
158	KeyOz	1137	}
		1138
199	KeyOz	1139	void MKTool::slot_SetFCSettings() // DONE 0.71g
158	KeyOz	1140	{
199	KeyOz	1141	char *TX_Data2 = f_Settings->GetFCSettings();
158	KeyOz	1142
199	KeyOz	1143	lb_Status->setText(tr("Schreibe FlightCtrl-Settings."));
167	KeyOz	1144
250	KeyOz	1145	Conn->send_Cmd('s', ADDRESS_FC, TX_Data2, MaxParameter + 2, false);
158	KeyOz	1146	}
		1147
159	KeyOz	1148
167	KeyOz	1149	// Save GUI-Preferences
		1150	///////////////////////
		1151	void MKTool::set_Preferences()
158	KeyOz	1152	{
163	KeyOz	1153	Settings->GUI.TabViews.setBit(0, ac_View0->isChecked());
		1154	Settings->GUI.TabViews.setBit(1, ac_View1->isChecked());
		1155	Settings->GUI.TabViews.setBit(2, ac_View2->isChecked());
		1156	Settings->GUI.TabViews.setBit(3, ac_View3->isChecked());
		1157	Settings->GUI.TabViews.setBit(4, ac_View4->isChecked());
		1158	Settings->GUI.TabViews.setBit(5, ac_View5->isChecked());
227	KeyOz	1159	Settings->GUI.TabViews.setBit(6, ac_View6->isChecked());
158	KeyOz	1160
227	KeyOz	1161	Settings->GUI.ToolViews.setBit(0, tb_Allgemein->isVisibleTo(this));
		1162	Settings->GUI.ToolViews.setBit(1, tb_Werkzeuge->isVisibleTo(this));
		1163	Settings->GUI.ToolViews.setBit(2, tb_Debug->isVisibleTo(this));
		1164	Settings->GUI.ToolViews.setBit(3, tb_TTY->isVisibleTo(this));
		1165	Settings->GUI.ToolViews.setBit(4, tb_Hardware->isVisibleTo(this));
		1166
162	KeyOz	1167	Settings->GUI.Term_Info = cb_ShowMSG->isChecked();
		1168	Settings->GUI.Term_Data = cb_ShowData->isChecked();
		1169	Settings->GUI.Term_Always = cb_ShowAlways->isChecked();
166	KeyOz	1170	Settings->GUI.Term_Send = cb_ShowSend->isChecked();
167	KeyOz	1171	Settings->GUI.isMax = isMaximized();
		1172	Settings->GUI.Size = size();
		1173	Settings->GUI.Point = pos();
162	KeyOz	1174
163	KeyOz	1175	Settings->TTY.Port = le_Port->text();
158	KeyOz	1176	}
		1177
159	KeyOz	1178
158	KeyOz	1179	void MKTool::show_DebugData()
		1180	{
241	KeyOz	1181	if (logger->is_active())
		1182	logger->write(AnalogData);
158	KeyOz	1183
		1184	if (ac_StartPlotter->isChecked())
		1185	{
		1186	aID[NextPlot] = NextPlot;
		1187
		1188	for (int a = 0; a < MaxAnalog; a++)
		1189	{
		1190	aData[a][NextPlot] = AnalogData[a];
		1191	}
		1192	NextPlot++;
		1193
		1194	if ((tab_Main->currentWidget()->objectName() == QString("Tab_1")))
		1195	update_Plot();
		1196	}
		1197
		1198	le_A_0->setText(QString("%1").arg(AnalogData[0]));
		1199	le_A_1->setText(QString("%1").arg(AnalogData[1]));
		1200	le_A_2->setText(QString("%1").arg(AnalogData[2]));
		1201	le_A_3->setText(QString("%1").arg(AnalogData[3]));
		1202	le_A_4->setText(QString("%1").arg(AnalogData[4]));
		1203	le_A_5->setText(QString("%1").arg(AnalogData[5]));
		1204	le_A_6->setText(QString("%1").arg(AnalogData[6]));
		1205	le_A_7->setText(QString("%1").arg(AnalogData[7]));
		1206	le_A_8->setText(QString("%1").arg(AnalogData[8]));
		1207	le_A_9->setText(QString("%1").arg(AnalogData[9]));
		1208	le_A_10->setText(QString("%1").arg(AnalogData[10]));
		1209	le_A_11->setText(QString("%1").arg(AnalogData[11]));
		1210	le_A_12->setText(QString("%1").arg(AnalogData[12]));
		1211	le_A_13->setText(QString("%1").arg(AnalogData[13]));
		1212	le_A_14->setText(QString("%1").arg(AnalogData[14]));
		1213	le_A_15->setText(QString("%1").arg(AnalogData[15]));
		1214	le_A_16->setText(QString("%1").arg(AnalogData[16]));
		1215	le_A_17->setText(QString("%1").arg(AnalogData[17]));
		1216	le_A_18->setText(QString("%1").arg(AnalogData[18]));
		1217	le_A_19->setText(QString("%1").arg(AnalogData[19]));
		1218	le_A_20->setText(QString("%1").arg(AnalogData[20]));
		1219	le_A_21->setText(QString("%1").arg(AnalogData[21]));
		1220	le_A_22->setText(QString("%1").arg(AnalogData[22]));
		1221	le_A_23->setText(QString("%1").arg(AnalogData[23]));
		1222	le_A_24->setText(QString("%1").arg(AnalogData[24]));
		1223	le_A_25->setText(QString("%1").arg(AnalogData[25]));
		1224	le_A_26->setText(QString("%1").arg(AnalogData[26]));
		1225	le_A_27->setText(QString("%1").arg(AnalogData[27]));
		1226	le_A_28->setText(QString("%1").arg(AnalogData[28]));
		1227	le_A_29->setText(QString("%1").arg(AnalogData[29]));
		1228	le_A_30->setText(QString("%1").arg(AnalogData[30]));
		1229	le_A_31->setText(QString("%1").arg(AnalogData[31]));
227	KeyOz	1230
		1231	if ((Mode.ID == ADDRESS_FC) && (FCSettings[P_GYRO_ACC_FAKTOR] > 0))
		1232	{
		1233	bar_UBAT->setValue(AnalogData[9]);
		1234	bar_RX->setValue(AnalogData[10]);
		1235
		1236	Compass->setValue(AnalogData[8]);
		1237
		1238	int Roll = (AnalogData[1] * FCSettings[P_GYRO_ACC_FAKTOR]) / 1024;
		1239	int Nick = (AnalogData[0] * FCSettings[P_GYRO_ACC_FAKTOR]) / 1024;
		1240
		1241	if (Roll > 128)
		1242	Roll = Roll - 255;
		1243
		1244	if (Nick > 128)
		1245	Nick = Nick - 255;
		1246
		1247	Attitude->setAngle(Roll);
		1248	Attitude->setGradient(double(double(Nick) / 100.0));
		1249	}
158	KeyOz	1250	}
		1251
159	KeyOz	1252
199	KeyOz	1253	void MKTool::new_NaviData(sRxData RX)
		1254	{
246	KeyOz	1255	Navi.Current.Longitude = ToolBox::Data2Long(RX.Decode, N_CUR_LONGITUDE, true);
		1256	Navi.Current.Latitude = ToolBox::Data2Long(RX.Decode, N_CUR_LATITUDE, true);
		1257	Navi.Current.Altitude = ToolBox::Data2Long(RX.Decode, N_CUR_ALTITUDE, true);
		1258	Navi.Target.Longitude = ToolBox::Data2Long(RX.Decode, N_TAR_LONGITUDE, true);
		1259	Navi.Target.Latitude = ToolBox::Data2Long(RX.Decode, N_TAR_LATITUDE, true);
		1260	Navi.Target.Altitude = ToolBox::Data2Long(RX.Decode, N_TAR_ALTITUDE, true);
199	KeyOz	1261
246	KeyOz	1262	le_CDistance->setText(QString("%1 cm").arg(ToolBox::Data2Int(RX.Decode, N_HOME_DISTANCE)));
		1263	le_CWPA->setText(QString("%1").arg(RX.Decode[N_WP_INDEX]));
		1264	le_CWPT->setText(QString("%1").arg(RX.Decode[N_WP_NUMBER]));
		1265	le_CSats->setText(QString("%1").arg(RX.Decode[N_SATS_IN_USER]));
227	KeyOz	1266
246	KeyOz	1267	qwt_Rate->setValue(double(ToolBox::Data2Int(RX.Decode, N_VARIOMETER, true)));
227	KeyOz	1268
246	KeyOz	1269	le_CTime->setText(QString("%1 sec.").arg(ToolBox::Data2Int(RX.Decode, N_FLYING_TIME)));
227	KeyOz	1270
246	KeyOz	1271	bar_UBAT->setValue(RX.Decode[N_UBAT]);
227	KeyOz	1272
246	KeyOz	1273	double Speed = double((ToolBox::Data2Int(RX.Decode, N_GROUND_SPEED)) / 10.0);
227	KeyOz	1274
		1275	if ((Speed > 4.5) && SpeedMeter->property("END") == 5)
		1276	{
		1277	SpeedMeter->setRange(0.0, 10.0);
		1278	SpeedMeter->setScale(1, 2, 1);
		1279	SpeedMeter->setProperty("END", 10);
		1280	}
		1281
		1282	if ((Speed > 9) && SpeedMeter->property("END") == 10)
		1283	{
		1284	SpeedMeter->setRange(0.0, 20.0);
		1285	SpeedMeter->setScale(1, 2, 2);
		1286	SpeedMeter->setProperty("END", 20);
		1287	}
		1288
		1289	SpeedMeter->setValue(Speed);
		1290
246	KeyOz	1291	Compass->setValue(ToolBox::Data2Int(RX.Decode, N_COMAPSS_HEADING)); //(68)
227	KeyOz	1292
246	KeyOz	1293	bar_RX->setValue(RX.Decode[N_RC_QUALITY]);
227	KeyOz	1294
246	KeyOz	1295	int Nick = RX.Decode[N_ANGLE_NICK];
		1296	int Roll = RX.Decode[N_ANGLE_ROLL];
227	KeyOz	1297
		1298	if (Roll > 128)
		1299	Roll = Roll - 255;
		1300
		1301	if (Nick > 128)
		1302	Nick = Nick - 255;
		1303
		1304	Attitude->setAngle(Roll);
234	KeyOz	1305	Attitude->setGradient(double(0.0 - (double(Nick) / 100.0)));
227	KeyOz	1306
199	KeyOz	1307	sNaviString NaviString;
		1308
		1309	NaviString.Longitude = ToolBox::get_Float(Navi.Current.Longitude,10000000);
		1310	NaviString.Latitude = ToolBox::get_Float(Navi.Current.Latitude,10000000);
		1311	NaviString.Altitude = ToolBox::get_Float(Navi.Current.Altitude,1000);
		1312
		1313	Server->store_NaviString(NaviString);
		1314
227	KeyOz	1315	if ((MyServer->property("Connect")) == true)
		1316	{
		1317	MyServer->NewPosition(NaviString);
		1318	}
199	KeyOz	1319	}
		1320
158	KeyOz	1321	// Seriel-Port Bereich, Befehle senden und Daten empfangen
		1322	//////////////////////////////////////////////////////////
		1323
		1324	// Neues Datenpacket empfangen -> Verarbeiten
250	KeyOz	1325	void MKTool::slot_newData(sRxData RX) // DONE 0.71g
158	KeyOz	1326	{
250	KeyOz	1327	slot_showTerminal(1, RX.String);
158	KeyOz	1328
		1329	if (LastSend.length() > 2)
		1330	{
		1331	}
		1332
162	KeyOz	1333	int HardwareID = RX.Input[1] - 'a';
		1334
167	KeyOz	1335	switch(HardwareID)
158	KeyOz	1336	{
167	KeyOz	1337	case ADDRESS_FC :
		1338	switch(RX.Input[2])
		1339	{
		1340	// Stick-Belegung der Fernsteuerung
		1341	case 'P' : // DONE 0.71g
		1342	if (ToolBox::Decode64(RX))
158	KeyOz	1343	{
167	KeyOz	1344	f_Settings->pb_K1->setValue(ToolBox::Data2Int(RX.Decode, 2,true));
		1345	f_Settings->pb_K2->setValue(ToolBox::Data2Int(RX.Decode, 4,true));
		1346	f_Settings->pb_K3->setValue(ToolBox::Data2Int(RX.Decode, 6,true));
		1347	f_Settings->pb_K4->setValue(ToolBox::Data2Int(RX.Decode, 8,true));
		1348	f_Settings->pb_K5->setValue(ToolBox::Data2Int(RX.Decode, 10 ,true));
		1349	f_Settings->pb_K6->setValue(ToolBox::Data2Int(RX.Decode, 12,true));
		1350	f_Settings->pb_K7->setValue(ToolBox::Data2Int(RX.Decode, 14,true));
		1351	f_Settings->pb_K8->setValue(ToolBox::Data2Int(RX.Decode, 16,true));
		1352	}
		1353	break;
		1354	// Settings lesen
		1355	case 'Q' : // DONE 0.71g
		1356	if (ToolBox::Decode64(RX))
		1357	{
		1358	TickerEvent[0] = false;
		1359
		1360	if (RX.Decode[1] == VERSION_SETTINGS)
		1361	{
		1362	int Settings_ID = RX.Decode[0];
		1363	for (int a = 0; a < MaxParameter; a++)
		1364	{
199	KeyOz	1365	FCSettings[a] = RX.Decode[a + 2];
167	KeyOz	1366	}
		1367	//show_ParameterSet(Settings_ID);
199	KeyOz	1368	f_Settings->show_FCSettings(Settings_ID, FCSettings);
		1369	f_Settings->pb_Read->setEnabled(true);
		1370	f_Settings->pb_Write->setEnabled(true);
167	KeyOz	1371	}
		1372	else
		1373	{
		1374	f_Settings->pb_Read->setDisabled(true);
		1375	f_Settings->pb_Write->setDisabled(true);
		1376
		1377	QMessageBox::warning(this, QA_NAME,
		1378	"Versionen inkompatibel. \nParameterbearbeitung nicht moeglich.", QMessageBox::Ok);
		1379	}
		1380	}
		1381	break;
		1382	// Settings geschrieben
		1383	case 'S' : // DONE 0.71g
		1384	TickerEvent[0] = false;
		1385	break;
		1386	}
		1387
		1388	case ADDRESS_NC :
		1389	switch(RX.Input[2])
		1390	{
		1391	// Navigationsdaten
		1392	case 'O' : // NOT DONE 0.12h
		1393	if (ToolBox::Decode64(RX))
		1394	{
199	KeyOz	1395	new_NaviData(RX);
167	KeyOz	1396	}
		1397	break;
		1398	}
		1399	// case ADDRESS_MK3MAG :
		1400
		1401	default :
		1402	switch(RX.Input[2])
		1403	{
		1404	// LCD-Anzeige
		1405	case 'L' : // DONE 0.71g
		1406	if (ToolBox::Decode64(RX))
		1407	{
159	KeyOz	1408	int LCD[150];
		1409	memcpy(LCD,RX.Decode, sizeof(RX.Decode));
		1410
227	KeyOz	1411	f_LCD->show_Data(LCD);
		1412
159	KeyOz	1413	LCD_Page = RX.Decode[0];
		1414	LCD_MAX_Page = RX.Decode[1];
		1415
		1416	TickerEvent[0] = false;
158	KeyOz	1417	}
		1418	break;
167	KeyOz	1419	// Analoglabels
		1420	case 'A' : // DONE 0.71g
		1421	if (ToolBox::Decode64(RX))
158	KeyOz	1422	{
159	KeyOz	1423	int Position = RX.Decode[0];
163	KeyOz	1424	if (Position != 31)
158	KeyOz	1425	{
162	KeyOz	1426	Settings->Analog1.Label[Position] = ToolBox::Data2QString(RX.Decode,1,17).trimmed();
167	KeyOz	1427	if (Settings->Analog1.Label[Position] == "")
		1428	{
		1429	Settings->Analog1.Label[Position] = "A-" + QString("%1").arg(Position);
		1430	}
158	KeyOz	1431	Position ++;
		1432	TX_Data[0] = Position;
250	KeyOz	1433	Conn->send_Cmd('a', ADDRESS_ALL, TX_Data, 1, true);
158	KeyOz	1434	}
166	KeyOz	1435	if (Position == 31)
158	KeyOz	1436	{
		1437	for (int a = 0; a < MaxAnalog; a++)
		1438	{
162	KeyOz	1439	lb_Analog[a]->setText(Settings->Analog1.Label[a]);
158	KeyOz	1440	}
163	KeyOz	1441	Settings->Analog1.Version = Mode.Version;
162	KeyOz	1442	Settings->write_Settings_AnalogLabels(HardwareID);
158	KeyOz	1443	config_Plot();
		1444	}
		1445	}
		1446	break;
167	KeyOz	1447	// Debug-Daten
		1448	case 'D' : // DONE 0.71g
		1449	if (ToolBox::Decode64(RX))
158	KeyOz	1450	{
		1451	for (int i = 0; i < MaxAnalog; i++)
		1452	{
		1453	AnalogData[i] = ToolBox::Data2Int(RX.Decode, (i * 2) + 2);
		1454	}
		1455	show_DebugData();
		1456	}
		1457	break;
167	KeyOz	1458	// Version
		1459	case 'V' : // DONE 0.71h
		1460	if (ToolBox::Decode64(RX))
159	KeyOz	1461	{
167	KeyOz	1462	TickerEvent[0] = false;
159	KeyOz	1463
167	KeyOz	1464	Mode.ID = HardwareID;
		1465	Mode.VERSION_MAJOR = RX.Decode[0];
		1466	Mode.VERSION_MINOR = RX.Decode[1];
		1467	Mode.VERSION_PATCH = RX.Decode[4];
		1468	Mode.VERSION_SERIAL_MAJOR = RX.Decode[2];
		1469	Mode.VERSION_SERIAL_MINOR = RX.Decode[3];
159	KeyOz	1470
167	KeyOz	1471	Mode.Hardware = HardwareType[Mode.ID];
		1472	Mode.Version = QString("%1").arg(RX.Decode[0]) + "." + QString("%1").arg(RX.Decode[1]) + QString(RX.Decode[4] + 'a');
158	KeyOz	1473
167	KeyOz	1474	setWindowTitle(QA_NAME + " v" + QA_VERSION + " - " + Mode.Hardware + " " + Mode.Version);
158	KeyOz	1475
167	KeyOz	1476	if (Mode.VERSION_SERIAL_MAJOR != VERSION_SERIAL_MAJOR)
		1477	{
		1478	AllowSend = false;
		1479	QMessageBox::warning(this, QA_NAME,
		1480	"Serielles Protokoll Inkompatibel. \nBitte neue Programmversion installieren,", QMessageBox::Ok);
		1481	}
159	KeyOz	1482
199	KeyOz	1483	if (ac_NoDebug->isChecked())
		1484	{
		1485	TX_Data[0] = 0;
		1486	}
		1487	else
		1488	if (ac_FastDebug->isChecked())
		1489	{
		1490	TX_Data[0] = Settings->Data.Debug_Fast / 10;
		1491	}
		1492	else
		1493	{
		1494	TX_Data[0] = Settings->Data.Debug_Slow / 10;
		1495	}
		1496
250	KeyOz	1497	Conn->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
199	KeyOz	1498
167	KeyOz	1499	// Wenn MK3MAG dann andauernd Daten neu anfragen.
		1500	if (Mode.ID == ADDRESS_MK3MAG)
		1501	{
		1502	TickerEvent[3] = true;
199	KeyOz	1503	rb_SelMag->setChecked(true);
167	KeyOz	1504	}
158	KeyOz	1505
199	KeyOz	1506	// Wenn NaviCtrl dann hier.
		1507	if (Mode.ID == ADDRESS_NC)
		1508	{
		1509	rb_SelNC->setChecked(true);
158	KeyOz	1510
199	KeyOz	1511	if (ac_NoNavi->isChecked())
		1512	{
		1513	TX_Data[0] = 0;
		1514	}
		1515	else
		1516	if (ac_FastNavi->isChecked())
		1517	{
		1518	TX_Data[0] = Settings->Data.Navi_Fast / 10;
		1519	}
		1520	else
		1521	{
		1522	TX_Data[0] = Settings->Data.Navi_Slow / 10;
		1523	}
		1524
250	KeyOz	1525	Conn->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
199	KeyOz	1526	}
		1527
		1528
167	KeyOz	1529	// Wenn FlightCtrl dann Settings abfragen.
		1530	if (Mode.ID == ADDRESS_FC)
		1531	{
199	KeyOz	1532	rb_SelFC->setChecked(true);
167	KeyOz	1533	{
		1534	TX_Data[0] = 0xff;
		1535	TX_Data[1] = 0;
250	KeyOz	1536
		1537	// DEP: Raus wenn Resend implementiert.
		1538	ToolBox::Wait(SLEEP);
		1539	Conn->send_Cmd('q', ADDRESS_FC, TX_Data, 1, true);
		1540	qDebug("FC - Get Settings");
167	KeyOz	1541	}
		1542	}
		1543	// Wenn nicht Lesen und Schreiben der Settings deaktivieren.
		1544	else
		1545	{
		1546	f_Settings->pb_Read->setDisabled(true);
		1547	f_Settings->pb_Write->setDisabled(true);
		1548	}
158	KeyOz	1549
167	KeyOz	1550	Settings->read_Settings_Analog(HardwareID);
		1551	Settings->read_Settings_AnalogLabels(HardwareID);
159	KeyOz	1552
167	KeyOz	1553	if (Settings->Analog1.Version != Mode.Version)
158	KeyOz	1554	{
167	KeyOz	1555	lb_Status->setText("Analoglabel-Version unterschiedlich. Lese Analoglabels neu aus.");
		1556	slot_ac_GetLabels();
158	KeyOz	1557	}
167	KeyOz	1558	else
		1559	for (int a = 0; a < MaxAnalog; a++)
		1560	{
		1561	lb_Analog[a]->setText(Settings->Analog1.Label[a]);
		1562	}
		1563	config_Plot();
158	KeyOz	1564	}
		1565	break;
167	KeyOz	1566	}
158	KeyOz	1567	}
		1568	}
		1569
250	KeyOz	1570	void MKTool::slot_showTerminal(int Typ, QString Text)
158	KeyOz	1571	{
250	KeyOz	1572	switch(Typ)
158	KeyOz	1573	{
250	KeyOz	1574	case 1 :
158	KeyOz	1575	{
250	KeyOz	1576	if ((cb_ShowData->isChecked()) && ((tab_Main->currentWidget()->objectName() == QString("Tab_3")) \|\| (cb_ShowAlways->isChecked())))
158	KeyOz	1577	{
250	KeyOz	1578	te_RX->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor);
		1579	te_RX->insertHtml("<span style=\"color:#00008b;\">" + Text + "<br /></span>");
158	KeyOz	1580	}
250	KeyOz	1581	}
		1582	break;
		1583	case 2 :
		1584	{
		1585	if ((cb_ShowMSG->isChecked()) && ((tab_Main->currentWidget()->objectName() == QString("Tab_3")) \|\| (cb_ShowAlways->isChecked())))
158	KeyOz	1586	{
250	KeyOz	1587	te_RX->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor);
		1588	te_RX->insertHtml("<span style=\"color:#008b00;\">" + Text + "</span>");
158	KeyOz	1589	}
		1590	}
250	KeyOz	1591	break;
		1592	case 3 :
158	KeyOz	1593	{
250	KeyOz	1594	if (cb_ShowSend->isChecked())
158	KeyOz	1595	{
250	KeyOz	1596	te_RX->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor);
		1597	te_RX->insertHtml("<span style='color:#8b0000;'>" + Text + "<br /></span>");
158	KeyOz	1598	}
		1599	}
250	KeyOz	1600	break;
158	KeyOz	1601	}
		1602	}
		1603
		1604	// Seriellen Port öffnen
		1605	void MKTool::slot_OpenPort()
		1606	{
250	KeyOz	1607	if (Conn->isOpen())
		1608	{
199	KeyOz	1609	TX_Data[0] = Settings->Data.Debug_Off / 10;
250	KeyOz	1610	Conn->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
227	KeyOz	1611	ToolBox::Wait(SLEEP);
158	KeyOz	1612
199	KeyOz	1613	if (Mode.ID == ADDRESS_NC)
		1614	{
		1615	TX_Data[0] = Settings->Data.Navi_Off / 10;
250	KeyOz	1616	Conn->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
227	KeyOz	1617	ToolBox::Wait(SLEEP);
199	KeyOz	1618	}
		1619
		1620	if (Mode.ID == ADDRESS_NC)
		1621	{
		1622	TX_Data[0] = 0;
		1623	TX_Data[1] = 0;
		1624	TX_Data[2] = 0;
		1625	TX_Data[3] = 0;
250	KeyOz	1626	Conn->send_Cmd('t', ADDRESS_FC, TX_Data, 4, false);
227	KeyOz	1627	ToolBox::Wait(SLEEP);
199	KeyOz	1628	}
250	KeyOz	1629
		1630	Conn->Close();
		1631
263	KeyOz	1632	ac_ConnectTTY->setText("Kopter Verbinden");
199	KeyOz	1633	le_Port->setEnabled(true);
		1634
167	KeyOz	1635	Ticker->stop();
158	KeyOz	1636	}
		1637	else
		1638	{
263	KeyOz	1639	int i_Type;
		1640	if (le_Port->text().contains(QString("IP:")))
158	KeyOz	1641	{
263	KeyOz	1642	i_Type = C_IP;
		1643	}
		1644	else
		1645	{
		1646	i_Type = C_TTY;
		1647	}
		1648
		1649	if (Conn->Open(i_Type, le_Port->text()))
		1650	{
		1651	ac_ConnectTTY->setText("Kopter Trennen");
199	KeyOz	1652	le_Port->setEnabled(false);
158	KeyOz	1653
250	KeyOz	1654	Conn->send_Cmd('v', ADDRESS_ALL, TX_Data, 0, true);
159	KeyOz	1655
167	KeyOz	1656	Ticker->start(2000);
158	KeyOz	1657	}
		1658	}
		1659	}
		1660
		1661	// Programm beenden
		1662	///////////////////
162	KeyOz	1663
		1664	MKTool::~MKTool()
158	KeyOz	1665	{
250	KeyOz	1666	if (Conn->isOpen())
158	KeyOz	1667	{
250	KeyOz	1668	Conn->Close();
158	KeyOz	1669	}
		1670
167	KeyOz	1671	set_Preferences();
162	KeyOz	1672	Settings->write_Settings();
158	KeyOz	1673
239	Brean	1674	logger->close();
158	KeyOz	1675	}

Subversion Repositories Projects

(root)/QMK-Groundstation/trunk/Forms/mktool.cpp @ 270 - Rev