Subversion Repositories Projects

Rev

Rev 450 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
307 KeyOz 1
/***************************************************************************
2
 *   Copyright (C) 2009 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
#include "dlg_MotorMixer.h"
20
 
21
dlg_MotorMixer::dlg_MotorMixer(QWidget *parent) : QDialog(parent)
22
{
23
    setupUi(this);
24
    connect(pb_READ, SIGNAL(clicked()), this, SLOT(slot_pb_READ()));
25
    connect(pb_LOAD, SIGNAL(clicked()), this, SLOT(slot_pb_LOAD()));
26
    connect(pb_SAVE, SIGNAL(clicked()), this, SLOT(slot_pb_SAVE()));
27
    connect(pb_WRITE, SIGNAL(clicked()), this, SLOT(slot_pb_WRITE()));
28
 
29
    connect(sb_NICK_1, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
30
    connect(sb_NICK_2, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
31
    connect(sb_NICK_3, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
32
    connect(sb_NICK_4, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
33
    connect(sb_NICK_5, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
34
    connect(sb_NICK_6, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
35
    connect(sb_NICK_7, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
36
    connect(sb_NICK_8, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
37
    connect(sb_NICK_9, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
38
    connect(sb_NICK_10, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
39
    connect(sb_NICK_11, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
40
    connect(sb_NICK_12, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
41
 
42
    connect(sb_ROLL_1, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
43
    connect(sb_ROLL_2, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
44
    connect(sb_ROLL_3, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
45
    connect(sb_ROLL_4, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
46
    connect(sb_ROLL_5, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
47
    connect(sb_ROLL_6, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
48
    connect(sb_ROLL_7, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
49
    connect(sb_ROLL_8, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
50
    connect(sb_ROLL_9, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
51
    connect(sb_ROLL_10, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
52
    connect(sb_ROLL_11, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
53
    connect(sb_ROLL_12, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
54
 
55
    connect(sb_GIER_1, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
56
    connect(sb_GIER_2, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
57
    connect(sb_GIER_3, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
58
    connect(sb_GIER_4, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
59
    connect(sb_GIER_5, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
60
    connect(sb_GIER_6, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
61
    connect(sb_GIER_7, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
62
    connect(sb_GIER_8, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
63
    connect(sb_GIER_9, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
64
    connect(sb_GIER_10, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
65
    connect(sb_GIER_11, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
66
    connect(sb_GIER_12, SIGNAL(valueChanged(int)), this, SLOT(slot_CheckValue(int)));
67
 
68
}
69
 
70
// Connection-Object übergeben.
396 Brean 71
void dlg_MotorMixer::set_Objects(Handler *handler, cSettings *t_Settings)
307 KeyOz 72
{
396 Brean 73
    this->handler = handler;
442 Brean 74
    this->data = handler->data;
307 KeyOz 75
    o_Settings   = t_Settings;
76
}
77
 
78
// Motordaten übernehmen.
449 Brean 79
//FIXME: put this in libMK/Handler.cpp and fill motor values in KopterData
451 Brean 80
/*
450 Brean 81
void dlg_MotorMixer::set_MotorConfig(char * data)
307 KeyOz 82
{
83
    int Pos = 0;
84
 
450 Brean 85
    MixerName = ToolBox::dataToQString(data, 1, 12);
307 KeyOz 86
 
87
    Pos = 13;
88
 
89
    for (int z = 0; z < 16; z++)
90
    {
91
        for (int y = 0; y < 4; y++)
92
        {
450 Brean 93
            Motor[z][y] = Parser::dataToChar(data,Pos);
307 KeyOz 94
            Pos++;
95
        }
96
    }
97
 
98
    set_MotorData();
449 Brean 99
}
451 Brean 100
*/
307 KeyOz 101
// Motordaten aus GUI übernehmen
102
void dlg_MotorMixer::get_MotorData()
103
{
442 Brean 104
    sMotorData motorData;
105
 
449 Brean 106
    motorData.mixer_name = le_NAME->text().toAscii().data();
307 KeyOz 107
 
442 Brean 108
    int gas[MAX_MOTORS] = {
109
        sb_GAS_1->value(), sb_GAS_2->value(), sb_GAS_3->value(), sb_GAS_4->value(),
110
        sb_GAS_5->value(), sb_GAS_6->value(), sb_GAS_7->value(), sb_GAS_8->value(),
111
        sb_GAS_9->value(), sb_GAS_10->value(), sb_GAS_11->value(), sb_GAS_12->value()
440 Brean 112
    };
442 Brean 113
    int nick[MAX_MOTORS] = {
114
        sb_NICK_1->value(), sb_NICK_2->value(), sb_NICK_3->value(), sb_NICK_4->value(),
115
        sb_NICK_5->value(), sb_NICK_6->value(), sb_NICK_7->value(), sb_NICK_8->value(),
116
        sb_NICK_9->value(), sb_NICK_10->value(), sb_NICK_11->value(), sb_NICK_12->value()
117
    };
118
    int roll[MAX_MOTORS] = {
119
        sb_ROLL_1->value(), sb_ROLL_2->value(), sb_ROLL_3->value(), sb_ROLL_4->value(),
120
        sb_ROLL_5->value(), sb_ROLL_6->value(), sb_ROLL_7->value(), sb_ROLL_8->value(),
121
        sb_ROLL_9->value(), sb_ROLL_10->value(), sb_ROLL_11->value(), sb_ROLL_12->value()
122
    };
123
    int yaw[MAX_MOTORS] = {
124
        sb_GIER_1->value(), sb_GIER_2->value(), sb_GIER_3->value(), sb_GIER_4->value(),
125
        sb_GIER_5->value(), sb_GIER_6->value(), sb_GIER_7->value(), sb_GIER_8->value(),
126
        sb_GIER_9->value(), sb_GIER_10->value(), sb_GIER_11->value(), sb_GIER_12->value()
127
    };
128
    for (int i = 0; i < MAX_MOTORS; i++) {
129
        motorData.mixer_gas[i] = gas[i];
130
        motorData.mixer_nick[i] = nick[i];
131
        motorData.mixer_roll[i] = roll[i];
132
        motorData.mixer_yaw[i] = yaw[i];
133
    }
134
    //FIXME: add Function in handler to send data
307 KeyOz 135
}
136
 
