← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/rigs/IC756PRO3.cxx

  • Committer: Package Import Robot
  • Author(s): Kamal Mostafa
  • Date: 2014-06-07 11:28:52 UTC
  • Revision ID: package-import@ubuntu.com-20140607112852-v4d5tb1m3h3vi0dl
Tags: upstream-1.3.15
Import upstream version 1.3.15

Show diffs side-by-side

added added

removed removed

Lines of Context:
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