Subversion Repositories Projects

Rev

Rev 199 | Rev 234 | 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
 
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
 
227 KeyOz 62
    // Tab mit Wegpunkte-Elementen verbergen
63
     tab_Main->removeTab(5);
64
 
167 KeyOz 65
    // Settings-Tab hinzufügen.
66
    f_Settings = new wdg_Settings( this );
227 KeyOz 67
    f_Settings->set_Config(Settings);
68
    tab_Main->insertTab ( 2, f_Settings, ac_View2->icon(), "FC-Settings");
167 KeyOz 69
    tab_Main->widget(2)->setObjectName("Tab_2");
70
 
71
    // Develop - Nicht gebrauchte sachen abschalten.
72
    pb_SettingsReset->hide();
73
    pb_Flash->hide();
74
    rb_NC->hide();
75
 
76
    // Zusätzliche Widgets in die Toolbar.
227 KeyOz 77
    tb_TTY->addWidget(lb_Port);
78
    tb_TTY->addWidget(le_Port);
166 KeyOz 79
 
227 KeyOz 80
    tb_Hardware->addWidget(rb_SelFC);
81
    tb_Hardware->addWidget(rb_SelNC);
82
    tb_Hardware->addWidget(rb_SelMag);
166 KeyOz 83
 
227 KeyOz 84
    tb_Allgemein->setVisible(Settings->GUI.ToolViews[0]);
85
    tb_Werkzeuge->setVisible(Settings->GUI.ToolViews[1]);
86
    tb_Debug->setVisible(Settings->GUI.ToolViews[2]);
87
    tb_TTY->setVisible(Settings->GUI.ToolViews[3]);
88
    tb_Hardware->setVisible(Settings->GUI.ToolViews[4]);
89
 
199 KeyOz 90
    lb_Status->setText(tr("Hallo bei QMK-Groundstation...!!!"));
91
 
227 KeyOz 92
    QPalette newPalette;
199 KeyOz 93
 
227 KeyOz 94
    newPalette.setColor(QPalette::Base, Qt::darkBlue);
95
    newPalette.setColor(QPalette::Foreground, QColor(Qt::darkBlue).dark(120));
96
    newPalette.setColor(QPalette::Text, Qt::white);
97
 
98
    Compass->setScaleOptions(QwtDial::ScaleTicks | QwtDial::ScaleLabel);
99
    Compass->setScaleTicks(0, 0, 3);
100
    Compass->setScale(36, 5, 0);
101
 
102
//    Compass->setNeedle(new QwtCompassMagnetNeedle(QwtCompassMagnetNeedle::ThinStyle));
103
    Compass->setNeedle(new QwtDialSimpleNeedle(QwtDialSimpleNeedle::Arrow, true, Qt::red, QColor(Qt::gray).light(130)));
104
    Compass->setPalette(newPalette);
105
    Compass->setMaximumSize(QSize(MeterSize, MeterSize));
106
    Compass->setMinimumSize(QSize(MeterSize, MeterSize));
107
 
108
    QPalette newPalette1;
109
 
110
    newPalette1.setColor(QPalette::Base, Qt::darkBlue);
111
    newPalette1.setColor(QPalette::Foreground, QColor(255,128,0).dark(120));
112
    newPalette1.setColor(QPalette::Text, Qt::white);
113
 
114
    Attitude = new AttitudeIndicator(this);
115
    Attitude->setMaximumSize(QSize(MeterSize, MeterSize));
116
    Attitude->setMinimumSize(QSize(MeterSize, MeterSize));
117
    Attitude->setPalette(newPalette1);
118
 
119
    verticalLayout->addWidget(Attitude);
120
 
121
    qwt_Rate->setRange(-10.0, 10.0, 0.1, 0);
122
 
123
    newPalette1.setColor(QPalette::Foreground, QColor(Qt::darkBlue).dark(120));
124
 
125
    SpeedMeter = new cSpeedMeter(this);
126
    SpeedMeter->setMaximumSize(QSize(MeterSize, MeterSize));
127
    SpeedMeter->setMinimumSize(QSize(MeterSize, MeterSize));
128
    SpeedMeter->setPalette(newPalette1);
129
    SpeedMeter->setRange(0.0, 5.0);
130
    SpeedMeter->setScale(1, 2, 0.5);
131
    SpeedMeter->setProperty("END", 5);
132
 
133
    LayOut_Speed->addWidget(SpeedMeter);
134
 
158 KeyOz 135
#ifdef _EEEPC_
166 KeyOz 136
    lb_Status->hide();
158 KeyOz 137
#endif
138
 
139
    resize(Settings->GUI.Size);
140
    move(Settings->GUI.Point);
141
 
142
    if (Settings->GUI.isMax)
143
    {
144
        showMaximized();
145
    }
146
 
199 KeyOz 147
    // Analoglabels anzeigen
158 KeyOz 148
    for (int a = 0; a < MaxAnalog; a++)
149
    {
162 KeyOz 150
        lb_Analog[a]->setText(Settings->Analog1.Label[a]);
158 KeyOz 151
    }
152
 
199 KeyOz 153
    // Kopie der Tabs anlegen
227 KeyOz 154
//    for (int b = 0; b < 7; b++)
158 KeyOz 155
    for (int b = 0; b < 6; b++)
156
    {
157
        TabWidgets[b] = tab_Main->widget(b);
158
    }
159
 
199 KeyOz 160
    // Ausgeblendete Tabs ausblenden
227 KeyOz 161
//    for (int c = 0; c < 7; c++)
158 KeyOz 162
    for (int c = 0; c < 6; c++)
163
    {
164
        if (Settings->GUI.TabViews[c] == false)
165
        {
166
            QString TabName = QString("Tab_%1").arg(c);
167
 
168
            for (int d = 0; d < tab_Main->count(); d++)
169
            {
170
                if (tab_Main->widget(d)->objectName() == TabName)
171
                {
172
                    tab_Main->removeTab(d);
173
                }
174
            }
175
        }
176
    }
177
 
178
    ac_View0->setChecked(Settings->GUI.TabViews[0]);
179
    ac_View1->setChecked(Settings->GUI.TabViews[1]);
180
    ac_View2->setChecked(Settings->GUI.TabViews[2]);
181
    ac_View3->setChecked(Settings->GUI.TabViews[3]);
182
    ac_View4->setChecked(Settings->GUI.TabViews[4]);
183
    ac_View5->setChecked(Settings->GUI.TabViews[5]);
227 KeyOz 184
//    ac_View6->setChecked(Settings->GUI.TabViews[6]);
158 KeyOz 185
 
186
    le_Port->setText(Settings->TTY.Port);
162 KeyOz 187
 
188
    cb_ShowMSG->setChecked(Settings->GUI.Term_Info);
189
    cb_ShowData->setChecked(Settings->GUI.Term_Data);
190
    cb_ShowAlways->setChecked(Settings->GUI.Term_Always);
158 KeyOz 191
}
192
 
193
void MKTool::init_Objects()
194
{
195
    // QTimer-Instanzen
199 KeyOz 196
    Ticker = new QTimer(this);
158 KeyOz 197
 
198
    // Seriell-Port
199
    serialPort = new ManageSerialPort;
200
 
201
    // QFile-Instanz (Log-Datei)
202
    CSVFile = new QFile("");
159 KeyOz 203
 
227 KeyOz 204
    // LCD-Dialog
205
    f_LCD = new dlg_LCD(this);
206
 
199 KeyOz 207
    // Senden erlauben (Warum auch immer)
159 KeyOz 208
    AllowSend = true;
199 KeyOz 209
 
210
    Server = new cServer();
211
 
227 KeyOz 212
    MyServer = new cQMK_Server();
213
    MyServer->setProperty("Connect", false);
214
 
215
 
199 KeyOz 216
    if (Settings->Server.StartServer)
217
    {
218
        ac_StartServer->setChecked(true);
219
        Server->start_Server(Settings->Server.Port.toInt(), Settings);
220
    }
158 KeyOz 221
}
222
 