137
// Motordaten anzeigen
138
void dlg_MotorMixer::set_MotorData()
139
{
442 Brean 140
    sMotorData motorData = handler->data->motor;
449 Brean 141
    le_NAME->setText(motorData.mixer_name);
307 KeyOz 142
 
442 Brean 143
    sb_GAS_1->setValue(motorData.mixer_gas[0]);
144
    sb_GAS_2->setValue(motorData.mixer_gas[1]);
145
    sb_GAS_3->setValue(motorData.mixer_gas[2]);
146
    sb_GAS_4->setValue(motorData.mixer_gas[3]);
147
    sb_GAS_5->setValue(motorData.mixer_gas[4]);
148
    sb_GAS_6->setValue(motorData.mixer_gas[5]);
149
    sb_GAS_7->setValue(motorData.mixer_gas[6]);
150
    sb_GAS_8->setValue(motorData.mixer_gas[7]);
151
    sb_GAS_9->setValue(motorData.mixer_gas[8]);
152
    sb_GAS_10->setValue(motorData.mixer_gas[9]);
153
    sb_GAS_11->setValue(motorData.mixer_gas[10]);
154
    sb_GAS_12->setValue(motorData.mixer_gas[11]);
307 KeyOz 155
 
442 Brean 156
    sb_NICK_1->setValue(motorData.mixer_nick[0]);
157
    sb_NICK_2->setValue(motorData.mixer_nick[1]);
158
    sb_NICK_3->setValue(motorData.mixer_nick[2]);
159
    sb_NICK_4->setValue(motorData.mixer_nick[3]);
160
    sb_NICK_5->setValue(motorData.mixer_nick[4]);
161
    sb_NICK_6->setValue(motorData.mixer_nick[5]);
162
    sb_NICK_7->setValue(motorData.mixer_nick[6]);
163
    sb_NICK_8->setValue(motorData.mixer_nick[7]);
164
    sb_NICK_9->setValue(motorData.mixer_nick[8]);
165
    sb_NICK_10->setValue(motorData.mixer_nick[9]);
166
    sb_NICK_11->setValue(motorData.mixer_nick[10]);
167
    sb_NICK_12->setValue(motorData.mixer_nick[11]);
307 KeyOz 168
 
442 Brean 169
    sb_ROLL_1->setValue(motorData.mixer_roll[0]);
170
    sb_ROLL_2->setValue(motorData.mixer_roll[1]);
171
    sb_ROLL_3->setValue(motorData.mixer_roll[2]);
172
    sb_ROLL_4->setValue(motorData.mixer_roll[3]);
173
    sb_ROLL_5->setValue(motorData.mixer_roll[4]);
174
    sb_ROLL_6->setValue(motorData.mixer_roll[5]);
175
    sb_ROLL_7->setValue(motorData.mixer_roll[6]);
176
    sb_ROLL_8->setValue(motorData.mixer_roll[7]);
177
    sb_ROLL_9->setValue(motorData.mixer_roll[8]);
178
    sb_ROLL_10->setValue(motorData.mixer_roll[9]);
179
    sb_ROLL_11->setValue(motorData.mixer_roll[10]);
180
    sb_ROLL_12->setValue(motorData.mixer_roll[11]);
307 KeyOz 181
 
442 Brean 182
    sb_GIER_1->setValue(motorData.mixer_yaw[0]);
183
    sb_GIER_2->setValue(motorData.mixer_yaw[1]);
184
    sb_GIER_3->setValue(motorData.mixer_yaw[2]);
185
    sb_GIER_4->setValue(motorData.mixer_yaw[3]);
186
    sb_GIER_5->setValue(motorData.mixer_yaw[4]);
187
    sb_GIER_6->setValue(motorData.mixer_yaw[5]);
188
    sb_GIER_7->setValue(motorData.mixer_yaw[6]);
189
    sb_GIER_8->setValue(motorData.mixer_yaw[7]);
190
    sb_GIER_9->setValue(motorData.mixer_yaw[8]);
191
    sb_GIER_10->setValue(motorData.mixer_yaw[9]);
192
    sb_GIER_11->setValue(motorData.mixer_yaw[10]);
193
    sb_GIER_12->setValue(motorData.mixer_yaw[11]);
307 KeyOz 194
}
195
 
