← 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/FTdx1200.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/FTdx1200.cxx
1
 
/*
2
 
 * Yaesu FT-950 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 "FTdx1200.h"
13
 
#include "debug.h"
14
 
#include "support.h"
15
 
 
16
 
#define WVALS_LIMIT -1
17
 
 
18
 
enum mFTdx1200 {
19
 
  mLSB, mUSB, mCW, mFM, mAM, mRTTY_L, mCW_R, mDATA_L, mRTTY_U, mFM_N, mDATA_U };
20
 
//  0,    1,    2,   3,   4,   5,       6,     7,      8,       9,       10     // mode index
21
 
 
22
 
static const char FTdx1200name_[] = "FTdx1200";
23
 
 
24
 
static const char *FTdx1200modes_[] = {
25
 
"LSB", "USB", "CW", "FM", "AM", "RTTY-L", "CW-R", "DATA-L", "RTTY-U", "FM-N", "DATA-U", NULL};
26
 
 
27
 
static const char FTdx1200_mode_chr[] =  { '1', '2', '3', '4', '5', '6', '7', '8', '9', 'B', 'C' };
28
 
static const char FTdx1200_mode_type[] = { 'L', 'U', 'L', 'U', 'U', 'L', 'U', 'L', 'U', 'U', 'U' };
29
 
//                                           lsb   usb  cw   fm   am  ttyL cwR  datL ttyU fmN  datU
30
 
 
31
 
static const int FTdx1200_def_bw[] = {
32
 
    18,   18,   10,   0,   0,   6,       10,     15,     6,        0,     15    };
33
 
// mLSB, mUSB, mCW, mFM, mAM, mRTTY_L, mCW_R, mDATA_L, mRTTY_U, mFM_N, mDATA_U
34
 
 
35
 
static const char *FTdx1200_widths_SSB[] = {
36
 
 "200",  "400",  "600",  "850", "1100",
37
 
"1350", "1500", "1650", "1800", "1950",
38
 
"2100", "2250", "2400", "2500", "2600",
39
 
"2700", "2800", "2900", "3000", "3200",
40
 
"3400", "3800", "4000", NULL }; // def_bw = 18
41
 
 
42
 
static int FTdx1200_wvals_SSB[] = {
43
 
1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,18,19,20,21,22,23, WVALS_LIMIT};
44
 
 
45
 
static const char *FTdx1200_widths_SSBD[] = {
46
 
  "50",  "150",  "100",  "150",  "200",
47
 
 "250",  "300",  "350",  "400",  "450",
48
 
 "500",  "800", "1200", "1400", "1700",
49
 
"2000", "2400", NULL }; // def_bw = 16 for DATA, 6 for RTTY
50
 
 
51
 
static int FTdx1200_wvals_SSBD[] = {
52
 
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, WVALS_LIMIT};
53
 
 
54
 
static const char *FTdx1200_widths_CW[] = {
55
 
  "50",  "150",  "100",  "150",  "200",
56
 
 "250",  "300",  "350",  "400",  "450",
57
 
 "500",  "800", "1200", "1400", "1700",
58
 
"2000", "2400", NULL }; // def_bw = 10
59
 
 
60
 
static int FTdx1200_wvals_CW[] = {
61
 
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, WVALS_LIMIT};
62
 
 
63
 
// Single bandwidth modes
64
 
static const char *FTdx1200_widths_FMnar[] = { "NARR", NULL };
65
 
static const char *FTdx1200_widths_AMFM[]  = { "NORM", NULL };
66
 
 
67
 
static const int FTdx1200_wvals_AMFM[] = { 0, WVALS_LIMIT };
68
 
 
69
 
// US 60M 5-USB, 5-CW
70
 
static const char *US_60m_chan[]  = {"000","125","126","127","128","130","141","142","143","144","146",NULL};
71
 
static const char *US_60m_label[] = {"VFO","U51","U52","U53","U54","U55","U56","U57","U58","U59","U50",NULL};
72
 
 
73
 
// UK 60m channel numbers by Brian, G8SEZ
74
 
static const char *UK_60m_chan[]  = {"000","118","120","121","127","128","129","130",NULL};
75
 
static const char *UK_60m_label[] = {"VFO","U51","U52","U53","U54","U55","U56","U57",NULL};
76
 
 
77
 
static const char **Channels_60m = US_60m_chan;
78
 
static const char **label_60m    = US_60m_label;
79
 
 
80
 
static GUI rig_widgets[]= {
81
 
        { (Fl_Widget *)btnVol,        2, 125,  50 },
82
 
        { (Fl_Widget *)sldrVOLUME,   54, 125, 156 },
83
 
        { (Fl_Widget *)sldrRFGAIN,   54, 145, 156 },
84
 
        { (Fl_Widget *)btnIFsh,     214, 105,  50 },
85
 
        { (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 },
86
 
        { (Fl_Widget *)btnNotch,    214, 125,  50 },
87
 
        { (Fl_Widget *)sldrNOTCH,   266, 125, 156 },
88
 
        { (Fl_Widget *)sldrMICGAIN, 266, 145, 156 },
89
 
        { (Fl_Widget *)sldrPOWER,   266, 165, 156 },
90
 
        { (Fl_Widget *)btnNR,         2, 165,  50 },
91
 
        { (Fl_Widget *)sldrNR,       54, 165, 156 },
92
 
        { (Fl_Widget *)NULL,          0,   0,   0 }
93
 
};
94
 
 
95
 
RIG_FTdx1200::RIG_FTdx1200() {
96
 
// base class values
97
 
        name_ = FTdx1200name_;
98
 
        modes_ = FTdx1200modes_;
99
 
        bandwidths_ = FTdx1200_widths_SSB;
100
 
        bw_vals_ = FTdx1200_wvals_SSB;
101
 
 
102
 
        widgets = rig_widgets;
103
 
 
104
 
        comm_baudrate = BR38400;
105
 
        stopbits = 1;
106
 
        comm_retries = 2;
107
 
        comm_wait = 5;
108
 
        comm_timeout = 50;
109
 
        comm_rtscts = true;
110
 
        comm_rtsplus = false;
111
 
        comm_dtrplus = false;
112
 
        comm_catptt = true;
113
 
        comm_rtsptt = false;
114
 
        comm_dtrptt = false;
115
 
 
116
 
        A.imode = B.imode = modeB = modeA = def_mode = 1;
117
 
        A.iBW = B.iBW = bwA = bwB = def_bw = 12;
118
 
        A.freq = B.freq = freqA = freqB = def_freq = 14070000;
119
 
 
120
 
        has_compON =
121
 
        has_compression =
122
 
        has_a2b =
123
 
        has_xcvr_auto_on_off =
124
 
        has_split =
125
 
        has_split_AB =
126
 
        has_band_selection =
127
 
        has_noise_reduction =
128
 
        has_noise_reduction_control =
129
 
        has_extras =
130
 
        has_vox_onoff =
131
 
        has_vox_gain =
132
 
        has_vox_anti =
133
 
        has_vox_hang =
134
 
        has_vox_on_dataport =
135
 
 
136
 
        has_vfo_adj =
137
 
 
138
 
        has_cw_wpm =
139
 
        has_cw_keyer =
140
 
//      has_cw_vol =
141
 
        has_cw_spot =
142
 
        has_cw_spot_tone =
143
 
        has_cw_qsk =
144
 
        has_cw_weight =
145
 
 
146
 
        can_change_alt_vfo =
147
 
        has_smeter =
148
 
        has_alc_control =
149
 
        has_swr_control =
150
 
        has_power_out =
151
 
        has_power_control =
152
 
        has_volume_control =
153
 
        has_rf_control =
154
 
        has_micgain_control =
155
 
        has_mode_control =
156
 
        has_noise_control =
157
 
        has_bandwidth_control =
158
 
        has_notch_control =
159
 
        has_auto_notch =
160
 
        has_attenuator_control =
161
 
        has_preamp_control =
162
 
        has_ifshift_control =
163
 
        has_ptt_control =
164
 
        has_tune_control = true;
165
 
 
166
 
// derived specific
167
 
        atten_level = 3;
168
 
        preamp_level = 2;
169
 
        notch_on = false;
170
 
        m_60m_indx = 0;
171
 
 
172
 
        precision = 1;
173
 
        ndigits = 8;
174
 
 
175
 
}
176
 
 
177
 
void RIG_FTdx1200::initialize()
178
 
{
179
 
        rig_widgets[0].W = btnVol;
180
 
        rig_widgets[1].W = sldrVOLUME;
181
 
        rig_widgets[2].W = sldrRFGAIN;
182
 
        rig_widgets[3].W = btnIFsh;
183
 
        rig_widgets[4].W = sldrIFSHIFT;
184
 
        rig_widgets[5].W = btnNotch;
185
 
        rig_widgets[6].W = sldrNOTCH;
186
 
        rig_widgets[7].W = sldrMICGAIN;
187
 
        rig_widgets[8].W = sldrPOWER;
188
 
        rig_widgets[9].W = btnNR;
189
 
        rig_widgets[10].W = sldrNR;
190
 
 
191
 
// set progStatus defaults
192
 
        if (progStatus.notch_val < 10) progStatus.notch_val = 1500;
193
 
        if (progStatus.noise_reduction_val < 1) progStatus.noise_reduction_val = 1;
194
 
        if (progStatus.power_level < 5) progStatus.power_level = 5;
195
 
// first-time-thru, or reset
196
 
        if (progStatus.cw_qsk < 15) {
197
 
                progStatus.cw_qsk = 15;
198
 
                progStatus.cw_spot_tone = 700;
199
 
                progStatus.cw_weight = 3.0;
200
 
                progStatus.cw_wpm = 18;
201
 
                progStatus.vox_on_dataport = false;
202
 
                progStatus.vox_gain = 50;
203
 
                progStatus.vox_anti = 50;
204
 
                progStatus.vox_hang = 500;
205
 
        }
206
 
// Disable Auto Information mode
207
 
        sendCommand("AI0;");
208
 
 
209
 
// "MRnnn;" if valid, returns last channel used, "mrlll...;", along with channel nnn info.
210
 
        cmd = "MR118;";
211
 
        waitN(27, 100, "Read UK 60m Channel Mem", ASC);
212
 
        size_t p = replystr.rfind("MR");
213
 
        if (p == string::npos) {
214
 
                Channels_60m = US_60m_chan;
215
 
                label_60m    = US_60m_label;
216
 
                opSelect60->clear();
217
 
                char **p = (char **)US_60m_label;
218
 
                while (*p) opSelect60->add(*p++);
219
 
        }
220
 
        else {
221
 
                Channels_60m = UK_60m_chan;
222
 
                label_60m    = UK_60m_label;
223
 
                opSelect60->clear();
224
 
                char **p = (char **)UK_60m_label;
225
 
                while (*p) opSelect60->add(*p++);
226
 
        }
227
 
        opSelect60->index(m_60m_indx);
228
 
 
229
 
//      cmd = "EX035;";
230
 
//      waitN(11,100,"Read Vfo Adjust", ASC);
231
 
//      size_t p = replystr.rfind("EX035");
232
 
 
233
 
}
234
 
 
235
 
void RIG_FTdx1200::post_initialize()
236
 
{
237
 
        enable_bandselect_btn(12, false);
238
 
        enable_bandselect_btn(13, true);
239
 
}
240
 
 
241
 
void RIG_FTdx1200::shutdown()
242
 
{
243
 
}
244
 
 
245
 
long RIG_FTdx1200::get_vfoA ()
246
 
{
247
 
        cmd = rsp = "FA";
248
 
        cmd += ';';
249
 
        waitN(11, 100, "get vfo A", ASC);
250
 
 
251
 
        size_t p = replystr.rfind(rsp);
252
 
        if (p == string::npos) return freqA;
253
 
        int f = 0;
254
 
        for (size_t n = 2; n < 10; n++)
255
 
                f = f*10 + replystr[p+n] - '0';
256
 
        freqA = f;
257
 
        return freqA;
258
 
}
259
 
 
260
 
void RIG_FTdx1200::set_vfoA (long freq)
261
 
{
262
 
        freqA = freq;
263
 
        cmd = "FA00000000;";
264
 
        for (int i = 9; i > 1; i--) {
265
 
                cmd[i] += freq % 10;
266
 
                freq /= 10;
267
 
        }
268
 
        sendCommand(cmd);
269
 
        showresp(WARN, ASC, "SET vfo A", cmd, replystr);
270
 
}
271
 
 
272
 
long RIG_FTdx1200::get_vfoB ()
273
 
{
274
 
        cmd = rsp = "FB";
275
 
        cmd += ';';
276
 
        waitN(11, 100, "get vfo B", ASC);
277
 
 
278
 
        size_t p = replystr.rfind(rsp);
279
 
        if (p == string::npos) return freqB;
280
 
        int f = 0;
281
 
        for (size_t n = 2; n < 10; n++)
282
 
                f = f*10 + replystr[p+n] - '0';
283
 
        freqB = f;
284
 
        return freqB;
285
 
}
286
 
 
287
 
 
288
 
void RIG_FTdx1200::set_vfoB (long freq)
289
 
{
290
 
        freqB = freq;
291
 
        cmd = "FB00000000;";
292
 
        for (int i = 9; i > 1; i--) {
293
 
                cmd[i] += freq % 10;
294
 
                freq /= 10;
295
 
        }
296
 
        sendCommand(cmd);
297
 
        showresp(WARN, ASC, "SET vfo B", cmd, replystr);
298
 
}
299
 
 
300
 
void RIG_FTdx1200::setVfoAdj(double v)
301
 
{
302
 
        char cmdstr[20];
303
 
        snprintf(cmdstr, sizeof(cmdstr), "EX035%+03d;", (int)v);
304
 
        cmd = cmdstr;
305
 
        sendCommand(cmd);
306
 
}
307
 
 
308
 
double RIG_FTdx1200::getVfoAdj()
309
 
{
310
 
        cmd = rsp = "EX035";
311
 
        sendCommand(cmd.append(";"));
312
 
        waitN(9, 100, "get Vfo Adjust", ASC);
313
 
 
314
 
        size_t p = replystr.rfind(rsp);
315
 
        if (p == string::npos) return 0;
316
 
        return (double)(atoi(&replystr[p+5]));
317
 
}
318
 
 
319
 
void RIG_FTdx1200::get_vfoadj_min_max_step(int &min, int &max, int &step)
320
 
{
321
 
        min = -25;
322
 
        max = 25;
323
 
        step = 1;
324
 
}
325
 
 
326
 
bool RIG_FTdx1200::twovfos()
327
 
{
328
 
        return true;
329
 
}
330
 
 
331
 
void RIG_FTdx1200::selectA()
332
 
{
333
 
        cmd = "FR0;FT2;";
334
 
        sendCommand(cmd);
335
 
        showresp(WARN, ASC, "select A", cmd, replystr);
336
 
}
337
 
 
338
 
void RIG_FTdx1200::selectB()
339
 
{
340
 
        cmd = "FR4;FT3;";
341
 
        sendCommand(cmd);
342
 
        showresp(WARN, ASC, "select B", cmd, replystr);
343
 
}
344
 
 
345
 
void RIG_FTdx1200::A2B()
346
 
{
347
 
        cmd = "AB;";
348
 
        sendCommand(cmd);
349
 
        showresp(WARN, ASC, "vfo A --> B", cmd, replystr);
350
 
}
351
 
 
352
 
bool RIG_FTdx1200::can_split()
353
 
{
354
 
        return true;
355
 
}
356
 
 
357
 
void RIG_FTdx1200::set_split(bool val)
358
 
{
359
 
        split = val;
360
 
        if (useB) {
361
 
                if (val) {
362
 
                        cmd = "FR4;FT2;";
363
 
                        sendCommand(cmd);
364
 
                        showresp(WARN, ASC, "Rx on B, Tx on A", cmd, replystr);
365
 
                } else {
366
 
                        cmd = "FR4;FT3;";
367
 
                        sendCommand(cmd);
368
 
                        showresp(WARN, ASC, "Rx on B, Tx on B", cmd, replystr);
369
 
                }
370
 
        } else {
371
 
                if (val) {
372
 
                        cmd = "FR0;FT3;";
373
 
                        sendCommand(cmd);
374
 
                        showresp(WARN, ASC, "Rx on A, Tx on B", cmd, replystr);
375
 
                } else {
376
 
                        cmd = "FR0;FT2;";
377
 
                        sendCommand(cmd);
378
 
                        showresp(WARN, ASC, "Rx on A, Tx on A", cmd, replystr);
379
 
                }
380
 
        }
381
 
        Fl::awake(highlight_vfo, (void *)0);
382
 
}
383
 
 
384
 
int RIG_FTdx1200::get_split()
385
 
{
386
 
        size_t p;
387
 
        int split = 0;
388
 
        char rx, tx;
389
 
// tx vfo
390
 
        cmd = rsp = "FT";
391
 
        cmd.append(";");
392
 
        waitN(4, 100, "get split tx vfo", ASC);
393
 
        p = replystr.rfind(rsp);
394
 
        if (p == string::npos) return false;
395
 
        tx = replystr[p+2] - '0';
396
 
 
397
 
// rx vfo
398
 
        cmd = rsp = "FR";
399
 
        cmd.append(";");
400
 
        waitN(4, 100, "get split rx vfo", ASC);
401
 
 
402
 
        p = replystr.rfind(rsp);
403
 
        if (p == string::npos) return false;
404
 
        rx = replystr[p+2] - '0';
405
 
 
406
 
        split = (tx == 1 ? 2 : 0) + (rx >= 4 ? 1 : 0);
407
 
 
408
 
        return split;
409
 
}
410
 
 
411
 
 
412
 
int RIG_FTdx1200::get_smeter()
413
 
{
414
 
        cmd = rsp = "SM0";
415
 
        cmd += ';';
416
 
        waitN(7, 100, "get smeter", ASC);
417
 
 
418
 
        size_t p = replystr.rfind(rsp);
419
 
        if (p == string::npos) return 0;
420
 
        if (p + 6 >= replystr.length()) return 0;
421
 
        int mtr = atoi(&replystr[p+3]);
422
 
        mtr = mtr * 100.0 / 256.0;
423
 
        return mtr;
424
 
}
425
 
 
426
 
int RIG_FTdx1200::get_swr()
427
 
{
428
 
        cmd = rsp = "RM6";
429
 
        cmd += ';';
430
 
        waitN(7, 100, "get swr", ASC);
431
 
 
432
 
        size_t p = replystr.rfind(rsp);
433
 
        if (p == string::npos) return 0;
434
 
        if (p + 6 >= replystr.length()) return 0;
435
 
        int mtr = atoi(&replystr[p+3]);
436
 
        return (int)ceil(mtr / 2.56);
437
 
}
438
 
 
439
 
int RIG_FTdx1200::get_alc()
440
 
{
441
 
        cmd = rsp = "RM4";
442
 
        cmd += ';';
443
 
        waitN(7, 100, "get alc", ASC);
444
 
 
445
 
        size_t p = replystr.rfind(rsp);
446
 
        if (p == string::npos) return 0;
447
 
        if (p + 6 >= replystr.length()) return 0;
448
 
        int mtr = atoi(&replystr[p+3]);
449
 
        return (int)ceil(mtr / 2.56);
450
 
}
451
 
 
452
 
int RIG_FTdx1200::get_power_out()
453
 
{
454
 
        cmd = rsp = "RM5";
455
 
        sendCommand(cmd.append(";"));
456
 
        waitN(7, 100, "get pout", ASC);
457
 
 
458
 
        size_t p = replystr.rfind(rsp);
459
 
        if (p == string::npos) return 0;
460
 
        if (p + 6 >= replystr.length()) return 0;
461
 
        double mtr = (double)(atoi(&replystr[p+3]));
462
 
 
463
 
// following conversion iaw data measured by Terry, KJ4EED
464
 
        mtr = (.06 * mtr) + (.002 * mtr * mtr);
465
 
 
466
 
        return (int)ceil(mtr);
467
 
}
468
 
 
469
 
// Transceiver power level
470
 
int RIG_FTdx1200::get_power_control()
471
 
{
472
 
        cmd = rsp = "PC";
473
 
        cmd += ';';
474
 
        waitN(6, 100, "get power", ASC);
475
 
 
476
 
        size_t p = replystr.rfind(rsp);
477
 
        if (p == string::npos) return progStatus.power_level;
478
 
        if (p + 5 >= replystr.length()) return progStatus.power_level;
479
 
 
480
 
        int mtr = atoi(&replystr[p+2]);
481
 
        return mtr;
482
 
}
483
 
 
484
 
void RIG_FTdx1200::set_power_control(double val)
485
 
{
486
 
        int ival = (int)val;
487
 
        cmd = "PC000;";
488
 
        for (int i = 4; i > 1; i--) {
489
 
                cmd[i] += ival % 10;
490
 
                ival /= 10;
491
 
        }
492
 
        sendCommand(cmd);
493
 
        showresp(WARN, ASC, "SET power", cmd, replystr);
494
 
}
495
 
 
496
 
// Volume control return 0 ... 100
497
 
int RIG_FTdx1200::get_volume_control()
498
 
{
499
 
        cmd = rsp = "AG0";
500
 
        cmd += ';';
501
 
        waitN(7, 100, "get vol", ASC);
502
 
 
503
 
        size_t p = replystr.rfind(rsp);
504
 
        if (p == string::npos) return progStatus.volume;
505
 
        if (p + 6 >= replystr.length()) return progStatus.volume;
506
 
        int val = round(atoi(&replystr[p+3]) / 2.55);
507
 
        if (val > 100) val = 100;
508
 
        return ceil(val);
509
 
}
510
 
 
511
 
void RIG_FTdx1200::set_volume_control(int val)
512
 
{
513
 
        int ivol = (int)(val * 2.55);
514
 
        cmd = "AG0000;";
515
 
        for (int i = 5; i > 2; i--) {
516
 
                cmd[i] += ivol % 10;
517
 
                ivol /= 10;
518
 
        }
519
 
        sendCommand(cmd);
520
 
        showresp(WARN, ASC, "SET vol", cmd, replystr);
521
 
}
522
 
 
523
 
// Tranceiver PTT on/off
524
 
void RIG_FTdx1200::set_PTT_control(int val)
525
 
{
526
 
        cmd = val ? "TX1;" : "TX0;";
527
 
        sendCommand(cmd);
528
 
        showresp(WARN, ASC, "SET PTT", cmd, replystr);
529
 
}
530
 
 
531
 
// internal or external tune mode
532
 
void RIG_FTdx1200::tune_rig()
533
 
{
534
 
        static bool extun_on = false;
535
 
        static int rmd = modeA;
536
 
        static int rbw = bwA;
537
 
        static int rpwr = 100;
538
 
        static long rfreq = freqA;      // fix for menu 047 OFSt default
539
 
        int use_int_tuner = true;
540
 
 
541
 
//  On-The-Fly bandstack by bandstack int/ext tuner
542
 
//  if rig "Tuner" light is on internal else external
543
 
        cmd = rsp = "AC";
544
 
        cmd.append(";");
545
 
        waitN(6, 100, "is Int. Tuner Enabled", ASC);
546
 
        size_t p = replystr.rfind(rsp);
547
 
        if (p == string::npos) return;
548
 
        if ((p + 5) >= replystr.length()) return;
549
 
        if (replystr[p+4] == '0') {
550
 
                use_int_tuner = false;
551
 
        }
552
 
 
553
 
        if (use_int_tuner) {
554
 
                cmd = "AC002;";
555
 
                sendCommand(cmd);
556
 
                showresp(WARN, ASC, "tune rig", cmd, replystr);
557
 
        } else {
558
 
                if (extun_on == false) {
559
 
                        if (btnPTT->value() == true) return;
560
 
                        if (get_split() == 1 || get_split() == 2) return;       // no split extune
561
 
                        useB ? rmd = modeB : rmd = modeA;
562
 
                        useB ? rbw = bwB : rbw = bwA;
563
 
                        useB ? rfreq = freqB : rfreq = freqA;
564
 
                        useB ? set_modeB(mAM) : set_modeA(mAM);
565
 
                        useB ? set_vfoB(rfreq) : set_vfoA(rfreq);
566
 
                        rpwr = get_power_control();
567
 
                        set_power_control(10);
568
 
                        sendCommand("EX0360000;");      // AM mic off
569
 
//                      sendCommand("EX0560000;");      // FM mic off
570
 
                        extun_on = true;
571
 
                        btnPTT->value(true);
572
 
                        sendCommand("MX1;");
573
 
                } else {
574
 
                        extun_on = false;
575
 
                        btnPTT->value(false);
576
 
                        sendCommand("MX0;");
577
 
                        sendCommand("EX0361000;");      // AM mic default
578
 
//                      sendCommand("EX0560050;");      // FM mic default
579
 
                        set_power_control(rpwr);
580
 
                        useB ? set_modeB(rmd) : set_modeA(rmd);
581
 
                        useB ? set_bwB(rbw) : set_bwA(rbw);
582
 
                        useB ? set_vfoB(rfreq) : set_vfoA(rfreq);
583
 
                }
584
 
        }
585
 
}
586
 
 
587
 
void RIG_FTdx1200::set_attenuator(int val)
588
 
{
589
 
        if (atten_level == 0) {
590
 
                atten_level = 1;
591
 
                atten_label("6 dB", true);
592
 
        } else if (atten_level == 1) {
593
 
                atten_level = 2;
594
 
                atten_label("12 dB", true);
595
 
        } else if (atten_level == 2) {
596
 
                atten_level = 3;
597
 
                atten_label("18 dB", true);
598
 
        } else if (atten_level == 3) {
599
 
                atten_level = 0;
600
 
                atten_label("Att", false);
601
 
        }
602
 
        cmd = "RA00;";
603
 
        cmd[3] += atten_level;
604
 
        sendCommand(cmd);
605
 
        showresp(WARN, ASC, "SET att", cmd, replystr);
606
 
}
607
 
 
608
 
int RIG_FTdx1200::get_attenuator()
609
 
{
610
 
        cmd = rsp = "RA0";
611
 
        cmd += ';';
612
 
        waitN(5, 100, "get att", ASC);
613
 
 
614
 
        size_t p = replystr.rfind(rsp);
615
 
        if (p == string::npos) return progStatus.attenuator;
616
 
        if (p + 3 >= replystr.length()) return progStatus.attenuator;
617
 
        atten_level = replystr[p+3] - '0';
618
 
        if (atten_level == 1) {
619
 
                atten_label("6 dB", true);
620
 
        } else if (atten_level == 2) {
621
 
                atten_label("12 dB", true);
622
 
        } else if (atten_level == 3) {
623
 
                atten_label("18 dB", true);
624
 
        } else {
625
 
                atten_level = 0;
626
 
                atten_label("Att", false);
627
 
        }
628
 
        return atten_level;
629
 
}
630
 
 
631
 
void RIG_FTdx1200::set_preamp(int val)
632
 
{
633
 
        cmd = "PA00;";
634
 
        if (preamp_level == 0) {
635
 
                preamp_level = 1;
636
 
                preamp_label("Amp 1", true);
637
 
        } else if (preamp_level == 1) {
638
 
                preamp_level = 2;
639
 
                preamp_label("Amp 2", true);
640
 
        } else if (preamp_level == 2) {
641
 
                preamp_level = 0;
642
 
                preamp_label("IPO", false);
643
 
        }
644
 
        cmd[3] = '0' + preamp_level;
645
 
        sendCommand (cmd);
646
 
        showresp(WARN, ASC, "SET preamp", cmd, replystr);
647
 
}
648
 
 
649
 
int RIG_FTdx1200::get_preamp()
650
 
{
651
 
        cmd = rsp = "PA0";
652
 
        cmd += ';';
653
 
        waitN(5, 100, "get pre", ASC);
654
 
 
655
 
        size_t p = replystr.rfind(rsp);
656
 
        if (p != string::npos)
657
 
                preamp_level = replystr[p+3] - '0';
658
 
        if (preamp_level == 1) {
659
 
                preamp_label("Amp 1", true);
660
 
        } else if (preamp_level == 2) {
661
 
                preamp_label("Amp 2", true);
662
 
        } else {
663
 
                preamp_label("IPO", false);
664
 
                preamp_level = 0;
665
 
        }
666
 
        return preamp_level;
667
 
}
668
 
 
669
 
int RIG_FTdx1200::adjust_bandwidth(int val)
670
 
{
671
 
        switch (val) {
672
 
                case mCW     :
673
 
                case mCW_R   :
674
 
                        bandwidths_ = FTdx1200_widths_CW;
675
 
                        bw_vals_ = FTdx1200_wvals_CW;
676
 
                        break;
677
 
                case mFM     :
678
 
                case mAM     :
679
 
                        bandwidths_ = FTdx1200_widths_AMFM;
680
 
                        bw_vals_    = FTdx1200_wvals_AMFM;
681
 
                        break;
682
 
                case mFM_N   :
683
 
                        bandwidths_ = FTdx1200_widths_FMnar;
684
 
                        bw_vals_    = FTdx1200_wvals_AMFM;
685
 
                        break;
686
 
                case mDATA_L :
687
 
                case mDATA_U :
688
 
                case mRTTY_L :
689
 
                case mRTTY_U :
690
 
                        bandwidths_ = FTdx1200_widths_SSBD;
691
 
                        bw_vals_ = FTdx1200_wvals_SSBD;
692
 
                        break;
693
 
                default:
694
 
                        bandwidths_ = FTdx1200_widths_SSB;
695
 
                        bw_vals_ = FTdx1200_wvals_SSB;
696
 
        }
697
 
        return FTdx1200_def_bw[val];
698
 
}
699
 
 
700
 
int RIG_FTdx1200::def_bandwidth(int val)
701
 
{
702
 
        return FTdx1200_def_bw[val];
703
 
}
704
 
 
705
 
const char ** RIG_FTdx1200::bwtable(int n)
706
 
{
707
 
        switch (n) {
708
 
                case mFM     : return FTdx1200_widths_AMFM;
709
 
                case mAM     : return FTdx1200_widths_AMFM;
710
 
                case mFM_N   : return FTdx1200_widths_FMnar;
711
 
                case mCW     : return FTdx1200_widths_CW;
712
 
                case mCW_R   : return FTdx1200_widths_CW;
713
 
                case mRTTY_L : return FTdx1200_widths_SSBD;
714
 
                case mRTTY_U : return FTdx1200_widths_SSBD;
715
 
                case mDATA_L : return FTdx1200_widths_SSBD;
716
 
                case mDATA_U : return FTdx1200_widths_SSBD;
717
 
        }
718
 
        return FTdx1200_widths_SSB;
719
 
}
720
 
 
721
 
void RIG_FTdx1200::set_modeA(int val)
722
 
{
723
 
        modeA = val;
724
 
        cmd = "MD0";
725
 
        cmd += FTdx1200_mode_chr[val];
726
 
        cmd += ';';
727
 
        sendCommand(cmd);
728
 
        showresp(WARN, ASC, "SET mode A", cmd, replystr);
729
 
        adjust_bandwidth(modeA);
730
 
        if (val != mCW && val != mCW_R) return;
731
 
        if (progStatus.spot_onoff) {
732
 
                progStatus.spot_onoff = false;
733
 
                set_spot_onoff();
734
 
                cmd = "CS0;";
735
 
                sendCommand(cmd);
736
 
                showresp(WARN, ASC, "SET spot off", cmd, replystr);
737
 
                btnSpot->value(0);
738
 
        }
739
 
}
740
 
 
741
 
int RIG_FTdx1200::get_modeA()
742
 
{
743
 
        cmd = rsp = "MD0";
744
 
        cmd += ';';
745
 
        waitN(5, 100, "get mode A", ASC);
746
 
 
747
 
        size_t p = replystr.rfind(rsp);
748
 
        if (p != string::npos) {
749
 
                if (p + 3 < replystr.length()) {
750
 
                        int md = replystr[p+3];
751
 
                        if (md <= '9') md = md - '1';
752
 
                        else md = 9 + md - 'A';
753
 
                        modeA = md;
754
 
                }
755
 
        }
756
 
        adjust_bandwidth(modeA);
757
 
        return modeA;
758
 
}
759
 
 
760
 
void RIG_FTdx1200::set_modeB(int val)
761
 
{
762
 
        modeB = val;
763
 
        cmd = "MD0";
764
 
        cmd += FTdx1200_mode_chr[val];
765
 
        cmd += ';';
766
 
        sendCommand(cmd);
767
 
        showresp(WARN, ASC, "SET mode B", cmd, replystr);
768
 
        adjust_bandwidth(modeB);
769
 
        if (val != mCW && val != mCW_R) return;
770
 
        if (progStatus.spot_onoff) {
771
 
                progStatus.spot_onoff = false;
772
 
                set_spot_onoff();
773
 
                cmd = "CS0;";
774
 
                sendCommand(cmd);
775
 
                showresp(WARN, ASC, "SET spot off", cmd, replystr);
776
 
                btnSpot->value(0);
777
 
        }
778
 
}
779
 
 
780
 
int RIG_FTdx1200::get_modeB()
781
 
{
782
 
        cmd = rsp = "MD0";
783
 
        cmd += ';';
784
 
        waitN(5, 100, "get mode B", ASC);
785
 
 
786
 
        size_t p = replystr.rfind(rsp);
787
 
        if (p != string::npos) {
788
 
                if (p + 3 < replystr.length()) {
789
 
                        int md = replystr[p+3];
790
 
                        if (md <= '9') md = md - '1';
791
 
                        else md = 9 + md - 'A';
792
 
                        modeB = md;
793
 
                }
794
 
        }
795
 
        adjust_bandwidth(modeB);
796
 
        return modeB;
797
 
}
798
 
 
799
 
void RIG_FTdx1200::set_bwA(int val)
800
 
{
801
 
        int bw_indx = bw_vals_[val];
802
 
        bwA = val;
803
 
 
804
 
        int md = modeA;
805
 
        if (md == mFM || md == mAM || md == mFM_N ) return;
806
 
        cmd = "NA00;";
807
 
        switch (md) {
808
 
                case mLSB : case mUSB :
809
 
                        if (val < 8 ) ++cmd[3];
810
 
                        break;
811
 
                case mCW : case mCW_R :
812
 
                        if (val < 9) ++cmd[3];
813
 
                        break;
814
 
                case mRTTY_L : case mRTTY_U :
815
 
                case mDATA_L : case mDATA_U :
816
 
                        if (val < 9) ++cmd[3];
817
 
                        break;
818
 
        }
819
 
 
820
 
        cmd.append("SH0");
821
 
        cmd += '0' + bw_indx / 10;
822
 
        cmd += '0' + bw_indx % 10;
823
 
        cmd += ';';
824
 
        sendCommand(cmd);
825
 
        showresp(WARN, ASC, "SET bw A", cmd, replystr);
826
 
}
827
 
 
828
 
int RIG_FTdx1200::get_bwA()
829
 
{
830
 
        size_t p;
831
 
        if (modeA == mFM || modeA == mAM || modeA == mFM_N) {
832
 
                bwA = 0;
833
 
                return bwA;
834
 
        }
835
 
        cmd = rsp = "SH0";
836
 
        cmd += ';';
837
 
        waitN(6, 100, "get bw A", ASC);
838
 
 
839
 
        p = replystr.rfind(rsp);
840
 
        if (p == string::npos) return bwA;
841
 
        if (p + 5 >= replystr.length()) return bwA;
842
 
 
843
 
        replystr[p+5] = 0;
844
 
        int bw_idx = fm_decimal(&replystr[p+3],2);
845
 
        const int *idx = bw_vals_;
846
 
        int i = 0;
847
 
        while (*idx != WVALS_LIMIT) {
848
 
                if (*idx == bw_idx) break;
849
 
                idx++;
850
 
                i++;
851
 
        }
852
 
        if (*idx == WVALS_LIMIT) i--;
853
 
        bwA = i;
854
 
        return bwA;
855
 
}
856
 
 
857
 
void RIG_FTdx1200::set_bwB(int val)
858
 
{
859
 
        int bw_indx = bw_vals_[val];
860
 
        bwB = val;
861
 
 
862
 
        int md = modeB;
863
 
        if (md == mFM || md == mAM || md == mFM_N ) return;
864
 
        cmd = "NA00;";
865
 
        switch (md) {
866
 
                case mLSB : case mUSB :
867
 
                        if (val < 8 ) ++cmd[3];
868
 
                        break;
869
 
                case mCW : case mCW_R :
870
 
                        if (val < 9) ++cmd[3];
871
 
                        break;
872
 
                case mRTTY_L : case mRTTY_U :
873
 
                case mDATA_L : case mDATA_U :
874
 
                        if (val < 9) ++cmd[3];
875
 
                        break;
876
 
        }
877
 
 
878
 
        cmd.append("SH0");
879
 
        cmd += '0' + bw_indx / 10;
880
 
        cmd += '0' + bw_indx % 10;
881
 
        cmd += ';';
882
 
        sendCommand(cmd);
883
 
        showresp(WARN, ASC, "SET bw B", cmd, replystr);
884
 
}
885
 
 
886
 
int RIG_FTdx1200::get_bwB()
887
 
{
888
 
        size_t p;
889
 
        if (modeB == mFM || modeB == mAM || modeB == mFM_N) {
890
 
                bwB = 0;
891
 
                return bwB;
892
 
        }
893
 
        cmd = rsp = "SH0";
894
 
        cmd += ';';
895
 
        waitN(6, 100, "get bw B", ASC);
896
 
 
897
 
        p = replystr.rfind(rsp);
898
 
        if (p == string::npos) return bwB;
899
 
        if (p + 5 >= replystr.length()) return bwB;
900
 
 
901
 
        replystr[p+5] = 0;
902
 
        int bw_idx = fm_decimal(&replystr[p+3],2);
903
 
        const int *idx = bw_vals_;
904
 
        int i = 0;
905
 
        while (*idx != WVALS_LIMIT) {
906
 
                if (*idx == bw_idx) break;
907
 
                idx++;
908
 
                i++;
909
 
        }
910
 
        if (*idx == WVALS_LIMIT) i--;
911
 
        bwB = i;
912
 
        return bwB;
913
 
}
914
 
 
915
 
int RIG_FTdx1200::get_modetype(int n)
916
 
{
917
 
        return FTdx1200_mode_type[n];
918
 
}
919
 
 
920
 
void RIG_FTdx1200::set_if_shift(int val)
921
 
{
922
 
        cmd = "IS0+0000;";
923
 
        if (val < 0) cmd[3] = '-';
924
 
        val = abs(val);
925
 
        for (int i = 4; i > 0; i--) {
926
 
                cmd[3+i] += val % 10;
927
 
                val /= 10;
928
 
        }
929
 
        sendCommand(cmd);
930
 
        showresp(WARN, ASC, "SET if shift", cmd, replystr);
931
 
}
932
 
 
933
 
bool RIG_FTdx1200::get_if_shift(int &val)
934
 
{
935
 
        cmd = rsp = "IS0";
936
 
        cmd += ';';
937
 
        waitN(9, 100, "get if shift", ASC);
938
 
 
939
 
        size_t p = replystr.rfind(rsp);
940
 
        val = progStatus.shift_val;
941
 
        if (p == string::npos) return progStatus.shift;
942
 
        val = atoi(&replystr[p+4]);
943
 
        if (replystr[p+3] == '-') val = -val;
944
 
        return (val != 0);
945
 
}
946
 
 
947
 
void RIG_FTdx1200::get_if_min_max_step(int &min, int &max, int &step)
948
 
{
949
 
        if_shift_min = min = -1000;
950
 
        if_shift_max = max = 1000;
951
 
        if_shift_step = step = 20;
952
 
        if_shift_mid = 0;
953
 
}
954
 
 
955
 
void RIG_FTdx1200::set_notch(bool on, int val)
956
 
{
957
 
// set notch frequency
958
 
        if (on) {
959
 
                cmd = "BP00001;";
960
 
                sendCommand(cmd);
961
 
                showresp(WARN, ASC, "SET notch on", cmd, replystr);
962
 
                cmd = "BP01000;";
963
 
                if (val % 10 >= 5) val += 10;
964
 
                val /= 10;
965
 
                for (int i = 3; i > 0; i--) {
966
 
                        cmd[3 + i] += val % 10;
967
 
                        val /=10;
968
 
                }
969
 
                sendCommand(cmd);
970
 
                showresp(WARN, ASC, "SET notch val", cmd, replystr);
971
 
                return;
972
 
        }
973
 
 
974
 
// set notch off
975
 
        cmd = "BP00000;";
976
 
        sendCommand(cmd);
977
 
        showresp(WARN, ASC, "SET notch off", cmd, replystr);
978
 
}
979
 
 
980
 
bool  RIG_FTdx1200::get_notch(int &val)
981
 
{
982
 
        bool ison = false;
983
 
        cmd = rsp = "BP00";
984
 
        cmd += ';';
985
 
        waitN(8, 100, "get notch on/off", ASC);
986
 
 
987
 
        size_t p = replystr.rfind(rsp);
988
 
        if (p == string::npos) return ison;
989
 
 
990
 
        if (replystr[p+6] == '1') { // manual notch enabled
991
 
                ison = true;
992
 
                val = progStatus.notch_val;
993
 
                cmd = rsp = "BP01";
994
 
                cmd += ';';
995
 
                waitN(8, 100, "get notch val", ASC);
996
 
                p = replystr.rfind(rsp);
997
 
                if (p == string::npos)
998
 
                        val = 10;
999
 
                else
1000
 
                        val = fm_decimal(&replystr[p+4],3) * 10;
1001
 
        }
1002
 
        return ison;
1003
 
}
1004
 
 
1005
 
void RIG_FTdx1200::get_notch_min_max_step(int &min, int &max, int &step)
1006
 
{
1007
 
        min = 10;
1008
 
        max = 3000;
1009
 
        step = 10;
1010
 
}
1011
 
 
1012
 
void RIG_FTdx1200::set_auto_notch(int v)
1013
 
{
1014
 
        cmd.assign("BC0").append(v ? "1" : "0" ).append(";");
1015
 
        sendCommand(cmd);
1016
 
        showresp(WARN, ASC, "SET DNF Auto Notch Filter", cmd, replystr);
1017
 
}
1018
 
 
1019
 
int  RIG_FTdx1200::get_auto_notch()
1020
 
{
1021
 
        cmd = "BC0;";
1022
 
        waitN(5, 100, "get auto notch", ASC);
1023
 
        size_t p = replystr.rfind("BC0");
1024
 
        if (p == string::npos) return 0;
1025
 
        if (replystr[p+3] == '1') return 1;
1026
 
        return 0;
1027
 
}
1028
 
 
1029
 
int FTdx1200_blanker_level = 2;
1030
 
 
1031
 
void RIG_FTdx1200::set_noise(bool b)
1032
 
{
1033
 
        cmd = "NB00;";
1034
 
        if (FTdx1200_blanker_level == 0) {
1035
 
                FTdx1200_blanker_level = 1;
1036
 
                nb_label("NB 1", true);
1037
 
        } else if (FTdx1200_blanker_level == 1) {
1038
 
                FTdx1200_blanker_level = 2;
1039
 
                nb_label("NB 2", true);
1040
 
        } else if (FTdx1200_blanker_level == 2) {
1041
 
                FTdx1200_blanker_level = 0;
1042
 
                nb_label("NB", false);
1043
 
        }
1044
 
        cmd[3] = '0' + FTdx1200_blanker_level;
1045
 
        sendCommand (cmd);
1046
 
        showresp(WARN, ASC, "SET NB", cmd, replystr);
1047
 
}
1048
 
 
1049
 
int RIG_FTdx1200::get_noise()
1050
 
{
1051
 
        cmd = rsp = "NB0";
1052
 
        cmd += ';';
1053
 
        waitN(5, 100, "get NB", ASC);
1054
 
 
1055
 
        size_t p = replystr.rfind(rsp);
1056
 
        if (p == string::npos) return FTdx1200_blanker_level;
1057
 
 
1058
 
        FTdx1200_blanker_level = replystr[p+3] - '0';
1059
 
        if (FTdx1200_blanker_level == 1) {
1060
 
                nb_label("NB 1", true);
1061
 
        } else if (FTdx1200_blanker_level == 2) {
1062
 
                nb_label("NB 2", true);
1063
 
        } else {
1064
 
                nb_label("NB", false);
1065
 
                FTdx1200_blanker_level = 0;
1066
 
        }
1067
 
        return FTdx1200_blanker_level;
1068
 
}
1069
 
 
1070
 
// val 0 .. 100
1071
 
void RIG_FTdx1200::set_mic_gain(int val)
1072
 
{
1073
 
        cmd = "MG000;";
1074
 
        val = (int)(val * 2.50);
1075
 
        for (int i = 3; i > 0; i--) {
1076
 
                cmd[1+i] += val % 10;
1077
 
                val /= 10;
1078
 
        }
1079
 
        sendCommand(cmd);
1080
 
        showresp(WARN, ASC, "SET mic", cmd, replystr);
1081
 
}
1082
 
 
1083
 
int RIG_FTdx1200::get_mic_gain()
1084
 
{
1085
 
        cmd = rsp = "MG";
1086
 
        cmd += ';';
1087
 
        waitN(6, 100, "get mic", ASC);
1088
 
 
1089
 
        size_t p = replystr.rfind(rsp);
1090
 
        if (p == string::npos) return progStatus.mic_gain;
1091
 
        int val = atoi(&replystr[p+2]);
1092
 
        val = (int)(val / 2.50);
1093
 
        if (val > 100) val = 100;
1094
 
        return ceil(val);
1095
 
}
1096
 
 
1097
 
void RIG_FTdx1200::get_mic_min_max_step(int &min, int &max, int &step)
1098
 
{
1099
 
        min = 0;
1100
 
        max = 100;
1101
 
        step = 1;
1102
 
}
1103
 
 
1104
 
void RIG_FTdx1200::set_rf_gain(int val)
1105
 
{
1106
 
        cmd = "RG0000;";
1107
 
        int rfval = (int)(val * 2.50);
1108
 
        for (int i = 5; i > 2; i--) {
1109
 
                cmd[i] = rfval % 10 + '0';
1110
 
                rfval /= 10;
1111
 
        }
1112
 
        sendCommand(cmd);
1113
 
        showresp(WARN, ASC, "SET rfgain", cmd, replystr);
1114
 
}
1115
 
 
1116
 
int  RIG_FTdx1200::get_rf_gain()
1117
 
{
1118
 
        int rfval = 0;
1119
 
        cmd = rsp = "RG0";
1120
 
        cmd += ';';
1121
 
        waitN(7, 100, "get rfgain", ASC);
1122
 
 
1123
 
        size_t p = replystr.rfind(rsp);
1124
 
        if (p == string::npos) return progStatus.rfgain;
1125
 
        for (int i = 3; i < 6; i++) {
1126
 
                rfval *= 10;
1127
 
                rfval += replystr[p+i] - '0';
1128
 
        }
1129
 
        rfval = (int)(rfval / 2.50);
1130
 
        if (rfval > 100) rfval = 100;
1131
 
        return ceil(rfval);
1132
 
}
1133
 
 
1134
 
void RIG_FTdx1200::get_rf_min_max_step(int &min, int &max, int &step)
1135
 
{
1136
 
        min = 0;
1137
 
        max = 100;
1138
 
        step = 1;
1139
 
}
1140
 
 
1141
 
void RIG_FTdx1200::set_vox_onoff()
1142
 
{
1143
 
        cmd = "VX0;";
1144
 
        if (progStatus.vox_onoff) cmd[2] = '1';
1145
 
        sendCommand(cmd);
1146
 
        showresp(WARN, ASC, "SET vox", cmd, replystr);
1147
 
}
1148
 
 
1149
 
void RIG_FTdx1200::set_vox_gain()
1150
 
{
1151
 
        cmd = "VG";
1152
 
        cmd.append(to_decimal(progStatus.vox_gain, 3)).append(";");
1153
 
        sendCommand(cmd);
1154
 
        showresp(WARN, ASC, "SET vox gain", cmd, replystr);
1155
 
}
1156
 
 
1157
 
void RIG_FTdx1200::set_vox_anti()
1158
 
{
1159
 
        cmd = "EX117";
1160
 
        cmd.append(to_decimal(progStatus.vox_anti, 3)).append(";");
1161
 
        sendCommand(cmd);
1162
 
        showresp(WARN, ASC, "SET anti-vox", cmd, replystr);
1163
 
}
1164
 
 
1165
 
void RIG_FTdx1200::set_vox_hang()
1166
 
{
1167
 
        cmd = "VD";
1168
 
        cmd.append(to_decimal(progStatus.vox_hang, 4)).append(";");
1169
 
        sendCommand(cmd);
1170
 
        showresp(WARN, ASC, "SET vox delay", cmd, replystr);
1171
 
}
1172
 
 
1173
 
void RIG_FTdx1200::set_vox_on_dataport()
1174
 
{
1175
 
        cmd = "EX1140;";
1176
 
        if (progStatus.vox_on_dataport) cmd[5] = '1';
1177
 
        sendCommand(cmd);
1178
 
        showresp(WARN, ASC, "SET vox on data port", cmd, replystr);
1179
 
}
1180
 
 
1181
 
void RIG_FTdx1200::set_cw_wpm()
1182
 
{
1183
 
        cmd = "KS";
1184
 
        if (progStatus.cw_wpm > 60) progStatus.cw_wpm = 60;
1185
 
        if (progStatus.cw_wpm < 4) progStatus.cw_wpm = 4;
1186
 
        cmd.append(to_decimal(progStatus.cw_wpm, 3)).append(";");
1187
 
        sendCommand(cmd);
1188
 
        showresp(WARN, ASC, "SET cw wpm", cmd, replystr);
1189
 
}
1190
 
 
1191
 
 
1192
 
void RIG_FTdx1200::enable_keyer()
1193
 
{
1194
 
        cmd = "KR0;";
1195
 
        if (progStatus.enable_keyer) cmd[2] = '1';
1196
 
        sendCommand(cmd);
1197
 
        showresp(WARN, ASC, "SET keyer on/off", cmd, replystr);
1198
 
}
1199
 
 
1200
 
bool RIG_FTdx1200::set_cw_spot()
1201
 
{
1202
 
        if (vfo.imode == mCW || vfo.imode == mCW_R) {
1203
 
                cmd = "CS0;";
1204
 
                if (progStatus.spot_onoff) cmd[2] = '1';
1205
 
                sendCommand(cmd);
1206
 
                showresp(WARN, ASC, "SET spot on/off", cmd, replystr);
1207
 
                return true;
1208
 
        } else
1209
 
                return false;
1210
 
}
1211
 
 
1212
 
void RIG_FTdx1200::set_cw_weight()
1213
 
{
1214
 
        int n = round(progStatus.cw_weight * 10);
1215
 
        cmd.assign("EX046").append(to_decimal(n, 2)).append(";");
1216
 
        sendCommand(cmd);
1217
 
        showresp(WARN, ASC, "SET cw weight", cmd, replystr);
1218
 
}
1219
 
 
1220
 
void RIG_FTdx1200::set_cw_qsk()
1221
 
{
1222
 
        int n = progStatus.cw_qsk / 5 - 3;
1223
 
        cmd.assign("EX049").append(to_decimal(n, 1)).append(";");
1224
 
        sendCommand(cmd);
1225
 
        showresp(WARN, ASC, "SET cw qsk", cmd, replystr);
1226
 
}
1227
 
 
1228
 
void RIG_FTdx1200::set_cw_spot_tone()
1229
 
{
1230
 
        int n = (progStatus.cw_spot_tone - 300) / 50;
1231
 
        cmd.assign("EX045").append(to_decimal(n, 2)).append(";");
1232
 
        sendCommand(cmd);
1233
 
        showresp(WARN, ASC, "SET cw tone", cmd, replystr);
1234
 
}
1235
 
 
1236
 
/*
1237
 
void RIG_FTdx1200::set_cw_vol()
1238
 
{
1239
 
}
1240
 
*/
1241
 
 
1242
 