223
void MKTool::init_Connections()
224
{
199 KeyOz 225
    connect(Dec,   SIGNAL(clicked()), this, SLOT(slot_Test()));
226
 
158 KeyOz 227
    // Seriel-Port Empfang
228
    connect(serialPort, SIGNAL(newDataReceived(const QByteArray &)), this, SLOT(slot_newDataReceived(const QByteArray &)));
229
 
199 KeyOz 230
    // Serielle Verbundung öffnen / schließen
231
    connect(ac_ConnectTTY, SIGNAL(triggered()), this, SLOT(slot_OpenPort()));
232
 
227 KeyOz 233
    // TCP-Connection verbinden / trennen
234
    connect(ac_QMKServer, SIGNAL(triggered()), this, SLOT(slot_QMKS_Connect()));
235
 
167 KeyOz 236
    // Buttons Settings lesen / schreiben
199 KeyOz 237
    connect(f_Settings->pb_Read,   SIGNAL(clicked()), this, SLOT(slot_GetFCSettings()));
238
    connect(f_Settings->pb_Write,  SIGNAL(clicked()), this, SLOT(slot_SetFCSettings()));
158 KeyOz 239
 
240
    // Actions
241
    connect(ac_Config,       SIGNAL(triggered()), this, SLOT(slot_ac_Config()));
159 KeyOz 242
    connect(ac_Preferences,  SIGNAL(triggered()), this, SLOT(slot_ac_Preferences()));
158 KeyOz 243
    connect(ac_Motortest,    SIGNAL(triggered()), this, SLOT(slot_ac_Motortest()));
227 KeyOz 244
    connect(ac_LCD,          SIGNAL(triggered()), this, SLOT(slot_ac_LCD()));
199 KeyOz 245
    connect(ac_FastDebug,    SIGNAL(triggered()), this, SLOT(slot_ac_FastDebug()));
246
    connect(ac_NoDebug,      SIGNAL(triggered()), this, SLOT(slot_ac_NoDebug()));
247
    connect(ac_FastNavi,     SIGNAL(triggered()), this, SLOT(slot_ac_FastNavi()));
248
    connect(ac_NoNavi,       SIGNAL(triggered()), this, SLOT(slot_ac_NoNavi()));
158 KeyOz 249
    connect(ac_GetLabels,    SIGNAL(triggered()), this, SLOT(slot_ac_GetLabels()));
250
 
167 KeyOz 251
    // Plotter starten / scrollen
252
    connect(scroll_plot,     SIGNAL(valueChanged(int)), this, SLOT(slot_ScrollPlot(int)));
253
    connect(ac_StartPlotter, SIGNAL(triggered()), this, SLOT(slot_ac_StartPlotter()));
199 KeyOz 254
    connect(ac_StartServer,  SIGNAL(triggered()), this, SLOT(slot_ac_StartServer()));
167 KeyOz 255
 
158 KeyOz 256
    // Tabs ein & ausblenden
257
    connect(ac_View0,        SIGNAL(triggered()), this, SLOT(slot_ac_View()));
258
    connect(ac_View1,        SIGNAL(triggered()), this, SLOT(slot_ac_View()));
259
    connect(ac_View2,        SIGNAL(triggered()), this, SLOT(slot_ac_View()));
260
    connect(ac_View3,        SIGNAL(triggered()), this, SLOT(slot_ac_View()));
261
    connect(ac_View4,        SIGNAL(triggered()), this, SLOT(slot_ac_View()));
262
    connect(ac_View5,        SIGNAL(triggered()), this, SLOT(slot_ac_View()));
227 KeyOz 263
    connect(ac_View6,        SIGNAL(triggered()), this, SLOT(slot_ac_View()));
158 KeyOz 264
 
199 KeyOz 265
    connect(ac_SelNC,        SIGNAL(triggered()), this, SLOT(slot_ac_Hardware()));
266
    connect(ac_SelFC,        SIGNAL(triggered()), this, SLOT(slot_ac_Hardware()));
267
    connect(ac_SelMag,       SIGNAL(triggered()), this, SLOT(slot_ac_Hardware()));
268
 
269
    connect(rb_SelNC,        SIGNAL(clicked()), this, SLOT(slot_rb_Hardware()));
270
    connect(rb_SelFC,        SIGNAL(clicked()), this, SLOT(slot_rb_Hardware()));
271
    connect(rb_SelMag,       SIGNAL(clicked()), this, SLOT(slot_rb_Hardware()));
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
158 KeyOz 278
    connect(ac_RecordCSV,  SIGNAL(triggered()), this, SLOT(slot_RecordCSV()));
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.
616
        if ((CSVFile->isOpen()) && (Old_Analog1.LogView != Settings->Analog1.LogView))
158 KeyOz 617
        {
163 KeyOz 618
            slot_RecordCSV();
619
            slot_RecordCSV();
158 KeyOz 620
        }
621
 
622
    }
623
}
624
 
159 KeyOz 625
void MKTool::slot_ac_Preferences()
626
{
627
    dlg_Preferences *f_Preferences = new dlg_Preferences(this);
628
 
166 KeyOz 629
    Settings->TTY.Port = le_Port->text();
163 KeyOz 630
    f_Preferences->set_Settings(Settings);
631
 
159 KeyOz 632
    if (f_Preferences->exec()==QDialog::Accepted)
633
    {
163 KeyOz 634
        Settings = f_Preferences->get_Settings();
635
        Settings->write_Settings();
166 KeyOz 636
        le_Port->setText(Settings->TTY.Port);
637
        config_Plot();
159 KeyOz 638
    }
639
}
640
 
158 KeyOz 641
void MKTool::slot_ac_StartPlotter()
642
{
643
    if (ac_StartPlotter->isChecked())
644
    {
199 KeyOz 645
        lb_Status->setText(tr("Datenplotter gestartet."));
158 KeyOz 646
        ac_StartPlotter->setText("Stop Plotter");
647
        pb_StartPlotter->setText("Stop Plotter");
648
    }
649
    else
650
    {
199 KeyOz 651
        lb_Status->setText(tr("Datenplotter gestopt."));
158 KeyOz 652
        ac_StartPlotter->setText("Start Plotter");
653
        pb_StartPlotter->setText("Start Plotter");
654
    }
655
}
656
 
657
void MKTool::slot_ac_View()
658
{
227 KeyOz 659
    int Aktive = -1;
158 KeyOz 660
 
661
    QAction *Action = (QAction*)sender();
662
 
663
    if (Action->objectName() == QString("ac_View0"))
664
        Aktive = 0;
665
    if (Action->objectName() == QString("ac_View1"))
666
        Aktive = 1;
667
    if (Action->objectName() == QString("ac_View2"))
668
        Aktive = 2;
669
    if (Action->objectName() == QString("ac_View3"))
670
        Aktive = 3;
671
    if (Action->objectName() == QString("ac_View4"))
672
        Aktive = 4;
673
    if (Action->objectName() == QString("ac_View5"))
674
        Aktive = 5;
227 KeyOz 675
//    if (Action->objectName() == QString("ac_View6"))
676
//        Aktive = 6;
158 KeyOz 677
 
678
    QString TabName = QString("Tab_%1").arg(Aktive);
679
 
680
    if (!Action->isChecked())
681
    {
682
        for (int a = 0; a < tab_Main->count(); a++)
683
        {
684
            if (tab_Main->widget(a)->objectName() == TabName)
685
            {
686
                tab_Main->removeTab(a);
687
            }
688
        }
689
    }
690
    else
691
    {
227 KeyOz 692
        tab_Main->insertTab(Aktive, TabWidgets[Aktive], Action->icon(), Action->text());
158 KeyOz 693
    }
694
}
695
 
