Subversion Repositories Projects

Rev

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