void RIG_FTdx1200::set_band_selection(int v)
1243
 
{
1244
 
        int chan_mem_on = false;
1245
 
        cmd = "IF;";
1246
 
        waitN(27, 100, "get vfo mode in set_band_selection", ASC);
1247
 
        size_t p = replystr.rfind("IF");
1248
 
        if (p == string::npos) return;
1249
 
        if ((p + 26) >= replystr.length()) return;
1250
 
        if (replystr[p+21] != '0') {    // vfo 60M memory mode
1251
 
                chan_mem_on = true;
1252
 
        }
1253
 
 
1254
 
        if (v == 13) {
1255
 
                m_60m_indx = opSelect60->index();
1256
 
                if (m_60m_indx)
1257
 
                        cmd.assign("MC").append(Channels_60m[m_60m_indx]).append(";");
1258
 
                else if (chan_mem_on)
1259
 
                        cmd = "VM;";
1260
 
        } else {                // v == 1..11 band selection OR return to vfo mode == 0
1261
 
                if (chan_mem_on) {
1262
 
                        cmd = "VM;";
1263
 
                        opSelect60->index(m_60m_indx = 0);
1264
 
                } else {
1265
 
                        if (v < 3)
1266
 
                                v = v - 1;
1267
 
                        cmd.assign("BS").append(to_decimal(v, 2)).append(";");
1268
 
                }
1269
 
        }
1270
 
 
1271
 
        sendCommand(cmd);
1272
 
        showresp(WARN, ASC, "Select Band Stacks", cmd, replystr);
1273
 
}
1274
 
 
1275
 
