Subversion Repositories Projects

Rev

Rev 462 | Rev 513 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 462 Rev 500
1
#include "Handler.h"
1
#include "Handler.h"
2
#include <iostream>
2
#include "FlightLog.h"
3
 
3
 
4
/**
4
/**
5
 * Constructor that gets a communication instance
5
 * Constructor that gets a communication instance
6
 */
6
 */
7
Handler::Handler(Communication * com, KopterData * data) {
7
Handler::Handler(Communication * com, KopterData * data) {
8
    this->com = com;
8
    this->com = com;
9
    this->data = data;
9
    this->data = data;
10
}
10
}
11
 
11
 
12
//-------------FlightCtrl commands--------------------
12
//-------------FlightCtrl commands--------------------
13
/**
13
/**
14
 * read settings from FlightCtrl (settings index 0x00-0x05)
14
 * read settings from FlightCtrl (settings index 0x00-0x05)
15
 */
15
 */
16
void Handler::get_flightctrl_settings(int index) {
16
void Handler::get_flightctrl_settings(int index) {
17
    char tx_data[2] = {index, 0};
17
    char tx_data[2] = {index, 0};
18
    com->send_cmd('q', ADDRESS_FC, tx_data, 1, true);
18
    com->send_cmd('q', ADDRESS_FC, tx_data, 1, true);
19
}
19
}
20
 
20
 
21
/**
21
/**
22
 * write settings to FlightCtrl
22
 * write settings to FlightCtrl
23
 */
23
 */
24
void Handler::set_flightctrl_settings(char * tx_data) {
24
void Handler::set_flightctrl_settings(char * tx_data) {
25
    com->send_cmd('s', ADDRESS_FC, tx_data, MaxParameter+2, true);
25
    com->send_cmd('s', ADDRESS_FC, tx_data, MaxParameter+2, true);
26
}
26
}
27
 
27
 
28
/**
28
/**
29
 * test one or more motors
29
 * test one or more motors
30
 */
30
 */
31
void Handler::motor_test(sMotorData motor) {
31
void Handler::motor_test(sMotorData motor) {
32
    char tx_data[MAX_MOTORS];
32
    char tx_data[MAX_MOTORS];
33
    for (int z = 0; z<MAX_MOTORS; z++)
33
    for (int z = 0; z<MAX_MOTORS; z++)
34
    {
34
    {
35
        tx_data[z] = motor.desired_speed[z];
35
        tx_data[z] = motor.desired_speed[z];
36
    }
36
    }
37
    com->send_cmd('t', ADDRESS_FC, tx_data, MAX_MOTORS, false);
37
    com->send_cmd('t', ADDRESS_FC, tx_data, MAX_MOTORS, false);
38
}
38
}
39
 
39
 
40
void Handler::reset_motor() {
40
void Handler::reset_motor() {
41
    for (int z = 0; z<MAX_MOTORS; z++)
41
    for (int z = 0; z<MAX_MOTORS; z++)
42
    {
42
    {
43
        data->motor.desired_speed[z] = 0;
43
        data->motor.desired_speed[z] = 0;
44
    }
44
    }
45
 
45
 
46
    motor_test(data->motor);
46
    motor_test(data->motor);
47
}
47
}
48
 
48
 
49
/**
49
/**
50
 * read mixer values from FlightCtrl
50
 * read mixer values from FlightCtrl
51
 */
51
 */
52
void Handler::read_motor_mixer() {
52
void Handler::read_motor_mixer() {
53
    char tx_data[1] = {0};
53
    char tx_data[1] = {0};
54
    //com->log("read motor mixer");
54
    //com->log("read motor mixer");
55
    com->send_cmd('n', ADDRESS_FC, tx_data, 1, true);
55
    com->send_cmd('n', ADDRESS_FC, tx_data, 1, true);
56
}
56
}
57
 
57
 
58
/**
58
/**
59
 * write motor mixer values to FlightCtrl
59
 * write motor mixer values to FlightCtrl
60
 */
60
 */
61
void Handler::write_motor_mixer(char * tx_data, int length) {
61
void Handler::write_motor_mixer(char * tx_data, int length) {
62
    com->send_cmd('m', ADDRESS_FC, tx_data, length, true);
62
    com->send_cmd('m', ADDRESS_FC, tx_data, length, true);
63
}
63
}
64
 
