← 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/IC756PRO3.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/IC756PRO3.cxx
1
 
/*
2
 
 * Icom 756PRO-III
3
 
 *
4
 
 * a part of flrig
5
 
 *
6
 
 * Copyright 2009, Dave Freese, W1HKJ
7
 
 *
8
 
 */
9
 
 
10
 
#include "IC756PRO3.h"
11
 
#include "debug.h"
12
 
#include "support.h"
13
 
 
14
 
//=============================================================================
15
 
// 756PRO-III
16
 
 
17
 
const char IC756PRO3name_[] = "IC-756PRO-III";
18
 
 
19
 
const char *IC756PRO3modes_[] = {
20
 
                "LSB", "USB", "AM", "CW", "RTTY", "FM", "CW-R", "RTTY-R",
21
 
                "D-LSB", "D-USB", "D-FM", NULL};
22
 
 
23
 
const char IC756PRO3_mode_type[] =
24
 
        { 'L', 'U', 'U', 'U', 'L', 'U', 'L', 'U',
25
 
          'L', 'U', 'U' };
26
 
 
27
 
const char *IC756PRO3_SSBwidths[] = {
28
 
  "50",  "100",  "150",  "200",  "250",  "300",  "350",  "400",  "450",  "500",
29
 
"600",   "700",  "800",  "900", "1000", "1100", "1200", "1300", "1400", "1500",
30
 
"1600", "1700", "1800", "1900", "2000", "2100", "2200", "2300", "2400", "2500",
31
 
"2600", "2700", "2800", "2900", "3000", "3100", "3200", "3300", "3400", "3500",
32
 
"3600",
33
 
NULL};
34
 
 
35
 
const char *IC756PRO3_RTTYwidths[] = {
36
 
  "50",  "100",  "150",  "200",  "250",  "300",  "350",  "400",  "450",  "500",
37
 
 "600",  "700",  "800",  "900", "1000", "1100", "1200", "1300", "1400", "1500",
38
 
"1600", "1700", "1800", "1900", "2000", "2100", "2200", "2300", "2400", "2500",
39
 
"2600", "2700",
40
 
NULL};
41
 
 
42
 
const char *IC756PRO3_AMFMwidths[] = { "FILT-1", "FILT-2", "FILT-3", NULL };
43
 
 
44
 