// DNR
1276
 
void RIG_FTdx1200::set_noise_reduction_val(int val)
1277
 
{
1278
 
        cmd.assign("RL0").append(to_decimal(val, 2)).append(";");
1279
 
        sendCommand(cmd);
1280
 
        showresp(WARN, ASC, "SET_noise_reduction_val", cmd, replystr);
1281
 
}
1282
 
 
1283
 
int  RIG_FTdx1200::get_noise_reduction_val()
1284
 
{
1285
 
        int val = 1;
1286
 
        cmd = rsp = "RL0";
1287
 
        cmd.append(";");
1288
 
        waitN(6, 100, "GET noise reduction val", ASC);
1289
 
        size_t p = replystr.rfind(rsp);
1290
 
        if (p == string::npos) return val;
1291
 
        val = atoi(&replystr[p+3]);
1292
 
        return val;
1293
 
}
1294
 
 
1295
 
// DNR
1296
 
void RIG_FTdx1200::set_noise_reduction(int val)
1297
 
{
1298
 
        cmd.assign("NR0").append(val ? "1" : "0" ).append(";");
1299
 
        sendCommand(cmd);
1300
 
        showresp(WARN, ASC, "SET noise reduction", cmd, replystr);
1301
 
}
1302
 
 
1303
 
int  RIG_FTdx1200::get_noise_reduction()
1304
 
