« back to all changes in this revision
Viewing changes to src/rigs/FTdx1200.cxx
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- 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
- files added:
- build-aux
- data
- data/mac
- data/win32
- m4
- scripts
- src
- src/UI
- src/UI/fluid-designs
- src/images
- src/include
- src/rigs
- src/xmlrpcpp
added
removed
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
*/
Loggerhead is a web-based interface for Breezy
Version: 2.0.1