Subversion Repositories Projects

Rev

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