199 KeyOz 696
void MKTool::slot_ac_FastNavi() // DONE NC 0.12i
158 KeyOz 697
{
199 KeyOz 698
    if (!ac_NoNavi->isChecked())
158 KeyOz 699
    {
199 KeyOz 700
        if (ac_FastNavi->isChecked())
166 KeyOz 701
        {
199 KeyOz 702
            lb_Status->setText(tr("Fordere schnelle NaviDaten an."));
703
            TX_Data[0] = Settings->Data.Navi_Fast / 10;
704
        }
705
        else
706
        {
707
            lb_Status->setText(tr("Fordere langsame NaviDaten an."));
708
            TX_Data[0] = Settings->Data.Navi_Slow / 10;
709
        }
710
        send_Data('o', ADDRESS_NC, TX_Data, 1, false);
711
    }
712
}
713
 
714
void MKTool::slot_ac_NoNavi() // DONE NC 0.12i
715
{
716
    if (ac_NoNavi->isChecked())
717
    {
718
        lb_Status->setText(tr("NaviDaten abstellen."));
719
        TX_Data[0] = 0;
720
    }
721
    else
722
    {
723
        if (ac_FastNavi->isChecked())
724
        {
725
            lb_Status->setText(tr("Fordere schnelle NaviDaten an."));
726
            TX_Data[0] = Settings->Data.Navi_Fast / 10;
727
        }
728
        else
729
        {
730
            lb_Status->setText(tr("Fordere langsame NaviDaten an."));
731
            TX_Data[0] = Settings->Data.Navi_Slow / 10;
732
        }
733
    }
734
    send_Data('o', ADDRESS_NC, TX_Data, 1, false);
735
}
736
 
737
void MKTool::slot_ac_FastDebug() // DONE 0.71g
738
{
739
    if (!ac_NoDebug->isChecked())
740
    {
741
        if (ac_FastDebug->isChecked())
742
        {
743
            lb_Status->setText(tr("Fordere schnelle DebugDaten an."));
166 KeyOz 744
            TX_Data[0] = Settings->Data.Debug_Fast / 10;
745
        }
746
        else
747
        {
199 KeyOz 748
            lb_Status->setText(tr("Fordere langsame DebugDaten an."));
166 KeyOz 749
            TX_Data[0] = Settings->Data.Debug_Slow / 10;
750
        }
199 KeyOz 751
        send_Data('d', ADDRESS_ALL, TX_Data, 1, false);
166 KeyOz 752
    }
753
}
754
 
199 KeyOz 755
void MKTool::slot_ac_NoDebug() // DONE 0.71g
166 KeyOz 756
{
199 KeyOz 757
    if (ac_NoDebug->isChecked())
166 KeyOz 758
    {
199 KeyOz 759
        lb_Status->setText(tr("DebugDaten abstellen."));
167 KeyOz 760
        TickerEvent[3] = false;
166 KeyOz 761
        TX_Data[0] = 0;
762
    }
158 KeyOz 763
    else
764
    {
167 KeyOz 765
        // Wenn MK3MAG dann andauernd Daten neu anfragen.
766
        if (Mode.ID == ADDRESS_MK3MAG)
767
            TickerEvent[3] = true;
768
 
199 KeyOz 769
        if (ac_FastDebug->isChecked())
166 KeyOz 770
        {
199 KeyOz 771
            lb_Status->setText(tr("Fordere schnelle DebugDaten an."));
166 KeyOz 772
            TX_Data[0] = Settings->Data.Debug_Fast / 10;
773
        }
774
        else
775
        {
199 KeyOz 776
            lb_Status->setText(tr("Fordere langsame DebugDaten an."));
166 KeyOz 777
            TX_Data[0] = Settings->Data.Debug_Slow / 10;
778
        }
779
    }
199 KeyOz 780
    send_Data('d', ADDRESS_ALL, TX_Data, 1, false);
158 KeyOz 781
}
782
 
783
void MKTool::slot_ac_About()
784
{
785
    QMessageBox::about(this, trUtf8(("Über ")) + QA_NAME, QA_ABOUT);
786
}
787
 
159 KeyOz 788
void MKTool::slot_ac_GetLabels() // DONE 0.71g
158 KeyOz 789
{
199 KeyOz 790
    lb_Status->setText(tr("Analoglabels auslesen."));
158 KeyOz 791
    TX_Data[0] = 0;
167 KeyOz 792
    send_Data('a', ADDRESS_ALL, TX_Data, 1, true);
158 KeyOz 793
}
794
 
199 KeyOz 795
void MKTool::slot_ac_StartServer()
796
{
797
    if (ac_StartServer->isChecked())
798
    {
799
        lb_Status->setText(tr("GoogleEarth-Server gestartet."));
800
        Server->start_Server(Settings->Server.Port.toInt(), Settings);
801
    }
802
    else
803
    {
804
        lb_Status->setText(tr("GoogleEarth-Server gestopt."));
805
        Server->stop_Server();
806
    }
807
}
159 KeyOz 808
 
227 KeyOz 809
 
158 KeyOz 810
//  Daten-Plotter
811
/////////////////
812
void MKTool::update_Plot()
813
{
814
    for (int a = 0; a < MaxAnalog; a++)
815
    {
816
        Plot[a]->setData(aID,aData[a],NextPlot - 1);
817
    }
818
 
166 KeyOz 819
    if ((NextPlot > Settings->Data.Plotter_Count))
158 KeyOz 820
    {
166 KeyOz 821
        scroll_plot->setMaximum(NextPlot - Settings->Data.Plotter_Count);
158 KeyOz 822
    }
823
 
166 KeyOz 824
    if ((scroll_plot->value() == NextPlot - (Settings->Data.Plotter_Count + 1)))
158 KeyOz 825
    {
166 KeyOz 826
        qwtPlot->setAxisScale(QwtPlot::xBottom,NextPlot - Settings->Data.Plotter_Count,NextPlot,0);
827
        scroll_plot->setValue(NextPlot - Settings->Data.Plotter_Count);
158 KeyOz 828
    }
829
 
830
    qwtPlot->replot();
831
}
832
 
833
void MKTool::config_Plot()
834
{
166 KeyOz 835
//    qDebug("Plotter rekonfiguriert..!!");
836
    qwtPlot->setAxisScale(QwtPlot::xBottom,0,Settings->Data.Plotter_Count,0);
837
 
158 KeyOz 838
    for (int a = 0; a < MaxAnalog; a++)
839
    {
840
        Plot[a]->detach();
162 KeyOz 841
        Plot[a]->setPen(QPen(QColor(Def_Colors[a])));
158 KeyOz 842
 
162 KeyOz 843
        if (Settings->Analog1.PlotView[a])
844
        {
845
            Plot[a]->setTitle(Settings->Analog1.Label[a]);
158 KeyOz 846
            Plot[a]->attach(qwtPlot);
162 KeyOz 847
        }
158 KeyOz 848
    }
166 KeyOz 849
    qwtPlot->replot();
158 KeyOz 850
}
851
 
852
void MKTool::slot_ScrollPlot(int Pos)
853
{
166 KeyOz 854
    qwtPlot->setAxisScale(QwtPlot::xBottom,Pos,Pos + Settings->Data.Plotter_Count,0);
158 KeyOz 855
    qwtPlot->replot();
856
}
857
 
858
 