static GUI ic756pro3_widgets[]= {
45
 
        { (Fl_Widget *)btnVol, 2, 125,  50 },
46
 
        { (Fl_Widget *)sldrVOLUME, 54, 125, 156 },
47
 
        { (Fl_Widget *)sldrRFGAIN, 54, 145, 156 },
48
 
        { (Fl_Widget *)sldrSQUELCH, 54, 165, 156 },
49
 
        { (Fl_Widget *)btnNR, 214, 125,  50 },
50
 
        { (Fl_Widget *)sldrNR, 266, 125, 156 },
51
 
        { (Fl_Widget *)btnIFsh, 214, 105,  50 },
52
 
        { (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 },
53
 
        { (Fl_Widget *)sldrMICGAIN, 266, 145, 156 },
54
 
        { (Fl_Widget *)sldrPOWER, 266, 165, 156 },
55
 
        { (Fl_Widget *)NULL, 0, 0, 0 }
56
 
};
57
 
 
58
 
RIG_IC756PRO3::RIG_IC756PRO3() {
59
 
        defaultCIV = 0x6E;
60
 
        name_ = IC756PRO3name_;
61
 
        modes_ = IC756PRO3modes_;
62
 
        bandwidths_ = IC756PRO3_SSBwidths;
63
 
        _mode_type = IC756PRO3_mode_type;
64
 
        atten_level = 3; // will force initializing to 0 dB
65
 
        preamp_level = 2; // will force initializaing to 0 dB
66
 
 
67
 
        widgets = ic756pro3_widgets;
68
 
 
69
 
        def_freq = freqA = freqB = A.freq = 14070000;
70
 
        def_mode = modeA = modeB = B.imode = 1;
71
 
        def_bw = bwA = bwB = A.iBW = B.iBW = 32;
72
 
 
73
 
        has_a2b =
74
 
        has_split =
75
 
        has_split_AB =
76
 
        has_bandwidth_control =
77
 
        has_ifshift_control =
78
 
        has_tune_control =
79
 
 
80
 
        has_swr_control =
81
 
        has_alc_control = 
82
 
        has_smeter =
83
 
        has_power_out =
84
 
 
85
 
        has_power_control =
86
 
        has_volume_control =
87
 
        has_mode_control =
88
 
        has_micgain_control =
89
 
        has_auto_notch =
90
 
        has_attenuator_control =
91
 
        has_preamp_control =
92
 
        has_ptt_control =
93
 
        has_noise_reduction =
94
 
        has_noise_reduction_control =
95
 
        has_noise_control =
96
 
        has_sql_control =
97
 
        has_rf_control = true;
98
 
 
99
 
        adjustCIV(defaultCIV);
100
 
 
101
 
        precision = 1;
102
 
        ndigits = 9;
103
 
 
104
 
};
105
 
 
106
 
void RIG_IC756PRO3::initialize()
107
 
{
108
 
        ic756pro3_widgets[0].W = btnVol;
109
 
        ic756pro3_widgets[1].W = sldrVOLUME;
110
 
        ic756pro3_widgets[2].W = sldrRFGAIN;
111
 
        ic756pro3_widgets[3].W = sldrSQUELCH;
112
 
        ic756pro3_widgets[4].W = btnNR;
113
 
        ic756pro3_widgets[5].W = sldrNR;
114
 
        ic756pro3_widgets[6].W = btnIFsh;
115
 
        ic756pro3_widgets[7].W = sldrIFSHIFT;
116
 
        ic756pro3_widgets[8].W = sldrMICGAIN;
117
 
        ic756pro3_widgets[9].W = sldrPOWER;
118
 
}
119
 
 
120
 
void RIG_IC756PRO3::selectA()
121
 
{
122
 
        cmd = pre_to;
123
 
        cmd += '\x07';
124
 
        cmd += '\xB0';
125
 
        cmd.append(post);
126
 
        waitFB("sel A");
127
 
}
128
 
 
129
 
void RIG_IC756PRO3::selectB()
130
 
{
131
 
        cmd = pre_to;
132
 
        cmd += '\x07';
133
 
        cmd += '\xB1';
134
 
        cmd.append(post);
135
 
        waitFB("sel B");
136
 
}
137
 
 
138
 
void RIG_IC756PRO3::A2B()
139
 
{
140
 
        cmd = pre_to;
141
 
        cmd += '\x07';
142
 
        cmd += '\xB1';
143
 
        cmd.append(post);
144
 
        waitFB("A->B");
145
 
}
146
 
 
147
 
long RIG_IC756PRO3::get_vfoA ()
148
 
{
149
 
        string cstr = "\x03";
150
 
        string resp = pre_fm;
151
 
        resp.append(cstr);
152
 
        cmd = pre_to;
153
 
        cmd.append(cstr);
154
 
        cmd.append(post);
155
 
        if (waitFOR(11, "get vfo A")) {
156
 
                size_t p = replystr.rfind(resp);
157
 
                if (p != string::npos)
158
 
                        A.freq = fm_bcd_be(&replystr[p+5], 10);
159
 
        }
160
 
        return A.freq;
161
 
}
162
 
 
163
 
void RIG_IC756PRO3::set_vfoA (long freq)
164
 
{
165
 
        A.freq = freq;
166
 
        cmd = pre_to;
167
 
        cmd += '\x05';
168
 
        cmd.append( to_bcd_be( freq, 10 ) );
169
 
        cmd.append( post );
170
 
        waitFB("set vfo A");
171
 
}
172
 
 
173
 
long RIG_IC756PRO3::get_vfoB ()
174
 
{
175
 
        string cstr = "\x03";
176
 
        string resp = pre_fm;
177
 
        resp.append(cstr);
178
 
        cmd = pre_to;
179
 
        cmd.append(cstr);
180
 
        cmd.append(post);
181
 
        if (waitFOR(11, "get vfo B")) {
182
 
                size_t p = replystr.rfind(resp);
183
 
                if (p != string::npos)
184
 
                        B.freq = fm_bcd_be(&replystr[p+5], 10);
185
 
        }
186
 
        return B.freq;
187
 
}
188
 
 
189
 
void RIG_IC756PRO3::set_vfoB (long freq)
190
 
{
191
 
        B.freq = freq;
192
 
        cmd = pre_to;
193
 
        cmd += '\x05';
194
 
        cmd.append( to_bcd_be( freq, 10 ) );
195
 
        cmd.append( post );
196
 
        waitFB("set vfo B");
197
 
}
198
 
 
199
 
int RIG_IC756PRO3::get_smeter()
200
 
{
201
 
        string cstr = "\x15\x02";
202
 
        string resp = pre_fm;
203
 
        resp.append(cstr);
204
 
        cmd = pre_to;
205
 
        cmd.append(cstr);
206
 
        cmd.append(post);
207
 
        if (waitFOR(9, "get smeter")) {
208
 
                size_t p = replystr.rfind(resp);
209
 
                if (p != string::npos)
210
 
                        return (int)ceil(fm_bcd(&replystr[p+6], 3) / 2.55);
211
 
        }
212
 
        return 0;
213
 
}
214
 
 
215
 
int RIG_IC756PRO3::get_power_out()
216
 
{
217
 
        string cstr = "\x15\x11";
218
 
        string resp = pre_fm;
219
 
        resp.append(cstr);
220
 
        cmd = pre_to;
221
 
        cmd.append(cstr);
222
 
        cmd.append(post);
223
 
        if (waitFOR(9, "get pout")) {
224
 
                size_t p = replystr.rfind(resp);
225
 
                if (p != string::npos)
226
 
                        return (int)ceil(fm_bcd(&replystr[p+6], 3) / 2.55);
227
 
        }
228
 
        return 0;
229
 
}
230
 
 
231
 
int RIG_IC756PRO3::get_alc()
232
 
{
233
 
        string cstr = "\x15\x13";
234
 
        string resp = pre_fm;
235
 
        resp.append(cstr);
236
 
        cmd = pre_to;
237
 
        cmd.append(cstr);
238
 
        cmd.append(post);
239
 
        if (waitFOR(9, "get alc")) {
240
 
                size_t p = replystr.rfind(resp);
241
 
                if (p != string::npos)
242
 
                        return (int)ceil(fm_bcd(&replystr[p+6], 3) / 2.55);
243
 
        }
244
 
        return 0;
245
 
}
246
 
 
247
 
int RIG_IC756PRO3::get_swr()
248
 
{
249
 
        string cstr = "\x15\x12";
250
 
        string resp = pre_fm;
251
 
        resp.append(cstr);
252
 
        cmd = pre_to;
253
 
        cmd.append(cstr);
254
 
        cmd.append(post);
255
 
        if (waitFOR(9, "get swr")) {
256
 
                size_t p = replystr.rfind(resp);
257
 
                if (p != string::npos)
258
 
                        return (int)ceil(fm_bcd(&replystr[p+6], 3) / 2.55);
259
 
        }
260
 
        return 0;
261
 
}
262
 
 
263
 
// Volume control val 0 ... 100
264
 
 
265
 
void RIG_IC756PRO3::set_volume_control(int val)
266
 
{
267
 
        ICvol = (int)(val * 2.55);
268
 
        cmd = pre_to;
269
 
        cmd.append("\x14\x01");
270
 
        cmd.append(to_bcd(ICvol, 3));
271
 
        cmd.append( post );
272
 
        waitFB("set vol");
273
 
}
274
 
 
275
 
int RIG_IC756PRO3::get_volume_control()
276
 
{
277
 
        string cstr = "\x14\x01";
278
 
        string resp = pre_fm;
279
 
        resp.append(cstr);
280
 
        cmd = pre_to;
281
 
        cmd.append(cstr);
282
 
        cmd.append(post);
283
 
        if (waitFOR(9, "get vol")) {
284
 
                size_t p = replystr.rfind(resp);
285
 
                if (p != string::npos)
286
 
                        return (int)ceil(fm_bcd(&replystr[p+6],3) / 2.55);
287
 
        }
288
 
        return 0;
289
 
}
290
 
 
291
 
void RIG_IC756PRO3::get_vol_min_max_step(int &min, int &max, int &step)
292
 
{
293
 
        min = 0; max = 100; step = 1;
294
 
}
295
 
 
296
 
// Tranceiver PTT on/off
297
 
void RIG_IC756PRO3::set_PTT_control(int val)
298
 
{
299
 
        cmd = pre_to;
300
 
        cmd += '\x1c';
301
 
        cmd += '\x00';
302
 
        cmd += (unsigned char) val;
303
 
        cmd.append( post );
304
 
        waitFB("set PTT");
305
 
}
306
 
 
307
 
// changed noise blanker to noise reduction
308
 
void RIG_IC756PRO3::set_noise(bool val)
309
 
{
310
 
        cmd = pre_to;
311
 
        cmd.append("\x16\x22");
312
 
        cmd += val ? 1 : 0;
313
 
        cmd.append(post);
314
 
        waitFB("set noise");
315
 
}
316
 
 
317
 
int RIG_IC756PRO3::get_noise()
318
 
{
319
 
        string cstr = "\x16\x22";
320
 
        string resp = pre_fm;
321
 
        resp.append(cstr);
322
 
        cmd = pre_to;
323
 
        cmd.append(cstr);
324
 
        cmd.append(post);
325
 
        if (waitFOR(8, "get noise")) {
326
 
                size_t p = replystr.rfind(resp);
327
 
                if (p != string::npos)
328
 
                        return (replystr[p+6] ? 1 : 0);
329
 
        }
330
 
        return progStatus.noise;
331
 
}
332
 
 
333
 
void RIG_IC756PRO3::set_noise_reduction(int val)
334
 
{
335
 
        cmd = pre_to;
336
 
        cmd.append("\x16\x40");
337
 
        cmd += val ? 1 : 0;
338
 
        cmd.append(post);
339
 
        waitFB("set NR");
340
 
}
341
 
 
342
 
int RIG_IC756PRO3::get_noise_reduction()
343
 
{
344
 
        string cstr = "\x16\x40";
345
 
        string resp = pre_fm;
346
 
        resp.append(cstr);
347
 
        cmd = pre_to;
348
 
        cmd.append(cstr);
349
 
        cmd.append(post);
350
 
        if (waitFOR(8, "get NR")) {
351
 
                size_t p = replystr.rfind(resp);
352
 
                if (p != string::npos)
353
 
                        return (replystr[p+6] ? 1 : 0);
354
 
        }
355
 
        return progStatus.noise_reduction;
356
 
}
357
 
 
358
 
// 0 < val < 100
359
 
void RIG_IC756PRO3::set_noise_reduction_val(int val)
360
 
{
361
 
        cmd = pre_to;
362
 
        cmd.append("\x14\x06");
363
 
        cmd.append(to_bcd(val * 2.55, 3));
364
 
        cmd.append(post);
365
 
        waitFB("set NR val");
366
 
}
367
 
 
368
 
int RIG_IC756PRO3::get_noise_reduction_val()
369
 
{
370
 
        string cstr = "\x14\x06";
371
 
        string resp = pre_fm;
372
 
        resp.append(cstr);
373
 
        cmd = pre_to;
374
 
        cmd.append(cstr);
375
 
        cmd.append(post);
376
 
        if (waitFOR(9, "get NR val")) {
377
 
                size_t p = replystr.rfind(resp);
378
 
                if (p != string::npos)
379
 
                        return (int)ceil(fm_bcd(&replystr[p+6],3) / 2.55);
380
 
        }
381
 
        return progStatus.noise_reduction_val;
382
 
}
383
 
 
384
 
int RIG_IC756PRO3::get_modetype(int n)
385
 
{
386
 
        return _mode_type[n];
387
 
}
388
 
 
389
 
int RIG_IC756PRO3::get_mic_gain()
390
 
{
391
 
        string cstr = "\x14\x0B";
392
 
        string resp = pre_fm;
393
 
        resp.append(cstr);
394
 
        cmd = pre_to;
395
 
        cmd.append(cstr);
396
 
        cmd.append(post);
397
 
        if (waitFOR(9, "get mic")) {
398
 
                size_t p = replystr.rfind(resp);
399
 
                if (p != string::npos)
400
 
                        return (int)ceil(fm_bcd(&replystr[p+6],3) / 2.55);
401
 
        }
402
 
        return 0;
403
 
}
404
 
 
405
 
void RIG_IC756PRO3::set_mic_gain(int val)
406
 
{
407
 
        val = (int)(val * 2.55);
408
 
        cmd = pre_to;
409
 
        cmd.append("\x14\x0B");
410
 
        cmd.append(to_bcd(val,3));
411
 
        cmd.append(post);
412
 
        waitFB("set mic");
413
 
}
414
 
 
415
 
void RIG_IC756PRO3::get_mic_gain_min_max_step(int &min, int &max, int &step)
416
 
{
417
 
        min = 0;
418
 
        max = 100;
419
 
        step = 1;
420
 
}
421
 
 
422
 
void RIG_IC756PRO3::set_if_shift(int val)
423
 
{
424
 
        int shift = (int)(val * 128.0 / 825.0 + 128);
425
 
        cmd = pre_to;
426
 
        cmd.append("\x14\x07");
427
 
        cmd.append(to_bcd(shift, 3));
428
 
        cmd.append(post);
429
 
        waitFB("set if-shift");
430
 
}
431
 
 
432
 
bool  RIG_IC756PRO3::get_if_shift(int &val)
433
 
{
434
 
        string cstr = "\x14\x07";
435
 
        string resp = pre_fm;
436
 
        resp.append(cstr);
437
 
        cmd = pre_to;
438
 
        cmd.append(cstr);
439
 
        cmd.append(post);
440
 
        val = progStatus.shift_val;
441
 
        if (waitFOR(9, "get if-shift")) {
442
 
                size_t p = replystr.rfind(resp);
443
 
                if (p != string::npos)
444
 
                        val = (int)((fm_bcd(&replystr[p+6], 3) - 128) * 825.0 / 128.0);
445
 
        }
446
 
        return (progStatus.shift = (val != 0));
447
 
}
448
 
 
449
 
void RIG_IC756PRO3::get_if_min_max_step(int &min, int &max, int &step)
450
 
{
451
 
        min = -825;
452
 
        max = +825;
453
 
        step = 25;
454
 
}
455
 
 
456
 
void RIG_IC756PRO3::set_squelch(int val)
457
 
{
458
 
        int IC756PRO3sql = (int)(val * 2.55);
459
 
        cmd = pre_to;
460
 
        cmd.append("\x14\x03");
461
 
        cmd.append(to_bcd(IC756PRO3sql, 3));
462
 
        cmd.append( post );
463
 
        waitFB("set sql");
464
 
}
465
 
 
466
 
int  RIG_IC756PRO3::get_squelch()
467
 
{
468
 
        string cstr = "\x14\x03";
469
 
        string resp = pre_fm;
470
 
        resp.append(cstr);
471
 
        cmd = pre_to;
472
 
        cmd.append(cstr);
473
 
        cmd.append(post);
474
 
        if (waitFOR(9, "get sql")) {
475
 
                size_t p = replystr.rfind(resp);
476
 
                if (p != string::npos)
477
 
                        return (int)ceil(fm_bcd(&replystr[p+6], 3) / 2.55);
478
 
        }
479
 
        return progStatus.squelch;
480
 
}
481
 
 
482
 
void RIG_IC756PRO3::set_rf_gain(int val)
483
 
{
484
 
        int IC756PRO3rfg = (int)(val * 2.55);
485
 
        cmd = pre_to;
486
 
        cmd.append("\x14\x02");
487
 
        cmd.append(to_bcd(IC756PRO3rfg, 3));
488
 
        cmd.append( post );
489
 
        waitFB("set rf gain");
490
 
}
491
 
 
492
 
int RIG_IC756PRO3::get_rf_gain()
493
 
{
494
 
        string cstr = "\x14\x02";
495
 
        string resp = pre_fm;
496
 
        cmd = pre_to;
497
 
        cmd.append(cstr).append(post);
498
 
        resp.append(cstr);
499
 
        if (waitFOR(9, "get rfgain")) {
500
 
                size_t p = replystr.rfind(resp);
501
 
                if (p != string::npos)
502
 
                        return (int)ceil(fm_bcd(&replystr[p + 6],3) / 2.55);
503
 
        }
504
 
        return progStatus.rfgain;
505
 
}
506
 
 
507
 
void RIG_IC756PRO3::set_power_control(double val)
508
 
{
509
 
        cmd = pre_to;
510
 
        cmd.append("\x14\x0A");
511
 
        cmd.append(to_bcd((int)(val * 2.55), 3));
512
 
        cmd.append( post );
513
 
        waitFB("set power");
514
 
}
515
 
 
516
 
int RIG_IC756PRO3::get_power_control()
517
 
{
518
 
        string cstr = "\x14\x0A";
519
 
        string resp = pre_fm;
520
 
        resp.append(cstr);
521
 
        cmd = pre_to;
522
 
        cmd.append(cstr).append(post);
523
 
        if (waitFOR(9, "get power")) {
524
 
                size_t p = replystr.rfind(resp);
525
 
                if (p != string::npos)
526
 
                        return (int)ceil(fm_bcd(&replystr[p + 6],3) / 2.55);
527
 
        }
528
 
        return progStatus.power_level;
529
 
}
530
 
 
531
 
void RIG_IC756PRO3::set_split(bool val)
532
 
{
533
 
        cmd = pre_to;
534
 
        cmd += 0x0F;
535
 
        cmd += val ? 0x01 : 0x00;
536
 
        cmd.append(post);
537
 
        waitFB("set split");
538
 
}
539
 
 
540
 
int RIG_IC756PRO3::get_split()
541
 
{
542
 
        LOG_WARN("%s", "get split - not implemented");
543
 
        return progStatus.split;
544
 
}
545
 
 
546
 
int RIG_IC756PRO3::adjust_bandwidth(int m)
547
 
{
548
 
        if (m == 0 || m == 1 || m == 8 || m == 9) { //SSB
549
 
                bandwidths_ = IC756PRO3_SSBwidths;
550
 
                return (32);
551
 
        }
552
 
        if (m == 3 || m == 6) { //CW
553
 
                bandwidths_ = IC756PRO3_SSBwidths;
554
 
                return (14);
555
 
        }
556
 
        if (m == 4 || m == 7) { //RTTY
557
 
                bandwidths_ = IC756PRO3_RTTYwidths;
558
 
                return (28);
559
 
        }
560
 
        bandwidths_ = IC756PRO3_AMFMwidths;
561
 
        return (0);
562
 
}
563
 
 
564
 
int RIG_IC756PRO3::def_bandwidth(int m)
565
 
{
566
 
        if (m == 0 || m == 1 || m == 8 || m == 9) { //SSB
567
 
                return (32);
568
 
        }
569
 
        if (m == 3 || m == 6) { //CW
570
 
                return (14);
571
 
        }
572
 
        if (m == 4 || m == 7) { //RTTY
573
 
                return (28);
574
 
        }
575
 
        bandwidths_ = IC756PRO3_AMFMwidths;
576
 
        return (0);
577
 
}
578
 
 
579
 
const char **RIG_IC756PRO3::bwtable(int m)
580
 
{
581
 
        if (m == 0 || m == 1 || m == 8 || m == 9) //SSB
582
 
                return IC756PRO3_SSBwidths;
583
 
        if (m == 3 || m == 6) //CW
584
 
                return IC756PRO3_SSBwidths;
585
 
        if (m == 4 || m == 7) //RTTY
586
 
                return IC756PRO3_RTTYwidths;
587
 
        return IC756PRO3_AMFMwidths;
588
 
}
589
 
 
590
 
void RIG_IC756PRO3::tune_rig()
591
 
{
592
 
        cmd = pre_to;
593
 
        cmd.append("\x1c\x01\x02");
594
 
        cmd.append( post );
595
 
        waitFB("tune");
596
 
}
597
 
 
598
 
void RIG_IC756PRO3::set_bwA(int val)
599
 
{
600
 
        if (bandwidths_ == IC756PRO3_AMFMwidths) {
601
 
                A.iBW = val + 1;
602
 
                set_modeA(A.imode);
603
 
                return;
604
 
        }
605
 
 
606
 
        A.iBW = val;
607
 
        cmd = pre_to;
608
 
        cmd.append("\x1A\x03");
609
 
        cmd.append(to_bcd(A.iBW,2));
610
 
        cmd.append( post );
611
 
        waitFB("set bw A");
612
 
}
613
 
 
614
 
int  RIG_IC756PRO3::get_bwA()
615
 
{
616
 
        if (bandwidths_ == IC756PRO3_AMFMwidths) {
617
 
                return A.iBW - 1;
618
 
        }
619
 
        string cstr = "\x1A\x03";
620
 
        string resp = pre_fm;
621
 
        resp.append(cstr);
622
 
        cmd = pre_to;
623
 
        cmd.append(cstr);
624
 
        cmd.append( post );
625
 
        if (waitFOR(8, "get bw A")) {
626
 
                size_t p = replystr.rfind(resp);
627
 
                if (p != string::npos)
628
 
                        A.iBW = (int)(fm_bcd(&replystr[p + 6], 2));
629
 
        }
630
 
        return A.iBW;
631
 
}
632
 
 
633
 
void RIG_IC756PRO3::set_bwB(int val)
634
 
{
635
 
        if (bandwidths_ == IC756PRO3_AMFMwidths) {
636
 
                B.iBW = val + 1;
637
 
                set_modeB(B.imode);
638
 
                return;
639
 
        }
640
 
 
641
 
        B.iBW = val;
642
 
        cmd = pre_to;
643
 
        cmd.append("\x1A\x03");
644
 
        cmd.append(to_bcd(B.iBW,2));
645
 
        cmd.append( post );
646
 
        waitFB("set bw B");
647
 
}
648
 
 
649
 
int  RIG_IC756PRO3::get_bwB()
650
 
{
651
 
        if (bandwidths_ == IC756PRO3_AMFMwidths) {
652
 
                return B.iBW - 1;
653
 
        }
654
 
        string cstr = "\x1A\x03";
655
 
        string resp = pre_fm;
656
 
        resp.append(cstr);
657
 
        cmd = pre_to;
658
 
        cmd.append(cstr);
659
 
        cmd.append( post );
660
 
        if (waitFOR(8, "get bw B")) {
661
 
                size_t p = replystr.rfind(resp);
662
 
                if (p != string::npos)
663
 
                        B.iBW = (int)(fm_bcd(&replystr[p + 6], 2));
664
 
        }
665
 
        return B.iBW;
666
 
}
667
 
 
668
 
bool IC756PRO3_notchon = false;
669
 
void RIG_IC756PRO3::set_notch(bool on, int val)
670
 
{
671
 
        int notch = (int)(val/20.0 + 128);
672
 
        if (notch > 256) notch = 255;
673
 
        if (on != IC756PRO3_notchon) {
674
 
                cmd = pre_to;
675
 
                cmd.append("\x16\x48");
676
 
                cmd += on ? '\x01' : '\x00';
677
 
                cmd.append(post);
678
 
                waitFB("set notch");
679
 
                IC756PRO3_notchon = on;
680
 
        }
681
 
 
682
 
        if (on) {
683
 
                cmd = pre_to;
684
 
                cmd.append("\x14\x0D");
685
 
                cmd.append(to_bcd(notch,3));
686
 
                cmd.append(post);
687
 
                waitFB("set notch val");
688
 
        }
689
 
}
690
 
 
691
 
bool RIG_IC756PRO3::get_notch(int &val)
692
 
{
693
 
        bool on = false;
694
 
        val = 0;
695
 
 
696
 
        string cstr = "\x16\x48";
697
 
        string resp = pre_fm;
698
 
        resp.append(cstr);
699
 
        cmd = pre_to;
700
 
        cmd.append(cstr);
701
 
        cmd.append( post );
702
 
        if (waitFOR(8, "get notch")) {
703
 
                size_t p = replystr.rfind(resp);
704
 
                if (p != string::npos)
705
 
                        on = replystr[p + 6] ? 1 : 0;
706
 
                cmd = pre_to;
707
 
                resp = pre_fm;
708
 
                cstr = "\x14\x0D";
709
 
                cmd.append(cstr);
710
 
                resp.append(cstr);
711
 
                cmd.append(post);
712
 
                if (waitFOR(9, "get notch val")) {
713
 
                        size_t p = replystr.rfind(resp);
714
 
                        if (p != string::npos)
715
 
                                val = 20*ceil(fm_bcd(&replystr[p + 6],3) - 128);
716
 
                }
717
 
        }
718
 
        return on;
719
 
}
720
 
 
721
 
void RIG_IC756PRO3::get_notch_min_max_step(int &min, int &max, int &step)
722
 
{
723
 
        min = -1280;
724
 
        max = 1280;
725
 
        step = 20;
726
 
}
727
 
 
728
 
void RIG_IC756PRO3::set_attenuator(int val)
729
 
{
730
 
        int cmdval = 0;
731
 
        if (atten_level == 0) {
732
 
                atten_level = 1;
733
 
                atten_label("6 dB", true);
734
 
                cmdval = 0x06;
735
 
        } else if (atten_level == 1) {
736
 
                atten_level = 2;
737
 
                atten_label("12 dB", true);
738
 
                cmdval = 0x12;
739
 
        } else if (atten_level == 2) {
740
 
                atten_level = 3;
741
 
                atten_label("18 dB", true);
742
 
                cmdval = 0x18;
743
 
        } else if (atten_level == 3) {
744
 
                atten_level = 0;
745
 
                atten_label("Att", false);
746
 
                cmdval = 0x00;
747
 
        }
748
 
        cmd = pre_to;
749
 
        cmd += '\x11';
750
 
        cmd += cmdval;
751
 
        cmd.append( post );
752
 
        waitFB("set att");
753
 
}
754
 
 
755
 
int RIG_IC756PRO3::get_attenuator()
756
 
{
757
 
        string cstr = "\x11";
758
 
        string resp = pre_fm;
759
 
        resp.append(cstr);
760
 
        cmd = pre_to;
761
 
        cmd.append(cstr);
762
 
        cmd.append( post );
763
 
        if (waitFOR(7, "get att")) {
764
 
                size_t p = replystr.rfind(resp);
765
 
                if (p != string::npos) {
766
 
                        if (replystr[p+5] == 0x06) {
767
 
                                atten_level = 1;
768
 
                                atten_label("6 dB", true);
769
 
                        } else if (replystr[p+5] == 0x12) {
770
 
                                atten_level = 2;
771
 
                                atten_label("12 dB", true);
772
 
                        } else if (replystr[p+5] == 0x18) {
773
 
                                atten_level = 3;
774
 
                                atten_label("18 dB", true);
775
 
                        } else if (replystr[p+5] == 0x00) {
776
 
                                atten_level = 0;
777
 
                                atten_label("Att", false);
778
 
                        }
779
 
                }
780
 
        }
781
 
        return atten_level;
782
 
}
783
 
 
784
 
void RIG_IC756PRO3::set_preamp(int val)
785
 
{
786
 
        if (preamp_level == 0) {
787
 
                preamp_level = 1;
788
 
                preamp_label("Pre 1", true);
789
 
        } else if (preamp_level == 1) {
790
 
                preamp_level = 2;
791
 
                preamp_label("Pre 2", true);
792
 
        } else if (preamp_level == 2) {
793
 
                preamp_level = 0;
794
 
                preamp_label("Pre", false);
795
 
        }
796
 
        cmd = pre_to;
797
 
        cmd += '\x16';
798
 
        cmd += '\x02';
799
 
        cmd += (unsigned char) preamp_level;
800
 
        cmd.append( post );
801
 
        waitFB("set preamp");
802
 
}
803
 
 
804
 
int RIG_IC756PRO3::get_preamp()
805
 
{
806
 
        string cstr = "\x16\x02";
807
 
        string resp = pre_fm;
808
 
        resp.append(cstr);
809
 
        cmd = pre_to;
810
 
        cmd.append(cstr);
811
 
        cmd.append( post );
812
 
        if (waitFOR(8, "get preamp")) {
813
 
                size_t p = replystr.rfind(resp);
814
 
                if (p != string::npos) {
815
 
                        if (replystr[p+6] == 0x01) {
816
 
                                preamp_label("Pre 1", true);
817
 
                                preamp_level = 1;
818
 
                        } else if (replystr[p+6] == 0x02) {
819
 
                                preamp_label("Pre 2", true);
820
 
                                preamp_level = 2;
821
 
                        } else {
822
 
                                preamp_label("Pre", false);
823
 
                                preamp_level = 0;
824
 
                        }
825
 
                }
826
 
        }
827
 
        return preamp_level;
828
 
}
829
 
 
830
 
 
831
 
void RIG_IC756PRO3::set_modeA(int val)
832
 
{
833
 
        A.imode = val;
834
 
        bool datamode = false;
835
 
        switch (val) {
836
 
                case 10 : val = 5; datamode = true; break;
837
 
                case 9  : val = 1; datamode = true; break;
838
 
                case 8  : val = 0; datamode = true; break;
839
 
                case 7  : val = 8; break;
840
 
                case 6  : val = 7; break;
841
 
                default: break;
842
 
        }
843
 
        cmd = pre_to;
844
 
        cmd += '\x06';
845
 
        cmd += val;
846
 
        cmd.append( post );
847
 
        waitFB("set mode A");
848
 
        if (datamode) { // LSB / USB ==> use DATA mode
849
 
                cmd = pre_to;
850
 
                cmd.append("\x1A\x06\x01");
851
 
                cmd.append(post);
852
 
                waitFB("data mode");
853
 
        }
854
 
}
855
 
 
856
 
int RIG_IC756PRO3::get_modeA()
857
 
{
858
 
        int md = 0;
859
 
        string cstr = "\x04";
860
 
        string resp = pre_fm;
861
 
        resp.append(cstr);
862
 
        cmd = pre_to;
863
 
        cmd.append(cstr);
864
 
        cmd.append(post);
865
 
        if (waitFOR(8, "get mode A")) {
866
 
                size_t p = replystr.rfind(resp);
867
 
                if (p != string::npos) {
868
 
                        md = replystr[p+5];
869
 
                        if (md > 6) md--;
870
 
                        A.iBW = replystr[p+6];
871
 
                        cstr = "\x1A\x06";
872
 
                        resp = pre_fm;
873
 
                        resp.append(cstr);
874
 
                        cmd = pre_to;
875
 
                        cmd.append(cstr);
876
 
                        cmd.append(post);
877
 
                        if (waitFOR(9, "data mode?")) {
878
 
                                p = replystr.rfind(resp);
879
 
                                if (p != string::npos) {
880
 
                                        if (replystr[p+6]) {
881
 
                                                switch (md) {
882
 
                                                        case 0 : md = 8; break;
883
 
                                                        case 1 : md = 9; break;
884
 
                                                        case 5 : md = 10; break;
885
 
                                                        default : break;
886
 
                                                }
887
 
                                        }
888
 
                                }
889
 
                        }
890
 
                        A.imode = md;
891
 
                }
892
 
        }
893
 
        return A.imode;
894
 
}
895
 
 
896
 
void RIG_IC756PRO3::set_modeB(int val)
897
 
{
898
 
        B.imode = val;
899
 
        bool datamode = false;
900
 
        switch (val) {
901
 
                case 10 : val = 5; datamode = true; break;
902
 
                case 9  : val = 1; datamode = true; break;
903
 
                case 8  : val = 0; datamode = true; break;
904
 
                case 7  : val = 8; break;
905
 
                case 6  : val = 7; break;
906
 
                default: break;
907
 
        }
908
 
        cmd = pre_to;
909
 
        cmd += '\x06';
910
 
        cmd += val;
911
 
        cmd.append( post );
912
 
        waitFB("set mode B");
913
 
        if (datamode) { // LSB / USB ==> use DATA mode
914
 
                cmd = pre_to;
915
 
                cmd.append("\x1A\x06\x01");
916
 
                cmd.append(post);
917
 
                waitFB("data mode");
918
 
        }
919
 
}
920
 
 
921
 
int RIG_IC756PRO3::get_modeB()
922
 
{
923
 
        int md = 0;
924
 
        string cstr = "\x04";
925
 
        string resp = pre_fm;
926
 
        resp.append(cstr);
927
 
        cmd = pre_to;
928
 
        cmd.append(cstr);
929
 
        cmd.append(post);
930
 
        if (waitFOR(8, "get mode B")) {
931
 
                size_t p = replystr.rfind(resp);
932
 
                if (p != string::npos) {
933
 
                        md = replystr[p+5];
934
 
                        if (md > 6) md--;
935
 
                        B.iBW = replystr[p+6];
936
 
                        cstr = "\x1A\x06";
937
 
                        resp = pre_fm;
938
 
                        resp.append(cstr);
939
 
                        cmd = pre_to;
940
 
                        cmd.append(cstr);
941
 
                        cmd.append(post);
942
 
                        if (waitFOR(9, "data mode?")) {
943
 
                                p = replystr.rfind(resp);
944
 
                                if (p != string::npos) {
945
 
                                        if (replystr[p+6]) {
946
 
                                                switch (md) {
947
 
                                                        case 0 : md = 8; break;
948
 
                                                        case 1 : md = 9; break;
949
 
                                                        case 5 : md = 10; break;
950
 
                                                        default : break;
951
 
                                                }
952
 
                                        }
953
 
                                }
954
 
                        }
955
 
                        B.imode = md;
956
 
                }
957
 
        }
958
 
        return B.imode;
959
 
}
960
 
 
961
 
void RIG_IC756PRO3::set_auto_notch(int val)
962
 
{
963
 
        cmd = pre_to;
964
 
        cmd += '\x16';
965
 
        cmd += '\x41';
966
 
        cmd += val ? 0x01 : 0x00;
967
 
        cmd.append( post );
968
 
        waitFB("set AN");
969
 
}
970
 
 
971
 
int RIG_IC756PRO3::get_auto_notch()
972
 
{
973
 
        string cstr = "\x16\x41";
974
 
        string resp = pre_fm;
975
 
        resp.append(cstr);
976
 
        cmd = pre_to;
977
 
        cmd.append(cstr);
978
 
        cmd.append( post );
979
 
        if (waitFOR(8, "get AN")) {
980
 
                size_t p = replystr.rfind(resp);
981
 
                if (p != string::npos) {
982
 
                        if (replystr[p+6] == 0x01) {
983
 
                                auto_notch_label("AN", true);
984
 
                                return true;
985
 
                        } else {
986
 
                                auto_notch_label("AN", false);
987
 
                                return false;
988
 
                        }
989
 
                }
990
 
        }
991
 
        return progStatus.auto_notch;
992
 
}
993