← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/rigs/FT5000.cxx

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rigs/FT5000.cxx
 
1
/*
 
2
 * Yaesu FT-5000 drivers
 
3
 * 
 
4
 * a part of flrig
 
5
 * 
 
6
 * Copyright 2009, Dave Freese, W1HKJ
 
7
 * Copyright 2011, Terry Embry, KJ4EED
 
8
 * 
 
9
 */
 
10
 
 
11
 
 
12
#include "FT5000.h"
 
13
#include "debug.h"
 
14
#include "support.h"
 
15
 
 
16
#define WVALS_LIMIT -1
 
17
enum mFTdx5000 {
 
18
  mLSB, mUSB, mCW, mFM, mAM, mRTTY_L, mCW_R, mPKT_L, mRTTY_U, mPKT_FM, mFM_N, mPKT_U };
 
19
// mLSB, mUSB, mCW, mFM, mAM, mRTTY_L, mCW_R, mPKT_L, mRTTY_U, mPKT_FM, mFM_N, mPKT_U
 
20
//  0,    1,    2,   3,   4,   5,       6,     7,      8,       9,       10,    11      // mode index
 
21
// 19,   19,    9,   0,   0,  10,       9,    15,     10,       0,        0,    15      // FTdx5000_def_bw
 
22
 
 
23
 
 
24
static const char FT5000name_[] = "FTdx5000";
 
25
 
 
26
static const char *FT5000modes_[] = {
 
27
"LSB", "USB", "CW", "FM", "AM", 
 
28
"RTTY-L", "CW-R", "PSK-L", "RTTY-U", "PKT-FM",
 
29
"FM-N", "PSK-U", NULL};
 
30
 
 
31
static const int FT5000_def_bw[] = {
 
32
19, 19, 9, 0, 0, 
 
33
10, 9, 15, 10, 0,
 
34
0, 15 };
 
35
 
 
36
static const char FT5000_mode_chr[] =  { '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C' };
 
37
static const char FT5000_mode_type[] = { 'L', 'U', 'U', 'U', 'U', 'L', 'L', 'L', 'U', 'U', 'U', 'U' };
 
38
 
 
39
static const char *FT5000_widths_SSB[] = {
 
40
"200", "400", "600", "850", "1100", "1350", "1500", // NA = 1 widths
 
41
"1650", "1800", "1950", "2100", "2250", "2400",
 
42
"2500", "2600", "2700", "2800", "2900", "3000",
 
43
"3200", "3400", "3600", "3800", "4000",             // NA = 0 widths
 
44
NULL };
 
45
 
 
46
static int FT5000_wvals_SSB[] = {
 
47
1,2,3,4,5,6,7,  8,9,10,11,12,13,  15,16,17,18,19,20,  21,22,23,24,25, WVALS_LIMIT};
 
48
 
 
49
static const char *FT5000_widths_CW[] = {
 
50
"50",   "100",  "150",  "200",  "250", "300",  "350", "400",  "450", "500", // NA1
 
51
"800", "1200", "1400", "1700", "2000", "2400",                              // NA0
 
52
NULL };
 
53
 
 
54
static int FT5000_wvals_CW[] = {
 
55
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, WVALS_LIMIT };
 
56
 
 
57
static const char *FT5000_widths_RTTY[] = {
 
58
"50",   "100",  "150",  "200",  "250", "300",  "350", "400",  "450", "500", // NA1
 
59
"800", "1200", "1400", "1700", "2000", "2400",                              // NA0
 
60
NULL };
 
61
 
 
62
static int FT5000_wvals_RTTY[] = {
 
63
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, WVALS_LIMIT };
 
64
 
 
65
static const char *FT5000_widths_PSK[] = {
 
66
"50",   "100",  "150",  "200",  "250", "300",  "350", "400",  "450", "500", // NA1
 
67
"800", "1200", "1400", "1700", "2000", "2400",                              // NA0
 
68
NULL };
 
69
 
 
70
static int FT5000_wvals_PSK[] = {
 
71
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, WVALS_LIMIT };
 
72
 
 
73
static const int FT5000_wvals_AMFM[] = { 0, WVALS_LIMIT };
 
74
 
 
75
static const char *FT5000_widths_AMwide[] = { "AM-bw", NULL };
 
76
static const char *FT5000_widths_FMnar[]  = { "FM-nar", NULL };
 
77
static const char *FT5000_widths_FMwide[] = { "FM-wid", NULL };
 
78
static const char *FT5000_widths_FMpkt[]  = { "FM-pkt", NULL };
 
79
 
 
80
static const char *FT5000_US_60m[] = {NULL, "126", "127", "128", "130", NULL};
 
81
// US has 5 60M presets. Using dummy numbers for all.
 
82
// First NULL means skip 60m sets in set_band_selection().
 
83
// Maybe someone can do a cat command MC; on all 5 presets and add returned numbers above.
 
84
// To send cat commands in flrig goto menu Config->Xcvr select->Send Cmd.
 
85
//
 
86
// UK has 7 60M presets. Using dummy numbers for all.  If you want support,
 
87
// Maybe someone can do a cat command MC; on all 7 presets and add returned numbers below.
 
88
// static const char *FT5000_UK_60m[] = {NULL, "126", "127", "128", "130", "131", "132", NULL};
 
89
 
 
90
static const char **Channels_60m = FT5000_US_60m;
 
