← 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/IC756PRO2.cxx

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

Show diffs side-by-side

added added

removed removed

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