{
1305
 
        int val;
1306
 
        cmd = rsp = "NR0";
1307
 
        cmd.append(";");
1308
 
        waitN(5, 100, "GET noise reduction", ASC);
1309
 
        size_t p = replystr.rfind(rsp);
1310
 
        if (p == string::npos) return 0;
1311
 
        val = replystr[p+3] - '0';
1312
 
        return val;
1313
 
}
1314
 
 
1315
 
void RIG_FTdx1200::set_xcvr_auto_on()
1316
 
{
1317
 
        if (!progStatus.xcvr_auto_on) return;
1318
 
 
1319
 
        cmd = rsp = "PS";
1320
 
        cmd.append(";");
1321
 
        waitN(4, 100, "Test: Is Rig ON", ASC);
1322
 
        size_t p = replystr.rfind(rsp);
1323
 
        if (p == string::npos) {        // rig is off, power on
1324
 
                cmd = "PS1;";
1325
 
                sendCommand(cmd);
1326
 
                MilliSleep(1500);       // 1.0 < T < 2.0 seconds
1327
 
                sendCommand(cmd);
1328
 
                MilliSleep(3000);       // Wait for rig startup?  Maybe not needed.
1329
 
        }
1330
 
}
1331
 
 
1332
 
void RIG_FTdx1200::set_xcvr_auto_off()
1333
 
