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

Subversion Repositories Projects

(root)/QMK-Groundstation/branches/waypoint/Forms/mktool.cpp - Rev 248