← 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/FT450.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/FT450.cxx
1
 
/*
2
 
 * Yaesu FT-450 drivers
3
 
 * 
4
 
 * a part of flrig
5
 
 * 
6
 
 * Copyright 2009, Dave Freese, W1HKJ
7
 
 * Copyright 2011-2012, Terry Embry, KJ4EED
8
 
 * 
9
 
 */
10
 
 
11
 
 
12
 
#include "FT450.h"
13
 
#include "rig.h"
14
 
 
15
 
static const char FT450name_[] = "FT-450";
16
 
 
17
 
static const char *FT450modes_[] = {
18
 
                "LSB", "USB", "CW", "FM", "AM", "RTTY-L", "CW-R", "USER-L", "RTTY-U", "FM-N", "USER-U", NULL};
19
 
static const char mode_chr[] =  { '1', '2', '3', '4', '5', '6', '7', '8', '9', 'B', 'C' };
20
 
static const char mode_type[] = { 'L', 'U', 'U', 'U', 'U', 'L', 'L', 'L', 'U', 'U', 'U' };
21
 
 
22
 
static const char *FT450_widths[] = {"NARR", "NORM", "WIDE", NULL};
23
 
 
24
 
static const char *FT450_US_60m[] = {NULL, "126", "127", "128", "130", NULL};
25
 
// US has 5 60M presets. Using dummy numbers for all.
26
 
// First NULL means skip 60m sets in set_band_selection().
27
 
// Maybe someone can do a cat command MC; on all 5 presets and add returned numbers above.
28
 
// To send cat commands in flrig goto menu Config->Xcvr select->Send Cmd.
29
 
 
30
 
static const char **Channels_60m = FT450_US_60m;
31
 
 
32
 