{
1334
 
        if (!progStatus.xcvr_auto_off) return;
1335
 
 
1336
 
        cmd = "PS0;";
1337
 
        sendCommand(cmd);
1338
 
}
1339
 
 
1340
 
void RIG_FTdx1200::set_compression()
1341
 
{
1342
 
        if (progStatus.compON) {
1343
 
                if (progStatus.compression == 0) {
1344
 
                        cmd.assign("PR2;");     // mic eq on
1345
 
                        sendCommand(cmd);
1346
 
                        showresp(WARN, ASC, "set Comp EQ on", cmd, replystr);
1347
 
                } else {
1348
 
                        cmd.assign("PR1;PL").append(to_decimal(progStatus.compression, 3)).append(";");
1349
 
                        sendCommand(cmd);
1350
 
                        showresp(WARN, ASC, "set Comp on", cmd, replystr);
1351
 
                }
1352
 
        } else{
1353
 
                cmd.assign("PR0;");
1354
 
                sendCommand(cmd);
1355
 
                showresp(WARN, ASC, "set Comp off", cmd, replystr);
1356
 
        }
1357
 
}
1358
 
 
1359
 
/*
1360
 
// Audio Peak Filter, like set_cw_spot
1361
 
bool RIG_FTdx1200::set_cw_APF()
1362
 
{
1363
 
        if (vfo.imode == mCW || vfo.imode == mCW_R) {
1364
 
                cmd = "CO0000;";
1365
 
                if (progStatus.apf_onoff) cmd[5] = '2';
1366
 
                sendCommand(cmd);
1367
 
                showresp(WARN, ASC, "SET APF on/off", cmd, replystr);
1368
 
                return true;
1369
 
        } else
1370
 
                return false;
1371
 
}
1372
 
*/