91
 
 
92
static GUI rig_widgets[]= {
 
93
        { (Fl_Widget *)btnVol,        2, 125,  50 },
 
94
        { (Fl_Widget *)sldrVOLUME,   54, 125, 156 },
 
95
        { (Fl_Widget *)sldrRFGAIN,   54, 145, 156 },
 
96
        { (Fl_Widget *)btnIFsh,     214, 105,  50 },
 
97
        { (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 },
 
98
        { (Fl_Widget *)btnNotch,    214, 125,  50 },
 
99
        { (Fl_Widget *)sldrNOTCH,   266, 125, 156 },
 
100
        { (Fl_Widget *)sldrMICGAIN, 266, 145, 156 },
 
101
        { (Fl_Widget *)sldrPOWER,    54, 165, 368 },
 
102
        { (Fl_Widget *)NULL,          0,   0,   0 }
 
103
};
 
104
 
 
105
void RIG_FT5000::initialize()
 
106
{
 
107
        rig_widgets[0].W = btnVol;
 
108
        rig_widgets[1].W = sldrVOLUME;
 
109
        rig_widgets[2].W = sldrRFGAIN;
 
110
        rig_widgets[3].W = btnIFsh;
 
111
        rig_widgets[4].W = sldrIFSHIFT;
 
112
        rig_widgets[5].W = btnNotch;
 
113
        rig_widgets[6].W = sldrNOTCH;
 
114
        rig_widgets[7].W = sldrMICGAIN;
 
115
        rig_widgets[8].W = sldrPOWER;
 
116
 
 
117
        cmd = "AI0;";
 
118
        sendCommand(cmd);
 
119
        showresp(WARN, ASC, "Auto Info OFF", cmd, replystr);
 
120
}
 
121
 
 
122
RIG_FT5000::RIG_FT5000() {
 
123
// base class values    
 
124
        name_ = FT5000name_;
 
125
        modes_ = FT5000modes_;
 
126
        bandwidths_ = FT5000_widths_SSB;
 
127
        bw_vals_ = FT5000_wvals_SSB;
 
128
 
 
129
        widgets = rig_widgets;
 
130
 
 
131
        comm_baudrate = BR38400;
 
132
        stopbits = 1;
 
133
        comm_retries = 2;
 
134
        comm_wait = 5;
 
135
        comm_timeout = 50;
 
136
        comm_rtscts = true;
 
137
        comm_rtsplus = false;
 
138
        comm_dtrplus = false;
 
139
        comm_catptt = true;
 
140
        comm_rtsptt = false;
 
141
        comm_dtrptt = false;
 
142
 
 
143
        A.imode = B.imode = modeB = modeA = def_mode = 1;
 
144
        A.iBW = B.iBW = bwA = bwB = def_bw = 19;
 
145
        A.freq = B.freq = freqA = freqB = def_freq = 14070000;
 
146
 
 
147
        notch_on = false;
 
148
 
 
149
        has_band_selection =
 
150
        has_extras =
 
151
        has_vox_onoff =
 
152
        has_vox_gain =
 
153
        has_vox_anti =
 
154
        has_vox_hang =
 
155
        has_vox_on_dataport =
 
156
 
 
157
        has_cw_wpm =
 
158
        has_cw_keyer =
 
159
//      has_cw_vol =
 
160
        has_cw_spot =
 
161
//      has_cw_spot_tone = // does not exist???
 
162
        has_cw_qsk =
 
163
        has_cw_weight =
 
164
 
 
165
        has_split_AB =
 
166
        can_change_alt_vfo =
 
167
        has_smeter =
 
168
        has_swr_control =
 
169
        has_power_out =
 
170
        has_power_control =
 
171
        has_volume_control =
 
172
        has_rf_control =
 
173
        has_micgain_control =
 
174
        has_mode_control =
 
175
        has_noise_control =
 
176
        has_bandwidth_control =
 
177
        has_notch_control =
 
178
        has_auto_notch =
 
179
        has_attenuator_control =
 
180
        has_preamp_control =
 
181
        has_ifshift_control =
 
182
        has_ptt_control =
 
183
        has_tune_control = true;
 
184
 
 
185
// derived specific
 
186
        atten_level = 0;
 
187
        preamp_level = 0;
 
188
        notch_on = false;
 
189
        m_60m_indx = 0;
 
190
 
 
191
        precision = 1;
 
192
        ndigits = 8;
 
193
 
 
194
}
 
195
 
 
196
void RIG_FT5000::set_band_selection(int v)
 
197
{
 
198
        int inc_60m = false;
 
199
        cmd = "IF;";
 
200
        waitN(27, 100, "get vfo mode in set_band_selection", ASC);
 
201
        size_t p = replystr.rfind("IF");
 
202
        if (p == string::npos) return;
 
203
        if (replystr[p+21] != '0') {    // vfo 60M memory mode
 
204
                inc_60m = true;
 
205
        }
 
206
 
 
207
        if (v == 12) {  // 5MHz 60m presets
 
208
                if (Channels_60m[0] == NULL) return;    // no 60m Channels so skip
 
209
                if (inc_60m) {
 
210
                        if (Channels_60m[++m_60m_indx] == NULL)
 
211
                                m_60m_indx = 0;
 
212
                }
 
213
                cmd.assign("MC").append(Channels_60m[m_60m_indx]).append(";");
 
214
        } else {                // v == 1..11 band selection OR return to vfo mode == 0
 
215
                if (inc_60m)
 
216
                        cmd = "VM;";
 
217
                else {
 
218
                        if (v < 3)
 
219
                                v = v - 1;
 
220
                        cmd.assign("BS").append(to_decimal(v, 2)).append(";");
 
221
                }
 
222
        }
 
223
 
 
224
        sendCommand(cmd);
 
225
        showresp(WARN, ASC, "Select Band Stacks", cmd, replystr);
 
226
}
 
227
 
 
228
long RIG_FT5000::get_vfoA ()
 
229
{
 
230
        cmd = rsp = "FA";
 
231
        cmd += ';';
 
232
        waitN(11, 100, "get vfo A", ASC);
 
233
 
 
234
        size_t p = replystr.rfind(rsp);
 
235
        if (p == string::npos) return freqA;
 
236
        int f = 0;
 
237
        for (size_t n = 2; n < 10; n++)
 
238
                f = f*10 + replystr[p+n] - '0';
 
239
        freqA = f;
 
240
        return freqA;
 
241
}
 
242
 
 
243
void RIG_FT5000::set_vfoA (long freq)
 
244
{
 
245
        freqA = freq;
 
246
        cmd = "FA00000000;";
 
247
        for (int i = 9; i > 1; i--) {
 
248
                cmd[i] += freq % 10;
 
249
                freq /= 10;
 
250
        }
 
251
        sendCommand(cmd);
 
252
        showresp(WARN, ASC, "SET vfo A", cmd, replystr);
 
253
}
 
254
 
 
255
long RIG_FT5000::get_vfoB ()
 
256
{
 
257
        cmd = rsp = "FB";
 
258
        cmd += ';';
 
259
        waitN(11, 100, "get vfo B", ASC);
 
260
 
 
261
        size_t p = replystr.rfind(rsp);
 
262
        if (p == string::npos) return freqB;
 
263
        int f = 0;
 
264
        for (size_t n = 2; n < 10; n++)
 
265
                f = f*10 + replystr[p+n] - '0';
 
266
        freqB = f;
 
267
        return freqB;
 
268
}
 
269
 
 
270
 
 
271
void RIG_FT5000::set_vfoB (long freq)
 
272
{
 
273
        freqB = freq;
 
274
        cmd = "FB00000000;";
 
275
        for (int i = 9; i > 1; i--) {
 
276
                cmd[i] += freq % 10;
 
277
                freq /= 10;
 
278
        }
 
279
        sendCommand(cmd);
 
280
        showresp(WARN, ASC, "SET vfo B", cmd, replystr);
 
281
}
 
282
 
 
283
 
 
284
bool RIG_FT5000::twovfos()
 
285
{
 
286
        return true;
 
287
}
 
288
 
 
289
void RIG_FT5000::selectA()
 
290
{
 
291
        cmd = "FR0;FT2;";
 
292
        sendCommand(cmd);
 
293
        showresp(WARN, ASC, "select A", cmd, replystr);
 
294
}
 
295
 
 
296
void RIG_FT5000::selectB()
 
297
{
 
298
        cmd = "FR4;FT3;";
 
299
        sendCommand(cmd);
 
300
        showresp(WARN, ASC, "select B", cmd, replystr);
 
301
}
 
302
 
 
303
void RIG_FT5000::A2B()
 
304
{
 
305
        cmd = "AB;";
 
306
        sendCommand(cmd);
 
307
        showresp(WARN, ASC, "vfo A --> B", cmd, replystr);
 
308
}
 
309
 
 
310
bool RIG_FT5000::can_split()
 
311
{
 
312
        return true;
 
313
}
 
314
 
 
315
void RIG_FT5000::set_split(bool val)
 
316
{
 
317
        split = val;
 
318
        if (val) {
 
319
                useB = false;
 
320
                cmd = "FR0;";
 
321
                sendCommand(cmd);
 
322
                showresp(WARN, ASC, "Rx on A", cmd, replystr);
 
323
                cmd = "FT3;";
 
324
                sendCommand(cmd);
 
325
                showresp(WARN, ASC, "Tx on B", cmd, replystr);
 
326
        } else {
 
327
                cmd = "FR0;";
 
328
                sendCommand(cmd);
 
329
                showresp(WARN, ASC, "Rx on A", cmd, replystr);
 
330
                cmd = "FT2;";
 
331
                sendCommand(cmd);
 
332
                showresp(WARN, ASC, "Tx on A", cmd, replystr);
 
333
        }
 
334
        Fl::awake(highlight_vfo, (void *)0);
 
335
}
 
336
 
 
337
int RIG_FT5000::get_split()
 
338
{
 
339
        return split;
 
340
}
 
341
 
 
342
 
 
343
int RIG_FT5000::get_smeter()
 
344
{
 
345
        cmd = rsp = "SM0";
 
346
        cmd += ';';
 
347
        waitN(7, 100, "get smeter", ASC);
 
348
 
 
349
        size_t p = replystr.rfind(rsp);
 
350
        if (p == string::npos) return 0;
 
351
        if (p + 6 >= replystr.length()) return 0;
 
352
        int mtr = atoi(&replystr[p+3]);
 
353
        mtr = mtr * 100.0 / 256.0;
 
354
        return mtr;
 
355
}
 
356
 
 
357
int RIG_FT5000::get_swr()
 
358
{
 
359
        cmd = rsp = "RM6";
 
360
        cmd += ';';
 
361
        waitN(7, 100, "get swr", ASC);
 
362
 
 
363
        size_t p = replystr.rfind(rsp);
 
364
        if (p == string::npos) return 0;
 
365
        if (p + 6 >= replystr.length()) return 0;
 
366
        int mtr = atoi(&replystr[p+3]);
 
367
        return mtr / 2.56;
 
368
}
 
369
 
 
370
int RIG_FT5000::get_power_out()
 
371
{
 
372
        cmd = rsp = "RM5";
 
373
        sendCommand(cmd.append(";"));
 
374
        waitN(7, 100, "get pout", ASC);
 
375
 
 
376
        size_t p = replystr.rfind(rsp);
 
377
        if (p == string::npos) return 0;
 
378
        if (p + 6 >= replystr.length()) return 0;
 
379
        double mtr = (double)(atoi(&replystr[p+3]));
 
380
//      mtr = -6.6263535 + .11813178 * mtr + .0013607405 * mtr * mtr;
 
381
        mtr = 0.116 * mtr + 0.0011 * mtr * mtr;
 
382
        return (int)mtr;
 
383
}
 
384
 
 
385
// Transceiver power level
 
386
int RIG_FT5000::get_power_control()
 
387
{
 
388
        cmd = rsp = "PC";
 
389
        cmd += ';';
 
390
        waitN(6, 100, "get power", ASC);
 
391
 
 
392
        size_t p = replystr.rfind(rsp);
 
393
        if (p == string::npos) return progStatus.power_level;
 
394
        if (p + 5 >= replystr.length()) return progStatus.power_level;
 
395
 
 
396
        int mtr = atoi(&replystr[p+2]);
 
397
        return mtr;
 
398
}
 
399
 
 
400
void RIG_FT5000::set_power_control(double val)
 
401
{
 
402
        int ival = (int)val;
 
403
        cmd = "PC000;";
 
404
        for (int i = 4; i > 1; i--) {
 
405
                cmd[i] += ival % 10;
 
406
                ival /= 10;
 
407
        }
 
408
        sendCommand(cmd);
 
409
        showresp(WARN, ASC, "SET power", cmd, replystr);
 
410
}
 
411
 
 
412
// Volume control return 0 ... 100
 
413
int RIG_FT5000::get_volume_control()
 
414
{
 
415
        cmd = rsp = "AG0";
 
416
        cmd += ';';
 
417
        waitN(7, 100, "get vol", ASC);
 
418
 
 
419
        size_t p = replystr.rfind(rsp);
 
420
        if (p == string::npos) return progStatus.volume;
 
421
        if (p + 6 >= replystr.length()) return progStatus.volume;
 
422
        int val = atoi(&replystr[p+3]) * 100 / 250;
 
423
        if (val > 100) val = 100;
 
424
        return val;
 
425
}
 
426
 
 
427
void RIG_FT5000::set_volume_control(int val) 
 
428
{
 
429
        int ivol = (int)(val * 250 / 100);
 
430
        cmd = "AG0000;";
 
431
        for (int i = 5; i > 2; i--) {
 
432
                cmd[i] += ivol % 10;
 
433
                ivol /= 10;
 
434
        }
 
435
        sendCommand(cmd);
 
436
        showresp(WARN, ASC, "SET vol", cmd, replystr);
 
437
}
 
438
 
 
439
// Tranceiver PTT on/off
 
440
void RIG_FT5000::set_PTT_control(int val)
 
441
{
 
442
        cmd = val ? "TX1;" : "TX0;";
 
443
        sendCommand(cmd);
 
444
        showresp(WARN, ASC, "SET PTT", cmd, replystr);
 
445
}
 
446
 
 
447
void RIG_FT5000::tune_rig()
 
448
{
 
449
        cmd = "AC002;";
 
450
        sendCommand(cmd);
 
451
        showresp(WARN, ASC, "tune rig", cmd, replystr);
 
452
}
 
453
 
 
454
void RIG_FT5000::set_attenuator(int val)
 
455
{
 
456
        if (atten_level == 0) {
 
457
                atten_level = 1;
 
458
                atten_label("6 dB", true);
 
459
        } else if (atten_level == 1) {
 
460
                atten_level = 2;
 
461
                atten_label("12 dB", true);
 
462
        } else if (atten_level == 2) {
 
463
                atten_level = 3;
 
464
                atten_label("18 dB", true);
 
465
        } else if (atten_level == 3) {
 
466
                atten_level = 0;
 
467
                atten_label("Att", false);
 
468
        }
 
469
        cmd = "RA00;";
 
470
        cmd[3] += atten_level;
 
471
        sendCommand(cmd);
 
472
        showresp(WARN, ASC, "SET att", cmd, replystr);
 
473
}
 
474
 
 
475
int RIG_FT5000::get_attenuator()
 
476
{
 
477
        cmd = rsp = "RA0";
 
478
        cmd += ';';
 
479
        waitN(5, 100, "get att", ASC);
 
480
 
 
481
        size_t p = replystr.rfind(rsp);
 
482
        if (p == string::npos) return progStatus.attenuator;
 
483
        if (p + 3 >= replystr.length()) return progStatus.attenuator;
 
484
        atten_level = replystr[p+3] - '0';
 
485
        if (atten_level == 1) {
 
486
                atten_label("6 dB", true);
 
487
        } else if (atten_level == 2) {
 
488
                atten_label("12 dB", true);
 
489
        } else if (atten_level == 3) {
 
490
                atten_label("18 dB", true);
 
491
        } else {
 
492
                atten_level = 0;
 
493
                atten_label("Att", false);
 
494
        }
 
495
        return atten_level;
 
496
}
 
497
 
 
498
void RIG_FT5000::set_preamp(int val)
 
499
{
 
500
        cmd = "PA00;";
 
501
        if (preamp_level == 0) {
 
502
                preamp_level = 1;
 
503
                preamp_label("Amp 1", true);
 
504
        } else if (preamp_level == 1) {
 
505
                preamp_level = 2;
 
506
                preamp_label("Amp 2", true);
 
507
        } else if (preamp_level == 2) {
 
508
                preamp_level = 3;
 
509
                preamp_label("IPO2", true);
 
510
        } else if (preamp_level == 3) {
 
511
                preamp_level = 0;
 
512
                preamp_label("IPO1", false);
 
513
        }
 
514
        cmd[3] = '0' + preamp_level;
 
515
        sendCommand (cmd);
 
516
        showresp(WARN, ASC, "SET preamp", cmd, replystr);
 
517
}
 
518
 
 
519
int RIG_FT5000::get_preamp()
 
520
{
 
521
        cmd = rsp = "PA0";
 
522
        cmd += ';';
 
523
        waitN(5, 100, "get pre", ASC);
 
524
 
 
525
        size_t p = replystr.rfind(rsp);
 
526
        if (p != string::npos)
 
527
                preamp_level = replystr[p+3] - '0';
 
528
        if (preamp_level == 1) {
 
529
                preamp_label("Amp 1", true);
 
530
        } else if (preamp_level == 2) {
 
531
                preamp_label("Amp 2", true);
 
532
        } else if (preamp_level == 3) {
 
533
                preamp_label("IPO2", true);
 
534
        } else {
 
535
                preamp_label("IPO1", false);
 
536
                preamp_level = 0;
 
537
        }
 
538
        return preamp_level;
 
539
}
 
540
 
 
541
int RIG_FT5000::adjust_bandwidth(int val)
 
542
{
 
543
        int bw = 0;
 
544
        if (val == mCW || val == mCW_R) {
 
545
                bandwidths_ = FT5000_widths_CW;
 
546
                bw_vals_ = FT5000_wvals_CW;
 
547
        } else if (val == mFM || val == mAM || val == mFM_N || val == mPKT_FM) {
 
548
                if (val == mFM) bandwidths_ = FT5000_widths_FMwide;
 
549
                else if (val ==  mAM) bandwidths_ = FT5000_widths_AMwide;
 
550
                else if (val == mFM_N) bandwidths_ = FT5000_widths_FMnar;
 
551
                else if (val == mPKT_FM) bandwidths_ = FT5000_widths_FMpkt;
 
552
                bw_vals_ = FT5000_wvals_AMFM;
 
553
        } else if (val == mRTTY_L || val == mRTTY_U) { // RTTY
 
554
                bandwidths_ = FT5000_widths_RTTY;
 
555
                bw_vals_ = FT5000_wvals_RTTY;
 
556
        } else if (val == mPKT_L || val == mPKT_U) { // PSK
 
557
                bandwidths_ = FT5000_widths_PSK;
 
558
                bw_vals_ = FT5000_wvals_PSK;
 
559
        } else {
 
560
                bandwidths_ = FT5000_widths_SSB;
 
561
                bw_vals_ = FT5000_wvals_SSB;
 
562
        }
 
563
        bw = FT5000_def_bw[val];
 
564
        return bw;
 
565
}
 
566
 
 
567
int RIG_FT5000::def_bandwidth(int val)
 
568
{
 
569
        return FT5000_def_bw[val];
 
570
}
 
571
 
 
572
const char ** RIG_FT5000::bwtable(int n)
 
573
{
 
574
        switch (n) {
 
575
                case mCW: case mCW_R: return FT5000_widths_CW;
 
576
                case mFM: return FT5000_widths_FMwide;
 
577
                case mAM: return FT5000_widths_AMwide;
 
578
                case mRTTY_L: case mRTTY_U: return FT5000_widths_RTTY;
 
579
                case mPKT_L: case mPKT_U: return FT5000_widths_PSK;
 
580
                case mFM_N: return FT5000_widths_FMnar;
 
581
                case mPKT_FM: return FT5000_widths_FMpkt;
 
582
                default: ;
 
583
        }
 
584
        return FT5000_widths_SSB;
 
585
}
 
586
 
 
587
void RIG_FT5000::set_modeA(int val)
 
588
{
 
589
        modeA = val;
 
590
        cmd = "MD0";
 
591
        cmd += FT5000_mode_chr[val];
 
592
        cmd += ';';
 
593
        sendCommand(cmd);
 
594
        showresp(WARN, ASC, "SET mode A", cmd, replystr);
 
595
        adjust_bandwidth(modeA);
 
596
        if (val == mCW || val == mCW_R) return;
 
597
        if (progStatus.spot_onoff) {
 
598
                progStatus.spot_onoff = false;
 
599
                set_spot_onoff();
 
600
                cmd = "CS0;";
 
601
                sendCommand(cmd);
 
602
                showresp(WARN, ASC, "SET spot off", cmd, replystr);
 
603
                btnSpot->value(0);
 
604
        }
 
605
}
 
606
 
 
607
int RIG_FT5000::get_modeA()
 
608
{
 
609
        cmd = rsp = "MD0";
 
610
        cmd += ';';
 
611
        waitN(5, 100, "get mode A", ASC);
 
612
 
 
613
        size_t p = replystr.rfind(rsp);
 
614
        if (p != string::npos) {
 
615
                if (p + 3 < replystr.length()) {
 
616
                        int md = replystr[p+3];
 
617
                        if (md <= '9') md = md - '1';
 
618
                        else md = 9 + md - 'A';
 
619
                        modeA = md;
 
620
                }
 
621
        }
 
622
        adjust_bandwidth(modeA);
 
623
        return modeA;
 
624
}
 
625
 
 
626
void RIG_FT5000::set_modeB(int val)
 
627
{
 
628
        modeB = val;
 
629
        cmd = "MD0";
 
630
        cmd += FT5000_mode_chr[val];
 
631
        cmd += ';';
 
632
        sendCommand(cmd);
 
633
        showresp(WARN, ASC, "SET mode B", cmd, replystr);
 
634
        adjust_bandwidth(modeA);
 
635
        if (val == mCW || val == mCW_R) return;
 
636
        if (progStatus.spot_onoff) {
 
637
                progStatus.spot_onoff = false;
 
638
                set_spot_onoff();
 
639
                cmd = "CS0;";
 
640
                sendCommand(cmd);
 
641
                showresp(WARN, ASC, "SET spot off", cmd, replystr);
 
642
                btnSpot->value(0);
 
643
        }
 
644
}
 
645
 
 
646
int RIG_FT5000::get_modeB()
 
647
{
 
648
        cmd = rsp = "MD0";
 
649
        cmd += ';';
 
650
        waitN(5, 100, "get mode B", ASC);
 
651
 
 
652
        size_t p = replystr.rfind(rsp);
 
653
        if (p != string::npos) {
 
654
                if (p + 3 < replystr.length()) {
 
655
                        int md = replystr[p+3];
 
656
                        if (md <= '9') md = md - '1';
 
657
                        else md = 9 + md - 'A';
 
658
                        modeB = md;
 
659
                }
 
660
        }
 
661
        adjust_bandwidth(modeB);
 
662
        return modeB;
 
663
}
 
664
 
 
665
void RIG_FT5000::set_bwA(int val)
 
666
{
 
667
        int bw_indx = bw_vals_[val];
 
668
        bwA = val;
 
669
 
 
670
        if (modeA == mFM || modeA == mAM || modeA == mFM_N || modeA == mPKT_FM ) {
 
671
                return;
 
672
        }
 
673
        if ((((modeA == mLSB || modeA == mUSB)  && val < 8)) ||
 
674
                 ((modeA == mCW  || modeA == mCW_R) && val < 11) ||
 
675
                 ((modeA == mRTTY_L || modeA == mRTTY_U) && val < 11) ||
 
676
                 ((modeA == mPKT_L  || modeA == mPKT_U)  && val < 11))  cmd = "NA01;";
 
677
        else cmd = "NA00;";
 
678
 
 
679
        cmd.append("SH0");
 
680
        cmd += '0' + bw_indx / 10;
 
681
        cmd += '0' + bw_indx % 10;
 
682
        cmd += ';';
 
683
        sendCommand(cmd);
 
684
        showresp(WARN, ASC, "SET bw A", cmd, replystr);
 
685
}
 
686
 
 
687
int RIG_FT5000::get_bwA()
 
688
{
 
689
        if (modeA == mFM || modeA == mAM || modeA == mFM_N || modeA == mPKT_FM) {
 
690
                bwA = 0;
 
691
                return bwA;     
 
692
        } 
 
693
        cmd = rsp = "SH0";
 
694
        cmd += ';';
 
695
        waitN(6, 100, "get bw A", ASC);
 
696
 
 
697
        size_t p = replystr.rfind(rsp);
 
698
        if (p == string::npos) return bwA;
 
699
        if (p + 5 >= replystr.length()) return bwA;
 
700
 
 
701
        replystr[p+5] = 0;
 
702
        int bw_idx = fm_decimal(&replystr[p+3],2);
 
703
        const int *idx = bw_vals_;
 
704
        int i = 0;
 
705
        while (*idx != WVALS_LIMIT) {
 
706
                if (*idx == bw_idx) break;
 
707
                idx++;
 
708
                i++;
 
709
        }
 
710
        if (*idx == WVALS_LIMIT) i--;
 
711
        bwA = i;
 
712
        return bwA;
 
713
}
 
714
 
 
715
void RIG_FT5000::set_bwB(int val)
 
716
{
 
717
        int bw_indx = bw_vals_[val];
 
718
        bwB = val;
 
719
 
 
720
        if (modeB == mFM || modeB == mAM || modeB == mFM_N || modeB == mPKT_FM) {
 
721
                return;
 
722
        }
 
723
        if ((((modeB == mLSB || modeB == mUSB)  && val < 8)) ||
 
724
                 ((modeB == mCW  || modeB == mCW_R) && val < 11) ||
 
725
                 ((modeB == mRTTY_L || modeB == mRTTY_U) && val < 11) ||
 
726
                 ((modeB == mPKT_L  || modeB == mPKT_U)  && val < 11))  cmd = "NA01;";
 
727
        else cmd = "NA00;";
 
728
 
 
729
        cmd.append("SH0");
 
730
        cmd += '0' + bw_indx / 10;
 
731
        cmd += '0' + bw_indx % 10;
 
732
        cmd += ';';
 
733
        sendCommand(cmd);
 
734
        showresp(WARN, ASC, "SET bw B", cmd, replystr);
 
735
}
 
736
 
 
737
int RIG_FT5000::get_bwB()
 
738
{
 
739
        if (modeB == mFM || modeB == mAM || modeB == mFM_N || modeB == mPKT_FM) {
 
740
                bwB = 0;
 
741
                return bwB;
 
742
        } 
 
743
        cmd = rsp = "SH0";
 
744
        cmd += ';';
 
745
        waitN(6, 100, "get bw B", ASC);
 
746
 
 
747
        size_t p = replystr.rfind(rsp);
 
748
        if (p == string::npos) return bwB;
 
749
        if (p + 5 >= replystr.length()) return bwB;
 
750
        
 
751
        replystr[p+5] = 0;
 
752
        int bw_idx = fm_decimal(&replystr[p+3],2);
 
753
        const int *idx = bw_vals_;
 
754
        int i = 0;
 
755
        while (*idx != WVALS_LIMIT) {
 
756
                if (*idx == bw_idx) break;
 
757
                idx++;
 
758
                i++;
 
759
        }
 
760
        if (*idx == WVALS_LIMIT) i--;
 
761
        bwB = i;
 
762
        return bwB;
 
763
}
 
764
 
 
765
int RIG_FT5000::get_modetype(int n)
 
766
{
 
767
        return FT5000_mode_type[n];
 
768
}
 
769
 
 
770
void RIG_FT5000::set_if_shift(int val)
 
771
{
 
772
        cmd = "IS0+0000;";
 
773
        if (val != 0) progStatus.shift = true;
 
774
        else progStatus.shift = false;
 
775
        if (val < 0) cmd[3] = '-';
 
776
        val = abs(val);
 
777
        for (int i = 4; i > 0; i--) {
 
778
                cmd[3+i] += val % 10;
 
779
                val /= 10;
 
780
        }
 
781
        sendCommand(cmd);
 
782
        showresp(WARN, ASC, "SET if shift", cmd, replystr);
 
783
}
 
784
 
 
785
bool RIG_FT5000::get_if_shift(int &val)
 
786
{
 
787
        cmd = rsp = "IS0";
 
788
        cmd += ';';
 
789
        waitN(9, 100, "get if shift", ASC);
 
790
 
 
791
        size_t p = replystr.rfind(rsp);
 
792
        val = progStatus.shift_val;
 
793
        if (p == string::npos) return progStatus.shift;
 
794
        val = atoi(&replystr[p+4]);
 
795
        if (replystr[p+3] == '-') val = -val;
 
796
        return (val != 0);
 
797
}
 
798
 
 
799
void RIG_FT5000::get_if_min_max_step(int &min, int &max, int &step)
 
800
{
 
801
        if_shift_min = min = -1000;
 
802
        if_shift_max = max = 1000;
 
803
        if_shift_step = step = 50;
 
804
        if_shift_mid = 0;
 
805
}
 
806
 
 
807
void RIG_FT5000::set_notch(bool on, int val)
 
808
{
 
809
        if (on && !notch_on) {
 
810
                notch_on = true;
 
811
                cmd = "BP00001;";
 
812
                sendCommand(cmd);
 
813
                showresp(WARN, ASC, "SET notch on", cmd, replystr);
 
814
        } else if (!on && notch_on) {
 
815
                notch_on = false;
 
816
                cmd = "BP00000;";
 
817
                sendCommand(cmd);
 
818
                showresp(WARN, ASC, "SET notch off", cmd, replystr);
 
819
                return;
 
820
        }
 
821
 
 
822
        cmd = "BP01";
 
823
        val /= 10;
 
824
        cmd.append(to_decimal(val,3)).append(";");
 
825
        sendCommand(cmd);
 
826
        showresp(WARN, ASC, "SET notch val", cmd, replystr);
 
827
}
 
828
 
 
829
bool  RIG_FT5000::get_notch(int &val)
 
830
{
 
831
        bool ison = false;
 
832
        cmd = rsp = "BP00";
 
833
        cmd += ';';
 
834
        waitN(8, 100, "get notch on/off", ASC);
 
835
        size_t p = replystr.rfind(rsp);
 
836
        if (p == string::npos) return ison;
 
837
 
 
838
        if (replystr[p+6] == '1') // manual notch enabled
 
839
                ison = true;
 
840
 
 
841
        val = progStatus.notch_val;
 
842
        cmd = rsp = "BP01";
 
843
        cmd += ';';
 
844
        waitN(8, 100, "get notch val", ASC);
 
845
        p = replystr.rfind(rsp);
 
846
        if (p == string::npos)
 
847
                val = 10;
 
848
        else
 
849
                val = fm_decimal(&replystr[p+4],3) * 10;
 
850
 
 
851
        return (notch_on = ison);
 
852
}
 
853
 
 
854
void RIG_FT5000::get_notch_min_max_step(int &min, int &max, int &step)
 
855
{
 
856
        min = 10;
 
857
        max = 3000;
 
858
        step = 10;
 
859
}
 
860
 
 
861
void RIG_FT5000::set_auto_notch(int v)
 
862
{
 
863
        cmd = "BC00;";
 
864
        if (v) cmd[3] = '1';
 
865
        sendCommand(cmd);
 
866
        showresp(WARN, ASC, "SET auto notch", cmd, replystr);
 
867
}
 
868
 
 
869
int  RIG_FT5000::get_auto_notch()
 
870
{
 
871
        cmd = "BC0;";
 
872
        waitN(5, 100, "get auto notch", ASC);
 
873
        size_t p = replystr.rfind("BC0");
 
874
        if (p == string::npos) return 0;
 
875
        if (replystr[p+3] == '1') return 1;
 
876
        return 0;
 
877
}
 
878
 
 
879
int FT5000_blanker_level = 0;
 
880
 
 
881
void RIG_FT5000::set_noise(bool b)
 
882
{
 
883
        cmd = "NB00;";
 
884
        if (FT5000_blanker_level == 0) {
 
885
                FT5000_blanker_level = 1;
 
886
                nb_label("NB 1", true);
 
887
        } else if (FT5000_blanker_level == 1) {
 
888
                FT5000_blanker_level = 2;
 
889
                nb_label("NB 2", true);
 
890
        } else if (FT5000_blanker_level == 2) {
 
891
                FT5000_blanker_level = 0;
 
892
                nb_label("NB", false);
 
893
        }
 
894
        cmd[3] = '0' + FT5000_blanker_level;
 
895
        sendCommand (cmd);
 
896
        showresp(WARN, ASC, "SET NB", cmd, replystr);
 
897
}
 
898
 
 
899
int RIG_FT5000::get_noise()
 
900
{
 
901
        cmd = rsp = "NB0";
 
902
        cmd += ';';
 
903
        waitN(5, 100, "get NB", ASC);
 
904
 
 
905
        size_t p = replystr.rfind(rsp);
 
906
        if (p == string::npos) return FT5000_blanker_level;
 
907
 
 
908
        FT5000_blanker_level = replystr[p+3] - '0';
 
909
        if (FT5000_blanker_level == 1) {
 
910
                nb_label("NB 1", true);
 
911
        } else if (FT5000_blanker_level == 2) {
 
912
                nb_label("NB 2", true);
 
913
        } else {
 
914
                nb_label("NB", false);
 
915
                FT5000_blanker_level = 0;
 
916
        }
 
917
        return FT5000_blanker_level;
 
918
}
 
919
 
 
920
// val 0 .. 100
 
921
void RIG_FT5000::set_mic_gain(int val)
 
922
{
 
923
        cmd = "MG000;";
 
924
        val = (int)(val * 255 / 100); // convert to 0 .. 255
 
925
        for (int i = 3; i > 0; i--) {
 
926
                cmd[1+i] += val % 10;
 
927
                val /= 10;
 
928
        }
 
929
        sendCommand(cmd);
 
930
        showresp(WARN, ASC, "SET mic", cmd, replystr);
 
931
}
 
932
 
 
933
int RIG_FT5000::get_mic_gain()
 
934
{
 
935
        cmd = rsp = "MG";
 
936
        cmd += ';';
 
937
        waitN(6, 100, "get mic", ASC);
 
938
 
 
939
        size_t p = replystr.rfind(rsp);
 
940
        if (p == string::npos) return progStatus.mic_gain;
 
941
        int val = atoi(&replystr[p+2]);
 
942
        return val * 100 / 255;
 
943
}
 
944
 
 
945
void RIG_FT5000::get_mic_min_max_step(int &min, int &max, int &step)
 
946
{
 
947
        min = 0;
 
948
        max = 100;
 
949
        step = 1;
 
950
}
 
951
 
 
952
void RIG_FT5000::set_rf_gain(int val)
 
953
{
 
954
        cmd = "RG0000;";
 
955
        int rfval = val * 250 / 100;
 
956
        for (int i = 5; i > 2; i--) {
 
957
                cmd[i] = rfval % 10 + '0';
 
958
                rfval /= 10;
 
959
        }
 
960
        sendCommand(cmd);
 
961
        showresp(WARN, ASC, "SET rfgain", cmd, replystr);
 
962
}
 
963
 
 
964
int  RIG_FT5000::get_rf_gain()
 
965
{
 
966
        int rfval = 0;
 
967
        cmd = rsp = "RG0";
 
968
        cmd += ';';
 
969
        waitN(7, 100, "get rfgain", ASC);
 
970
 
 
971
        size_t p = replystr.rfind(rsp);
 
972
        if (p == string::npos) return progStatus.rfgain;
 
973
        for (int i = 3; i < 6; i++) {
 
974
                rfval *= 10;
 
975
                rfval += replystr[p+i] - '0';
 
976
        }
 
977
        rfval = rfval * 100 / 250;
 
978
        if (rfval > 100) rfval = 100;
 
979
        return rfval;
 
980
}
 
981
 
 
982
void RIG_FT5000::get_rf_min_max_step(int &min, int &max, int &step)
 
983
{
 
984
        min = 0;
 
985
        max = 100;
 
986
        step = 1;
 
987
}
 
988
 
 
989
void RIG_FT5000::set_vox_onoff()
 
990
{
 
991
        cmd = "VX0;";
 
992
        if (progStatus.vox_onoff) cmd[2] = '1';
 
993
        sendCommand(cmd);
 
994
        showresp(WARN, ASC, "SET vox", cmd, replystr);
 
995
}
 
996
 
 
997
void RIG_FT5000::set_vox_gain()
 
998
{
 
999
        cmd = "VG";
 
1000
        cmd.append(to_decimal(progStatus.vox_gain, 3)).append(";");
 
1001
        sendCommand(cmd);
 
1002
        showresp(WARN, ASC, "SET vox gain", cmd, replystr);
 
1003
}
 
1004
 
 
1005
void RIG_FT5000::set_vox_anti()
 
1006
{
 
1007
        cmd = "EX175";
 
1008
        cmd.append(to_decimal(progStatus.vox_anti, 3)).append(";");
 
1009
        sendCommand(cmd);
 
1010
        showresp(WARN, ASC, "SET anti-vox", cmd, replystr);
 
1011
}
 
1012
 
 
1013
void RIG_FT5000::set_vox_hang()
 
1014
{
 
1015
        cmd = "VD";
 
1016
        cmd.append(to_decimal(progStatus.vox_hang, 4)).append(";");
 
1017
        sendCommand(cmd);
 
1018
        showresp(WARN, ASC, "SET vox delay", cmd, replystr);
 
1019
}
 
1020
 
 
1021
void RIG_FT5000::set_vox_on_dataport()
 
1022
{
 
1023
        cmd = "EX1140;";
 
1024
        if (progStatus.vox_on_dataport) cmd[5] = '1';
 
1025
        sendCommand(cmd);
 
1026
        showresp(WARN, ASC, "SET vox on data port", cmd, replystr);
 
1027
}
 
1028
 
 
1029
void RIG_FT5000::set_cw_wpm()
 
1030
{
 
1031
        cmd = "KS";
 
1032
        if (progStatus.cw_wpm > 60) progStatus.cw_wpm = 60;
 
1033
        if (progStatus.cw_wpm < 4) progStatus.cw_wpm = 4;
 
1034
        cmd.append(to_decimal(progStatus.cw_wpm, 3)).append(";");
 
1035
        sendCommand(cmd);
 
1036
        showresp(WARN, ASC, "SET cw wpm", cmd, replystr);
 
1037
}
 
1038
 
 
1039
 
 
1040
void RIG_FT5000::enable_keyer()
 
1041
{
 
1042
        cmd = "KR0;";
 
1043
        if (progStatus.enable_keyer) cmd[2] = '1';
 
1044
        sendCommand(cmd);
 
1045
        showresp(WARN, ASC, "SET keyer on/off", cmd, replystr);
 
1046
}
 
1047
 
 
1048
bool RIG_FT5000::set_cw_spot()
 
1049
{
 
1050
        if (vfo.imode == 2 || vfo.imode == 6) {
 
1051
                cmd = "CS0;";
 
1052
                if (progStatus.spot_onoff) cmd[2] = '1';
 
1053
                sendCommand(cmd);
 
1054
                showresp(WARN, ASC, "SET spot on/off", cmd, replystr);
 
1055
                return true;
 
1056
        } else
 
1057
                return false;
 
1058
}
 
1059
 
 
1060
void RIG_FT5000::set_cw_weight()
 
1061
{
 
1062
        int n = round(progStatus.cw_weight * 10);
 
1063
        cmd.assign("EX065").append(to_decimal(n, 2)).append(";");
 
1064
        sendCommand(cmd);
 
1065
        showresp(WARN, ASC, "SET cw weight", cmd, replystr);
 
1066
}
 
1067
 
 
1068
void RIG_FT5000::set_cw_qsk()
 
1069
{
 
1070
        int n = progStatus.cw_qsk / 5 - 3;
 
1071
        cmd.assign("EX068").append(to_decimal(n, 1)).append(";");
 
1072
        sendCommand(cmd);
 
1073
        showresp(WARN, ASC, "SET cw qsk", cmd, replystr);
 
1074
}
 
1075
 
 
1076
void RIG_FT5000::set_cw_spot_tone()
 
1077
{
 
1078
        int n = (progStatus.cw_spot_tone - 300) / 50;
 
1079
        cmd = "EX045";
 
1080
        cmd.append(to_decimal(n, 2)).append(";");
 
1081
        sendCommand(cmd);
 
1082
        showresp(WARN, ASC, "SET cw tone", cmd, replystr);
 
1083
}
 
1084
 
 
1085
/*
 
1086
void RIG_FT5000::set_cw_vol()
 
1087
{
 
1088
}
 
1089
*/