196
// Prüfen auf vollstaändigkeit
197
void dlg_MotorMixer::slot_CheckValue(int Wert)
198
{
199
    Wert = Wert;
200
 
442 Brean 201
    int NICK = sb_NICK_1->value()  + sb_NICK_2->value()  + sb_NICK_3->value() +
202
               sb_NICK_4->value()  + sb_NICK_5->value()  + sb_NICK_6->value() +
203
               sb_NICK_7->value()  + sb_NICK_8->value()  + sb_NICK_9->value() +
204
               sb_NICK_10->value() + sb_NICK_11->value() + sb_NICK_12->value();
307 KeyOz 205
 
442 Brean 206
    int ROLL = sb_ROLL_1->value()  + sb_ROLL_2->value()  + sb_ROLL_3->value() +
207
               sb_ROLL_4->value()  + sb_ROLL_5->value()  + sb_ROLL_6->value() +
208
               sb_ROLL_7->value()  + sb_ROLL_8->value()  + sb_ROLL_9->value() +
209
               sb_ROLL_10->value() + sb_ROLL_11->value() + sb_ROLL_12->value();
307 KeyOz 210
 
442 Brean 211
    int GIER = sb_GIER_1->value()  + sb_GIER_2->value()  + sb_GIER_3->value() +
212
               sb_GIER_4->value()  + sb_GIER_5->value()  + sb_GIER_6->value() +
213
               sb_GIER_7->value()  + sb_GIER_8->value()  + sb_GIER_9->value() +
214
               sb_GIER_10->value() + sb_GIER_11->value() + sb_GIER_12->value();
307 KeyOz 215
 
216
    if (NICK == 0)
217
    {
218
        lb_NICK->setEnabled(true);
219
    }
220
    else
221
    {
222
        lb_NICK->setEnabled(false);
223
    }
224
 
225
    if (ROLL == 0)
226
    {
227
        lb_ROLL->setEnabled(true);
228
    }
229
    else
230
    {
231
        lb_ROLL->setEnabled(false);
232
    }
233
 
234
    if (GIER == 0)
235
    {
236
        lb_GIER->setEnabled(true);
237
    }
238
    else
239
    {
240
        lb_GIER->setEnabled(false);
241
    }
242
}
243
 
440 Brean 244
//FIXME: put this in libMK/Handler.cpp
396 Brean 245
/*
307 KeyOz 246
int dlg_MotorMixer::get_MotorConfig()
247
{
248
    get_MotorData();
249
 
250
    TX_Data[0] = VERSION_MIXER;
251
 
252
    char *Name = MixerName.toLatin1().data();
253
 
254
    int a;
255
 
256
    for (a = 0; a < MixerName.length(); a++)
257
    {
258
        TX_Data[1+a] = Name[a];
259
    }
260
 
261
    while(a < 12)
262
    {
263
        TX_Data[1+a] = 0;
264
        a++;
265
    }
266
 
267
    int Pos = 13;
268
 
269
    for (int z = 0; z < 16; z++)
270
    {
271
        for (int y = 0; y < 4; y++)
272
        {
396 Brean 273
            TX_Data[Pos] = Parser::charToData(Motor[z][y]);
307 KeyOz 274
            Pos++;
275
        }
276
    }
277
 
278
    return Pos - 1;
279
}
440 Brean 280
*/
307 KeyOz 281
 
396 Brean 282
// read motor values
307 KeyOz 283
void dlg_MotorMixer::slot_pb_READ()
284
{
396 Brean 285
    //send command to get mixer values
440 Brean 286
    handler->read_motor_mixer();
307 KeyOz 287
}
288
 