64
 
65
int Handler::get_motor_config(char * tx_data) {
65
int Handler::get_motor_config(char * tx_data) {
66
    return -1;
66
    return -1;
67
}
67
}
68
 
68
 
69
//-------------NaviCtrl commands--------------------
69
//-------------NaviCtrl commands--------------------
70
/**
70
/**
71
 * set debug values for NaviCtrl
71
 * set debug values for NaviCtrl
72
 */
72
 */
73
void Handler::set_navictrl_debug(int speed) {
73
void Handler::set_navictrl_debug(int speed) {
74
    char tx_data[1] = { speed };
74
    char tx_data[1] = { speed };
75
    com->send_cmd('o', ADDRESS_NC, tx_data, 1, false);
75
    com->send_cmd('o', ADDRESS_NC, tx_data, 1, false);
76
}
76
}
77
 
77
 
78
/**
78
/**
79
 * stop debug for NaviCtrl
79
 * stop debug for NaviCtrl
80
 */
80
 */
81
void Handler::stop_navictrl_debug() {
81
void Handler::stop_navictrl_debug() {
82
    set_navictrl_debug(0);
82
    set_navictrl_debug(0);
83
}
83
}
84
 
84
 
85
/**
85
/**
86
 * send a waypoint to the NaviCtrl (the MikroKopter will fly to the position emidiately)
86
 * send a waypoint to the NaviCtrl (the MikroKopter will fly to the position emidiately)
87
 */
87
 */
88
void Handler::send_waypoint(Waypoint_t desired_pos) {
88
void Handler::send_waypoint(Waypoint_t desired_pos) {
89
    com->send_cmd('s', ADDRESS_NC, (char *)&desired_pos, sizeof(desired_pos), false);
89
    com->send_cmd('s', ADDRESS_NC, (char *)&desired_pos, sizeof(desired_pos), false);
90
}
90
}
91
 
91
 
92
/**
92
/**
93
 * add waypoint to waypoint list
93
 * add waypoint to waypoint list
94
 */
94
 */
95
void Handler::add_waypoint(Waypoint_t wp) {
95
void Handler::add_waypoint(Waypoint_t wp) {
96
    com->send_cmd('w', ADDRESS_NC, (char *)&wp, sizeof(wp), false);
96
    com->send_cmd('w', ADDRESS_NC, (char *)&wp, sizeof(wp), false);
97
}
97
}
98
 
98
 
99
/**
99
/**
100
 * clear waypoint list on MK
100
 * clear waypoint list on MK
101
 */
101
 */
102
void Handler::delete_waypoints() {
102
void Handler::delete_waypoints() {
103
    Waypoint_t wp;
103
    Waypoint_t wp;
104
    wp.Position.Status = INVALID;
104
    wp.Position.Status = INVALID;
105
    send_waypoint(wp);
105
    send_waypoint(wp);
106
}
106
}
107
//-------------switch between Hardware--------------------
107
//-------------switch between Hardware--------------------
108
void Handler::switch_navictrl() {
108
void Handler::switch_navictrl() {
109
    char tx_data[6] = { 0x1B, 0x1B, 0x55, 0xAA, 0x00, '\r'};
109
    char tx_data[6] = { 0x1B, 0x1B, 0x55, 0xAA, 0x00, '\r'};
110
    com->send_cmd('#', ADDRESS_NC, tx_data, 6, false);
110
    com->send_cmd('#', ADDRESS_NC, tx_data, 6, false);
111
}
111
}
112
 
112
 
113
void Handler::switch_flightctrl() {
113
void Handler::switch_flightctrl() {
114
    char tx_data[1] = { 0 };
114
    char tx_data[1] = { 0 };
115
    com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
115
    com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
116
}
116
}
117
 
117
 
118
void Handler::switch_mk3mag() {
118
void Handler::switch_mk3mag() {
119
    char tx_data[1] = { 1 };
119
    char tx_data[1] = { 1 };
120
    com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
120
    com->send_cmd('u', ADDRESS_NC, tx_data, 1, false);
121
}
121
}
122
 
122
 
123
//-------------commands for MK3MAG-----------------
123
//-------------commands for MK3MAG-----------------
124
 
124
 
125
 
125
 
126
//-------------commands for all--------------------
126
//-------------commands for all--------------------
127
 
127
 