859
// Firmeware-Update
860
///////////////////
861
void MKTool::slot_pb_Update()
862
{
167 KeyOz 863
    QString Device;
864
    QString Hardware;
158 KeyOz 865
 
167 KeyOz 866
    if (rb_FC->isChecked())
867
    {
868
        Device   = "m644";
869
        Hardware = "FlightCtrl";
870
    }
871
    else if (rb_MK3MAG->isChecked())
872
    {
873
        Device   = "m168";
874
        Hardware = "MK3MAG";
875
    }
876
    else if (rb_BL->isChecked())
877
    {
878
        Device   = "m8";
879
        Hardware = "BL-Ctrl";
880
    }
166 KeyOz 881
 
882
    QString Message = "Firmeware-Datei \n\n";
883
    Message = Message + le_HexFile->text() + "\n\n";
167 KeyOz 884
    Message = Message + "an " + Hardware + trUtf8(" mit AVRDUDE - Seriel & Bootloader über ") + le_Port->text() + trUtf8(" übertragen?\n");
166 KeyOz 885
 
886
    if (le_HexFile->text() == "")
162 KeyOz 887
    {
166 KeyOz 888
        QMessageBox::warning(this, QA_NAME, trUtf8("Bitte Firmeware-Datei wählen."), QMessageBox::Ok);
162 KeyOz 889
    }
166 KeyOz 890
    else if (QMessageBox::warning(this, QA_NAME, Message, QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes)
891
    {
892
        QString Programm = "avrdude" ;
162 KeyOz 893
 
166 KeyOz 894
        QStringList Argumente;
162 KeyOz 895
 
166 KeyOz 896
        Update = new QProcess();
162 KeyOz 897
 
166 KeyOz 898
        if (serialPort->isOpen())
899
        {
900
            slot_OpenPort();
901
        }
902
 
903
        Argumente << "-P";
904
        Argumente << le_Port->text();
905
        Argumente << "-p";
906
        Argumente << Device;
907
        Argumente << "-c";
908
        Argumente << "butterfly";
909
        Argumente << "-b";
910
        Argumente << "57600";
911
        Argumente << "-U";
912
        Argumente << "flash:w:" + le_HexFile->text();
913
 
914
//    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";
915
 
916
        te_Shell->setText(""); // Ausgabefenster säubern
917
 
918
        connect(Update, SIGNAL(readyReadStandardOutput()), this, SLOT(slot_UpdateShell()) );
919
        connect(Update, SIGNAL(readyReadStandardError()), this, SLOT(slot_UpdateShell()) );
920
 
921
        Update->start(Programm, Argumente); // Programmaufruf
922
    }
158 KeyOz 923
}
924
 
925
void MKTool::slot_UpdateShell()
926
{
162 KeyOz 927
    QByteArray Output;
158 KeyOz 928
 
166 KeyOz 929
    Output = Update->readAllStandardError(); // Shellausgabe an Variable
162 KeyOz 930
    te_Shell->moveCursor(QTextCursor::End,  QTextCursor::MoveAnchor);
931
    te_Shell->insertPlainText(QString::fromUtf8(Output));
158 KeyOz 932
 
166 KeyOz 933
    Output = Update->readAll();
934
    te_Shell->moveCursor(QTextCursor::End,  QTextCursor::MoveAnchor);
935
    te_Shell->insertPlainText(QString::fromUtf8(Output));
158 KeyOz 936
}
937
 
166 KeyOz 938
void MKTool::slot_pb_HexFile()
939
{
940
    QString FileName = QFileDialog::getOpenFileName(this,trUtf8(("Firmeware-Datei wählen")),"",
941
                                tr("Intel Hex(*.hex);;Alle Dateien (*)"));
942
    if (!FileName.isEmpty())
943
    {
944
        le_HexFile->setText(FileName);
945
    }
946
}
158 KeyOz 947
 
948
 
167 KeyOz 949
// Wechsel der Tabs erkennen
159 KeyOz 950
void MKTool::slot_TabChanged(int Tab) // DONE 0.71g
158 KeyOz 951
{
952
    Tab = Tab;
162 KeyOz 953
    if (tab_Main->count() != 0)
158 KeyOz 954
    {
167 KeyOz 955
        if ((tab_Main->currentWidget()->objectName() == QString("Tab_2")) && (f_Settings->tab_Par->currentIndex() == 1))
162 KeyOz 956
        {
957
            TX_Data[0] = 0;
958
            send_Data('p', ADDRESS_FC, TX_Data, 0, true);
159 KeyOz 959
 
162 KeyOz 960
            Ticker->setInterval(500);
961
            TickerEvent[1] = true;
962
        }
963
        else
964
        {
965
            Ticker->setInterval(2000);
966
            TickerEvent[1] = false;
967
        }
227 KeyOz 968
/*
162 KeyOz 969
        if ((tab_Main->currentWidget()->objectName() == QString("Tab_4")))
970
        {
971
            TX_Data[0] = 0;
972
            TX_Data[1] = 0;
973
            send_Data('l', ADDRESS_ALL, TX_Data, 1, true);
159 KeyOz 974
 
162 KeyOz 975
            Ticker->setInterval(500);
976
            TickerEvent[2] = true;
977
        }
978
        else
979
        {
980
            Ticker->setInterval(2000);
981
            TickerEvent[2] = false;
982
        }
227 KeyOz 983
*/
159 KeyOz 984
    }
158 KeyOz 985
}
986
 
167 KeyOz 987
// LCD-Seiten weiterschalten
159 KeyOz 988
void MKTool::slot_LCD_UP() // DONE 0.71g
158 KeyOz 989
{
159 KeyOz 990
    if (LCD_Page == LCD_MAX_Page)
991
        TX_Data[0] = 0;
992
    else
993
        TX_Data[0] = LCD_Page + 1;
994
 
995
    TX_Data[1] = 0;
996
    send_Data('l', ADDRESS_ALL, TX_Data, 1, true);
227 KeyOz 997
 
159 KeyOz 998
}
999
 
1000
void MKTool::slot_LCD_DOWN() // DONE 0.71g
1001
{
1002
    if (LCD_Page == 0)
1003
        TX_Data[0] = LCD_MAX_Page;
1004
    else
1005
        TX_Data[0] = LCD_Page - 1;
1006
 
1007
    TX_Data[1] = 0;
1008
    send_Data('l', ADDRESS_ALL, TX_Data, 1, true);
227 KeyOz 1009
 
1010
    aa--;
1011
 
159 KeyOz 1012
}
1013
 
167 KeyOz 1014
// Settings aus MK lesen / in MK schreiben
199 KeyOz 1015
void MKTool::slot_GetFCSettings() // DONE 0.71g
159 KeyOz 1016
{
199 KeyOz 1017
    lb_Status->setText(tr("Lese FlightCtrl-Settings aus."));
167 KeyOz 1018
    TX_Data[0] = f_Settings->sb_Set->value();
158 KeyOz 1019
    TX_Data[1] = 0;
159 KeyOz 1020
    send_Data('q', ADDRESS_FC, TX_Data, 1);
158 KeyOz 1021
}
1022
 
199 KeyOz 1023
void MKTool::slot_SetFCSettings() // DONE 0.71g
158 KeyOz 1024
{
199 KeyOz 1025
    char *TX_Data2 = f_Settings->GetFCSettings();
158 KeyOz 1026
 
199 KeyOz 1027
    lb_Status->setText(tr("Schreibe FlightCtrl-Settings."));
167 KeyOz 1028
 
1029
    send_Data('s', ADDRESS_FC, TX_Data2, MaxParameter + 2, false);
158 KeyOz 1030
}
1031
 
159 KeyOz 1032
 
167 KeyOz 1033
// Save GUI-Preferences
1034
///////////////////////
1035
void MKTool::set_Preferences()
158 KeyOz 1036
{
163 KeyOz 1037
    Settings->GUI.TabViews.setBit(0, ac_View0->isChecked());
1038
    Settings->GUI.TabViews.setBit(1, ac_View1->isChecked());
1039
    Settings->GUI.TabViews.setBit(2, ac_View2->isChecked());
1040
    Settings->GUI.TabViews.setBit(3, ac_View3->isChecked());
1041
    Settings->GUI.TabViews.setBit(4, ac_View4->isChecked());
1042
    Settings->GUI.TabViews.setBit(5, ac_View5->isChecked());
227 KeyOz 1043
    Settings->GUI.TabViews.setBit(6, ac_View6->isChecked());
158 KeyOz 1044
 
227 KeyOz 1045
    Settings->GUI.ToolViews.setBit(0, tb_Allgemein->isVisibleTo(this));
1046
    Settings->GUI.ToolViews.setBit(1, tb_Werkzeuge->isVisibleTo(this));
1047
    Settings->GUI.ToolViews.setBit(2, tb_Debug->isVisibleTo(this));
1048
    Settings->GUI.ToolViews.setBit(3, tb_TTY->isVisibleTo(this));
1049
    Settings->GUI.ToolViews.setBit(4, tb_Hardware->isVisibleTo(this));
1050
 
162 KeyOz 1051
    Settings->GUI.Term_Info   = cb_ShowMSG->isChecked();
1052
    Settings->GUI.Term_Data   = cb_ShowData->isChecked();
1053
    Settings->GUI.Term_Always = cb_ShowAlways->isChecked();
166 KeyOz 1054
    Settings->GUI.Term_Send   = cb_ShowSend->isChecked();
167 KeyOz 1055
    Settings->GUI.isMax       = isMaximized();
1056
    Settings->GUI.Size        = size();
1057
    Settings->GUI.Point       = pos();
162 KeyOz 1058
 
163 KeyOz 1059
    Settings->TTY.Port = le_Port->text();
158 KeyOz 1060
}
1061
 
159 KeyOz 1062
 
158 KeyOz 1063
// Debug-Daten anzeigen und Aufzeichnen
1064
///////////////////////////////////////
1065
void MKTool::write_CSV()
1066
{
1067
    QTextStream Out(CSVFile);
1068
    for (int a=0; a<MaxAnalog; a++)
1069
    {
162 KeyOz 1070
        if (Settings->Analog1.LogView[a])
158 KeyOz 1071
        {
1072
            Out << AnalogData[a];
1073
            if (a < MaxAnalog - 1)
1074
                Out << ';';
1075
        }
1076
    }
1077
    Out << "\n";
1078
}
1079
 
159 KeyOz 1080
void MKTool::slot_RecordCSV() // DONE 0.71g
158 KeyOz 1081
{
1082
    if (!CSVFile->isOpen())
199 KeyOz 1083
    {      
159 KeyOz 1084
        QString Filename = Settings->DIR.Logging + Mode.Hardware + " - " + QDate::currentDate().toString(("yyyy-MM-dd")) + " -- " + QTime::currentTime().toString("hh-mm") + ".csv";
158 KeyOz 1085
 
1086
        CSVFile = new QFile(Filename);
1087
        if (!CSVFile->exists())
1088
        {
1089
            CSVFile->open(QIODevice::Append | QIODevice::Text);
1090
 
1091
            QTextStream Out(CSVFile);
1092
 
1093
            for (int a = 0; a < MaxAnalog; a++)
1094
            {
162 KeyOz 1095
                if (Settings->Analog1.LogView[a])
158 KeyOz 1096
                {
162 KeyOz 1097
                    Out << Settings->Analog1.Label[a];
158 KeyOz 1098
 
1099
                    if (a < MaxAnalog - 1)
1100
                        Out << ';';
1101
                }
1102
            }
1103
            Out << "\n";
1104
        }
1105
        else
1106
        {
1107
            CSVFile->open(QIODevice::Append | QIODevice::Text);
1108
        }
1109
 
227 KeyOz 1110
//        pb_Record->setIcon(ToolBox::Icon(6));
1111
//        pb_Record->setText("CSV Stop");
1112
//        ac_RecordCSV->setIcon(ToolBox::Icon(6));
158 KeyOz 1113
        ac_RecordCSV->setText("CSV Stop");
199 KeyOz 1114
        lb_Status->setText(tr("CVS-Record gestartet."));
158 KeyOz 1115
    }
1116
    else
1117
    {
1118
        CSVFile->close();
227 KeyOz 1119
//        pb_Record->setIcon(ToolBox::Icon(7));
1120
//        pb_Record->setText("CSV Aufzeichnen");
1121
//        ac_RecordCSV->setIcon(ToolBox::Icon(7));
158 KeyOz 1122
        ac_RecordCSV->setText("CSV  Aufzeichnen");
199 KeyOz 1123
        lb_Status->setText(tr("CVS-Record gestopt."));
158 KeyOz 1124
    }
1125
}
1126
 
1127
void MKTool::show_DebugData()
1128
{
1129
    if (CSVFile->isOpen())
1130
    {
1131
        write_CSV();
1132
    }
1133
 
1134
    if (ac_StartPlotter->isChecked())
1135
    {
1136
        aID[NextPlot] = NextPlot;
1137
 
1138
        for (int a = 0; a < MaxAnalog; a++)
1139
        {
1140
            aData[a][NextPlot] = AnalogData[a];
1141
        }
1142
        NextPlot++;
1143
 
1144
        if ((tab_Main->currentWidget()->objectName() == QString("Tab_1")))
1145
            update_Plot();
1146
    }
1147
 
1148
    le_A_0->setText(QString("%1").arg(AnalogData[0]));
1149
    le_A_1->setText(QString("%1").arg(AnalogData[1]));
1150
    le_A_2->setText(QString("%1").arg(AnalogData[2]));
1151
    le_A_3->setText(QString("%1").arg(AnalogData[3]));
1152
    le_A_4->setText(QString("%1").arg(AnalogData[4]));
1153
    le_A_5->setText(QString("%1").arg(AnalogData[5]));
1154
    le_A_6->setText(QString("%1").arg(AnalogData[6]));
1155
    le_A_7->setText(QString("%1").arg(AnalogData[7]));
1156
    le_A_8->setText(QString("%1").arg(AnalogData[8]));
1157
    le_A_9->setText(QString("%1").arg(AnalogData[9]));
1158
    le_A_10->setText(QString("%1").arg(AnalogData[10]));
1159
    le_A_11->setText(QString("%1").arg(AnalogData[11]));
1160
    le_A_12->setText(QString("%1").arg(AnalogData[12]));
1161
    le_A_13->setText(QString("%1").arg(AnalogData[13]));
1162
    le_A_14->setText(QString("%1").arg(AnalogData[14]));
1163
    le_A_15->setText(QString("%1").arg(AnalogData[15]));
1164
    le_A_16->setText(QString("%1").arg(AnalogData[16]));
1165
    le_A_17->setText(QString("%1").arg(AnalogData[17]));
1166
    le_A_18->setText(QString("%1").arg(AnalogData[18]));
1167
    le_A_19->setText(QString("%1").arg(AnalogData[19]));
1168
    le_A_20->setText(QString("%1").arg(AnalogData[20]));
1169
    le_A_21->setText(QString("%1").arg(AnalogData[21]));
1170
    le_A_22->setText(QString("%1").arg(AnalogData[22]));
1171
    le_A_23->setText(QString("%1").arg(AnalogData[23]));
1172
    le_A_24->setText(QString("%1").arg(AnalogData[24]));
1173
    le_A_25->setText(QString("%1").arg(AnalogData[25]));
1174
    le_A_26->setText(QString("%1").arg(AnalogData[26]));
1175
    le_A_27->setText(QString("%1").arg(AnalogData[27]));
1176
    le_A_28->setText(QString("%1").arg(AnalogData[28]));
1177
    le_A_29->setText(QString("%1").arg(AnalogData[29]));
1178
    le_A_30->setText(QString("%1").arg(AnalogData[30]));
1179
    le_A_31->setText(QString("%1").arg(AnalogData[31]));
227 KeyOz 1180
 
1181
    if ((Mode.ID == ADDRESS_FC) && (FCSettings[P_GYRO_ACC_FAKTOR] > 0))
1182
    {
1183
        bar_UBAT->setValue(AnalogData[9]);
1184
        bar_RX->setValue(AnalogData[10]);
1185
 
1186
        Compass->setValue(AnalogData[8]);
1187
 
1188
        int Roll = (AnalogData[1] * FCSettings[P_GYRO_ACC_FAKTOR]) / 1024;
1189
        int Nick = (AnalogData[0] * FCSettings[P_GYRO_ACC_FAKTOR]) / 1024;
1190
 
1191
        if (Roll > 128)
1192
            Roll = Roll - 255;
1193
 
1194
        if (Nick > 128)
1195
            Nick = Nick - 255;
1196
 
1197
        Attitude->setAngle(Roll);
1198
        Attitude->setGradient(double(double(Nick) / 100.0));
1199
    }
158 KeyOz 1200
}
1201
 
159 KeyOz 1202
 
199 KeyOz 1203
void MKTool::new_NaviData(sRxData RX)
1204
{
1205
    Navi.Current.Longitude = ToolBox::Data2Long(RX.Decode, 0, true);
1206
    Navi.Current.Latitude  = ToolBox::Data2Long(RX.Decode, 4, true);
1207
    Navi.Current.Altitude  = ToolBox::Data2Long(RX.Decode, 8, true);
227 KeyOz 1208
    Navi.Target.Longitude  = ToolBox::Data2Long(RX.Decode, 16, true);
1209
    Navi.Target.Latitude   = ToolBox::Data2Long(RX.Decode, 20, true);
1210
    Navi.Target.Altitude   = ToolBox::Data2Long(RX.Decode, 24, true);
199 KeyOz 1211
 
227 KeyOz 1212
    le_CDistance->setText(QString("%1 cm").arg(ToolBox::Data2Int(RX.Decode, 52)));
1213
    le_CWPA->setText(QString("%1").arg(RX.Decode[56]));
1214
    le_CWPT->setText(QString("%1").arg(RX.Decode[57]));
1215
    le_CSats->setText(QString("%1").arg(RX.Decode[58]));
1216
 
1217
    qwt_Rate->setValue(double(ToolBox::Data2Int(RX.Decode, 61, true)));
1218
 
1219
    le_CTime->setText(QString("%1 sec.").arg(ToolBox::Data2Int(RX.Decode, 63)));
1220
 
1221
    bar_UBAT->setValue(RX.Decode[65]);
1222
 
1223
    double Speed = double((ToolBox::Data2Int(RX.Decode, 66)) / 10.0);
1224
 
1225
    if ((Speed > 4.5) && SpeedMeter->property("END") == 5)
1226
    {
1227
        SpeedMeter->setRange(0.0, 10.0);
1228
        SpeedMeter->setScale(1, 2, 1);
1229
        SpeedMeter->setProperty("END", 10);
1230
    }
1231
 
1232
    if ((Speed > 9) && SpeedMeter->property("END") == 10)
1233
    {
1234
        SpeedMeter->setRange(0.0, 20.0);
1235
        SpeedMeter->setScale(1, 2, 2);
1236
        SpeedMeter->setProperty("END", 20);
1237
    }
1238
 
1239
    SpeedMeter->setValue(Speed);
1240
 
1241
    Compass->setValue(ToolBox::Data2Int(RX.Decode, 70)); //(68)
1242
 
1243
    bar_RX->setValue(RX.Decode[74]);
1244
 
1245
    int Nick = RX.Decode[72];
1246
    int Roll = RX.Decode[73];
1247
 
1248
    if (Roll > 128)
1249
        Roll = Roll - 255;
1250
 
1251
    if (Nick > 128)
1252
        Nick = Nick - 255;
1253
 
1254
    Attitude->setAngle(Roll);
1255
    Attitude->setGradient(double(double(Nick) / 100.0));
1256
 
199 KeyOz 1257
    sNaviString NaviString;
1258
 
1259
    NaviString.Longitude = ToolBox::get_Float(Navi.Current.Longitude,10000000);
1260
    NaviString.Latitude  = ToolBox::get_Float(Navi.Current.Latitude,10000000);
1261
    NaviString.Altitude  = ToolBox::get_Float(Navi.Current.Altitude,1000);
1262
 
1263
    Server->store_NaviString(NaviString);
1264
 
227 KeyOz 1265
    if ((MyServer->property("Connect")) == true)
1266
    {
1267
        MyServer->NewPosition(NaviString);
1268
    }
1269
 
199 KeyOz 1270
    /*
1271
    qDebug(NaviString.Longitude.toLatin1().data());
1272
    qDebug(NaviString.Latitude.toLatin1().data());
1273
    qDebug(NaviString.Altitude.toLatin1().data());
1274
    */
1275
}
1276
 
158 KeyOz 1277
// Seriel-Port Bereich, Befehle senden und Daten empfangen
1278
//////////////////////////////////////////////////////////
1279
 
1280
// Neues Datenpacket empfangen -> Verarbeiten
159 KeyOz 1281
void MKTool::new_RXData(sRxData RX) // DONE 0.71g
158 KeyOz 1282
{
1283
 
1284
    if (LastSend.length() > 2)
1285
    {
1286
    }
1287
 
162 KeyOz 1288
    int HardwareID = RX.Input[1] - 'a';
1289
 
167 KeyOz 1290
    switch(HardwareID)
158 KeyOz 1291
    {
167 KeyOz 1292
        case ADDRESS_FC :
1293
            switch(RX.Input[2])
1294
            {
1295
                // Stick-Belegung der Fernsteuerung
1296
                case 'P' : // DONE 0.71g
1297
                    if (ToolBox::Decode64(RX))
158 KeyOz 1298
                    {
167 KeyOz 1299
                        f_Settings->pb_K1->setValue(ToolBox::Data2Int(RX.Decode,  2,true));
1300
                        f_Settings->pb_K2->setValue(ToolBox::Data2Int(RX.Decode,  4,true));
1301
                        f_Settings->pb_K3->setValue(ToolBox::Data2Int(RX.Decode,  6,true));
1302
                        f_Settings->pb_K4->setValue(ToolBox::Data2Int(RX.Decode,  8,true));
1303
                        f_Settings->pb_K5->setValue(ToolBox::Data2Int(RX.Decode, 10 ,true));
1304
                        f_Settings->pb_K6->setValue(ToolBox::Data2Int(RX.Decode, 12,true));
1305
                        f_Settings->pb_K7->setValue(ToolBox::Data2Int(RX.Decode, 14,true));
1306
                        f_Settings->pb_K8->setValue(ToolBox::Data2Int(RX.Decode, 16,true));
1307
                    }
1308
                break;
1309
                // Settings lesen
1310
                case 'Q' : // DONE 0.71g
1311
                    if (ToolBox::Decode64(RX))
1312
                    {
1313
                        TickerEvent[0] = false;
1314
 
1315
                        if (RX.Decode[1] == VERSION_SETTINGS)
1316
                        {
1317
                            int Settings_ID = RX.Decode[0];
1318
                            for (int a = 0; a < MaxParameter; a++)
1319
                            {
199 KeyOz 1320
                                FCSettings[a] = RX.Decode[a + 2];
167 KeyOz 1321
                            }
1322
                            //show_ParameterSet(Settings_ID);
199 KeyOz 1323
                            f_Settings->show_FCSettings(Settings_ID, FCSettings);
1324
                            f_Settings->pb_Read->setEnabled(true);
1325
                            f_Settings->pb_Write->setEnabled(true);
167 KeyOz 1326
                        }
1327
                        else
1328
                        {
1329
                            f_Settings->pb_Read->setDisabled(true);
1330
                            f_Settings->pb_Write->setDisabled(true);
1331
 
1332
                            QMessageBox::warning(this, QA_NAME,
1333
                                   "Versionen inkompatibel. \nParameterbearbeitung nicht moeglich.", QMessageBox::Ok);
1334
                        }
1335
                    }
1336
                break;
1337
                // Settings geschrieben
1338
                case 'S' : // DONE 0.71g
1339
                    TickerEvent[0] = false;
1340
                break;
1341
            }
1342
 
1343
        case ADDRESS_NC :
1344
            switch(RX.Input[2])
1345
            {
1346
                // Navigationsdaten
1347
                case 'O' : // NOT DONE 0.12h
1348
                    if (ToolBox::Decode64(RX))
1349
                    {
199 KeyOz 1350
                        new_NaviData(RX);
167 KeyOz 1351
                    }
1352
                break;
1353
            }
1354
//        case ADDRESS_MK3MAG :
1355
 
1356
        default :
1357
            switch(RX.Input[2])
1358
            {
1359
                // LCD-Anzeige
1360
                case 'L' : // DONE 0.71g
1361
                    if (ToolBox::Decode64(RX))
1362
                    {
159 KeyOz 1363
                        int LCD[150];
1364
                        memcpy(LCD,RX.Decode, sizeof(RX.Decode));
1365
 
227 KeyOz 1366
                        f_LCD->show_Data(LCD);
1367
 
159 KeyOz 1368
                        LCD_Page     = RX.Decode[0];
1369
                        LCD_MAX_Page = RX.Decode[1];
1370
 
1371
                        TickerEvent[0] = false;
158 KeyOz 1372
                    }
1373
                break;
167 KeyOz 1374
                // Analoglabels
1375
                case 'A' : // DONE 0.71g
1376
                    if (ToolBox::Decode64(RX))
158 KeyOz 1377
                    {
159 KeyOz 1378
                        int Position = RX.Decode[0];
163 KeyOz 1379
                        if (Position != 31)
158 KeyOz 1380
                        {
162 KeyOz 1381
                            Settings->Analog1.Label[Position] = ToolBox::Data2QString(RX.Decode,1,17).trimmed();
167 KeyOz 1382
                            if (Settings->Analog1.Label[Position] == "")
1383
                            {
1384
                                Settings->Analog1.Label[Position] = "A-" + QString("%1").arg(Position);
1385
                            }
158 KeyOz 1386
                            Position ++;
1387
                            TX_Data[0] = Position;
167 KeyOz 1388
                            send_Data('a', ADDRESS_ALL, TX_Data, 1, true);
158 KeyOz 1389
                        }
166 KeyOz 1390
                        if (Position == 31)
158 KeyOz 1391
                        {
1392
                            for (int a = 0; a < MaxAnalog; a++)
1393
                            {
162 KeyOz 1394
                                lb_Analog[a]->setText(Settings->Analog1.Label[a]);
158 KeyOz 1395
                            }
163 KeyOz 1396
                            Settings->Analog1.Version = Mode.Version;
162 KeyOz 1397
                            Settings->write_Settings_AnalogLabels(HardwareID);
158 KeyOz 1398
                            config_Plot();
1399
                        }
1400
                    }
1401
                break;
167 KeyOz 1402
                // Debug-Daten
1403
                case 'D' : // DONE 0.71g
1404
                    if (ToolBox::Decode64(RX))
158 KeyOz 1405
                    {
1406
                        for (int i = 0; i < MaxAnalog; i++)
1407
                        {
1408
                            AnalogData[i] = ToolBox::Data2Int(RX.Decode, (i * 2) + 2);
1409
                        }
1410
                        show_DebugData();
1411
                    }
1412
                break;
167 KeyOz 1413
                // Version
1414
                case 'V' : // DONE 0.71h
1415
                    if (ToolBox::Decode64(RX))
159 KeyOz 1416
                    {
167 KeyOz 1417
                        TickerEvent[0] = false;
159 KeyOz 1418
 
167 KeyOz 1419
                        Mode.ID            = HardwareID;
1420
                        Mode.VERSION_MAJOR = RX.Decode[0];
1421
                        Mode.VERSION_MINOR = RX.Decode[1];
1422
                        Mode.VERSION_PATCH = RX.Decode[4];
1423
                        Mode.VERSION_SERIAL_MAJOR = RX.Decode[2];
1424
                        Mode.VERSION_SERIAL_MINOR = RX.Decode[3];
159 KeyOz 1425
 
167 KeyOz 1426
                        Mode.Hardware   = HardwareType[Mode.ID];
1427
                        Mode.Version    = QString("%1").arg(RX.Decode[0]) + "." + QString("%1").arg(RX.Decode[1]) + QString(RX.Decode[4] + 'a');
158 KeyOz 1428
 
167 KeyOz 1429
                        setWindowTitle(QA_NAME + " v" + QA_VERSION + " - " + Mode.Hardware + " " + Mode.Version);
158 KeyOz 1430
 
167 KeyOz 1431
                        if (Mode.VERSION_SERIAL_MAJOR != VERSION_SERIAL_MAJOR)
1432
                        {
1433
                                AllowSend = false;
1434
                                QMessageBox::warning(this, QA_NAME,
1435
                                   "Serielles Protokoll Inkompatibel. \nBitte neue Programmversion installieren,", QMessageBox::Ok);
1436
                        }
159 KeyOz 1437
 
199 KeyOz 1438
                        if (ac_NoDebug->isChecked())
1439
                        {
1440
                            TX_Data[0] = 0;
1441
                        }
1442
                        else
1443
                        if (ac_FastDebug->isChecked())
1444
                        {
1445
                            TX_Data[0] = Settings->Data.Debug_Fast / 10;
1446
                        }
1447
                        else
1448
                        {
1449
                            TX_Data[0] = Settings->Data.Debug_Slow / 10;
1450
                        }
1451
 
1452
                        send_Data('d', ADDRESS_ALL, TX_Data, 1, false);
1453
 
167 KeyOz 1454
                        // Wenn MK3MAG dann andauernd Daten neu anfragen.
1455
                        if (Mode.ID == ADDRESS_MK3MAG)
1456
                        {
1457
                            TickerEvent[3] = true;
199 KeyOz 1458
                            rb_SelMag->setChecked(true);
167 KeyOz 1459
                        }
158 KeyOz 1460
 
199 KeyOz 1461
                        // Wenn NaviCtrl dann hier.
1462
                        if (Mode.ID == ADDRESS_NC)
1463
                        {
1464
                            rb_SelNC->setChecked(true);
158 KeyOz 1465
 
199 KeyOz 1466
                            if (ac_NoNavi->isChecked())
1467
                            {
1468
                                TX_Data[0] = 0;
1469
                            }
1470
                            else
1471
                            if (ac_FastNavi->isChecked())
1472
                            {
1473
                                TX_Data[0] = Settings->Data.Navi_Fast / 10;
1474
                            }
1475
                            else
1476
                            {
1477
                                TX_Data[0] = Settings->Data.Navi_Slow / 10;
1478
                            }
1479
 
1480
                            send_Data('o', ADDRESS_NC, TX_Data, 1, false);
1481
                        }
1482
 
1483
 
167 KeyOz 1484
                        // Wenn FlightCtrl dann Settings abfragen.
1485
                        if (Mode.ID == ADDRESS_FC)
1486
                        {
199 KeyOz 1487
                            rb_SelFC->setChecked(true);
167 KeyOz 1488
                            {
1489
                                TX_Data[0] = 0xff;
1490
                                TX_Data[1] = 0;
1491
                                send_Data('q', ADDRESS_FC, TX_Data, 1);
1492
                            }
1493
                        }
1494
                        // Wenn nicht Lesen und Schreiben der Settings deaktivieren.
1495
                        else
1496
                        {
1497
                                f_Settings->pb_Read->setDisabled(true);
1498
                                f_Settings->pb_Write->setDisabled(true);
1499
                        }
158 KeyOz 1500
 
167 KeyOz 1501
                        Settings->read_Settings_Analog(HardwareID);
1502
                        Settings->read_Settings_AnalogLabels(HardwareID);
159 KeyOz 1503
 
167 KeyOz 1504
                        if (Settings->Analog1.Version != Mode.Version)
158 KeyOz 1505
                        {
167 KeyOz 1506
                            lb_Status->setText("Analoglabel-Version unterschiedlich. Lese Analoglabels neu aus.");
1507
                            slot_ac_GetLabels();
158 KeyOz 1508
                        }
167 KeyOz 1509
                        else
1510
                        for (int a = 0; a < MaxAnalog; a++)
1511
                        {
1512
                            lb_Analog[a]->setText(Settings->Analog1.Label[a]);
1513
                        }
1514
                        config_Plot();
158 KeyOz 1515
                    }
1516
                break;
167 KeyOz 1517
            }
158 KeyOz 1518
    }
1519
}
1520
 
1521
// Neue Daten an der Schnittstelle
159 KeyOz 1522
void MKTool::slot_newDataReceived(const QByteArray &dataReceived) // DONE 0.71g
158 KeyOz 1523
{
1524
    const char *RXt;
1525
    RXt = dataReceived.data();
1526
    int a = 0;
1527
 
1528
    while (RXt[a] != '\0')
1529
    {
1530
        if (RXt[a] == '\r')
1531
        {
1532
            while ((RxData.String.length() > 1) && (RxData.String.at(1) == '#'))
1533
            {
1534
                RxData.String.remove(0,1);
1535
            }
1536
 
1537
            if (ToolBox::check_CRC(RxData.String))
1538
            {
1539
                RxData.Input = RxData.String.toLatin1().data();
1540
                new_RXData(RxData);
1541
 
162 KeyOz 1542
                if ((cb_ShowData->isChecked()) && ((tab_Main->currentWidget()->objectName() == QString("Tab_3")) || (cb_ShowAlways->isChecked())))
158 KeyOz 1543
                {
1544
                    te_RX->moveCursor(QTextCursor::End,  QTextCursor::MoveAnchor);
166 KeyOz 1545
//                    te_RX->insertPlainText(" > " + RxData.String + '\r');
1546
                    te_RX->insertHtml("<span style=\"color:#00008b;\">" + RxData.String + "<br /></span>");
158 KeyOz 1547
                }
1548
            }
1549
            else
1550
            {
162 KeyOz 1551
                if ((cb_ShowMSG->isChecked()) && ((tab_Main->currentWidget()->objectName() == QString("Tab_3")) || (cb_ShowAlways->isChecked())))
158 KeyOz 1552
                {
1553
                    te_RX->moveCursor(QTextCursor::End,  QTextCursor::MoveAnchor);
166 KeyOz 1554
//                    te_RX->insertPlainText(" > " + RxData.String + '\r');
1555
                    te_RX->insertHtml("<span style=\"color:#008b00;\">" + RxData.String + "<br /></span>");
158 KeyOz 1556
                }
1557
            }
1558
            RxData.String = QString("");
1559
        }
1560
        else
1561
        {
1562
            {
1563
                RxData.String = RxData.String + QString(RXt[a]);
1564
            }
1565
        }
1566
        a++;
1567
    }
1568
}
1569
 
1570
// Seriellen Port öffnen
1571
void MKTool::slot_OpenPort()
1572
{
1573
    if (serialPort->isOpen())
227 KeyOz 1574
    {        
199 KeyOz 1575
        TX_Data[0] = Settings->Data.Debug_Off / 10;
1576
        send_Data('d', ADDRESS_ALL, TX_Data, 1, false);
227 KeyOz 1577
        ToolBox::Wait(SLEEP);
158 KeyOz 1578
 
199 KeyOz 1579
        if (Mode.ID == ADDRESS_NC)
1580
        {
1581
            TX_Data[0] = Settings->Data.Navi_Off / 10;
1582
            send_Data('o', ADDRESS_NC, TX_Data, 1, false);
227 KeyOz 1583
            ToolBox::Wait(SLEEP);
199 KeyOz 1584
        }
1585
 
1586
        if (Mode.ID == ADDRESS_NC)
1587
        {
1588
            TX_Data[0] = 0;
1589
            TX_Data[1] = 0;
1590
            TX_Data[2] = 0;
1591
            TX_Data[3] = 0;
1592
            send_Data('t', ADDRESS_FC, TX_Data, 4, false);
227 KeyOz 1593
            ToolBox::Wait(SLEEP);
199 KeyOz 1594
        }
158 KeyOz 1595
        serialPort->close();
227 KeyOz 1596
//        pb_Open->setText("Seriell Verbinden");
1597
        ac_ConnectTTY->setText("Seriell Verbinden");
1598
//        pb_Open->setIcon(ToolBox::Icon(9));
1599
//        ac_ConnectTTY->setIcon(ToolBox::Icon(9));
167 KeyOz 1600
 
199 KeyOz 1601
        le_Port->setEnabled(true);
1602
 
167 KeyOz 1603
        Ticker->stop();
158 KeyOz 1604
    }
1605
    else
1606
    {
1607
        serialPort->setPort(le_Port->text()); //Port
1608
 
1609
        serialPort->setBaudRate(BAUD57600); //BaudRate
1610
        serialPort->setDataBits(DATA_8); //DataBits
1611
        serialPort->setParity(PAR_NONE); //Parity
1612
        serialPort->setStopBits(STOP_1); //StopBits
1613
        serialPort->setFlowControl(FLOW_OFF); //FlowControl
1614
 
1615
        serialPort->setTimeout(0, 10);
1616
        serialPort->enableSending();
1617
        serialPort->enableReceiving();
1618
 
1619
        serialPort->open();
1620
        if (serialPort->isOpen())
1621
        {
199 KeyOz 1622
            le_Port->setEnabled(false);
158 KeyOz 1623
            serialPort->receiveData();
1624
 
159 KeyOz 1625
            send_Data('v', ADDRESS_ALL, TX_Data, 0, true);
1626
 
227 KeyOz 1627
//            pb_Open->setText("Seriell Trennen");
1628
            ac_ConnectTTY->setText("Seriell Trennen");
1629
//            pb_Open->setIcon(ToolBox::Icon(8));
1630
//            ac_ConnectTTY->setIcon(ToolBox::Icon(8));
167 KeyOz 1631
 
1632
            Ticker->start(2000);
158 KeyOz 1633
        }
1634
    }
1635
}
1636
 
1637
// Daten senden
159 KeyOz 1638
void MKTool::send_Data(char CMD, int Address, char Data[150],unsigned int Length, bool Resend) // DONE 0.71g
158 KeyOz 1639
{
159 KeyOz 1640
    if (serialPort->isOpen() && AllowSend)
158 KeyOz 1641
    {
199 KeyOz 1642
        QByteArray Temp;
1643
        QString TX_Data;
158 KeyOz 1644
 
199 KeyOz 1645
        if (CMD != '#')
1646
        {
1647
//            qDebug("Send data..");
1648
            TX_Data = ToolBox::Encode64(Data, Length);
158 KeyOz 1649
 
199 KeyOz 1650
            TX_Data = QString("#") + (QString('a' + Address)) + QString(CMD) + TX_Data;
1651
 
158 KeyOz 1652
//    qDebug(TX_Data.toLatin1().data());
1653
 
199 KeyOz 1654
            TX_Data = ToolBox::add_CRC(TX_Data) + '\r';
158 KeyOz 1655
 
1656
//    qDebug(TX_Data.toLatin1().data());
1657
 
199 KeyOz 1658
            if (Resend)
1659
            {
1660
                LastSend = TX_Data;
1661
                TickerEvent[0] = true;
1662
            }
1663
            Temp = QByteArray(TX_Data.toUtf8());
1664
        }
1665
        else
158 KeyOz 1666
        {
199 KeyOz 1667
//            qDebug("Send Raw..");
1668
            for (unsigned int a = 0; a < Length; a++)
1669
            {
1670
                Temp[a] = Data[a];
1671
//                qDebug(QString("%1").arg(Temp[a]).toLatin1().data());
1672
            }
158 KeyOz 1673
        }
1674
 
1675
        serialPort->sendData(Temp);
166 KeyOz 1676
 
199 KeyOz 1677
        if (cb_ShowSend->isChecked() && (CMD != '#'))
166 KeyOz 1678
        {
1679
            te_RX->moveCursor(QTextCursor::End,  QTextCursor::MoveAnchor);
1680
            te_RX->insertHtml("<span style='color:#8b0000;'>" + TX_Data + "<br /></span>");
1681
        }
158 KeyOz 1682
    }
1683
}
1684
 
1685
 
1686
// Programm beenden
1687
///////////////////
162 KeyOz 1688
 
1689
MKTool::~MKTool()
158 KeyOz 1690
{
166 KeyOz 1691
//    qDebug(" Programm Ende ..!! ");
158 KeyOz 1692
    if (serialPort->isOpen())
1693
    {
1694
        serialPort->close();
1695
    }
1696
 
167 KeyOz 1697
    set_Preferences();
162 KeyOz 1698
    Settings->write_Settings();
158 KeyOz 1699
 
1700
    if (CSVFile->isOpen())
1701
    {
1702
        CSVFile->close();
1703
    }
1704
}