396 Brean 289
//write motor values
440 Brean 290
//FIXME: put this in libMK/Handler.cpp
307 KeyOz 291
void dlg_MotorMixer::slot_pb_WRITE()
292
{
440 Brean 293
    char tx_data[150];
294
    int length = handler->get_motor_config(tx_data);
295
    handler->write_motor_mixer(tx_data, length);
307 KeyOz 296
}
297
 
298
void dlg_MotorMixer::slot_pb_LOAD()
299
{
358 KeyOz 300
    QString Filename = QFileDialog::getOpenFileName(this, tr("Mikrokopter MotorMixer laden"),  o_Settings->DIR.Parameter + "", tr("MK MotorMixer(*.mkm);;Alle Dateien (*)"));
307 KeyOz 301
 
302
    if (!Filename.isEmpty())
303
    {
304
        QSettings Setting(Filename, QSettings::IniFormat);
305
 
306
        Setting.beginGroup("Info");
442 Brean 307
            data->motor.mixer_name = Setting.value("Name", QString("--noname--")).toString().toAscii().data();
308
            data->motor.mixer_version = Setting.value("Version", 0).toInt();
307 KeyOz 309
        Setting.endGroup();
310
 
311
        Setting.beginGroup("Gas");
312
            for (int z = 0; z < MAXMOTOR; z++)
313
            {
442 Brean 314
                data->motor.mixer_gas[z] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
307 KeyOz 315
            }
316
        Setting.endGroup();
317
 
318
        Setting.beginGroup("Nick");
319
            for (int z = 0; z < MAXMOTOR; z++)
320
            {
442 Brean 321
                data->motor.mixer_nick[z] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
307 KeyOz 322
            }
323
        Setting.endGroup();
324
 
325
        Setting.beginGroup("Roll");
326
            for (int z = 0; z < MAXMOTOR; z++)
327
            {
442 Brean 328
                data->motor.mixer_roll[z] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
307 KeyOz 329
            }
330
        Setting.endGroup();
331
 
332
        Setting.beginGroup("Yaw");
333
            for (int z = 0; z < MAXMOTOR; z++)
334
            {
442 Brean 335
                data->motor.mixer_yaw[z] = Setting.value(QString("Motor%1").arg(z+1), 0).toInt();
307 KeyOz 336
            }
337
        Setting.endGroup();
442 Brean 338
 
339
        if (data->motor.mixer_version == VERSION_MIXER)
307 KeyOz 340
        {
341
            set_MotorData();
342
        }
343
    }
344
}
345
 
346
void dlg_MotorMixer::slot_pb_SAVE()
347
{
358 KeyOz 348
    QString Filename = QFileDialog::getSaveFileName(this, tr("Mikrokopter MotorMixer speichern"), o_Settings->DIR.Parameter + "/" + le_NAME->text(), tr("MK MotorMixer(*.mkm);;Alle Dateien (*)"));
307 KeyOz 349
 
350
    if (!Filename.isEmpty())
351
    {
352
        if (!(Filename.endsWith(".mkm", Qt::CaseInsensitive)))
353
        {
354
            Filename = Filename + QString(".mkm");
355
        }
356
 
357
        get_MotorData();
358
 
359
        QSettings Setting(Filename, QSettings::IniFormat);
360
 
361
        Setting.beginGroup("Info");
449 Brean 362
            Setting.setValue("Name",         data->motor.mixer_name);
442 Brean 363
            Setting.setValue("Version",      data->motor.mixer_version);
307 KeyOz 364
        Setting.endGroup();
365
 
366
        Setting.beginGroup("Gas");
367
            for (int z = 0; z < MAXMOTOR; z++)
368
            {
442 Brean 369
                Setting.setValue(QString("Motor%1").arg(z+1), data->motor.mixer_gas[z]);
307 KeyOz 370
            }
371
        Setting.endGroup();
372
 
373
        Setting.beginGroup("Nick");
374
            for (int z = 0; z < MAXMOTOR; z++)
375
            {
442 Brean 376
                 Setting.setValue(QString("Motor%1").arg(z+1), data->motor.mixer_nick[z]);
307 KeyOz 377
            }
378
        Setting.endGroup();
379
 
380
        Setting.beginGroup("Roll");
381
            for (int z = 0; z < MAXMOTOR; z++)
382
            {
442 Brean 383
                Setting.setValue(QString("Motor%1").arg(z+1), data->motor.mixer_roll[z]);
307 KeyOz 384
            }
385
        Setting.endGroup();
386
 
387
        Setting.beginGroup("Yaw");
388
            for (int z = 0; z < MAXMOTOR; z++)
389
            {
442 Brean 390
                Setting.setValue(QString("Motor%1").arg(z+1), data->motor.mixer_yaw[z]);
307 KeyOz 391
            }
392
        Setting.endGroup();
393
    }
394
}