128
/**
128
/**
129
 * set debug values for all components
129
 * set debug values for all components
130
 */
130
 */
131
void Handler::set_all_debug(int speed) {
131
void Handler::set_all_debug(int speed) {
132
    char tx_data[1] = { speed };
132
    char tx_data[1] = { speed };
133
    com->send_cmd('d', ADDRESS_ALL, tx_data, 1, false);
133
    com->send_cmd('d', ADDRESS_ALL, tx_data, 1, false);
134
}
134
}
135
 
135
 
136
/**
136
/**
137
 * stop debug for all components
137
 * stop debug for all components
138
 */
138
 */
139
void Handler::stop_all_debug() {
139
void Handler::stop_all_debug() {
140
    set_all_debug(0);
140
    set_all_debug(0);
141
}
141
}
142
 
142
 
143
/**
143
/**
144
 * get all analog labels
144
 * get all analog labels
145
 */
145
 */
146
void Handler::get_analog() {
146
void Handler::get_analog() {
147
    char tx_data[1] = { 0 };
147
    char tx_data[1] = { 0 };
148
    com->send_cmd('a', ADDRESS_ALL, tx_data, 1, true);
148
    com->send_cmd('a', ADDRESS_ALL, tx_data, 1, true);
149
}
149
}
150
 
150
 
151
/**
151
/**
152
 * get values from LCD / show LCD
152
 * get values from LCD / show LCD
153
 */
153
 */
154
void Handler::show_lcd() {
154
void Handler::show_lcd() {
155
    char tx_data[1] = {0};
155
    char tx_data[1] = {0};
156
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
156
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
157
}
157
}
158
 
158
 
159
/**
159
/**
160
 * got to next LCD Page
160
 * got to next LCD Page
161
 */
161
 */
162
void Handler::lcd_up() {
162
void Handler::lcd_up() {
163
    char tx_data[2] = { 0, 0 };
163
    char tx_data[2] = { 0, 0 };
164
    if (data->lcd_cur != data->lcd_max)
164
    if (data->lcd_cur != data->lcd_max)
165
        tx_data[0] = data->lcd_cur+1;
165
        tx_data[0] = data->lcd_cur+1;
166
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
166
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
167
}
167
}
168
 
168
 
169
/**
169
/**
170
 * got to previous LCD Page
170
 * got to previous LCD Page
171
 */
171
 */
172
void Handler::lcd_down() {
172
void Handler::lcd_down() {
173
    char tx_data[2] = { 0, 0 };
173
    char tx_data[2] = { 0, 0 };
174
    if (data->lcd_cur != 0)
174
    if (data->lcd_cur != 0)
175
        tx_data[0] = data->lcd_cur-1;
175
        tx_data[0] = data->lcd_cur-1;
176
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
176
    com->send_cmd('l', ADDRESS_ALL, tx_data, 1, true);
177
}
177
}
178
 
178
 
179
void Handler::get_version() {
179
void Handler::get_version() {
180
    //TODO: Check if is this correct or do we need data from switch_...
180
    //TODO: Check if is this correct or do we need data from switch_...
181
    char tx_data[1] = { 0 };
181
    char tx_data[1] = { 0 };
182
    com->send_cmd('v', ADDRESS_ALL, tx_data, 0, true);
182
    com->send_cmd('v', ADDRESS_ALL, tx_data, 0, true);
183
}
183
}
184
 
184
 
185
void Handler::get_ppm_channels() {
185
void Handler::get_ppm_channels() {
186
    char tx_data[1] = { 0 };
186
    char tx_data[1] = { 0 };
187
    com->send_cmd('p', ADDRESS_ALL, tx_data, 0, false);
187
    com->send_cmd('p', ADDRESS_ALL, tx_data, 0, false);
188
}
188
}
189
 
189
 
190
/**
190
/**
191
 * receive data
191
 * receive data
192
 */
192
 */
-
 
