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