← 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-10-25 11:17:10 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20141025111710-n32skgya3l9u1brw
Tags: 1.3.17-1
http://bugs.debian.org/761839
* New upstream release (Closes: #761839)
* Debian Standards-Version: 3.9.6

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