Subversion Repositories Projects

Rev

Rev 313 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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