193
void Handler::receive_data(char * incomming, int length) {
-
 
194
    if (incomming[0] != '#')
-
 
195
        FlightLog::error("this frame is not correct");
-
 
196
        FlightLog::info(incomming);
-
 
197
        return;
-
 
198
    int hardwareID = incomming[1] - 'a';
-
 
199
 
-
 
200
    //The cmd is also known as ID-Byte (or ID for short) in the wiki-dokumentation
-
 
201
    char cmd = incomming[2];
193
//Parser::decode64(data);
202
    //decode data
-
 
203
    unsigned char data[150];
-
 
204
 
194
void Handler::receive_data(int hardwareID, int cmd, char * data) {
205
    Parser::decode64(incomming, length, data, 3);
-
 
206
 
195
    switch(hardwareID)
207
    switch(hardwareID)
196
    {
208
    {
197
        case ADDRESS_FC :
209
        case ADDRESS_FC :
198
            switch(cmd)
210
            switch(cmd)
199
            {
211
            {
200
                // Motor-Mixer
212
                // Motor-Mixer
201
                case 'N' :
213
                case 'N' :
202
                    //if (Parser::decode64(RX))
214
                    //if (Parser::decode64(RX))
203
                    //{
215
                    //{
204
                        com->stop_resend();
216
                        com->stop_resend();
205
                        //decoded data
217
                        //decoded data
-
 
218
                        FlightLog::info("received motortest values from FlightCtrl");
206
                        if (data[0] == VERSION_MIXER)
219
                        if (data[0] == VERSION_MIXER)
207
                        {
220
                        {
208
                            //f_MotorMixer->set_MotorConfig(RX);
221
                            //f_MotorMixer->set_MotorConfig(RX);
209
                        }
222
                        }
210
                    //}
223
                    //}
211
                    break;
224
                    break;
212
                // Motor-Mixer Schreib-Best├Ątigung
225
                // Motor-Mixer Schreib-Best├Ątigung
213
                case 'M' :
226
                case 'M' :
214
                    com->stop_resend();
227
                    com->stop_resend();
215
 
228
 
216
                    if (data[0] == 1)
229
                    if (data[0] == 1)
217
                    {
230
                    {
-
 
231
                        FlightLog::info("motor values written to FlightCtrl.");
218
                        //lb_Status->setText(tr("MotorMixer-Daten in FC geschrieben."));
232
                        //lb_Status->setText(tr("MotorMixer-Daten in FC geschrieben."));
-
 
233
                    } else {
-
 
234
                        FlightLog::warning("could not write motor values to FlightCtrl!");
219
                    }
235
                    }
220
                    break;
236
                    break;
221
 
237
 
222
                // Stick-Belegung der Fernsteuerung
238
                // Stick-Belegung der Fernsteuerung
223
                case 'P' : // DONE 0.71g
239
                case 'P' : // DONE 0.71g
-
 
240
                    FlightLog::info("received stick-settings from FlightCtrl:");
224
                    /*f_Settings->pb_K1->setValue(Parser::dataToInt(RX.decode,  2,true));
241
                    /*f_Settings->pb_K1->setValue(Parser::dataToInt(RX.decode,  2,true));
225
                    f_Settings->pb_K2->setValue(Parser::dataToInt(RX.decode,  4,true));
242
                    f_Settings->pb_K2->setValue(Parser::dataToInt(RX.decode,  4,true));
226
                    f_Settings->pb_K3->setValue(Parser::dataToInt(RX.decode,  6,true));
243
                    f_Settings->pb_K3->setValue(Parser::dataToInt(RX.decode,  6,true));
227
                    f_Settings->pb_K4->setValue(Parser::dataToInt(RX.decode,  8,true));
244
                    f_Settings->pb_K4->setValue(Parser::dataToInt(RX.decode,  8,true));
228
                    f_Settings->pb_K5->setValue(Parser::dataToInt(RX.decode, 10 ,true));
245
                    f_Settings->pb_K5->setValue(Parser::dataToInt(RX.decode, 10 ,true));
229
                    f_Settings->pb_K6->setValue(Parser::dataToInt(RX.decode, 12,true));
246
                    f_Settings->pb_K6->setValue(Parser::dataToInt(RX.decode, 12,true));
230
                    f_Settings->pb_K7->setValue(Parser::dataToInt(RX.decode, 14,true));
247
                    f_Settings->pb_K7->setValue(Parser::dataToInt(RX.decode, 14,true));
231
                    f_Settings->pb_K8->setValue(Parser::dataToInt(RX.decode, 16,true));*/
248
                    f_Settings->pb_K8->setValue(Parser::dataToInt(RX.decode, 16,true));*/
232
                    break;
249
                    break;
233
                // Settings lesen
250
                // Settings lesen
234
                case 'Q' : // DONE 0.71g
251
                case 'Q' : // DONE 0.71g
235
                    com->stop_resend();
252
                    com->stop_resend();
236
 
-
 
-
 
253
                    FlightLog::info("received settings from FlightCtrl");
237
                    if (data[1] == VERSION_SETTINGS)
254
                    if (data[1] == VERSION_SETTINGS)
238
                    {
255
                    {
239
                        int Settings_ID = data[0];
256
                        int Settings_ID = data[0];
240
                        /*for (int a = 0; a < MaxParameter; a++)
257
                        /*for (int a = 0; a < MaxParameter; a++)
241
                        {
258
                        {
242
                            FCSettings[a] = RX.decode[a + 2];
259
                            FCSettings[a] = RX.decode[a + 2];
243
                        }
260
                        }
244
                        f_Settings->show_FCSettings(Settings_ID, FCSettings);
261
                        f_Settings->show_FCSettings(Settings_ID, FCSettings);
245
                        f_Settings->pb_Read->setEnabled(true);
262
                        f_Settings->pb_Read->setEnabled(true);
246
                        f_Settings->pb_Write->setEnabled(true);*/
263
                        f_Settings->pb_Write->setEnabled(true);*/
247
                    }
264
                    }
248
                    else
265
                    else
249
                    {
266
                    {
-
 
267
                        FlightLog::error("wrong FlightCtrl version");
250
                        /*f_Settings->pb_Read->setDisabled(true);
268
                        /*f_Settings->pb_Read->setDisabled(true);
251
                        f_Settings->pb_Write->setDisabled(true);
269
                        f_Settings->pb_Write->setDisabled(true);
252
 
270
 
253
                        QString name = QString("Versionen inkompatibel.\n") +
271
                        QString name = QString("Versionen inkompatibel.\n") +
254
                                    QString("Version von GroundStation benoetigt: ") +
272
                                    QString("Version von GroundStation benoetigt: ") +
255
                                    QString(VERSION_SETTINGS) +
273
                                    QString(VERSION_SETTINGS) +
256
                                    QString("\nVersion auf der FlightCtrl: ") +
274
                                    QString("\nVersion auf der FlightCtrl: ") +
257
                                    QString(RX.decode[1]) +
275
                                    QString(RX.decode[1]) +
258
                                    QString("\nParameterbearbeitung nicht moeglich.");
276
                                    QString("\nParameterbearbeitung nicht moeglich.");
259
                        QMessageBox::warning(this, QA_NAME,
277
                        QMessageBox::warning(this, QA_NAME,
260
                                name, QMessageBox::Ok);*/
278
                                name, QMessageBox::Ok);*/
261
                    }
279
                    }
262
                    break;
280
                    break;
263
                // Settings written
281
                // Settings written
264
                case 'S' : // DONE 0.71g
282
                case 'S' : // DONE 0.71g
265
                    com->stop_resend();
283
                    com->stop_resend();
-
 
284
                    FlightLog::info("settings written successfully to FlightCtrl");
266
                    //TODO: QMessagebox("settings written successful") ?
285
                    //TODO: QMessagebox("settings written successful") ?
267
                    break;
286
                    break;
268
            }
287
            }
269
 
288
 
270
        case ADDRESS_NC :
289
        case ADDRESS_NC :
271
            switch(cmd)
290
            switch(cmd)
272
            {
291
            {
273
                // Navigationsdaten
292
                // Navigationsdaten
274
                case 'O' : // NOT DONE 0.12h
293
                case 'O' : // NOT DONE 0.12h
275
                    //new_NaviData(RX);
294
                    //new_NaviData(RX);
-
 
295
                    FlightLog::info("received navigation data from NaviCtrl");
276
                    break;
296
                    break;
277
            }
297
            }
278
//        case ADDRESS_MK3MAG :
298
//        case ADDRESS_MK3MAG :
279
 
299
 
280
        default :
300
        default :
281
            switch(cmd)
301
            switch(cmd)
282
            {
302
            {
283
                // LCD-Anzeige
303
                // LCD-Anzeige
284
                case 'L' : // DONE 0.71g
304
                case 'L' : // DONE 0.71g
285
                    com->stop_resend();
305
                    com->stop_resend();
286
 
-
 
-
 
306
                    FlightLog::info("received LCD page.");
287
                    /*int LCD[150];
307
                    /*int LCD[150];
288
                    memcpy(LCD,RX.decode, sizeof(RX.decode));
308
                    memcpy(LCD,RX.decode, sizeof(RX.decode));
289
 
309
 
290
                    f_LCD->show_Data(LCD);
310
                    f_LCD->show_Data(LCD);
291
 
311
 
292
                    LCD_Page     = RX.decode[0];
312
                    LCD_Page     = RX.decode[0];
293
                    LCD_MAX_Page = RX.decode[1];
313
                    LCD_MAX_Page = RX.decode[1];
294
                    */
314
                    */
295
                    break;
315
                    break;
296
                // Analoglabels
316
                // Analoglabels
297
                case 'A' : // DONE 0.71g
317
                case 'A' : // DONE 0.71g
298
                    com->stop_resend();
318
                    com->stop_resend();
299
 
-
 
-
 
319
                    FlightLog::info("received analog labels");
300
                    //check position
320
                    //check position
301
                    if (data[0] != 31) {
321
                    if (data[0] != 31) {
302
                        /*
322
                        /*
303
                        Settings->Analog1.Label[Position] = ToolBox::dataToQString(RX.decode,1,17).trimmed();
323
                        Settings->Analog1.Label[Position] = ToolBox::dataToQString(RX.decode,1,17).trimmed();
304
                        if (Settings->Analog1.Label[Position] == "")
324
                        if (Settings->Analog1.Label[Position] == "")
305
                        {
325
                        {
306
                            Settings->Analog1.Label[Position] = "A-" + QString("%1").arg(Position);
326
                            Settings->Analog1.Label[Position] = "A-" + QString("%1").arg(Position);
307
                        }
327
                        }
308
                        Position ++;
328
                        Position ++;
309
                        TX_Data[0] = Position;
329
                        TX_Data[0] = Position;
310
                        o_Connection->send_Cmd('a', ADDRESS_ALL, TX_Data, 1, true);*/
330
                        o_Connection->send_Cmd('a', ADDRESS_ALL, TX_Data, 1, true);*/
311
                    } else {
331
                    } else {
312
                        /*
332
                        /*
313
                        for (int a = 0; a < MaxAnalog; a++)
333
                        for (int a = 0; a < MaxAnalog; a++)
314
                        {
334
                        {
315
                            lb_Analog[a]->setText(Settings->Analog1.Label[a]);
335
                            lb_Analog[a]->setText(Settings->Analog1.Label[a]);
316
                        }
336
                        }
317
                        Settings->Analog1.Version = QString(Mode.Version);
337
                        Settings->Analog1.Version = QString(Mode.Version);
318
                        Settings->write_Settings_AnalogLabels(HardwareID);
338
                        Settings->write_Settings_AnalogLabels(HardwareID);
319
                        config_Plot();*/
339
                        config_Plot();*/
320
                    }
340
                    }
321
                    break;
341
                    break;
322
                // Debug-Daten
342
                // Debug-Daten
323
                case 'D' : // DONE 0.71g
343
                case 'D' : // DONE 0.71g
-
 
344
                    FlightLog::info("received debug data:");
324
                    for (int i = 0; i < MaxAnalog; i++) {
345
                    for (int i = 0; i < MaxAnalog; i++) {
-
 
346
                        /*
325
                        std::cout << Parser::dataToInt(data, (i * 2) + 2) << std::endl;
347
                        Parser::dataToInt((char *)data, (i * 2) + 2, false);
-
 
348
                        */
326
                    }
349
                    }
327
                    //show_DebugData();
350
                    //show_DebugData();
328
                    break;
351
                    break;
329
                // Version
352
                // Version
330
                case 'V' : // DONE 0.71h
353
                case 'V' : // DONE 0.71h
331
                    com->stop_resend();
354
                    com->stop_resend();
-
 
355
                    FlightLog::info("received version");
332
                    /*
356
                    /*
333
                    Mode.ID            = HardwareID;
357
                    Mode.ID            = HardwareID;
334
                    Mode.VERSION_MAJOR = RX.decode[0];
358
                    Mode.VERSION_MAJOR = RX.decode[0];
335
                    Mode.VERSION_MINOR = RX.decode[1];
359
                    Mode.VERSION_MINOR = RX.decode[1];
336
                    Mode.VERSION_PATCH = RX.decode[4];
360
                    Mode.VERSION_PATCH = RX.decode[4];
337
                    Mode.VERSION_SERIAL_MAJOR = RX.decode[2];
361
                    Mode.VERSION_SERIAL_MAJOR = RX.decode[2];
338
                    Mode.VERSION_SERIAL_MINOR = RX.decode[3];
362
                    Mode.VERSION_SERIAL_MINOR = RX.decode[3];
339
 
363
 
340
                    Mode.Hardware   = HardwareType[Mode.ID];
364
                    Mode.Hardware   = HardwareType[Mode.ID];
341
                    //TODO: Funktion im Handler get_version() oder sowas
365
                    //TODO: Funktion im Handler get_version() oder sowas
342
                    QString version = QString("%1").arg(RX.decode[0]) + "." +
366
                    QString version = QString("%1").arg(RX.decode[0]) + "." +
343
                                        QString("%1").arg(RX.decode[1]) +
367
                                        QString("%1").arg(RX.decode[1]) +
344
                                        QString(RX.decode[4] + 'a');
368
                                        QString(RX.decode[4] + 'a');
345
                    Mode.Version = version.toLatin1().data;
369
                    Mode.Version = version.toLatin1().data;
346
                    setWindowTitle(QA_NAME + " v" + QA_VERSION + " - " +
370
                    setWindowTitle(QA_NAME + " v" + QA_VERSION + " - " +
347
                                Mode.Hardware + " " +
371
                                Mode.Hardware + " " +
348
                                Mode.Version);
372
                                Mode.Version);
349
 
373
 
350
                    if (Mode.VERSION_SERIAL_MAJOR != VERSION_SERIAL_MAJOR)
374
                    if (Mode.VERSION_SERIAL_MAJOR != VERSION_SERIAL_MAJOR)
351
                    {
375
                    {
352
//                                AllowSend = false;
376
//                                AllowSend = false;
353
                            QMessageBox::warning(this, QA_NAME,
377
                            QMessageBox::warning(this, QA_NAME,
354
                            tr("Serielles Protokoll Inkompatibel. \nBitte neue Programmversion installieren,"), QMessageBox::Ok);
378
                            tr("Serielles Protokoll Inkompatibel. \nBitte neue Programmversion installieren,"), QMessageBox::Ok);
355
                    }
379
                    }
356
 
380
 
357
                    if (ac_NoDebug->isChecked())
381
                    if (ac_NoDebug->isChecked())
358
                    {
382
                    {
359
                        TX_Data[0] = 0;
383
                        TX_Data[0] = 0;
360
                    }
384
                    }
361
                    else
385
                    else
362
                    if (ac_FastDebug->isChecked())
386
                    if (ac_FastDebug->isChecked())
363
                    {
387
                    {
364
                        TX_Data[0] = Settings->Data.Debug_Fast / 10;
388
                        TX_Data[0] = Settings->Data.Debug_Fast / 10;
365
                    }
389
                    }
366
                    else
390
                    else
367
                    {
391
                    {
368
                        TX_Data[0] = Settings->Data.Debug_Slow / 10;
392
                        TX_Data[0] = Settings->Data.Debug_Slow / 10;
369
                    }
393
                    }
370
 
394
 
371
                    o_Connection->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
395
                    o_Connection->send_Cmd('d', ADDRESS_ALL, TX_Data, 1, false);
372
 
396
 
373
                    // Wenn MK3MAG dann andauernd Daten neu anfragen.
397
                    // Wenn MK3MAG dann andauernd Daten neu anfragen.
374
                    if (Mode.ID == ADDRESS_MK3MAG)
398
                    if (Mode.ID == ADDRESS_MK3MAG)
375
                    {
399
                    {
376
                        TickerEvent[3] = true;
400
                        TickerEvent[3] = true;
377
                        rb_SelMag->setChecked(true);
401
                        rb_SelMag->setChecked(true);
378
                    }
402
                    }
379
 
403
 
380
                    // Wenn NaviCtrl dann hier.
404
                    // Wenn NaviCtrl dann hier.
381
                    if (Mode.ID == ADDRESS_NC)
405
                    if (Mode.ID == ADDRESS_NC)
382
                    {
406
                    {
383
                        rb_SelNC->setChecked(true);
407
                        rb_SelNC->setChecked(true);
384
 
408
 
385
                        if (ac_NoNavi->isChecked())
409
                        if (ac_NoNavi->isChecked())
386
                        {
410
                        {
387
                            TX_Data[0] = 0;
411
                            TX_Data[0] = 0;
388
                        }
412
                        }
389
                        else
413
                        else
390
                        if (ac_FastNavi->isChecked())
414
                        if (ac_FastNavi->isChecked())
391
                        {
415
                        {
392
                            TX_Data[0] = Settings->Data.Navi_Fast / 10;
416
                            TX_Data[0] = Settings->Data.Navi_Fast / 10;
393
                        }
417
                        }
394
                        else
418
                        else
395
                        {
419
                        {
396
                            TX_Data[0] = Settings->Data.Navi_Slow / 10;
420
                            TX_Data[0] = Settings->Data.Navi_Slow / 10;
397
                        }
421
                        }
398
 
422
 
399
                        o_Connection->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
423
                        o_Connection->send_Cmd('o', ADDRESS_NC, TX_Data, 1, false);
400
                    }
424
                    }
401
 
425
 
402
 
426
 
403
                    // Wenn FlightCtrl dann Settings abfragen.
427
                    // Wenn FlightCtrl dann Settings abfragen.
404
                    if (Mode.ID == ADDRESS_FC)
428
                    if (Mode.ID == ADDRESS_FC)
405
                    {
429
                    {
406
                        rb_SelFC->setChecked(true);
430
                        rb_SelFC->setChecked(true);
407
                        {
431
                        {
408
                            TX_Data[0] = 0xff;
432
                            TX_Data[0] = 0xff;
409
                            TX_Data[1] = 0;
433
                            TX_Data[1] = 0;
410
 
434
 
411
                            // DEP: Raus wenn Resend implementiert.
435
                            // DEP: Raus wenn Resend implementiert.
412
//                                ToolBox::Wait(SLEEP);
436
//                                ToolBox::Wait(SLEEP);
413
                            o_Connection->send_Cmd('q', ADDRESS_FC, TX_Data, 1, true);
437
                            o_Connection->send_Cmd('q', ADDRESS_FC, TX_Data, 1, true);
414
                            qDebug("FC - Get Settings");
438
                            qDebug("FC - Get Settings");
415
                        }
439
                        }
416
                    }
440
                    }
417
                    // Wenn nicht Lesen und Schreiben der Settings deaktivieren.
441
                    // Wenn nicht Lesen und Schreiben der Settings deaktivieren.
418
                    else
442
                    else
419
                    {
443
                    {
420
                            f_Settings->pb_Read->setDisabled(true);
444
                            f_Settings->pb_Read->setDisabled(true);
421
                            f_Settings->pb_Write->setDisabled(true);
445
                            f_Settings->pb_Write->setDisabled(true);
422
                    }
446
                    }
423
 
447
 
424
                    Settings->read_Settings_Analog(HardwareID);
448
                    Settings->read_Settings_Analog(HardwareID);
425
                    Settings->read_Settings_AnalogLabels(HardwareID);
449
                    Settings->read_Settings_AnalogLabels(HardwareID);
426
 
450
 
427
                    if (Settings->Analog1.Version != QString(Mode.Version))
451
                    if (Settings->Analog1.Version != QString(Mode.Version))
428
                    {
452
                    {
429
                        lb_Status->setText(tr("Analoglabel-Version unterschiedlich. Lese Analoglabels neu aus."));
453
                        lb_Status->setText(tr("Analoglabel-Version unterschiedlich. Lese Analoglabels neu aus."));
430
                        slot_ac_GetLabels();
454
                        slot_ac_GetLabels();
431
                    }
455
                    }
432
                    else
456
                    else
433
                    for (int a = 0; a < MaxAnalog; a++)
457
                    for (int a = 0; a < MaxAnalog; a++)
434
                    {
458
                    {
435
                        lb_Analog[a]->setText(Settings->Analog1.Label[a]);
459
                        lb_Analog[a]->setText(Settings->Analog1.Label[a]);
436
                    }
460
                    }
437
                    config_Plot();*/
461
                    config_Plot();*/
438
                    break;
462
                    break;
439
            }
463
            }
440
    }
464
    }
441
}
465
}