← Back to branch summary

~ubuntu-branches/ubuntu/wily/flrig/wily

« back to all changes in this revision

Viewing changes to .pc/0001-License-Declaration.patch/src/rigs/IC7200.cxx

  • Committer: Package Import Robot
  • Author(s): Kamal Mostafa
  • Date: 2014-06-07 11:28:52 UTC
  • Revision ID: package-import@ubuntu.com-20140607112852-pj9xhtlvwpgqjy5x
Tags: 1.3.15-1
http://bugs.debian.org/750861
* Initial release (Closes: #750861)
  flrig version 1.3.15 plus the following upstream commits:
  - 0001-License-Declaration.patch
  - 0002-FL_APPS-folder.patch
  - 0003-rig-home-dir.patch
  - 0004-RTS-DTR-restore.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0001-License-Declaration.patch/src/rigs/IC7200.cxx
 
1
/*
 
2
 * Icom 7200
 
3
 *
 
4
 * a part of flrig
 
5
 *
 
6
 * Copyright 2009, Dave Freese, W1HKJ
 
7
 *
 
8
 */
 
9
 
 
10
#include "IC7200.h"
 
11
 
 
12
bool DEBUG_7200 = true;
 
13
 
 
14
//=============================================================================
 
15
// IC-7200
 
16
 
 
17
const char IC7200name_[] = "IC-7200";
 
18
const char *IC7200modes_[] = { 
 
19
"LSB", "USB", "AM", "CW", "RTTY", "CW-R", "RTTY-R", 
 
20
"LSB-D", "USB-D", NULL};
 
21
 
 
22
const char IC7200_mode_type[] = { 
 
23
'L', 'U', 'U', 'L', 'L', 'U', 'U',
 
24
'L', 'U' };
 
25
 
 
26
const char *IC7200_SSBwidths[] = {
 
27
  "50",  "100",  "150",  "200",  "250",  "300",  "350",  "400",  "450",  "500",
 
28
"600",   "700",  "800",  "900", "1000", "1100", "1200", "1300", "1400", "1500",
 
29
"1600", "1700", "1800", "1900", "2000", "2100", "2200", "2300", "2400", "2500",
 
30
"2600", "2700", "2800", "2900", "3000", "3100", "3200", "3300", "3400", "3500",
 
31
"3600",
 
32
NULL};
 
33
 
 
34
const char *IC7200_RTTYwidths[] = {
 
35
  "50",  "100",  "150",  "200",  "250",  "300",  "350",  "400",  "450",  "500",
 
36
 "600",  "700",  "800",  "900", "1000", "1100", "1200", "1300", "1400", "1500",
 
37
"1600", "1700", "1800", "1900", "2000", "2100", "2200", "2300", "2400", "2500",
 
38
"2600", "2700",
 
39
NULL};
 
40
 
 
41
const char *IC7200_AMwidths[] = {
 
42
  "200",  "400",  "600",  "800", "1000", "1200", "1400", "1600", "1800", "2000",
 
43
 "2200", "2400", "2600", "2800", "3000", "3200", "3400", "3600", "3800", "4000",
 
44
 "4200", "4400", "4600", "4800", "5000", "5200", "5400", "5600", "5800", "5000",
 
45
 "6200", "6400", "6600", "6800", "6000", "6200", "6400", "6600", "6800", "6000",
 
46
NULL};
 
47
 
 
48
static GUI rig_widgets[]= {
 
49
        { (Fl_Widget *)btnVol, 2, 125,  50 },
 
50
        { (Fl_Widget *)sldrVOLUME, 54, 125, 156 },
 
51
        { (Fl_Widget *)sldrRFGAIN, 54, 145, 156 },
 
52
        { (Fl_Widget *)sldrMICGAIN, 54, 165, 156 },
 
53
        { (Fl_Widget *)sldrSQUELCH, 266, 125, 156 },
 
54
        { (Fl_Widget *)btnNR, 214, 145,  50 },
 
55
        { (Fl_Widget *)sldrNR, 266, 145, 156 },
 
56
        { (Fl_Widget *)sldrPOWER, 266, 165, 156 },
 
57
        { (Fl_Widget *)NULL, 0, 0, 0 }
 
58
};
 
59
 
 
60
//======================================================================
 
61
// IC7200 unique commands
 
62
//======================================================================
 
63
 
 
64
RIG_IC7200::RIG_IC7200() {
 
65
        name_ = IC7200name_;
 
66
        modes_ = IC7200modes_;
 
67
        _mode_type = IC7200_mode_type;
 
68
        bandwidths_ = IC7200_SSBwidths;
 
69
        widgets = rig_widgets;
 
70
 
 
71
        comm_baudrate = BR9600;
 
72
        stopbits = 1;
 
73
        comm_retries = 2;
 
74
        comm_wait = 5;
 
75
        comm_timeout = 50;
 
76
        comm_echo = true;
 
77
        comm_rtscts = false;
 
78
        comm_rtsplus = true;
 
79
        comm_dtrplus = true;
 
80
        comm_catptt = true;
 
81
        comm_rtsptt = false;
 
82
        comm_dtrptt = false;
 
83
 
 
84
        A.freq = 14070000;
 
85
        A.imode = 1;
 
86
        A.iBW = 32;
 
87
        B.freq = 7015000;
 
88
        B.imode = 3;
 
89
        B.iBW = 12;
 
90
 
 
91
        has_extras =
 
92
        has_smeter =
 
93
        has_power_out =
 
94
        has_swr_control =
 
95
        has_alc_control =
 
96
        has_sql_control = true;
 
97
        has_power_control = true;
 
98
        has_volume_control = true;
 
99
        has_mode_control = true;
 
100
        has_bandwidth_control = true;
 
101
        has_micgain_control = true;
 
102
        has_attenuator_control = true;
 
103
        has_preamp_control = true;
 
104
        has_noise_control = true;
 
105
        has_noise_reduction = true;
 
106
        has_noise_reduction_control = true;
 
107
        has_auto_notch = true;
 
108
        has_rf_control = true;
 
109
        has_compON = true;
 
110
        has_vox_onoff = true;
 
111
        has_ptt_control = true;
 
112
        has_tune_control = true;
 
113
 
 
114
        defaultCIV = 0x76;
 
115
        adjustCIV(defaultCIV);
 
116
 
 
117
        precision = 1;
 
118
        ndigits = 8;
 
119
 
 
120
};
 
121
 
 
122
void RIG_IC7200::initialize()
 
123
{
 
124
        rig_widgets[0].W = btnVol;
 
125
        rig_widgets[1].W = sldrVOLUME;
 
126
        rig_widgets[2].W = sldrRFGAIN;
 
127
        rig_widgets[3].W = sldrMICGAIN;
 
128
        rig_widgets[4].W = sldrSQUELCH;
 
129
        rig_widgets[5].W = btnNR;
 
130
        rig_widgets[6].W = sldrNR;
 
131
        rig_widgets[7].W = sldrPOWER;
 
132
}
 
133
 
 
134
//=============================================================================
 
135
void RIG_IC7200::selectA()
 
136
{
 
137
        cmd = pre_to;
 
138
        cmd += '\x07';
 
139
        cmd += '\x00';
 
140
        cmd.append(post);
 
141
        waitFB("select A");
 
142
}
 
143
 
 
144
void RIG_IC7200::selectB()
 
145
{
 
146
        cmd = pre_to;
 
147
        cmd += '\x07';
 
148
        cmd += '\x01';
 
149
        cmd.append(post);
 
150
        waitFB("select B");
 
151
}
 
152
 
 
153
long RIG_IC7200::get_vfoA ()
 
154
{
 
155
        string resp = pre_fm;
 
156
        resp += '\x03';
 
157
        cmd = pre_to;
 
158
        cmd += '\x03';
 
159
        cmd.append( post );
 
160
        if (waitFOR(11, "get vfo A")) {
 
161
                size_t p = replystr.rfind(resp);
 
162
                if (p != string::npos)
 
163
                        A.freq = fm_bcd_be(&replystr[p+5], 10);
 
164
        }
 
165
        return A.freq;
 
166
}
 
167
 
 
168
void RIG_IC7200::set_vfoA (long freq)
 
169
{
 
170
        A.freq = freq;
 
171
        cmd = pre_to;
 
172
        cmd += '\x05';
 
173
        cmd.append( to_bcd_be( freq, 10 ) );
 
174
        cmd.append( post );
 
175
        waitFB("set vfo A");
 
176
}
 
177
 
 
178
long RIG_IC7200::get_vfoB ()
 
179
{
 
180
        string resp = pre_fm;
 
181
        resp += '\x03';
 
182
        cmd = pre_to;
 
183
        cmd += '\x03';
 
184
        cmd.append( post );
 
185
        if (waitFOR(11, "get vfo B")) {
 
186
                size_t p = replystr.rfind(resp);
 
187
                if (p != string::npos)
 
188
                        B.freq = fm_bcd_be(&replystr[p+5], 10);
 
189
        }
 
190
        return B.freq;
 
191
}
 
192
 
 
193
void RIG_IC7200::set_vfoB (long freq)
 
194
{
 
195
        selectB();
 
196
        B.freq = freq;
 
197
        cmd = pre_to;
 
198
        cmd += '\x05';
 
199
        cmd.append( to_bcd_be( freq, 10 ) );
 
200
        cmd.append( post );
 
201
        waitFB("set vfo B");
 
202
}
 
203
 
 
204
void RIG_IC7200::set_split(bool b)
 
205
{
 
206
        cmd = pre_to;
 
207
        cmd += '\x0F';
 
208
        cmd += b ? '\x01' : '\x00';
 
209
        cmd.append( post );
 
210
        waitFB("set split");
 
211
}
 
212
 
 
213
// Tranceiver PTT on/off
 
214
void RIG_IC7200::set_PTT_control(int val)
 
215
{
 
216
        cmd = pre_to;
 
217
        cmd += '\x1c';
 
218
        cmd += '\x00';
 
219
        cmd += (unsigned char) val;
 
220
        cmd.append( post );
 
221
        waitFB("set ptt");
 
222
}
 
223
 
 
224
 
 
225
// Volume control val 0 ... 100
 
226
void RIG_IC7200::set_volume_control(int val)
 
227
{
 
228
        int ICvol = (int)(val * 255 / 100);
 
229
        cmd = pre_to;
 
230
        cmd.append("\x14\x01");
 
231
        cmd.append(to_bcd(ICvol, 3));
 
232
        cmd.append( post );
 
233
        waitFB("set vol");
 
234
}
 
235
 
 
236
int RIG_IC7200::get_volume_control()
 
237
{
 
238
        string cstr = "\x14\x01";
 
239
        string resp = pre_fm;
 
240
        resp.append(cstr);
 
241
        cmd = pre_to;
 
242
        cmd.append(cstr);
 
243
        cmd.append( post );
 
244
        if (waitFOR(9, "get vol")) {
 
245
                size_t p = replystr.rfind(resp);
 
246
                if (p != string::npos)
 
247
                        return (int)ceil(fm_bcd(&replystr[p + 6],3) * 100 / 255);
 
248
        }
 
249
        return progStatus.volume;
 
250
}
 
251
 
 
252
void RIG_IC7200::get_vol_min_max_step(int &min, int &max, int &step)
 
253
{
 
254
        min = 0; max = 100; step = 1;
 
255
}
 
256
 
 
257
int RIG_IC7200::get_smeter()
 
258
{
 
259
        string cstr = "\x15\x02";
 
260
        string resp = pre_fm;
 
261
        resp.append(cstr);
 
262
        cmd = pre_to;
 
263
        cmd.append(cstr);
 
264
        cmd.append( post );
 
265
        int mtr= -1;
 
266
        if (waitFOR(9, "get smeter")) {
 
267
                size_t p = replystr.rfind(resp);
 
268
                if (p != string::npos) {
 
269
                        mtr = fm_bcd(&replystr[p+6], 3);
 
270
                        mtr = (int)ceil(mtr /2.55);
 
271
                        if (mtr > 100) mtr = 100;
 
272
                }
 
273
        }
 
274
        return mtr;
 
275
}
 
276
 
 
277
int RIG_IC7200::get_power_out(void) 
 
278
{
 
279
        string cstr = "\x15\x11";
 
280
        string resp = pre_fm;
 
281
        resp.append(cstr);
 
282
        cmd = pre_to;
 
283
        cmd.append(cstr);
 
284
        cmd.append( post );
 
285
        int mtr= -1;
 
286
        if (waitFOR(9, "get power out")) {
 
287
                size_t p = replystr.rfind(resp);
 
288
                if (p != string::npos) {
 
289
                        mtr = fm_bcd(&replystr[p+6], 3);
 
290
                        mtr = (int)ceil(mtr /2.55);
 
291
                        if (mtr > 100) mtr = 100;
 
292
                }
 
293
        }
 
294
        return mtr;
 
295
}
 
296
 
 
297
int RIG_IC7200::get_swr(void) 
 
298
{
 
299
        string cstr = "\x15\x12";
 
300
        string resp = pre_fm;
 
301
        resp.append(cstr);
 
302
        cmd = pre_to;
 
303
        cmd.append(cstr);
 
304
        cmd.append( post );
 
305
        int mtr= -1;
 
306
        if (waitFOR(9, "get swr")) {
 
307
                size_t p = replystr.rfind(resp);
 
308
                if (p != string::npos) {
 
309
                        mtr = fm_bcd(&replystr[p+6], 3);
 
310
                        mtr = (int)ceil(mtr /2.55);
 
311
                        if (mtr > 100) mtr = 100;
 
312
                }
 
313
        }
 
314
        return mtr;
 
315
}
 
316
 
 
317
int RIG_IC7200::get_alc(void)
 
318
{
 
319
        string cstr = "\x15\x13";
 
320
        string resp = pre_fm;
 
321
        resp.append(cstr);
 
322
        cmd = pre_to;
 
323
        cmd.append(cstr);
 
324
        cmd.append( post );
 
325
        int mtr= -1;
 
326
        if (waitFOR(9, "get alc")) {
 
327
                size_t p = replystr.rfind(resp);
 
328
                if (p != string::npos) {
 
329
                        mtr = fm_bcd(&replystr[p+6], 3);
 
330
                        mtr = (int)ceil(mtr /2.55);
 
331
                        if (mtr > 100) mtr = 100;
 
332
                }
 
333
        }
 
334
        return mtr;
 
335
}
 
336
 
 
337
void RIG_IC7200::set_attenuator(int val)
 
338
{
 
339
        cmd = pre_to;
 
340
        cmd += '\x11';
 
341
        cmd += val ? '\x20' : '\x00';
 
342
        cmd.append( post );
 
343
        waitFB("set att");
 
344
}
 
345
 
 
346
void RIG_IC7200::set_noise(bool val)
 
347
{
 
348
        cmd = pre_to;
 
349
        cmd.append("\x16\x22");
 
350
        cmd += val ? 1 : 0;
 
351
        cmd.append(post);
 
352
        waitFB("set noise");
 
353
}
 
354
 
 
355
int RIG_IC7200::get_noise()
 
356
{
 
357
        string cstr = "\x16\x22";
 
358
        string resp = pre_fm;
 
359
        resp.append(cstr);
 
360
        cmd = pre_to;
 
361
        cmd.append(cstr);
 
362
        cmd.append(post);
 
363
        if (waitFOR(8, "get noise")) {
 
364
                size_t p = replystr.rfind(resp);
 
365
                if (p != string::npos)
 
366
                        return (replystr[p+6] ? 1 : 0);
 
367
        }
 
368
        return progStatus.noise;
 
369
}
 
370
 
 
371
void RIG_IC7200::set_noise_reduction(int val)
 
372
{
 
373
        cmd = pre_to;
 
374
        cmd.append("\x16\x40");
 
375
        cmd += val ? 1 : 0;
 
376
        cmd.append(post);
 
377
        waitFB("set NR");
 
378
}
 
379
 
 
380
int RIG_IC7200::get_noise_reduction()
 
381
{
 
382
        string cstr = "\x16\x40";
 
383
        string resp = pre_fm;
 
384
        resp.append(cstr);
 
385
        cmd = pre_to;
 
386
        cmd.append(cstr);
 
387
        cmd.append(post);
 
388
        if (waitFOR(8, "get NR")) {
 
389
                size_t p = replystr.rfind(resp);
 
390
                if (p != string::npos)
 
391
                        return (replystr[p+6] ? 1 : 0);
 
392
        }
 
393
        return progStatus.noise_reduction;
 
394
}
 
395
 
 
396
// 0 < val < 100
 
397
void RIG_IC7200::set_noise_reduction_val(int val)
 
398
{
 
399
        cmd = pre_to;
 
400
        cmd.append("\x14\x06");
 
401
        cmd.append(to_bcd(val * 255 / 100, 3));
 
402
        cmd.append(post);
 
403
        waitFB("set NRval");
 
404
}
 
405
 
 
406
int RIG_IC7200::get_noise_reduction_val()
 
407
{
 
408
        string cstr = "\x14\x06";
 
409
        string resp = pre_fm;
 
410
        resp.append(cstr);
 
411
        cmd = pre_to;
 
412
        cmd.append(cstr);
 
413
        cmd.append(post);
 
414
        if (waitFOR(9, "get NRval")) {
 
415
                size_t p = replystr.rfind(resp);
 
416
                if (p != string::npos)
 
417
                        return (int)ceil(fm_bcd(&replystr[p+6],3) * 100 / 255);
 
418
        }
 
419
        return progStatus.noise_reduction_val;
 
420
}
 
421
 
 
422
void RIG_IC7200::set_preamp(int val)
 
423
{
 
424
        cmd = pre_to;
 
425
        cmd += '\x16';
 
426
        cmd += '\x02';
 
427
        cmd += (unsigned char)val;
 
428
        cmd.append( post );
 
429
        waitFB("set Pre");
 
430
}
 
431
 
 
432
int RIG_IC7200::get_preamp()
 
433
{
 
434
        string cstr = "\x16\x02";
 
435
        string resp = pre_fm;
 
436
        resp.append(cstr);
 
437
        cmd = pre_to;
 
438
        cmd.append(cstr);
 
439
        cmd.append( post );
 
440
        if (waitFOR(8, "get Pre")) {
 
441
                size_t p = replystr.rfind(resp);
 
442
                if (p != string::npos) {
 
443
                        if (replystr[p+6] == 0x01) {
 
444
                                preamp_label("Pre", true);
 
445
                                return true;
 
446
                        } else {
 
447
                                preamp_label("Pre", false);
 
448
                                return false;
 
449
                        }
 
450
                }
 
451
        }
 
452
        return progStatus.preamp;
 
453
}
 
454
 
 
455
void RIG_IC7200::set_rf_gain(int val)
 
456
{
 
457
        int ICrfg = (int)(val * 255 / 100);
 
458
        cmd = pre_to;
 
459
        cmd.append("\x14\x02");
 
460
        cmd.append(to_bcd(ICrfg, 3));
 
461
        cmd.append( post );
 
462
        waitFB("set RF");
 
463
}
 
464
 
 
465
int RIG_IC7200::get_rf_gain()
 
466
{
 
467
        string cstr = "\x14\x02";
 
468
        string resp = pre_fm;
 
469
        cmd = pre_to;
 
470
        cmd.append(cstr).append(post);
 
471
        resp.append(cstr);
 
472
        if (waitFOR(9, "get RF")) {
 
473
                size_t p = replystr.rfind(resp);
 
474
                if (p != string::npos)
 
475
                        return (int)ceil(fm_bcd(&replystr[p + 6],3) * 100 / 255);
 
476
        }
 
477
        return progStatus.rfgain;
 
478
}
 
479
 
 
480
void RIG_IC7200::set_squelch(int val)
 
481
{
 
482
        int ICsql = (int)(val * 255 / 100);
 
483
        cmd = pre_to;
 
484
        cmd.append("\x14\x03");
 
485
        cmd.append(to_bcd(ICsql, 3));
 
486
        cmd.append( post );
 
487
        waitFB("set Sqlch");
 
488
}
 
489
 
 
490
int  RIG_IC7200::get_squelch()
 
491
{
 
492
        string cstr = "\x14\x03";
 
493
        string resp = pre_fm;
 
494
        resp.append(cstr);
 
495
        cmd = pre_to;
 
496
        cmd.append(cstr);
 
497
        cmd.append(post);
 
498
        if (waitFOR(9, "get squelch")) {
 
499
                size_t p = replystr.rfind(resp);
 
500
                if (p != string::npos)
 
501
                        return (int)ceil(fm_bcd(&replystr[p+6], 3) * 100 / 255);
 
502
        }
 
503
        return progStatus.squelch;
 
504
}
 
505
 
 
506
void RIG_IC7200::set_power_control(double val)
 
507
{
 
508
        cmd = pre_to;
 
509
        cmd.append("\x14\x0A");
 
510
        cmd.append(to_bcd((int)(val * 255 / 100), 3));
 
511
        cmd.append( post );
 
512
        waitFB("set power");
 
513
}
 
514
 
 
515
int RIG_IC7200::get_power_control()
 
516
{
 
517
        string cstr = "\x14\x0A";
 
518
        string resp = pre_fm;
 
519
        cmd = pre_to;
 
520
        cmd.append(cstr).append(post);
 
521
        resp.append(cstr);
 
522
        if (waitFOR(9, "get power")) {
 
523
                size_t p = replystr.rfind(resp);
 
524
                if (p != string::npos)
 
525
                        return (int)ceil(fm_bcd(&replystr[p + 6],3) * 100 / 255);
 
526
        }
 
527
        return progStatus.power_level;
 
528
}
 
529
 
 
530
void RIG_IC7200::get_mic_gain_min_max_step(int &min, int &max, int &step)
 
531
{
 
532
        min = 0;
 
533
        max = 100;
 
534
        step = 1;
 
535
}
 
536
 
 
537
int RIG_IC7200::get_mic_gain()
 
538
{
 
539
        string cstr = "\x14\x0B";
 
540
        string resp = pre_fm;
 
541
        resp.append(cstr);
 
542
        cmd = pre_to;
 
543
        cmd.append(cstr);
 
544
        cmd.append(post);
 
545
        if (waitFOR(9, "get mic")) {
 
546
                size_t p = replystr.rfind(resp);
 
547
                if (p != string::npos)
 
548
                        return (int)ceil(fm_bcd(&replystr[p+6],3) / 2.55);
 
549
        }
 
550
        return 0;
 
551
}
 
552
 
 
553
void RIG_IC7200::set_mic_gain(int val)
 
554
{
 
555
        val = (int)(val * 255 / 100);
 
556
        cmd = pre_to;
 
557
        cmd.append("\x14\x0B");
 
558
        cmd.append(to_bcd(val,3));
 
559
        cmd.append(post);
 
560
        waitFB("set mic");
 
561
}
 
562
 
 
563
int RIG_IC7200::get_modeA()
 
564
{
 
565
        int md = A.imode;
 
566
        string resp = pre_fm;
 
567
        resp += '\x04';
 
568
        cmd = pre_to;
 
569
        cmd += '\x04';
 
570
        cmd.append(post);
 
571
        if (waitFOR(8, "get mode A")) {
 
572
                size_t p = replystr.rfind(resp);
 
573
                if (p != string::npos) {
 
574
                        md = replystr[p + 5];
 
575
                        if (md > 6) md -= 2;
 
576
                        A.iBW = replystr[p + 6];
 
577
                }
 
578
        }
 
579
        cmd = pre_to;
 
580
        cmd += "\x1A\04";
 
581
        cmd.append(post);
 
582
        resp = pre_fm;
 
583
        resp += "\x1A\04";
 
584
        if (waitFOR(9, "data mode?")) {
 
585
                size_t p = replystr.rfind(resp);
 
586
                if (p != string::npos) {
 
587
                        if ((replystr[p+6] & 0x01) == 0x01) {
 
588
                                if (md == 0) md = 7;
 
589
                                if (md == 1) md = 8;
 
590
                        }
 
591
                }
 
592
        }
 
593
        return (A.imode = md);
 
594
}
 
595
 
 
596
void RIG_IC7200::set_modeA(int val)
 
597
{
 
598
        A.imode = val;
 
599
        if (val > 6) val -= 7;
 
600
        cmd = pre_to;
 
601
        cmd += '\x06';
 
602
        cmd += val > 4 ? val + 2 : val;
 
603
        cmd.append( post );
 
604
        waitFB("set mode A");
 
605
 
 
606
        cmd = pre_to;
 
607
        cmd += '\x1A'; cmd += '\x04';
 
608
        if (A.imode > 6) cmd += '\x01';
 
609
        else cmd += '\x00';
 
610
        cmd.append( post);
 
611
        waitFB("data mode");
 
612
}
 
613
 
 
614
int RIG_IC7200::get_modeB()
 
615
{
 
616
        int md = B.imode;
 
617
        cmd = pre_to;
 
618
        cmd += '\x04';
 
619
        cmd.append(post);
 
620
        string resp = pre_fm;
 
621
        resp += '\x04';
 
622
        if (waitFOR(8, "get mode B")) {
 
623
                size_t p = replystr.rfind(resp);
 
624
                if (p != string::npos) {
 
625
                        md = replystr[p+5];
 
626
                        if (md > 6) md -= 2;
 
627
                        B.iBW = replystr[p+6];
 
628
                }
 
629
        }
 
630
        cmd = pre_to;
 
631
        cmd += "x1A\04";
 
632
        cmd.append(post);
 
633
        resp = pre_fm;
 
634
        resp += "x1A\04";
 
635
        if (waitFOR(9, "get data B")) {
 
636
                size_t p = replystr.rfind(resp);
 
637
                if (p != string::npos) {
 
638
                        if ((replystr[p+6] & 0x01) == 0x01) {
 
639
                                if (md == 0) md = 7;
 
640
                                if (md == 1) md = 8;
 
641
                        }
 
642
                }
 
643
        }
 
644
        return (B.imode = md);
 
645
}
 
646
 
 
647
void RIG_IC7200::set_modeB(int val)
 
648
{
 
649
        B.imode = val;
 
650
        if (val > 6) val -= 7;
 
651
        cmd = pre_to;
 
652
        cmd += '\x06';
 
653
        cmd += val > 4 ? val + 2 : val;
 
654
        cmd.append( post );
 
655
        waitFB("set mode B");
 
656
 
 
657
        cmd = pre_to;
 
658
        cmd += '\x1A'; cmd += '\x04';
 
659
        if (B.imode > 6) cmd += '\x01';
 
660
        else cmd += '\x00';
 
661
        cmd.append( post);
 
662
        waitFB("data mode");
 
663
}
 
664
 
 
665
int RIG_IC7200::get_modetype(int n)
 
666
{
 
667
        return _mode_type[n];
 
668
}
 
669
 
 
670
int RIG_IC7200::adjust_bandwidth(int m)
 
671
{
 
672
        switch (m) {
 
673
                case 2: // AM
 
674
                        bandwidths_ = IC7200_AMwidths;
 
675
                        bwA = 30;
 
676
                        break;
 
677
                case 3:
 
678
                case 5: // CW
 
679
                        bandwidths_ = IC7200_SSBwidths;
 
680
                        bwA = 14;
 
681
                        break;
 
682
                case 4:
 
683
                case 6: // RTTY
 
684
                        bandwidths_ = IC7200_RTTYwidths;
 
685
                        bwA = 28;
 
686
                        break;
 
687
                case 0:
 
688
                case 1:
 
689
                case 7:
 
690
                case 8: 
 
691
                default: // SSB
 
692
                        bandwidths_ = IC7200_SSBwidths;
 
693
                        bwA = 32;
 
694
        }
 
695
        return bwA;
 
696
}
 
697
 
 
698
int RIG_IC7200::def_bandwidth(int m)
 
699
{
 
700
        return adjust_bandwidth(m);
 
701
}
 
702
 
 
703
const char ** RIG_IC7200::bwtable(int m)
 
704
{
 
705
        switch (m) {
 
706
                case 2: // AM
 
707
                        return IC7200_AMwidths;
 
708
                        break;
 
709
                case 3:
 
710
                case 5: // CW
 
711
                        return IC7200_SSBwidths;
 
712
                        break;
 
713
                case 4:
 
714
                case 6: // RTTY
 
715
                        return IC7200_RTTYwidths;
 
716
                        break;
 
717
                case 0:
 
718
                case 1:
 
719
                case 7:
 
720
                case 8: 
 
721
                default: // SSB
 
722
                        return IC7200_SSBwidths;
 
723
        }
 
724
        return IC7200_SSBwidths;
 
725
}
 
726
 
 
727
void RIG_IC7200::set_bwA(int val)
 
728
{
 
729
        A.iBW = val;
 
730
        cmd = pre_to;
 
731
        cmd.append("\x1A\x02");
 
732
        cmd.append(to_bcd(val, 2));
 
733
        cmd.append( post );
 
734
        waitFB("set BW A");
 
735
}
 
736
 
 
737
int  RIG_IC7200::get_bwA()
 
738
{
 
739
        cmd = pre_to;
 
740
        cmd += "\x1A\x02";
 
741
        cmd.append( post );
 
742
        string resp = pre_fm;
 
743
        resp += "\x1A\x02";
 
744
        if (waitFOR(8, "get BW A")) {
 
745
                size_t p = replystr.rfind(resp);
 
746
                if (p != string::npos)
 
747
                        A.iBW = (fm_bcd(&replystr[p+6],2));
 
748
        }
 
749
        return A.iBW;
 
750
}
 
751
 
 
752
void RIG_IC7200::set_bwB(int val)
 
753
{
 
754
        B.iBW = val;
 
755
        cmd = pre_to;
 
756
        cmd.append("\x1A\x02");
 
757
        cmd.append(to_bcd(val, 2));
 
758
        cmd.append( post );
 
759
        waitFB("set BW B");
 
760
}
 
761
 
 
762
int  RIG_IC7200::get_bwB()
 
763
{
 
764
        cmd = pre_to;
 
765
        cmd += "\x1A\x02";
 
766
        cmd.append( post );
 
767
        string resp = pre_fm;
 
768
        resp += "\x1A\x02";
 
769
        if (waitFOR(8, "get BW B")) {
 
770
                size_t p = replystr.rfind(resp);
 
771
                if (p != string::npos)
 
772
                        B.iBW = (fm_bcd(&replystr[p+6],2));
 
773
        }
 
774
        return B.iBW;
 
775
}
 
776
 
 
777
void RIG_IC7200::set_auto_notch(int val)
 
778
{
 
779
        cmd = pre_to;
 
780
        cmd += '\x16';
 
781
        cmd += '\x41';
 
782
        cmd += (unsigned char)val;
 
783
        cmd.append( post );
 
784
        waitFB("set AN");
 
785
}
 
786
 
 
787
int RIG_IC7200::get_auto_notch()
 
788
{
 
789
        string cstr = "\x16\x41";
 
790
        string resp = pre_fm;
 
791
        resp.append(cstr);
 
792
        cmd = pre_to;
 
793
        cmd.append(cstr);
 
794
        cmd.append( post );
 
795
        if (waitFOR(8, "get AN")) {
 
796
                size_t p = replystr.rfind(resp);
 
797
                if (p != string::npos) {
 
798
                        if (replystr[p+6] == 0x01) {
 
799
                                auto_notch_label("AN", true);
 
800
                                return true;
 
801
                        } else {
 
802
                                auto_notch_label("AN", false);
 
803
                                return false;
 
804
                        }
 
805
                }
 
806
        }
 
807
        return progStatus.auto_notch;
 
808
}
 
809
 
 
810
void RIG_IC7200::set_compression()
 
811
{
 
812
        if (progStatus.compON) {
 
813
                cmd = pre_to;
 
814
                cmd.append("\x16\x44");
 
815
                cmd += '\x01';
 
816
                cmd.append(post);
 
817
                waitFB("set Comp ON");
 
818
        } else {
 
819
                cmd = pre_to;
 
820
                cmd.append("\x16\x44");
 
821
                cmd += '\x00';
 
822
                cmd.append(post);
 
823
                waitFB("set Comp OFF");
 
824
        }
 
825
}
 
826
 
 
827
void RIG_IC7200::set_vox_onoff()
 
828
{
 
829
        if (progStatus.vox_onoff) {
 
830
                cmd = pre_to;
 
831
                cmd.append("\x16\x46");
 
832
                cmd += '\x01';
 
833
                cmd.append(post);
 
834
                waitFB("set Vox ON");
 
835
        } else {
 
836
                cmd = pre_to;
 
837
                cmd.append("\x16\x46");
 
838
                cmd += '\x00';
 
839
                cmd.append(post);
 
840
                waitFB("set Vox OFF");
 
841
        }
 
842
}
 
843
 
 
844
void RIG_IC7200::tune_rig()
 
845
{
 
846
        cmd = pre_to;
 
847
        cmd.append("\x1c\x01\x02");
 
848
        cmd.append( post );
 
849
        waitFB("tune rig");
 
850
}
 
851