static GUI rig_widgets[]= {
33
 
        { (Fl_Widget *)btnVol,        2, 125,  50 },
34
 
        { (Fl_Widget *)sldrVOLUME,   54, 125, 156 },
35
 
        { (Fl_Widget *)btnIFsh,     214, 105,  50 },
36
 
        { (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 },
37
 
        { (Fl_Widget *)btnNotch,    214, 125,  50 },
38
 
        { (Fl_Widget *)sldrNOTCH,   266, 125, 156 },
39
 
        { (Fl_Widget *)sldrMICGAIN,  54, 145, 156 },
40
 
        { (Fl_Widget *)sldrPOWER,    54, 165, 368 },
41
 
        { (Fl_Widget *)btnNR,       214, 145,  50 },
42
 
        { (Fl_Widget *)sldrNR,      266, 145, 156 },
43
 
        { (Fl_Widget *)NULL,          0,   0,   0 }
44
 
};
45
 
 
46
 
RIG_FT450::RIG_FT450() {
47
 
// base class values    
48
 
        name_ = FT450name_;
49
 
        modes_ = FT450modes_;
50
 
        bandwidths_ = FT450_widths;
51
 
 
52
 
        widgets = rig_widgets;
53
 
 
54
 
        comm_baudrate = BR38400;
55
 
        stopbits = 1;
56
 
        comm_retries = 2;
57
 
        comm_wait = 5;
58
 
        comm_timeout = 50;
59
 
        comm_rtscts = true;
60
 
        comm_rtsplus = false;
61
 
        comm_dtrplus = false;
62
 
        comm_catptt = true;
63
 
        comm_rtsptt = false;
64
 
        comm_dtrptt = false;
65
 
        modeA = 1;
66
 
        bwA = 2;
67
 
        def_mode = 10;
68
 
        def_bw = 2;
69
 
        def_freq = 14070000;
70
 
 
71
 
        precision = 10;
72
 
        ndigits = 8;
73
 
 
74
 
        has_a2b =
75
 
        can_change_alt_vfo =
76
 
        has_xcvr_auto_on_off =
77
 
        has_noise_reduction =
78
 
        has_noise_reduction_control =
79
 
        has_band_selection =
80
 
        has_extras =
81
 
        has_vox_onoff =
82
 
        has_vox_gain =
83
 
        has_vox_hang =
84
 
 
85
 
        has_cw_wpm =
86
 
        has_cw_keyer =
87
 
//      has_cw_vol =
88
 
        has_cw_spot =
89
 
        has_cw_spot_tone =
90
 
        has_cw_qsk =
91
 
        has_cw_weight =
92
 
 
93
 
        has_split =
94
 
        has_smeter =
95
 
        has_swr_control =
96
 
        has_power_out =
97
 
        has_power_control =
98
 
        has_volume_control =
99
 
        has_mode_control =
100
 
        has_noise_control =
101
 
        has_bandwidth_control =
102
 
        has_micgain_control =
103
 
        has_notch_control =
104
 
        has_attenuator_control =
105
 
        has_preamp_control =
106
 
        has_ifshift_control =
107
 
        has_ptt_control =
108
 
        has_tune_control = true;
109
 
 
110
 
// derived specific
111
 
        notch_on = false;
112
 
        m_60m_indx = 0;
113
 
 
114
 
        precision = 1;
115
 
        ndigits = 8;
116
 
}
117
 
 
118
 
void RIG_FT450::initialize()
119
 
{
120
 
        rig_widgets[0].W = btnVol;
121
 
        rig_widgets[1].W = sldrVOLUME;
122
 
        rig_widgets[2].W = btnIFsh;
123
 
        rig_widgets[3].W = sldrIFSHIFT;
124
 
        rig_widgets[4].W = btnNotch;
125
 
        rig_widgets[5].W = sldrNOTCH;
126
 
        rig_widgets[6].W = sldrMICGAIN;
127
 
        rig_widgets[7].W = sldrPOWER;
128
 
        rig_widgets[8].W = btnNR;
129
 
        rig_widgets[9].W = sldrNR;
130
 
 
131
 
// set progStatus defaults
132
 
        if (progStatus.noise_reduction_val < 1) progStatus.noise_reduction_val = 1;
133
 
// first-time-thru, or reset
134
 
        if (progStatus.cw_qsk < 15) {
135
 
                progStatus.cw_qsk = 15;
136
 
                progStatus.cw_spot_tone = 700;
137
 
                progStatus.cw_weight = 3.0;
138
 
                progStatus.cw_wpm = 18;
139
 
                progStatus.vox_gain = 50;
140
 
                progStatus.vox_hang = 500;
141
 
        }
142
 
 
143
 
// turn off auto information mode
144
 
        sendCommand("AI0;");
145
 
 
146
 
        selectA();
147
 
}
148
 
 
149
 
void RIG_FT450::set_band_selection(int v)
150
 
{
151
 
        int inc_60m = false;
152
 
        cmd = "IF;";
153
 
        waitN(27, 100, "get vfo mode in set_band_selection", ASC);
154
 
        size_t p = replystr.rfind("IF");
155
 
        if (p == string::npos) return;
156
 
        if (replystr[p+21] != '0') {    // vfo 60M memory mode
157
 
                inc_60m = true;
158
 
        }
159
 
 
160
 
        if (v == 12) {  // 5MHz 60m presets
161
 
                if (Channels_60m[0] == NULL) return;    // no 60m Channels so skip
162
 
                if (inc_60m) {
163
 
                        if (Channels_60m[++m_60m_indx] == NULL)
164
 
                                m_60m_indx = 0;
165
 
                }
166
 
                cmd.assign("MC").append(Channels_60m[m_60m_indx]).append(";");
167
 
        } else {                // v == 1..11 band selection OR return to vfo mode == 0
168
 
                if (inc_60m)
169
 
                        cmd = "VM;";
170
 
                else {
171
 
                        if (v < 3)
172
 
                                v = v - 1;
173
 
                        cmd.assign("BS").append(to_decimal(v, 2)).append(";");
174
 
                }
175
 
        }
176
 
 
177
 
        sendCommand(cmd);
178
 
        showresp(WARN, ASC, "Select Band Stacks", cmd, replystr);
179
 
}
180
 
 
181
 
int  RIG_FT450::adjust_bandwidth(int m)
182
 
{
183
 
        return 1;
184
 
}
185
 
 
186
 
void RIG_FT450::selectA()
187
 
{
188
 
        cmd = "VS0;";
189
 
        sendCommand(cmd, 0);
190
 
}
191
 
 
192
 
void RIG_FT450::selectB()
193
 
{
194
 
        cmd = "VS1;";
195
 
        sendCommand(cmd, 0);
196
 
}
197
 
 
198
 
void RIG_FT450::A2B()
199
 
{
200
 
        cmd = "VV;";
201
 
        sendCommand(cmd);
202
 
        showresp(WARN, ASC, "vfo A --> B", cmd, replystr);
203
 
}
204
 
 
205
 
long RIG_FT450::get_vfoA ()
206
 
{
207
 
        cmd = rsp = "FA";
208
 
        cmd += ';';
209
 
        waitN(11, 100, "get vfo A", ASC);
210
 
 
211
 
        size_t p = replystr.rfind(rsp);
212
 
        if (p == string::npos) return freqA;
213
 
        int f = 0;
214
 
        for (size_t n = 2; n < 10; n++)
215
 
                f = f*10 + replystr[p+n] - '0';
216
 
        freqA = f;
217
 
        return freqA;
218
 
}
219
 
 
220
 
void RIG_FT450::set_vfoA (long freq)
221
 
{
222
 
        freqA = freq;
223
 
        cmd = "FA00000000;";
224
 
        for (int i = 9; i > 1; i--) {
225
 
                cmd[i] += freq % 10;
226
 
                freq /= 10;
227
 
        }
228
 
        sendCommand(cmd);
229
 
        showresp(WARN, ASC, "SET vfo A", cmd, replystr);
230
 
}
231
 
 
232
 
long RIG_FT450::get_vfoB ()
233
 
{
234
 
        cmd = rsp = "FB";
235
 
        cmd += ';';
236
 
        waitN(11, 100, "get vfo B", ASC);
237
 
 
238
 
        size_t p = replystr.rfind(rsp);
239
 
        if (p == string::npos) return freqB;
240
 
        int f = 0;
241
 
        for (size_t n = 2; n < 10; n++)
242
 
                f = f*10 + replystr[p+n] - '0';
243
 
        freqB = f;
244
 
        return freqB;
245
 
}
246
 
 
247
 
void RIG_FT450::set_vfoB (long freq)
248
 
{
249
 
        freqB = freq;
250
 
        cmd = "FB00000000;";
251
 
        for (int i = 9; i > 1; i--) {
252
 
                cmd[i] += freq % 10;
253
 
                freq /= 10;
254
 
        }
255
 
        sendCommand(cmd);
256
 
        showresp(WARN, ASC, "SET vfo B", cmd, replystr);
257
 
}
258
 
 
259
 
void RIG_FT450::set_split(bool on)
260
 
{
261
 
        if (on) cmd = "FT1;";
262
 
        else cmd = "FT0;";
263
 
        sendCommand(cmd);
264
 
        showresp(WARN, ASC, "SET split", cmd, replystr);
265
 
}
266
 
 
267
 
int RIG_FT450::get_split()
268
 
{
269
 
        size_t p;
270
 
        int split = 0;
271
 
        char rx, tx;
272
 
// tx vfo
273
 
        cmd = rsp = "FT";
274
 
        cmd.append(";");
275
 
        waitN(4, 100, "get split tx vfo", ASC);
276
 
        p = replystr.rfind(rsp);
277
 
        if (p == string::npos) return false;
278
 
        tx = replystr[p+2] - '0';
279
 
 
280
 
// rx vfo
281
 
        cmd = rsp = "FR";
282
 
        cmd.append(";");
283
 
        waitN(4, 100, "get split rx vfo", ASC);
284
 
 
285
 
        p = replystr.rfind(rsp);
286
 
        if (p == string::npos) return false;
287
 
        rx = replystr[p+2] - '0';
288
 
 
289
 
        split = (tx == 1 ? 2 : 0) + (rx >= 4 ? 1 : 0);
290
 
 
291
 
        return split;
292
 
}
293
 
 
294
 
int RIG_FT450::get_smeter()
295
 
{
296
 
        cmd = rsp = "SM0";
297
 
        cmd += ';';
298
 
        waitN(7, 100, "get smeter", ASC);
299
 
 
300
 
        size_t p = replystr.rfind(rsp);
301
 
        if (p == string::npos) return 0;
302
 
        replystr[p+6] = 0;
303
 
        int mtr = atoi(&replystr[p+3]);
304
 
        mtr = mtr * 100.0 / 256.0;
305
 
        return mtr;
306
 
}
307
 
 
308
 
// measured by W3NR
309
 
//  SWR..... mtr ... display
310
 
//  6:1..... 255 ... 100
311
 
//  3:1..... 132 ...  50
312
 
//  2:1..... 066 ...  26
313
 
//  2.5:1... 099 ...  39
314
 
//  1.5:1... 033 ...  13
315
 
//  1.1:1... 008 ...   3
316
 
 
317
 
int RIG_FT450::get_swr()
318
 
{
319
 
        cmd = rsp = "RM6";
320
 
        cmd += ';';
321
 
        waitN(7, 100, "get swr", ASC);
322
 
 
323
 
        size_t p = replystr.rfind(rsp);
324
 
        if (p == string::npos) return 0;
325
 
        replystr[p+6] = 0;
326
 
        int mtr = atoi(&replystr[p+3]);
327
 
        return mtr / 2.55;
328
 
}
329
 
 
330
 
 
331
 
int RIG_FT450::get_power_out()
332
 
{
333
 
        cmd = rsp = "RM5";
334
 
        sendCommand(cmd.append(";"));
335
 
        waitN(7, 100, "get pout", ASC);
336
 
 
337
 
        size_t p = replystr.rfind(rsp);
338
 
        if (p == string::npos) return 0;
339
 
        replystr[p+6] = 0;
340
 
        double mtr = (double)(atoi(&replystr[p+3]));
341
 
        mtr = -6.6263535 + .11813178 * mtr + .0013607405 * mtr * mtr;
342
 
        return (int)mtr;
343
 
}
344
 
 
345
 
int RIG_FT450::get_power_control()
346
 
{
347
 
        cmd = rsp = "PC";
348
 
        cmd += ';';
349
 
        waitN(6, 100, "get power", ASC);
350
 
 
351
 
        size_t p = replystr.rfind(rsp);
352
 
        if (p == string::npos) return 0;
353
 
        replystr[p+5] = 0;
354
 
        int mtr = atoi(&replystr[p+2]);
355
 
        return mtr;
356
 
}
357
 
 
358
 
void RIG_FT450::set_power_control(double val)
359
 
{
360
 
        int ival = (int)val;
361
 
        cmd = "PC000;";
362
 
        for (int i = 4; i > 1; i--) {
363
 
                cmd[i] += ival % 10;
364
 
                ival /= 10;
365
 
        }
366
 
        sendCommand(cmd);
367
 
        showresp(WARN, ASC, "SET power", cmd, replystr);
368
 
}
369
 
 
370
 
// Volume control return 0 ... 100
371
 
int RIG_FT450::get_volume_control()
372
 
{
373
 
        cmd = rsp = "AG0";
374
 
        cmd += ';';
375
 
        waitN(7, 100, "get vol", ASC);
376
 
 
377
 
        size_t p = replystr.rfind(rsp);
378
 
        if (p == string::npos) return progStatus.volume;
379
 
        if (p + 6 >= replystr.length()) return progStatus.volume;
380
 
        int val = atoi(&replystr[p+3]) * 100 / 250;
381
 
        if (val > 100) val = 100;
382
 
        return val;
383
 
}
384
 
 
385
 
void RIG_FT450::set_volume_control(int val) 
386
 
{
387
 
        int ivol = (int)(val * 250 / 100);
388
 
        cmd = "AG0000;";
389
 
        for (int i = 5; i > 2; i--) {
390
 
                cmd[i] += ivol % 10;
391
 
                ivol /= 10;
392
 
        }
393
 
        sendCommand(cmd);
394
 
        showresp(WARN, ASC, "SET vol", cmd, replystr);
395
 
}
396
 
 
397
 
void RIG_FT450::get_vol_min_max_step(int &min, int &max, int &step)
398
 
{
399
 
        min = 0; max = 255; step = 1;
400
 
}
401
 
 
402
 
// Tranceiver PTT on/off
403
 
void RIG_FT450::set_PTT_control(int val)
404
 
{
405
 
        cmd = val ? "TX1;" : "TX0;";
406
 
        sendCommand(cmd);
407
 
        showresp(WARN, ASC, "SET PTT", cmd, replystr);
408
 
}
409
 
 
410
 
void RIG_FT450::tune_rig()
411
 
{
412
 
        cmd = "AC002;";
413
 
        sendCommand(cmd);
414
 
        showresp(WARN, ASC, "tune rig", cmd, replystr);
415
 
}
416
 
 
417
 
void RIG_FT450::set_attenuator(int val)
418
 
{
419
 
        if (val) cmd = "RA01;";
420
 
        else     cmd = "RA00;";
421
 
        sendCommand(cmd);
422
 
        showresp(WARN, ASC, "get att", cmd, replystr);
423
 
}
424
 
 
425
 
int RIG_FT450::get_attenuator()
426
 
{
427
 
        cmd = rsp = "RA0";
428
 
        cmd += ';';
429
 
        waitN(5, 100, "get att", ASC);
430
 
 
431
 
        size_t p = replystr.rfind(rsp);
432
 
        if (p == string::npos) return 0;
433
 
        return (replystr[p+3] == '1' ? 1 : 0);
434
 
}
435
 
 
436
 
void RIG_FT450::set_preamp(int val)
437
 
{
438
 
        if (val) cmd = "PA00;";
439
 
        else     cmd = "PA01;";
440
 
        sendCommand(cmd);
441
 
        showresp(WARN, ASC, "set preamp", cmd, replystr);
442
 
}
443
 
 
444
 
int RIG_FT450::get_preamp()
445
 
{
446
 
        cmd = rsp = "PA0";
447
 
        cmd += ';';
448
 
        waitN(5, 100, "get pre", ASC);
449
 
 
450
 
        size_t p = replystr.rfind(rsp);
451
 
        if (p == string::npos) return 0;
452
 
        return (replystr[p+3] == '1' ? 0 : 1);
453
 
}
454
 
 
455
 
void RIG_FT450::set_modeA(int val)
456
 
{
457
 
        modeA = val;
458
 
        cmd = "MD0";
459
 
        cmd += mode_chr[val];
460
 
        cmd += ';';
461
 
        sendCommand(cmd);
462
 
        showresp(WARN, ASC, "SET mode A", cmd, replystr);
463
 
        if (val == 2 || val == 6) return;
464
 
        if (progStatus.spot_onoff) {
465
 
                progStatus.spot_onoff = false;
466
 
                set_spot_onoff();
467
 
                cmd = "CS0;";
468
 
                sendCommand(cmd);
469
 
                showresp(WARN, ASC, "SET spot off", cmd, replystr);
470
 
                btnSpot->value(0);
471
 
        }
472
 
}
473
 
 
474
 
int RIG_FT450::get_modeA()
475
 
{
476
 
        cmd = rsp = "MD0";
477
 
        cmd += ';';
478
 
        waitN(5, 100, "get mode A", ASC);
479
 
 
480
 
        size_t p = replystr.rfind(rsp);
481
 
        if (p == string::npos) return modeA;
482
 
        int md = replystr[p+3];
483
 
        if (md <= '9') md = md - '1';
484
 
        else md = 9 + md - 'B';
485
 
        modeA = md;
486
 
        return modeA;
487
 
}
488
 
 
489
 
void RIG_FT450::set_bwA(int val)
490
 
{
491
 
        bwA = val;
492
 
        switch (val) {
493
 
                case 0 : cmd = "SH000;"; break;
494
 
                case 1 : cmd = "SH016;"; break;
495
 
                case 2 : cmd = "SH031;"; break;
496
 
                default: cmd = "SH031;";
497
 
        }
498
 
        sendCommand(cmd);
499
 
        showresp(WARN, ASC, "SET bwA", cmd, replystr);
500
 
}
501
 
 
502
 
int RIG_FT450::get_bwA()
503
 
{
504
 
        cmd = rsp = "SH0";
505
 
        cmd += ';';
506
 
        waitN(6, 100, "get bw A", ASC);
507
 
 
508
 
        size_t p = replystr.rfind(rsp);
509
 
        if (p == string::npos) return bwA;
510
 
        string bws = replystr.substr(p+3,2);
511
 
        if (bws == "00") bwA = 0;
512
 
        else if (bws == "16") bwA = 1;
513
 
        else if (bws == "31") bwA = 2;
514
 
        return bwA;
515
 
}
516
 
 
517
 
void RIG_FT450::set_modeB(int val)
518
 
{
519
 
        modeB = val;
520
 
        cmd = "MD0";
521
 
        cmd += mode_chr[val];
522
 
        cmd += ';';
523
 
        sendCommand(cmd);
524
 
        showresp(WARN, ASC, "SET mode B", cmd, replystr);
525
 
        if (val == 2 || val == 6) return;
526
 
        if (progStatus.spot_onoff) {
527
 
                progStatus.spot_onoff = false;
528
 
                set_spot_onoff();
529
 
                cmd = "CS0;";
530
 
                sendCommand(cmd);
531
 
                showresp(WARN, ASC, "SET spot off", cmd, replystr);
532
 
                btnSpot->value(0);
533
 
        }
534
 
}
535
 
 
536
 
int RIG_FT450::get_modeB()
537
 
{
538
 
        cmd = rsp = "MD0";
539
 
        cmd += ';';
540
 
        waitN(5, 100, "get mode B", ASC);
541
 
 
542
 
        size_t p = replystr.rfind(rsp);
543
 
        if (p == string::npos) return modeB;
544
 
        int md = replystr[p+3];
545
 
        if (md <= '9') md = md - '1';
546
 
        else md = 9 + md - 'B';
547
 
        modeB = md;
548
 
        return modeB;
549
 
}
550
 
 
551
 
void RIG_FT450::set_bwB(int val)
552
 
{
553
 
        bwB = val;
554
 
        switch (val) {
555
 
                case 0 : cmd = "SH000;"; break;
556
 
                case 1 : cmd = "SH016;"; break;
557
 
                case 2 : cmd = "SH031;"; break;
558
 
                default: cmd = "SH031;";
559
 
        }
560
 
        sendCommand(cmd);
561
 
        showresp(WARN, ASC, "SET bwB", cmd, replystr);
562
 
}
563
 
 
564
 
int RIG_FT450::get_bwB()
565
 
{
566
 
        cmd = rsp = "SH0";
567
 
        cmd += ';';
568
 
        waitN(6, 100, "get bw B", ASC);
569
 
 
570
 
        size_t p = replystr.rfind(rsp);
571
 
        if (p == string::npos) return bwB;
572
 
        string bws = replystr.substr(p+3,2);
573
 
        if (bws == "00") bwB = 0;
574
 
        else if (bws == "16") bwB = 1;
575
 
        else if (bws == "31") bwB = 2;
576
 
        return bwB;
577
 
}
578
 
 
579
 
int RIG_FT450::get_modetype(int n)
580
 
{
581
 
        return mode_type[n];
582
 
}
583
 
 
584
 
void RIG_FT450::set_if_shift(int val)
585
 
{
586
 
        cmd = "IS0+0000;";
587
 
        if (val < 0) cmd[3] = '-';
588
 
        val = abs(val);
589
 
        for (int i = 4; i > 0; i--) {
590
 
                cmd[3+i] += val % 10;
591
 
                val /= 10;
592
 
        }
593
 
        sendCommand(cmd);
594
 
        showresp(WARN, ASC, "SET ifshift", cmd, replystr);
595
 
}
596
 
 
597
 
bool RIG_FT450::get_if_shift(int &val)
598
 
{
599
 
        cmd = rsp = "IS0";
600
 
        cmd += ';';
601
 
        waitN(9, 100, "get if shift", ASC);
602
 
 
603
 
        size_t p = replystr.rfind(rsp);
604
 
        val = progStatus.shift_val;
605
 
        if (p == string::npos) return progStatus.shift;
606
 
        val = atoi(&replystr[p+4]);
607
 
        if (replystr[p+3] == '-') val = -val;
608
 
        return (val != 0);
609
 
}
610
 
 
611
 
void RIG_FT450::get_if_min_max_step(int &min, int &max, int &step)
612
 
{
613
 
        min = -1000;
614
 
        max = 1000;
615
 
        step = 100;
616
 
}
617
 
 
618
 
void RIG_FT450::set_notch(bool on, int val)
619
 
{
620
 
        cmd = "BP00000;";
621
 
        if (on == false) {
622
 
                sendCommand(cmd);
623
 
                showresp(WARN, ASC, "SET notch off", cmd, replystr);
624
 
                notch_on = false;
625
 
                return;
626
 
        }
627
 
        cmd[6] = '1';
628
 
        sendCommand(cmd);
629
 
        showresp(WARN, ASC, "SET notch on", cmd, replystr);
630
 
        notch_on = true;
631
 
 
632
 
        cmd[3] = '1'; // manual NOTCH position
633
 
        cmd[6] = '0';
634
 
        val = val / 10 + 200;
635
 
        for (int i = 3; i > 0; i--) {
636
 
                cmd[3 + i] += val % 10;
637
 
                val /=10;
638
 
        }
639
 
        sendCommand(cmd);
640
 
        showresp(WARN, ASC, "SET notch val", cmd, replystr);
641
 
}
642
 
 
643
 
bool  RIG_FT450::get_notch(int &val)
644
 
{
645
 
        bool ison = false;
646
 
        cmd = rsp = "BP00";
647
 
        cmd += ';';
648
 
        waitN(8, 100, "get notch on/off", ASC);
649
 
 
650
 
        size_t p = replystr.rfind(rsp);
651
 
        val = progStatus.notch_val = 0; // disabled default slider position
652
 
        if (p == string::npos) return ison;
653
 
 
654
 
        if (replystr[p+6] == '1') { // manual notch enabled
655
 
                ison = true;
656
 
                val = progStatus.notch_val;
657
 
                cmd = rsp = "BP01";
658
 
                cmd += ';';
659
 
                waitN(8, 100, "get notch val", ASC);
660
 
                p = replystr.rfind(rsp);
661
 
                if (p == string::npos) return ison;
662
 
                val = atoi(&replystr[p+4]);
663
 
                val = (val - 200) * 10;
664
 
        }
665
 
        return ison;
666
 
}
667
 
 
668
 
void RIG_FT450::get_notch_min_max_step(int &min, int &max, int &step)
669
 
{
670
 
        min = -1990;
671
 
        max = +2000;
672
 
        step = 100;
673
 
}
674
 
 
675
 
void RIG_FT450::set_noise(bool b)
676
 
{
677
 
        if (b)
678
 
                cmd = "NB01;";
679
 
        else
680
 
                cmd = "NB00;";
681
 
        sendCommand (cmd);
682
 
        showresp(WARN, ASC, "SET NB", cmd, replystr);
683
 
}
684
 
 
685
 
void RIG_FT450::set_xcvr_auto_on()
686
 
{
687
 
        if (!progStatus.xcvr_auto_on) return;
688
 
 
689
 
        cmd = rsp = "PS";
690
 
        cmd.append(";");
691
 
        waitN(4, 100, "Test: Is Rig ON", ASC);
692
 
        size_t p = replystr.rfind(rsp);
693
 
        if (p == string::npos) {        // rig is off, power on
694
 
                cmd = "PS1;";
695
 
                sendCommand(cmd);
696
 
                MilliSleep(1500);       // 1.0 < T < 2.0 seconds
697
 
                sendCommand(cmd);
698
 
                MilliSleep(3000);       // Wait for rig startup?  Maybe not needed.
699
 
        }
700
 
}
701
 
 
702
 
void RIG_FT450::set_xcvr_auto_off()
703
 
{
704
 
        if (!progStatus.xcvr_auto_off) return;
705
 
 
706
 
        cmd = "PS0;";
707
 
        sendCommand(cmd);
708
 
}
709
 
 
710
 
// val 0 .. 100
711
 
void RIG_FT450::set_mic_gain(int val)
712
 
{
713
 
        cmd = "MG000;";
714
 
        val = (int)(val * 2.55); // convert to 0 .. 255
715
 
        for (int i = 3; i > 0; i--) {
716
 
                cmd[1+i] += val % 10;
717
 
                val /= 10;
718
 
        }
719
 
        sendCommand(cmd);
720
 
        showresp(WARN, ASC, "SET mic", cmd, replystr);
721
 
}
722
 
 
723
 
int RIG_FT450::get_mic_gain()
724
 
{
725
 
        cmd = rsp = "MG";
726
 
        cmd += ';';
727
 
        waitN(6, 100, "get mic", ASC);
728
 
 
729
 
        size_t p = replystr.rfind(rsp);
730
 
        if (p == string::npos) return 0;
731
 
        replystr[p+5] = 0;
732
 
        return atoi(&replystr[p+2]);;
733
 
}
734
 
 
735
 
void RIG_FT450::get_mic_min_max_step(int &min, int &max, int &step)
736
 
{
737
 
        min = 0;
738
 
        max = 100;
739
 
        step = 1;
740
 
}
741
 
 
742
 
void RIG_FT450::set_special(int v)
743
 
{
744
 
        if (v) cmd = "VR1;";
745
 
        else   cmd = "VR0;";
746
 
        sendCommand(cmd);
747
 
        showresp(WARN, ASC, "Set special", cmd, replystr);
748
 
}
749
 
 
750
 
void RIG_FT450::set_vox_onoff()
751
 
{
752
 
        cmd = "VX0;";
753
 
        if (progStatus.vox_onoff) cmd[2] = '1';
754
 
        sendCommand(cmd);
755
 
        showresp(WARN, ASC, "SET vox on/off", cmd, replystr);
756
 
}
757
 
 
758
 
void RIG_FT450::set_vox_gain()
759
 
{
760
 
        cmd = "VG";
761
 
        cmd.append(to_decimal(progStatus.vox_gain, 3)).append(";");
762
 
        sendCommand(cmd);
763
 
        showresp(WARN, ASC, "SET vox gain", cmd, replystr);
764
 
}
765
 
 
766
 
void RIG_FT450::set_vox_hang()
767
 
{
768
 
        cmd = "VD";
769
 
        cmd.append(to_decimal(progStatus.vox_hang, 4)).append(";");
770
 
        sendCommand(cmd);
771
 
        showresp(WARN, ASC, "SET vox delay", cmd, replystr);
772
 
}
773
 
 
774
 
void RIG_FT450::set_cw_wpm()
775
 
{
776
 
        cmd = "KS";
777
 
        if (progStatus.cw_wpm > 60) progStatus.cw_wpm = 60;
778
 
        if (progStatus.cw_wpm < 4) progStatus.cw_wpm = 4;
779
 
        cmd.append(to_decimal(progStatus.cw_wpm, 3)).append(";");
780
 
        sendCommand(cmd);
781
 
        showresp(WARN, ASC, "SET cw wpm", cmd, replystr);
782
 
}
783
 
 
784
 
 
785
 
void RIG_FT450::enable_keyer()
786
 
{
787
 
        cmd = "KR0;";
788
 
        if (progStatus.enable_keyer) cmd[2] = '1';
789
 
        sendCommand(cmd);
790
 
        showresp(WARN, ASC, "SET keyer on/off", cmd, replystr);
791
 
}
792
 
 
793
 
bool RIG_FT450::set_cw_spot()
794
 
{
795
 
        if (vfo.imode == 2 || vfo.imode == 6) {
796
 
                cmd = "CS0;";
797
 
                if (progStatus.spot_onoff) cmd[2] = '1';
798
 
                sendCommand(cmd);
799
 
                showresp(WARN, ASC, "SET spot on/off", cmd, replystr);
800
 
                return true;
801
 
        } else
802
 
                return false;
803
 
}
804
 
 
805
 
void RIG_FT450::set_cw_weight()
806
 
{
807
 
        int n = round(progStatus.cw_weight * 10);
808
 
        cmd.assign("EX024").append(to_decimal(n, 2)).append(";");
809
 
        sendCommand(cmd);
810
 
        showresp(WARN, ASC, "SET cw weight", cmd, replystr);
811
 
}
812
 
 
813
 
void RIG_FT450::set_cw_qsk()
814
 
{
815
 
        int n = progStatus.cw_qsk / 5 - 3;
816
 
        cmd.assign("EX018").append(to_decimal(n, 1)).append(";");
817
 
        sendCommand(cmd);
818
 
        showresp(WARN, ASC, "SET cw qsk", cmd, replystr);
819
 
}
820
 
 
821
 
void RIG_FT450::set_cw_spot_tone()
822
 
{
823
 
        int n = (progStatus.cw_spot_tone - 400) / 50 + 1;
824
 
        cmd = "EX020";
825
 
        cmd.append(to_decimal(n, 2)).append(";");
826
 
        sendCommand(cmd);
827
 
        showresp(WARN, ASC, "SET cw tone", cmd, replystr);
828
 
}
829
 
 
830
 
// DNR
831
 
void RIG_FT450::set_noise_reduction_val(int val)
832
 
{
833
 
        cmd.assign("RL0").append(to_decimal(val, 2)).append(";");
834
 
        sendCommand(cmd);
835
 
        showresp(WARN, ASC, "SET_noise_reduction_val", cmd, replystr);
836
 
}
837
 
 
838
 
int  RIG_FT450::get_noise_reduction_val()
839
 
{
840
 
        int val = 1;
841
 
        cmd = rsp = "RL0";
842
 
        cmd.append(";");
843
 
        waitN(6, 100, "GET noise reduction val", ASC);
844
 
        size_t p = replystr.rfind(rsp);
845
 
        if (p == string::npos) return val;
846
 
        val = atoi(&replystr[p+3]);
847
 
        return val;
848
 
}
849
 
 
850
 
// DNR
851
 
void RIG_FT450::set_noise_reduction(int val)
852
 
{
853
 
        cmd.assign("NR0").append(val ? "1" : "0" ).append(";");
854
 
        sendCommand(cmd);
855
 
        showresp(WARN, ASC, "SET noise reduction", cmd, replystr);
856
 
}
857
 
 
858
 
int  RIG_FT450::get_noise_reduction()
859
 
{
860
 
        int val;
861
 
        cmd = rsp = "NR0";
862
 
        cmd.append(";");
863
 
        waitN(5, 100, "GET noise reduction", ASC);
864
 
        size_t p = replystr.rfind(rsp);
865
 
        if (p == string::npos) return 0;
866
 
        val = replystr[p+3] - '0';
867
 
        return val;
868
 
}