Subversion Repositories Projects

Rev

Rev 513 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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