← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/rigs/TS990.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/TS990.cxx
 
1
/*
 
2
 * Kenwood TS990 driver
 
3
 *
 
4
 * a part of flrig
 
5
 *
 
6
 * Copyright 2013
 
7
 *     Dave Freese, W1HKJ
 
8
 *     Andy Burnett, G0HIX
 
9
 *
 
10
 */
 
11
 
 
12
#include "config.h"
 
13
 
 
14
#include "TS990.h"
 
15
#include "support.h"
 
16
 
 
17
static const char TS990name_[] = "TS-990";
 
18
 
 
19
static const char *TS990modes_[] = {
 
20
"LSB",    "USB",    "CW",    "FM",     "AM",
 
21
"FSK",    "PSK",    "CW-R",  "FSK-R",  "PSK-R",
 
22
"LSB-D1", "USB-D1", "FM-D1", "AM-D1",
 
23
"LSB-D2", "USB-D2", "FM-D2",  "AM-D2",
 
24
"LSB-D3", "USB-D3", "FM-D3",  "AM-D3",  NULL};
 
25
 
 
26
static const char TS990_mode_chr[] =  {
 
27
'1', '2', '3', '4', '5',
 
28
'6', 'A', '7', '9', 'B',
 
29
'C', 'D', 'E', 'F',
 
30
'G', 'H', 'I', 'J',
 
31
'K', 'L', 'M', 'N' };
 
32
 
 
33
static const char TS990_mode_type[] = {
 
34
'L', 'U', 'U', 'U', 'U',
 
35
'U', 'U', 'L', 'U', 'U',
 
36
'L', 'U', 'U', 'U',
 
37
'L', 'U', 'U', 'U',
 
38
'L', 'U', 'U', 'U' };
 
39
 
 
40
//==============================================================================
 
41
static const char *TS990_empty[] = { "N/A", NULL };
 
42
 
 
43
//==============================================================================
 
44
// SSB - Width / Shift  filters
 
45
//
 
46
// BW indicates 0x8000 & (width << 8) & shift
 
47
// Maximum assignable BW value 0x910C
 
48
// Default BW value 0x9005
 
49
//==============================================================================
 
50
 
 
51
static const char *TS990_filt_width[] = {
 
52
  "50",   "80",  "100",  "150",  "200",
 
53
 "250",  "300",  "400",  "500",  "600",
 
54
"1000", "1500", "2000", "2200", "2400",
 
55
"2600", "2800", "3000", NULL };
 
56
 
 
57
static const char *TS990_CAT_filt_width[] = {
 
58
"00;", "01;", "02;", "03;", "04;",
 
59
"05;", "06;", "07;", "08;", "09;",
 
60
"10;", "11;", "12;", "13;", "14;",
 
61
"15;", "16;", "17;", NULL };
 
62
 
 
63
static const char *TS990_filt_width_tooltip = "filter width";
 
64
static const char *TS990_filt_width_label = "W";
 
65
 
 
66
static const char *TS990_filt_shift[] = {
 
67
"1000", "1100", "1200", "1300", "1400",
 
68
"1500", "1600", "1700", "1800", "1900",
 
69
"2000", "2100", "2210", NULL };
 
70
 
 
71
static const char *TS990_CAT_filt_shift[] = {
 
72
"00;", "01;", "02;", "03;", "04;",
 
73
"05;", "06;", "07;", "08;", "09;",
 
74
"10;", "11;", "12;", NULL };
 
75
 
 
76
static const char *TS990_filt_shift_tooltip = "shift frequency";
 
77
static const char *TS990_filt_shift_label = "S";
 
78
 
 
79
//==============================================================================
 
80
// SSB, FM, Other lo/hi cutoff filters
 
81
//
 
82
// BW indicates 0x8000 & (hi << 8) & lo
 
83
// Maximum assignable BW value 0x8D0B
 
84
// Default BW value 0x8A02 for SSB 3000 / 100
 
85
// Default BW value 0x8201 for FM  4000 / 200
 
86
//==============================================================================
 
87
 
 
88
static const char *TS990_filt_hi[] = {
 
89
"1000", "1200", "1400", "1600", "1800",
 
90
"2000", "2200", "2400", "2600", "2800",
 
91
"3000", "3400", "4000", "5000", NULL };
 
92
 
 
93
static const char *TS990_CAT_filt_hi[] = {
 
94
"00;", "01;", "02;", "03;", "04;",
 
95
"05;", "06;", "07;", "08;", "09;",
 
96
"10;", "11;", "12;", "13;", NULL };
 
97
 
 
98
static const char *TS990_filt_hi_tooltip = "hi cutoff";
 
99
static const char *TS990_filt_hi_label = "H";
 
100
 
 
101
static const char *TS990_filt_lo[] = {
 
102
"0", "50", "100", "200", "300",
 
103
"400", "500", "600", "700", "800",
 
104
"900", "1000", NULL };
 
105
 
 
106
static const char *TS990_CAT_filt_lo[] = {
 
107
"00;", "01;", "02;", "03;", "04;",
 
108
"05;", "06;", "07;", "08;", "09;",
 
109
"10;", "11;", NULL };
 
110
 
 
111
static const char *TS990_filt_lo_tooltip = "lo cutoff";
 
112
static const char *TS990_filt_lo_label = "L";
 
113
 
 
114
//==============================================================================
 
115
// CW filters
 
116
//
 
117
// BW indicates 0x8000 & (width << 8) & shift
 
118
// Maximum assignable BW value 0x8D20
 
119
// Default BW value 0x8810 --> no shift, bandwidth = 500 Hz
 
120
//==============================================================================
 
121
 
 
122
static const char *TS990_CW_width[] = {
 
123
  "50",   "80",  "100",  "150", "200",
 
124
 "250",  "300",  "400",  "500", "600",
 
125
"1000", "1500", "2000", "2500",  NULL };
 
126
 
 
127
static const char *TS990_CAT_CW_width[] = {
 
128
"00;", "01;", "02;", "03;", "04;",
 
129
"05;", "06;", "07;", "08;", "09;",
 
130
"10;", "11;", "12;", "13;", NULL };
 
131
 
 
132
static const char *TS990_CW_W_tooltip = "filter width";
 
133
static const char *TS990_CW_W_btn_label = "W";
 
134
 
 
135
static const char *TS990_CW_shift[] = {
 
136
"-800", "-750", "-700", "-650", "-600",
 
137
"-550", "-500", "-450", "-400", "-350",
 
138
"-300", "-250", "-200", "-150", "-100",
 
139
"-50",  "0",    "50",   "100",  "150",
 
140
"200",  "250",  "300",  "350",  "400",
 
141
"450",  "500",  "550",  "600",  "650",
 
142
"700",  "750",  "800", NULL };
 
143
 
 
144
static const char *TS990_CAT_CW_shift[] = {
 
145
"00;", "01;", "02;", "03;", "04;",
 
146
"05;", "06;", "07;", "08;", "09;",
 
147
"10;", "11;", "12;", "13;", "14;",
 
148
"15;", "16;", "17;", "18;", "19;",
 
149
"20;", "21;", "22;", "23;", "24;",
 
150
"25;", "26;", "27;", "28;", "29;",
 
151
"30;", "31;", "32;", NULL };
 
152
 
 
153
static const char *TS990_CW_S_tooltip = "shift frequency";
 
154
static const char *TS990_CW_S_btn_label = "S";
 
155
 
 
156
//==============================================================================
 
157
 
 
158
static const char *TS990_AM_lo[] = {
 
159
"0", "100", "200", "300", NULL };
 
160
 
 
161
static const char *TS990_CAT_AM_lo[] = {
 
162
"00;", "01;", "02;", "03;", NULL};
 
163
 
 
164
static const char *TS990_AM_lo_tooltip = "lo cutoff";
 
165
static const char *TS990_AM_btn_lo_label = "L";
 
166
 
 
167
static const char *TS990_AM_hi[] = {
 
168
"2500", "3000", "4000", "5000", NULL };
 
169
 
 
170
static const char *TS990_CAT_AM_hi[] = {
 
171
"00;", "01;", "02;", "03;", NULL};
 
172
 
 
173
static const char *TS990_AM_hi_tooltip = "hi cutoff";
 
174
static const char *TS990_AM_btn_hi_label = "H";
 
175
 
 
176
//==============================================================================
 
177
 
 
178
static const char *TS990_FSK_filt[] = {
 
179
"250", "300", "400", "500", "1000", "1500", NULL};
 
180
 
 
181
static const char *TS990_CAT_FSK_filt[] = {
 
182
"00;", "01;", "02;", "03;", "04;", "05;", NULL };
 
183
 
 
184
//==============================================================================
 
185
 
 
186
static const char *TS990_PSK_filt[] = {
 
187
"50",   "80",  "100",  "150", "200", "250",  "300",  "400",  "500", "600",
 
188
"1000", "1500", NULL};
 
189
 
 
190
static const char *TS990_CAT_PSK_filt[] = {
 
191
"00;", "01;", "02;", "03;", "04;",
 
192
"05;", "06;", "07;", "08;", "09;",
 
193
"10;", "11;", NULL };
 
194
 
 
195
//==============================================================================
 
196
 
 
197
static GUI rig_widgets[]= {
 
198
        { (Fl_Widget *)btnVol,        2, 125,  50 },
 
199
        { (Fl_Widget *)sldrVOLUME,   54, 125, 156 },
 
200
        { (Fl_Widget *)sldrRFGAIN,   54, 145, 156 },
 
201
        { (Fl_Widget *)btnIFsh,     214, 105,  50 },
 
202
        { (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 },
 
203
        { (Fl_Widget *)btnNotch,    214, 125,  50 },
 
204
        { (Fl_Widget *)sldrNOTCH,   266, 125, 156 },
 
205
        { (Fl_Widget *)sldrMICGAIN, 266, 145, 156 },
 
206
        { (Fl_Widget *)sldrPOWER,   266, 165, 156 },
 
207
        { (Fl_Widget *)btnNR,         2, 165,  50 },
 
208
        { (Fl_Widget *)sldrNR,       54, 165, 156 },
 
209
        { (Fl_Widget *)NULL,          0,   0,   0 }
 
210
};
 
211
 
 
212
static string menu_0001;
 
213
 
 
214
void RIG_TS990::initialize()
 
215
{
 
216
        rig_widgets[0].W = btnVol;
 
217
        rig_widgets[1].W = sldrVOLUME;
 
218
        rig_widgets[2].W = sldrRFGAIN;
 
219
        rig_widgets[3].W = btnIFsh;
 
220
        rig_widgets[4].W = sldrIFSHIFT;
 
221
        rig_widgets[5].W = btnNotch;
 
222
        rig_widgets[6].W = sldrNOTCH;
 
223
        rig_widgets[7].W = sldrMICGAIN;
 
224
        rig_widgets[8].W = sldrPOWER;
 
225
        rig_widgets[9].W = btnNR;
 
226
        rig_widgets[10].W = sldrNR;
 
227
 
 
228
        RIG_DEBUG = true;
 
229
 
 
230
        cmd = "AC000;";
 
231
        sendCommand(cmd);
 
232
 
 
233
        cmd = "EX00100;";
 
234
        if (waitN(11, 100, "read ex 00100", ASC) == 11)
 
235
                menu_0001 = replystr;
 
236
        cmd = "EX00100 00"; // turn off beeps
 
237
        sendCommand(cmd);
 
238
 
 
239
        selectA();
 
240
        get_preamp();
 
241
        get_attenuator();
 
242
 
 
243
        read_menu_0607();
 
244
        read_menu_0608();
 
245
        menu_0607 = false;
 
246
        menu_0608 = true;
 
247
        set_menu_0607(false); // SSB uses lower/upper cutoff frequencies
 
248
        set_menu_0608(true);  // SSB data uses shift/width frequencies
 
249
 
 
250
        A_default_SH_WI = 0x9005;
 
251
        A_default_SH_WI_D1 = 0x8E05;
 
252
        A_default_SH_WI_D2 = 0x8A05;
 
253
        A_default_SH_WI_D3 = 0x8805;
 
254
        A_default_HI_LO = 0x8A03;
 
255
        A_default_FM = 0x8C05;
 
256
        A_default_FM_D1 = 0x8903;
 
257
        A_default_FM_D2 = 0x8707;
 
258
        A_default_FM_D3 = 0x850B;
 
259
        A_default_CW = 0x8810;
 
260
        A_default_AM = 0x8201;
 
261
        A_default_AM_D1 = 0x8202;
 
262
        A_default_AM_D2 = 0x8102;
 
263
        A_default_AM_D3 = 0x8002;
 
264
        A_default_FSK = 0x0001;
 
265
        A_default_PSK = 0x0006;
 
266
 
 
267
        B_default_SH_WI = 0x9005;
 
268
        B_default_SH_WI_D1 = 0x8E05;
 
269
        B_default_SH_WI_D2 = 0x8A05;
 
270
        B_default_SH_WI_D3 = 0x8805;
 
271
        B_default_HI_LO = 0x8A03;
 
272
        B_default_FM = 0x8C05;
 
273
        B_default_FM_D1 = 0x8903;
 
274
        B_default_FM_D2 = 0x8707;
 
275
        B_default_FM_D3 = 0x850B;
 
276
        B_default_CW = 0x8810;
 
277
        B_default_AM = 0x8201;
 
278
        B_default_AM_D1 = 0x8202;
 
279
        B_default_AM_D2 = 0x8102;
 
280
        B_default_AM_D3 = 0x8002;
 
281
        B_default_FSK = 0x0001;
 
282
        B_default_PSK = 0x0006;
 
283
}
 
284
 
 
285
void RIG_TS990::shutdown()
 
286
{
 
287
        set_menu_0607(save_menu_0607);
 
288
        set_menu_0608(save_menu_0608);
 
289
        cmd = menu_0001; // restore beep level
 
290
        sendCommand(cmd);
 
291
}
 
292
 
 
293
//==============================================================================
 
294
 
 
295
RIG_TS990::RIG_TS990() {
 
296
 
 
297
        name_ = TS990name_;
 
298
        modes_ = TS990modes_;
 
299
 
 
300
        B.freq = A.freq = 14107500;
 
301
 
 
302
        A.imode = USB;
 
303
        A.iBW = A_default_HI_LO;
 
304
        B.imode = USB;
 
305
        B.iBW = B_default_HI_LO;
 
306
 
 
307
        bandwidths_ = TS990_filt_hi;
 
308
 
 
309
        dsp_lo     = TS990_filt_lo;
 
310
        lo_tooltip = TS990_filt_lo_tooltip;
 
311
        lo_label   = TS990_filt_lo_label;
 
312
 
 
313
        dsp_hi     = TS990_filt_hi;
 
314
        hi_tooltip = TS990_filt_hi_label;
 
315
        hi_label   = TS990_filt_hi_label;
 
316
 
 
317
        widgets = rig_widgets;
 
318
 
 
319
        comm_baudrate = BR115200;
 
320
        stopbits = 1;
 
321
        comm_retries = 2;
 
322
        comm_wait = 5;
 
323
        comm_timeout = 50;
 
324
        comm_rtscts = true;
 
325
        comm_rtsplus = false;
 
326
        comm_dtrplus = false;
 
327
        comm_catptt = true;
 
328
        comm_rtsptt = false;
 
329
        comm_dtrptt = false;
 
330
 
 
331
        can_change_alt_vfo = true;
 
332
 
 
333
        nb_level = 1;
 
334
 
 
335
        has_auto_notch =
 
336
        has_notch_control =
 
337
        has_sql_control =
 
338
        has_swr_control =
 
339
        has_noise_reduction =
 
340
        has_noise_reduction_control =
 
341
        has_alc_control =
 
342
        has_dsp_controls =
 
343
        has_smeter =
 
344
        has_power_out =
 
345
        has_split =
 
346
        has_split_AB =
 
347
        has_noise_control =
 
348
        has_micgain_control =
 
349
        has_rf_control =
 
350
        has_volume_control =
 
351
        has_power_control =
 
352
        has_tune_control =
 
353
        has_attenuator_control =
 
354
        has_preamp_control =
 
355
        has_mode_control =
 
356
        has_bandwidth_control =
 
357
        has_ifshift_control =
 
358
        has_ptt_control = true;
 
359
 
 
360
        rxtxa = true;
 
361
 
 
362
        precision = 1;
 
363
        ndigits = 8;
 
364
}
 
365
 
 
366
//==============================================================================
 
367
 
 
368
void RIG_TS990::selectA()
 
369
{
 
370
        cmd = "CB0;";
 
371
        sendCommand(cmd, 0);
 
372
        showresp(INFO, ASC, "Rx A, Tx A", cmd, replystr);
 
373
        rxtxa = true;
 
374
        get_attenuator();
 
375
        get_preamp();
 
376
        get_smeter();
 
377
        get_power_out();
 
378
        get_volume_control();
 
379
        get_rf_gain();
 
380
        get_noise_reduction_val();
 
381
        get_auto_notch();
 
382
        get_agc();
 
383
}
 
384
 
 
385
void RIG_TS990::selectB()
 
386
{
 
387
        cmd = "CB1;";
 
388
        sendCommand(cmd, 0);
 
389
        showresp(INFO, ASC, "Rx B, Tx B", cmd, replystr);
 
390
        rxtxa = false;
 
391
        get_attenuator();
 
392
        get_preamp();
 
393
        get_smeter();
 
394
        get_power_out();
 
395
        get_volume_control();
 
396
        get_rf_gain();
 
397
        get_noise_reduction_val();
 
398
        get_auto_notch();
 
399
        get_agc();
 
400
}
 
401
 
 
402
//==============================================================================
 
403
//  Get Attenuator
 
404
//  The TS990 actually has 4 attenuator settings.
 
405
//  RA00; = Off,  RA01; = 6dB,  RA02; = 12dB,  RA03; = 18dB
 
406
//==============================================================================
 
407
 
 
408
void RIG_TS990::set_attenuator(int val) {
 
409
 
 
410
        if (useB) {
 
411
                if (att_level == 0) {                   // If attenuator level = 0 (off)
 
412
                        att_level = 1;                          // then turn it on, at 6dB
 
413
                        cmd = "RA11;";                          // this is the command...
 
414
                        atten_label("Att 6", true);     // show it in the button...
 
415
                }
 
416
                else if (att_level == 1) {              // If attenuator level = 1 (6dB)
 
417
                        att_level = 2;                          // then make it 12dB
 
418
                        cmd = "RA12;";
 
419
                        atten_label("Att 12", true);
 
420
                } else if (att_level == 2) {            // if it's 12dB
 
421
                        att_level = 3;                          // go to 18dB
 
422
                        cmd = "RA13;";
 
423
                        atten_label("Att 18", true);
 
424
                } else if (att_level == 3) {            // If it's 18dB
 
425
                        att_level = 0;                          // Loop back to none.
 
426
                        cmd = "RA10;";
 
427
                        atten_label("Att", false);
 
428
                }
 
429
                sendCommand(cmd);
 
430
                showresp(INFO, ASC, "set Att B", cmd, replystr);
 
431
 
 
432
        } else {
 
433
                if (att_level == 0) {
 
434
                        att_level = 1;
 
435
                        cmd = "RA01;";
 
436
                        atten_label("Att 6", true);
 
437
                }
 
438
                else if (att_level == 1) {
 
439
                        att_level = 2;
 
440
                        cmd = "RA02;";
 
441
                        atten_label("Att 12", true);
 
442
                } else if (att_level == 2) {
 
443
                        att_level = 3;
 
444
                        cmd = "RA03;";
 
445
                        atten_label("Att 18", true);
 
446
                } else if (att_level == 3) {
 
447
                        att_level = 0;
 
448
                        cmd = "RA00;";
 
449
                        atten_label("Att", false);
 
450
                }
 
451
                sendCommand(cmd);
 
452
                showresp(INFO, ASC, "set Att A", cmd, replystr);
 
453
        }
 
454
}
 
455
 
 
456
//==============================================================================
 
457
//  Modified to read and show the actual radio setting, in the button.
 
458
//==============================================================================
 
459
int RIG_TS990::get_attenuator() {
 
460
 
 
461
        if (useB) {
 
462
                cmd = "RA1;";
 
463
                int ret = sendCommand(cmd);
 
464
                showresp(INFO, ASC, "get Att B", cmd, replystr);
 
465
                if (ret < 5) return att_on;
 
466
                size_t p = replystr.rfind("RA");
 
467
                if (p == string::npos) return att_on;
 
468
 
 
469
                if (replystr[p + 2] == '1' && replystr[p + 3] == '0') {
 
470
                        att_on = 0;                                             // Attenuator is OFF
 
471
                        att_level = 0;                                  // remember it...
 
472
                        atten_label("Att", false);              // show it...
 
473
                } else if (replystr[p + 2] == '1' && replystr[p + 3] == '1') {
 
474
                        att_on = 1;                                             // Attenuator is ON, 6dB
 
475
                        att_level = 1;                                  // remember the level
 
476
                        atten_label("Att 6", true);             // show it...
 
477
                } else if (replystr[p + 2] == '1' && replystr[p + 3] == '2') {
 
478
                        att_on = 1;                                             // .. still ON, 12dB
 
479
                        att_level = 2;                                  // remember this level
 
480
                        atten_label("Att 12", true);    // show it.
 
481
                } else if (replystr[p + 2] == '1' && replystr[p + 3] == '3') {
 
482
                        att_on = 1;                                             // .. still ON 18dB
 
483
                        att_level = 3;                                  // remember...
 
484
                        atten_label("Att 18", true);    // show this too..
 
485
                }
 
486
        } else {
 
487
                cmd = "RA0;";
 
488
                int ret = sendCommand(cmd);
 
489
                showresp(INFO, ASC, "get Att A", cmd, replystr);
 
490
                if (ret < 5) return att_on;
 
491
                size_t p = replystr.rfind("RA");
 
492
                if (p == string::npos) return att_on;
 
493
 
 
494
                if (replystr[p + 2] == '0' && replystr[p + 3] == '0') {
 
495
                        att_on = 0;
 
496
                        att_level = 0;
 
497
                        atten_label("Att", false);
 
498
                } else if (replystr[p + 2] == '0' && replystr[p + 3] == '1') {
 
499
                        att_on = 1;
 
500
                        att_level = 1;
 
501
                        atten_label("Att 6", true);
 
502
                } else if (replystr[p + 2] == '0' && replystr[p + 3] == '2') {
 
503
                        att_on = 1;
 
504
                        att_level = 2;
 
505
                        atten_label("Att 12", true);
 
506
                } else if (replystr[p + 2] == '0' && replystr[p + 3] == '3') {
 
507
                        att_on = 1;
 
508
                        att_level = 3;
 
509
                        atten_label("Att 18", true);
 
510
                }
 
511
        }
 
512
        return att_on;
 
513
}
 
514
 
 
515
 
 
516
//==============================================================================
 
517
//Get PreAmp
 
518
//==============================================================================
 
519
 
 
520
void RIG_TS990::set_preamp(int val)
 
521
{
 
522
 
 
523
        if (useB) {
 
524
                preamp_level = val;
 
525
                if (val) cmd = "PA11;";
 
526
                else     cmd = "PA10;";
 
527
                sendCommand(cmd, 0);
 
528
        } else {
 
529
                preamp_level = val;
 
530
                if (val) cmd = "PA01;";
 
531
                else     cmd = "PA00;";
 
532
                sendCommand(cmd, 0);
 
533
        }
 
534
        showresp(INFO, ASC, "set preamp", cmd, replystr);
 
535
}
 
536
 
 
537
int RIG_TS990::get_preamp()
 
538
{
 
539
        if (useB) {
 
540
                cmd = "PA1;";
 
541
                int ret = waitN(5, 20, "get preamp", ASC);
 
542
                if (ret < 5) return 0;
 
543
                size_t p = replystr.rfind("PA");
 
544
                if (p == string::npos) return 0;
 
545
 
 
546
                if (replystr[p  + 3] == '1')
 
547
                        preamp_level = 1;
 
548
                else
 
549
                        preamp_level = 0;
 
550
 
 
551
        } else {
 
552
                cmd = "PA0;";
 
553
                int ret = waitN(5, 20, "get preamp", ASC);
 
554
                if (ret < 5) return 0;
 
555
                size_t p = replystr.rfind("PA");
 
556
                if (p == string::npos) return 0;
 
557
 
 
558
                if (replystr[p  + 3] == '1')
 
559
                        preamp_level = 1;
 
560
                else
 
561
                        preamp_level = 0;
 
562
        }
 
563
 
 
564
        return preamp_level;
 
565
}
 
566
 
 
567
//==============================================================================
 
568
 
 
569
void RIG_TS990::set_split(bool val)
 
570
{
 
571
        split = val;
 
572
        if (useB) {
 
573
                if (val) {
 
574
                        cmd = "MV10;TB0;";
 
575
                        sendCommand(cmd);
 
576
                        showresp(INFO, ASC, "Rx on B, Tx on A", cmd, replystr);
 
577
                } else {
 
578
                        cmd = "MV10;TB1;";
 
579
                        sendCommand(cmd);
 
580
                        showresp(INFO, ASC, "Rx on B, Tx on B", cmd, replystr);
 
581
                }
 
582
        } else {
 
583
                if (val) {
 
584
                        cmd = "MV00;TB1;";
 
585
                        sendCommand(cmd);
 
586
                        showresp(INFO, ASC, "Rx on A, Tx on B", cmd, replystr);
 
587
                } else {
 
588
                        cmd = "MV00;TB0;";
 
589
                        sendCommand(cmd);
 
590
                        showresp(INFO, ASC, "Rx on A, Tx on A", cmd, replystr);
 
591
                }
 
592
        }
 
593
        Fl::awake(highlight_vfo, (void *)0);
 
594
}
 
595
 
 
596
 
 
597
int RIG_TS990::get_split()
 
598
{
 
599
        size_t p;
 
600
        int split = 0;
 
601
        char rx, tx;
 
602
// tx vfo
 
603
        cmd = rsp = "TB";
 
604
        cmd.append(";");
 
605
        waitN(4, 20, "get split tx vfo", ASC);
 
606
        p = replystr.rfind(rsp);
 
607
        if (p == string::npos) return split;
 
608
        tx = replystr[p+2];
 
609
 
 
610
// rx vfo
 
611
        cmd = rsp = "CB";
 
612
        cmd.append(";");
 
613
        waitN(4, 20, "get split rx vfo", ASC);
 
614
 
 
615
        p = replystr.rfind(rsp);
 
616
        if (p == string::npos) return split;
 
617
        rx = replystr[p+2];
 
618
 //split test
 
619
        split = (tx == '1' ? 2 : 0) + (rx == '1' ? 1 : 0);
 
620
 
 
621
        return split;
 
622
}
 
623
 
 
624
//==============================================================================
 
625
const char * RIG_TS990::get_bwname_(int n, int md)
 
626
{
 
627
        static char bwname[20];
 
628
        if (n > 256) {
 
629
                int hi = (n >> 8) & 0x7F;
 
630
                int lo = n & 0x7F;
 
631
                snprintf(bwname, sizeof(bwname), "%s/%s",
 
632
                        (md == LSB || md == USB || md == FM) ? TS990_filt_lo[lo] :
 
633
                        (md == AM || md == AMD1 || md == AMD2 || md == AMD3) ? TS990_AM_lo[lo] :
 
634
                        (md == CW ||md == CWR) ? TS990_CAT_CW_width [lo]:
 
635
                        (md == FSK ||md == FSKR) ? TS990_FSK_filt [lo]:
 
636
                        (md == PSK ||md == PSKR) ? TS990_PSK_filt [lo]:
 
637
                        TS990_filt_shift[lo],
 
638
                        (md == LSB || md == USB || md == FM) ? TS990_filt_hi[hi] :
 
639
                        (md == AM || md == AMD1 || md == AMD2 || md == AMD3) ? TS990_AM_hi[hi] :
 
640
                        (md == CW ||md == CWR) ? TS990_CAT_CW_shift [hi]:
 
641
                        (md == FSK ||md == FSKR) ? TS990_FSK_filt [hi]:
 
642
                        (md == PSK ||md == PSKR) ? TS990_PSK_filt [hi]:
 
643
                        TS990_filt_width[hi] );
 
644
        }
 
645
        return bwname;
 
646
}
 
647
 
 
648
//==============================================================================
 
649
// Get/Set VFO for A and B
 
650
//==============================================================================
 
651
 
 
652
long RIG_TS990::get_vfoA ()
 
653
{
 
654
        cmd = "FA;";
 
655
        int ret = waitN(14, 20, "get vfoA", ASC);
 
656
 
 
657
        if (ret < 14) return A.freq;
 
658
        size_t p = replystr.rfind("FA");
 
659
        if (p == string::npos) return A.freq;
 
660
 
 
661
        long f = 0L;
 
662
        long mul = 1L;
 
663
        for (size_t n = 12; n > 1; n--) {
 
664
                f += (replystr[p + n] - '0') * mul;
 
665
                mul *= 10;
 
666
        }
 
667
        A.freq = f;
 
668
        return A.freq;
 
669
}
 
670
 
 
671
void RIG_TS990::set_vfoA (long freq)
 
672
{
 
673
        A.freq = freq;
 
674
        cmd = "FA00000000000;";
 
675
        for (int i = 12; i > 1; i--) {
 
676
                cmd[i] += freq % 10;
 
677
                freq /= 10;
 
678
        }
 
679
        sendCommand(cmd, 0);
 
680
        showresp(INFO, ASC, "set vfo A", cmd, replystr);
 
681
}
 
682
 
 
683
long RIG_TS990::get_vfoB ()
 
684
{
 
685
        cmd = "FB;";
 
686
        int ret = waitN(14, 20, "get vfoB", ASC);
 
687
 
 
688
        if (ret < 14) return B.freq;
 
689
        size_t p = replystr.rfind("FB");
 
690
        if (p == string::npos) return B.freq;
 
691
 
 
692
        long f = 0L;
 
693
        long mul = 1L;
 
694
        for (size_t n = 12; n > 1; n--) {
 
695
                f += (replystr[p + n] - '0') * mul;
 
696
                mul *= 10;
 
697
        }
 
698
        B.freq = f;
 
699
 
 
700
        return B.freq;
 
701
}
 
702
 
 
703
void RIG_TS990::set_vfoB (long freq)
 
704
{
 
705
        B.freq = freq;
 
706
        cmd = "FB00000000000;";
 
707
        for (int i = 12; i > 1; i--) {
 
708
                cmd[i] += freq % 10;
 
709
                freq /= 10;
 
710
        }
 
711
        sendCommand(cmd, 0);
 
712
        showresp(INFO, ASC, "set vfo B", cmd, replystr);
 
713
}
 
714
 
 
715
//==============================================================================
 
716
// Smeter reading
 
717
//==============================================================================
 
718
 
 
719
int RIG_TS990::get_smeter()
 
720
{
 
721
        if (useB) {
 
722
                int mtr = 0;
 
723
                cmd = "SM1;";
 
724
                int ret = waitN(8, 20, "get", ASC);
 
725
                if (ret < 8) return 0;
 
726
                size_t p = replystr.find("SM1");
 
727
                if (p == string::npos) return 0;
 
728
                replystr[p + 7] = 0;
 
729
                mtr = atoi(&replystr[p + 3]);
 
730
                mtr *= 50;
 
731
                mtr /= 15;
 
732
                if (mtr > 100) mtr = 100;
 
733
                return mtr;
 
734
        } else {
 
735
                int mtr = 0;
 
736
                cmd = "SM0;";
 
737
                int ret = waitN(8, 20, "get", ASC);
 
738
                if (ret < 8) return 0;
 
739
                size_t p = replystr.find("SM0");
 
740
                if (p == string::npos) return 0;
 
741
                replystr[p + 7] = 0;
 
742
                mtr = atoi(&replystr[p + 3]);
 
743
                mtr *= 50;
 
744
                mtr /= 15;
 
745
                if (mtr > 100) mtr = 100;
 
746
                return mtr;
 
747
        }
 
748
}
 
749
 
 
750
//==============================================================================
 
751
// Power out reading
 
752
//==============================================================================
 
753
 
 
754
int RIG_TS990::get_power_out()
 
755
{
 
756
        if (useB) {
 
757
                int mtr = 0;
 
758
                cmd = "SM1;";
 
759
                int ret = waitN(8, 20, "get power", ASC);
 
760
                if (ret < 8) return mtr;
 
761
                size_t p = replystr.rfind("SM1");
 
762
                if (p == string::npos) return mtr;
 
763
 
 
764
                mtr = atoi(&replystr[p + 3]);
 
765
                mtr *= 50;
 
766
                mtr /= 18;
 
767
                if (mtr > 200) mtr = 200;
 
768
                return mtr;
 
769
        } else {
 
770
                int mtr = 0;
 
771
                cmd = "SM0;";
 
772
                int ret = waitN(8, 20, "get power", ASC);
 
773
                if (ret < 8) return mtr;
 
774
                size_t p = replystr.rfind("SM0");
 
775
                if (p == string::npos) return mtr;
 
776
                mtr = atoi(&replystr[p + 3]);
 
777
                mtr *= 50;
 
778
                mtr /= 18;
 
779
                if (mtr > 200) mtr = 200;
 
780
                return mtr;
 
781
        }
 
782
}
 
783
 
 
784
//==============================================================================
 
785
// ALC, SWR readings
 
786
//==============================================================================
 
787
 
 
788
static bool read_alc = false;
 
789
static int alc_val = 0;
 
790
 
 
791
int RIG_TS990::get_swr(void)
 
792
{
 
793
 
 
794
        int mtr = 0;
 
795
 
 
796
        read_alc = false;
 
797
 
 
798
        cmd = "RM;";
 
799
        int ret = waitN(16, 20, "get swr/alc", ASC);
 
800
        if (ret < 16) return 0;
 
801
 
 
802
        size_t p = replystr.find("RM1");
 
803
        if (p != string::npos) {
 
804
                replystr[p + 7] = 0;
 
805
                alc_val = atoi(&replystr[p + 3]);
 
806
                alc_val *= 100;
 
807
                alc_val /= 15;
 
808
                if (alc_val > 100) alc_val = 100;
 
809
                read_alc = true;
 
810
        }
 
811
 
 
812
        p = replystr.find("RM2");
 
813
        if (p == string::npos) return 0;
 
814
 
 
815
        replystr[p + 7] = 0;
 
816
        mtr = atoi(&replystr[p + 3]);
 
817
        mtr *= 50;
 
818
        mtr /= 15;
 
819
        if (mtr > 100) mtr = 100;
 
820
 
 
821
        return mtr;
 
822
}
 
823
 
 
824
int RIG_TS990::get_alc(void)
 
825
{
 
826
        if (read_alc) {
 
827
                read_alc = false;
 
828
                return alc_val;
 
829
        }
 
830
        cmd = "RM;";
 
831
        int ret = waitN(8, 20, "get alc", ASC);
 
832
        if (ret < 8) return 0;
 
833
 
 
834
        size_t p = replystr.find("RM1");
 
835
        if (p == string::npos) return 0;
 
836
 
 
837
        replystr[p + 7] = 0;
 
838
        alc_val = atoi(&replystr[p + 3]);
 
839
        alc_val *= 100;
 
840
        alc_val /= 15;
 
841
        if (alc_val > 100) alc_val = 100;
 
842
        return alc_val;
 
843
}
 
844
 
 
845
//==============================================================================
 
846
// Transceiver power level
 
847
//==============================================================================
 
848
 
 
849
void RIG_TS990::set_power_control(double val)
 
850
{
 
851
        int ival = (int)val;
 
852
        cmd = "PC000;";
 
853
        for (int i = 4; i > 1; i--) {
 
854
                cmd[i] += ival % 10;
 
855
                ival /= 10;
 
856
        }
 
857
        sendCommand(cmd, 0);
 
858
}
 
859
 
 
860
int RIG_TS990::get_power_control()
 
861
{
 
862
        cmd = "PC;";
 
863
        int ret = waitN(6, 20, "get pwr ctrl", ASC);
 
864
 
 
865
        if (ret < 6) return 0;
 
866
        size_t p = replystr.rfind("PC");
 
867
        if (p == string::npos) return 0;
 
868
        int mtr = 0;
 
869
        if (ret >= 6) {
 
870
                replystr[p + 5] = 0;
 
871
                        mtr = atoi(&replystr[p + 2]);
 
872
 
 
873
        }
 
874
        return mtr;
 
875
}
 
876
 
 
877
//==============================================================================
 
878
// Volume control return 0 ... 100
 
879
//==============================================================================
 
880
 
 
881
int RIG_TS990::get_volume_control()
 
882
{
 
883
        if (useB) {
 
884
 
 
885
        cmd = "AG1;";
 
886
        int ret = waitN(7, 20, "get vol ctrl", ASC);
 
887
 
 
888
        if (ret < 7) return 0;
 
889
        size_t p = replystr.rfind("AG");
 
890
        if (p == string::npos) return 0;
 
891
 
 
892
        replystr[p + 6] = 0;
 
893
        int val = atoi(&replystr[p + 3]);
 
894
        return (int)(val / 2.55);
 
895
 
 
896
        } else {
 
897
 
 
898
        cmd = "AG0;";
 
899
        int ret = waitN(7, 20, "get vol ctrl", ASC);
 
900
 
 
901
        if (ret < 7) return 0;
 
902
        size_t p = replystr.rfind("AG");
 
903
        if (p == string::npos) return 0;
 
904
 
 
905
        replystr[p + 6] = 0;
 
906
        int val = atoi(&replystr[p + 3]);
 
907
        return (int)(val / 2.55);
 
908
        }
 
909
 
 
910
}
 
911
 
 
912
void RIG_TS990::set_volume_control(int val)
 
913
{
 
914
        if (useB) {
 
915
 
 
916
        int ivol = (int)(val * 2.55);
 
917
        cmd = "AG1000;";
 
918
        for (int i = 5; i > 2; i--) {
 
919
                cmd[i] += ivol % 10;
 
920
                ivol /= 10;
 
921
        }
 
922
        sendCommand(cmd, 0);
 
923
 
 
924
        } else {
 
925
 
 
926
        int ivol = (int)(val * 2.55);
 
927
        cmd = "AG0000;";
 
928
        for (int i = 5; i > 2; i--) {
 
929
                cmd[i] += ivol % 10;
 
930
                ivol /= 10;
 
931
        }
 
932
        sendCommand(cmd, 0);
 
933
        }
 
934
}
 
935
 
 
936
//==============================================================================
 
937
// Tranceiver PTT on/off
 
938
//==============================================================================
 
939
 
 
940
void RIG_TS990::set_PTT_control(int val)
 
941
{
 
942
        if (val) {
 
943
                if (data_mode)
 
944
                        cmd = "TX1;";
 
945
                else
 
946
                        cmd = "TX0;";
 
947
        } else
 
948
                cmd = "RX;";
 
949
        sendCommand(cmd, 0);
 
950
}
 
951
 
 
952
//==============================================================================
 
953
// Transceiver Tune
 
954
//==============================================================================
 
955
 
 
956
void RIG_TS990::tune_rig()
 
957
{
 
958
        cmd = "AC111;";
 
959
        sendCommand(cmd, 0);
 
960
}
 
961
 
 
962
//==============================================================================
 
963
// Mode A / B
 
964
//==============================================================================
 
965
 
 
966
void RIG_TS990::set_modeA(int val)
 
967
{
 
968
        active_mode = A.imode = val;
 
969
        cmd = "OM0";
 
970
        cmd += TS990_mode_chr[val];
 
971
        cmd += ';';
 
972
        sendCommand(cmd, 0);
 
973
        showresp(INFO, ASC, "set mode main band", cmd, replystr);
 
974
        set_widths(val);
 
975
        get_bwA();
 
976
}
 
977
 
 
978
int RIG_TS990::get_modeA()
 
979
{
 
980
        int md = A.imode;
 
981
        cmd = "OM0;";
 
982
        int ret = waitN(5, 20, "get mode main band", ASC);
 
983
        if (ret < 5) return A.imode;
 
984
        size_t p = replystr.rfind("OM");
 
985
        if (p == string::npos) return A.imode;
 
986
 
 
987
// this switch statement can be replaced with
 
988
// md = replystr[p+3] - 1;
 
989
// if (md < LSB) md = LSB;
 
990
// if (md > AMD3) md = AMD3;
 
991
 
 
992
        switch (replystr[p + 3]) {
 
993
                case '1' : md = LSB; break;
 
994
                case '2' : md = USB; break;
 
995
                case '3' : md = CW; break;
 
996
                case '4' : md = FM; break;
 
997
                case '5' : md = AM; break;
 
998
                case '6' : md = FSK; break;
 
999
                case '7' : md = CWR; break;
 
1000
                case '9' : md = FSKR; break;
 
1001
                case 'A' : md = PSK; break;
 
1002
                case 'B' : md = PSKR; break;
 
1003
                case 'C' : md = LSBD1; break;
 
1004
                case 'D' : md = USBD1; break;
 
1005
                case 'E' : md = FMD1; break;
 
1006
                case 'F' : md = AMD1; break;
 
1007
                case 'G' : md = LSBD2; break;
 
1008
                case 'H' : md = USBD2; break;
 
1009
                case 'I' : md = FMD2; break;
 
1010
                case 'J' : md = AMD2; break;
 
1011
                case 'K' : md = LSBD3; break;
 
1012
                case 'L' : md = USBD3; break;
 
1013
                case 'M' : md = FMD3; break;
 
1014
                case 'N' : md = AMD3; break;
 
1015
                default : md = A.imode;
 
1016
        }
 
1017
        if (md != A.imode) {
 
1018
                active_mode = A.imode = md;
 
1019
                set_widths(md);
 
1020
        }
 
1021
        get_agc();
 
1022
        return A.imode;
 
1023
}
 
1024
 
 
1025
void RIG_TS990::set_modeB(int val)
 
1026
{
 
1027
        active_mode = B.imode = val;
 
1028
        cmd = "OM1";
 
1029
        cmd += TS990_mode_chr[val];
 
1030
        cmd += ';';
 
1031
        sendCommand(cmd, 0);
 
1032
        showresp(INFO, ASC, "set mode sub band", cmd, replystr);
 
1033
        set_widths(val);
 
1034
        get_bwB();
 
1035
}
 
1036
 
 
1037
int RIG_TS990::get_modeB()
 
1038
{
 
1039
 
 
1040
        int md = B.imode;
 
1041
        cmd = "OM1;";
 
1042
        int ret = waitN(5, 20, "get mode sub band", ASC);
 
1043
 
 
1044
        if (ret < 5) return B.imode;
 
1045
        size_t p = replystr.rfind("OM");
 
1046
        if (p == string::npos) return B.imode;
 
1047
 
 
1048
// this switch statement can be replaced with
 
1049
// md = replystr[p+3] - 1;
 
1050
// if (md < LSB) md = LSB;
 
1051
// if (md > AMD3) md = AMD3;
 
1052
 
 
1053
        switch (replystr[p + 3]) {
 
1054
                case '1' : md = LSB; break;
 
1055
                case '2' : md = USB; break;
 
1056
                case '3' : md = CW; break;
 
1057
                case '4' : md = FM; break;
 
1058
                case '5' : md = AM; break;
 
1059
                case '6' : md = FSK; break;
 
1060
                case '7' : md = CWR; break;
 
1061
                case '9' : md = FSKR; break;
 
1062
                case 'A' : md = PSK; break;
 
1063
                case 'B' : md = PSKR; break;
 
1064
                case 'C' : md = LSBD1; break;
 
1065
                case 'D' : md = USBD1; break;
 
1066
                case 'E' : md = FMD1; break;
 
1067
                case 'F' : md = AMD1; break;
 
1068
                case 'G' : md = LSBD2; break;
 
1069
                case 'H' : md = USBD2; break;
 
1070
                case 'I' : md = FMD2; break;
 
1071
                case 'J' : md = AMD2; break;
 
1072
                case 'K' : md = LSBD3; break;
 
1073
                case 'L' : md = USBD3; break;
 
1074
                case 'M' : md = FMD3; break;
 
1075
                case 'N' : md = AMD3; break;
 
1076
                default : md = B.imode;
 
1077
        }
 
1078
        if (md != B.imode) {
 
1079
                active_mode = B.imode = md;
 
1080
                set_widths(md);
 
1081
        }
 
1082
        get_agc();
 
1083
        return B.imode;
 
1084
}
 
1085
 
 
1086
//==============================================================================
 
1087
// Microphone gain
 
1088
//==============================================================================
 
1089
 
 
1090
void RIG_TS990::set_mic_gain(int val)
 
1091
{
 
1092
        cmd = "MG000;";
 
1093
        for (int i = 3; i > 0; i--) {
 
1094
                cmd[1+i] += val % 10;
 
1095
                val /= 10;
 
1096
        }
 
1097
        sendCommand(cmd, 0);
 
1098
}
 
1099
 
 
1100
int RIG_TS990::get_mic_gain()
 
1101
{
 
1102
        int val = 0;
 
1103
        cmd = "MG;";
 
1104
        int ret = waitN(6, 20, "get mic ctrl", ASC);
 
1105
 
 
1106
        if (ret >= 6) {
 
1107
                size_t p = replystr.rfind("MG");
 
1108
                if (p == string::npos) return val;
 
1109
                replystr[p + 5] = 0;
 
1110
                val = atoi(&replystr[p + 2]);
 
1111
        }
 
1112
        return val;
 
1113
}
 
1114
 
 
1115
void RIG_TS990::get_mic_min_max_step(int &min, int &max, int &step)
 
1116
{
 
1117
        min = 0;
 
1118
        max = 100;
 
1119
        step = 1;
 
1120
}
 
1121
 
 
1122
//==============================================================================
 
1123
//  Read/Write SSB and Data Mode Filter Settings
 
1124
//==============================================================================
 
1125
 
 
1126
void RIG_TS990::read_menu_0607()
 
1127
{
 
1128
        save_menu_0607 = false;
 
1129
        cmd = "EX00607;"; sendCommand(cmd);
 
1130
        int ret = waitN(12, 20, "Read menu 0607", ASC);
 
1131
        if (ret >= 12) {
 
1132
                size_t p = replystr.rfind("EX00607");
 
1133
                if (p != string::npos)
 
1134
                        save_menu_0607 = (replystr[p+10] == '1');
 
1135
        }
 
1136
}
 
1137
 
 
1138
void RIG_TS990::read_menu_0608()
 
1139
{
 
1140
        save_menu_0608 = false;
 
1141
        cmd = "EX00608;"; sendCommand(cmd);
 
1142
        int ret = waitN(12, 20, "Read menu 0608", ASC);
 
1143
        if (ret >= 12) {
 
1144
                size_t p = replystr.rfind("EX00608");
 
1145
                if (p != string::npos)
 
1146
                        save_menu_0608 = (replystr[p+10] == '1');
 
1147
        }
 
1148
}
 
1149
 
 
1150
void RIG_TS990::set_menu_0607(int val)
 
1151
{
 
1152
        menu_0607 = (val != 0);
 
1153
        cmd = "EX00607 00";
 
1154
        cmd += menu_0607 ? "1" : "0";
 
1155
        cmd += ";";
 
1156
        sendCommand(cmd, 0);
 
1157
}
 
1158
 
 
1159
void RIG_TS990::set_menu_0608(int val)
 
1160
{
 
1161
        menu_0608 = (val != 0);
 
1162
        cmd = "EX00608 00";
 
1163
        cmd += menu_0608 ? "1" : "0";
 
1164
        cmd += ";";
 
1165
        sendCommand(cmd, 0);
 
1166
}
 
1167
 
 
1168
//==============================================================================
 
1169
// Bandpass filter commands
 
1170
//==============================================================================
 
1171
 
 
1172
int RIG_TS990::set_widths(int val)
 
1173
{
 
1174
        int bw = 0;
 
1175
        if (useB) bw = B.iBW;
 
1176
        else bw = A.iBW;
 
1177
        switch (val) {
 
1178
        case LSB: case USB:
 
1179
                if (menu_0607) {
 
1180
                        bandwidths_ = TS990_filt_width;
 
1181
                        dsp_hi     = TS990_filt_width;
 
1182
                        hi_tooltip = TS990_filt_width_tooltip;
 
1183
                        hi_label   = TS990_filt_width_label;
 
1184
                        dsp_lo     = TS990_filt_shift;
 
1185
                        lo_tooltip = TS990_filt_shift_tooltip;
 
1186
                        lo_label   = TS990_filt_shift_label;
 
1187
                } else {
 
1188
                        bandwidths_ = TS990_filt_hi;
 
1189
                        dsp_lo = TS990_filt_lo;
 
1190
                        lo_tooltip = TS990_filt_lo_tooltip;
 
1191
                        lo_label   = TS990_filt_lo_label;
 
1192
                        dsp_hi = TS990_filt_hi;
 
1193
                        hi_tooltip = TS990_filt_hi_tooltip;
 
1194
                        hi_label   = TS990_filt_hi_label;
 
1195
                }
 
1196
                break;
 
1197
        case LSBD1: case LSBD2: case LSBD3:
 
1198
        case USBD1: case USBD2: case USBD3:
 
1199
                if (menu_0608) {
 
1200
                        bandwidths_ = TS990_filt_width;
 
1201
                        dsp_hi     = TS990_filt_width;
 
1202
                        hi_tooltip = TS990_filt_width_tooltip;
 
1203
                        hi_label   = TS990_filt_width_label;
 
1204
                        dsp_lo     = TS990_filt_shift;
 
1205
                        lo_tooltip = TS990_filt_shift_tooltip;
 
1206
                        lo_label   = TS990_filt_shift_label;
 
1207
                } else {
 
1208
                        bandwidths_ = TS990_filt_hi;
 
1209
                        dsp_lo = TS990_filt_lo;
 
1210
                        lo_tooltip = TS990_filt_lo_tooltip;
 
1211
                        lo_label   = TS990_filt_lo_label;
 
1212
                        dsp_hi = TS990_filt_hi;
 
1213
                        hi_tooltip = TS990_filt_hi_tooltip;
 
1214
                        hi_label   = TS990_filt_hi_label;
 
1215
                }
 
1216
                break;
 
1217
        case CW: case CWR:
 
1218
                bandwidths_ = TS990_CW_width;
 
1219
                dsp_hi = TS990_CW_width;
 
1220
                hi_tooltip = TS990_CW_W_tooltip;
 
1221
                hi_label   = TS990_CW_W_btn_label;
 
1222
                dsp_lo = TS990_CW_shift;
 
1223
                lo_tooltip = TS990_CW_S_tooltip;
 
1224
                lo_label   = TS990_CW_S_btn_label;
 
1225
                break;
 
1226
        case FSK: case FSKR:
 
1227
                bandwidths_ = TS990_FSK_filt;
 
1228
                dsp_lo = TS990_empty;
 
1229
                dsp_hi = TS990_empty;
 
1230
                break;
 
1231
        case PSK: case PSKR:
 
1232
                bandwidths_ = TS990_PSK_filt;
 
1233
                dsp_lo = TS990_empty;
 
1234
                dsp_hi = TS990_empty;
 
1235
                break;
 
1236
        case AM: case AMD1: case AMD2: case AMD3:
 
1237
                bandwidths_ = TS990_AM_hi;
 
1238
                dsp_lo = TS990_AM_lo;
 
1239
                dsp_hi = TS990_AM_hi;
 
1240
                lo_tooltip = TS990_AM_lo_tooltip;
 
1241
                lo_label   = TS990_AM_btn_lo_label;
 
1242
                hi_tooltip = TS990_AM_hi_tooltip;
 
1243
                hi_label   = TS990_AM_btn_hi_label;
 
1244
                break;
 
1245
        case FM: case FMD1: case FMD2: case FMD3:
 
1246
                bandwidths_ = TS990_filt_hi;
 
1247
                dsp_lo = TS990_filt_lo;
 
1248
                dsp_hi = TS990_filt_hi;
 
1249
                lo_tooltip = TS990_filt_lo_tooltip;
 
1250
                lo_label   = TS990_filt_lo_label;
 
1251
                hi_tooltip = TS990_filt_hi_tooltip;
 
1252
                hi_label   = TS990_filt_hi_label;
 
1253
                break;
 
1254
        }
 
1255
        return bw;
 
1256
}
 
1257
 
 
1258
 
 
1259
const char **RIG_TS990::bwtable(int m)
 
1260
{
 
1261
        const char **filter = TS990_filt_hi;
 
1262
        switch (m) {
 
1263
                case LSB: case USB:
 
1264
                        if (menu_0607)
 
1265
                                filter = TS990_filt_width;
 
1266
                        else
 
1267
                                filter = TS990_filt_hi;
 
1268
                        break;
 
1269
                 case FM: case FMD1: case FMD2: case FMD3:
 
1270
                        filter = TS990_filt_hi;
 
1271
                        break;
 
1272
                case LSBD1: case LSBD2: case LSBD3:
 
1273
                case USBD1: case USBD2: case USBD3:
 
1274
                        if (menu_0608)
 
1275
                                filter = TS990_filt_width;
 
1276
                        else
 
1277
                                filter = TS990_filt_hi;
 
1278
                        break;
 
1279
                case AM: case AMD1: case AMD2: case AMD3:
 
1280
                        filter = TS990_AM_hi;
 
1281
                        break;
 
1282
                case CW: case CWR:
 
1283
                        filter = TS990_CW_width;
 
1284
                        break;
 
1285
                case FSK: case FSKR:
 
1286
                        filter = TS990_FSK_filt;
 
1287
                        break;
 
1288
                case PSK: case PSKR:
 
1289
                        filter = TS990_PSK_filt;
 
1290
                        break;
 
1291
        }
 
1292
        return filter;
 
1293
}
 
1294
 
 
1295
const char **RIG_TS990::lotable(int m)
 
1296
{
 
1297
        const char **filter = TS990_filt_lo;
 
1298
        switch (m) {
 
1299
                case LSB: case USB:
 
1300
                        if (menu_0607)
 
1301
                                filter = TS990_filt_shift;
 
1302
                        else
 
1303
                                filter = TS990_filt_lo;
 
1304
                        break;
 
1305
                case FM: case FMD1: case FMD2: case FMD3:
 
1306
                        filter = TS990_filt_lo;
 
1307
                        break;
 
1308
                case LSBD1: case LSBD2: case LSBD3:
 
1309
                case USBD1: case USBD2: case USBD3:
 
1310
                        if (menu_0608)
 
1311
                                filter = TS990_filt_shift;
 
1312
                        else
 
1313
                                filter = TS990_filt_lo;
 
1314
                        break;
 
1315
                case CW: case CWR:
 
1316
                        filter = TS990_CW_shift;
 
1317
                        break;
 
1318
                case FSK: case FSKR:
 
1319
                        filter = TS990_FSK_filt;
 
1320
                        break;
 
1321
                case PSK: case PSKR:
 
1322
                        filter = TS990_PSK_filt;
 
1323
                        break;
 
1324
                case AM: case AMD1: case AMD2: case AMD3:
 
1325
                        filter = TS990_AM_lo;
 
1326
                        break;
 
1327
        }
 
1328
        return filter;
 
1329
}
 
1330
 
 
1331
const char **RIG_TS990::hitable(int m)
 
1332
{
 
1333
        const char **filter = TS990_filt_hi;
 
1334
        switch (m) {
 
1335
                case LSB: case USB: case FM:
 
1336
                        if (menu_0607)
 
1337
                                filter = TS990_filt_width;
 
1338
                        else
 
1339
                                filter = TS990_filt_hi;
 
1340
                        break;
 
1341
                case LSBD1: case LSBD2: case LSBD3:
 
1342
                case USBD1: case USBD2: case USBD3:
 
1343
                        if (menu_0608)
 
1344
                                filter = TS990_filt_width;
 
1345
                        else
 
1346
                                filter = TS990_filt_hi;
 
1347
                        break;
 
1348
                case CW: case CWR:
 
1349
                        filter = TS990_CW_width;
 
1350
                        break;
 
1351
                case FMD1: case FMD2: case FMD3:
 
1352
                        filter = TS990_filt_hi;
 
1353
                        break;
 
1354
                case FSK: case FSKR:
 
1355
                        filter = NULL;
 
1356
                        break;
 
1357
                case PSK: case PSKR:
 
1358
                        filter = NULL;
 
1359
                        break;
 
1360
                case AM: case AMD1: case AMD2: case AMD3:
 
1361
                        filter = TS990_AM_hi;
 
1362
                        break;
 
1363
        }
 
1364
        return filter;
 
1365
}
 
1366
 
 
1367
int RIG_TS990::adjust_bandwidth(int val)
 
1368
{
 
1369
        int retval = 0;
 
1370
        switch (val) {
 
1371
                case LSB: case USB:
 
1372
                        if (useB)
 
1373
                                retval = menu_0607 ? B_default_SH_WI : B_default_HI_LO;
 
1374
                        else
 
1375
                                retval = menu_0607 ? A_default_SH_WI : A_default_HI_LO;
 
1376
                        break;
 
1377
                case LSBD1: case USBD1: 
 
1378
                        if (useB)
 
1379
                                retval = menu_0608 ? B_default_SH_WI_D1 : B_default_HI_LO;
 
1380
                        else
 
1381
                                retval = menu_0608 ? A_default_SH_WI_D1 : A_default_HI_LO;
 
1382
                        break;
 
1383
                case LSBD2: case USBD2: 
 
1384
                        if (useB)
 
1385
                                retval = menu_0608 ? B_default_SH_WI_D2 : B_default_HI_LO;
 
1386
                        else
 
1387
                                retval = menu_0608 ? A_default_SH_WI_D2 : A_default_HI_LO;
 
1388
                        break;
 
1389
                case LSBD3: case USBD3: 
 
1390
                        if (useB)
 
1391
                                retval = menu_0608 ? B_default_SH_WI_D3 : B_default_HI_LO;
 
1392
                        else
 
1393
                                retval = menu_0608 ? A_default_SH_WI_D3 : A_default_HI_LO;
 
1394
                        break;  
 
1395
                case FM: 
 
1396
                        retval = useB ? B_default_FM : A_default_FM;
 
1397
                        break;
 
1398
                case FMD1: 
 
1399
                        retval = useB ? B_default_FM_D1 : A_default_FM_D1;
 
1400
                        break;  
 
1401
                case FMD2: 
 
1402
                        retval = useB ? B_default_FM_D2 : A_default_FM_D2;
 
1403
                        break;
 
1404
                case FMD3: 
 
1405
                        retval = useB ? B_default_FM_D3 : A_default_FM_D3;
 
1406
                        break;                          
 
1407
                case AM: 
 
1408
                        retval = useB ? B_default_AM : A_default_AM;
 
1409
                        break;
 
1410
                case AMD1: 
 
1411
                        retval = useB ? B_default_AM_D1 : A_default_AM_D1;
 
1412
                        break;
 
1413
                case AMD2: 
 
1414
                        retval = useB ? B_default_AM_D2 : A_default_AM_D2;
 
1415
                        break;
 
1416
                case AMD3: 
 
1417
                        retval = useB ? B_default_AM_D3 : A_default_AM_D3;
 
1418
                        break;                  
 
1419
                case CW: case CWR:
 
1420
                        retval = useB ? B_default_CW : A_default_CW;
 
1421
                        break;
 
1422
                case FSK: case FSKR:
 
1423
                        retval = useB ? B_default_FSK : A_default_CW;
 
1424
                        break;
 
1425
                case PSK: case PSKR:
 
1426
                        retval = useB ? B_default_PSK : A_default_PSK;
 
1427
                        break;
 
1428
                }
 
1429
        return retval;
 
1430
}
 
1431
 
 
1432
int RIG_TS990::def_bandwidth(int val)
 
1433
{
 
1434
        return adjust_bandwidth(val);
 
1435
}
 
1436
 
 
1437
void RIG_TS990::set_bwA(int val)
 
1438
{
 
1439
        size_t lo = 0, hi = 0;
 
1440
        switch (A.imode) {
 
1441
        case LSB: case USB:
 
1442
                if (val < 256) break;
 
1443
                if (menu_0607) {
 
1444
                        lo = val & 0x7F;
 
1445
                        hi = (val >> 8) & 0x7F;
 
1446
                        if (hi >= sizeof(TS990_CAT_filt_width)/sizeof(*TS990_CAT_filt_width) ||
 
1447
                                 lo >= sizeof(TS990_CAT_filt_shift)/sizeof(*TS990_CAT_filt_shift) )
 
1448
                                A.iBW = A_default_SH_WI;                
 
1449
                        else
 
1450
                                A.iBW = val;
 
1451
                        cmd = "SL0";
 
1452
                        cmd += TS990_CAT_filt_width[(A.iBW >> 8) & 0x7F];
 
1453
                        sendCommand(cmd,0);
 
1454
                        showresp(INFO, ASC, "set filter width", cmd, replystr);
 
1455
                        cmd = "SH0";
 
1456
                        cmd += TS990_CAT_filt_shift[A.iBW & 0x7F];
 
1457
                        sendCommand(cmd,0);
 
1458
                        showresp(INFO, ASC, "set filter shift", cmd, replystr);
 
1459
                } else {
 
1460
                        lo = val & 0x7F;
 
1461
                        hi = (val >> 8) & 0x7F;
 
1462
                        if (hi >= sizeof(TS990_CAT_filt_hi)/sizeof(*TS990_CAT_filt_lo) ||
 
1463
                                 lo >= sizeof(TS990_CAT_filt_lo)/sizeof(*TS990_CAT_filt_lo) )
 
1464
                                A.iBW = A_default_HI_LO;
 
1465
                        else
 
1466
                                A.iBW = val;
 
1467
                        cmd = "SL0";
 
1468
                        cmd += TS990_CAT_filt_lo[A.iBW  & 0x7F];
 
1469
                        sendCommand(cmd,0);
 
1470
                        showresp(INFO, ASC, "set filter lower cutoff", cmd, replystr);
 
1471
                        cmd = "SH0";
 
1472
                        cmd += TS990_CAT_filt_hi[(A.iBW >> 8) & 0x7F];
 
1473
                        sendCommand(cmd,0);
 
1474
                        showresp(INFO, ASC, "set filter upper cutoff", cmd, replystr);
 
1475
                }
 
1476
                break;
 
1477
 
 
1478
        case LSBD1: case LSBD2: case LSBD3:
 
1479
        case USBD1: case USBD2: case USBD3:
 
1480
                if (val < 256) break;
 
1481
                if (menu_0608) {
 
1482
                        lo = val & 0x7F;
 
1483
                        hi = (val >> 8) & 0x7F;
 
1484
                        if (hi >= sizeof(TS990_CAT_filt_width)/sizeof(*TS990_CAT_filt_width) ||
 
1485
                                 lo >= sizeof(TS990_CAT_filt_shift)/sizeof(*TS990_CAT_filt_shift) )
 
1486
                                A.iBW = A_default_SH_WI;                
 
1487
                        else
 
1488
                                A.iBW = val;
 
1489
                        cmd = "SL0";
 
1490
                        cmd += TS990_CAT_filt_width[(A.iBW >> 8) & 0x7F];
 
1491
                        sendCommand(cmd,0);
 
1492
                        showresp(INFO, ASC, "set data width", cmd, replystr);
 
1493
                        cmd = "SH0";
 
1494
                        cmd += TS990_CAT_filt_shift[A.iBW & 0x7F];
 
1495
                        sendCommand(cmd,0);
 
1496
                        showresp(INFO, ASC, "set data shift", cmd, replystr);
 
1497
                } else {
 
1498
                        lo = val & 0x7F;
 
1499
                        hi = (val >> 8) & 0x7F;
 
1500
                        if (hi >= sizeof(TS990_CAT_filt_hi)/sizeof(*TS990_CAT_filt_lo) ||
 
1501
                                 lo >= sizeof(TS990_CAT_filt_lo)/sizeof(*TS990_CAT_filt_lo) )
 
1502
                                A.iBW = A_default_HI_LO;
 
1503
                        else
 
1504
                                A.iBW = val;
 
1505
                        cmd = "SL0";
 
1506
                        cmd += TS990_CAT_filt_lo[A.iBW & 0x7F];
 
1507
                        sendCommand(cmd,0);
 
1508
                        showresp(INFO, ASC, "set data lower cutoff", cmd, replystr);
 
1509
                        cmd = "SH0";
 
1510
                        cmd += TS990_CAT_filt_hi[(A.iBW >> 8) & 0x7F];
 
1511
                        sendCommand(cmd,0);
 
1512
                        showresp(INFO, ASC, "set data upper cutoff", cmd, replystr);
 
1513
                }
 
1514
                break;
 
1515
 
 
1516
        case AM: case AMD1: case AMD2: case AMD3:
 
1517
                if (val < 256) break;
 
1518
                lo = val & 0x7F;
 
1519
                hi = (val >> 8) & 0x7F;
 
1520
                if (hi >= sizeof(TS990_CAT_AM_hi) / sizeof(*TS990_CAT_AM_hi) ||
 
1521
                        lo >= sizeof(TS990_CAT_AM_lo) / sizeof(*TS990_CAT_AM_lo) )
 
1522
                        A.iBW = A_default_AM;
 
1523
                else
 
1524
                        A.iBW = val;
 
1525
                cmd = "SL0";
 
1526
                cmd += TS990_CAT_AM_lo[A.iBW & 0x7F];
 
1527
                sendCommand(cmd,0);
 
1528
                showresp(INFO, ASC, "set AM lower", cmd, replystr);
 
1529
                cmd = "SH0";
 
1530
                cmd += TS990_CAT_AM_hi[(A.iBW >> 8) & 0x7F];
 
1531
                sendCommand(cmd,0);
 
1532
                showresp(INFO, ASC, "set AM upper", cmd, replystr);
 
1533
                break;
 
1534
 
 
1535
        case FM: case FMD1: case FMD2: case FMD3:
 
1536
                if (val < 256) break;
 
1537
                lo = val & 0x7F;
 
1538
                hi = (val >> 8) & 0x7F;
 
1539
                if (hi >= sizeof(TS990_CAT_filt_hi) / sizeof(*TS990_CAT_filt_hi) ||
 
1540
                        lo >= sizeof(TS990_CAT_filt_lo) / sizeof(*TS990_CAT_filt_lo) )
 
1541
                        A.iBW = A_default_FM;
 
1542
                else
 
1543
                        A.iBW = val;
 
1544
                cmd = "SL0";
 
1545
                cmd += TS990_CAT_filt_lo[A.iBW & 0x7F];
 
1546
                sendCommand(cmd,0);
 
1547
                showresp(INFO, ASC, "set FM lower", cmd, replystr);
 
1548
                cmd = "SH0";
 
1549
                cmd += TS990_CAT_filt_hi[(A.iBW >> 8) & 0x7F];
 
1550
                sendCommand(cmd,0);
 
1551
                showresp(INFO, ASC, "set FM upper", cmd, replystr);
 
1552
                break;
 
1553
 
 
1554
        case CW: case CWR:
 
1555
                if (val < 256) break;
 
1556
                lo = val & 0x7F;
 
1557
                hi = (val >> 8) & 0x7F;
 
1558
                if (hi >= sizeof(TS990_CAT_CW_width) / sizeof(*TS990_CAT_CW_width) ||
 
1559
                        lo >= sizeof(TS990_CAT_CW_shift) / sizeof(*TS990_CAT_CW_shift) )
 
1560
                        A.iBW = A_default_CW;
 
1561
                else
 
1562
                        A.iBW = val;
 
1563
                cmd = "SL0";
 
1564
                cmd += TS990_CAT_CW_width[(A.iBW >> 8) & 0x7F];
 
1565
                sendCommand(cmd,0);
 
1566
                showresp(INFO, ASC, "set cw width", cmd, replystr);
 
1567
                cmd = "SH0";
 
1568
                cmd += TS990_CAT_CW_shift[A.iBW & 0x7F];
 
1569
                sendCommand(cmd,0);
 
1570
                showresp(INFO, ASC, "set cw shift", cmd, replystr);
 
1571
                break;
 
1572
 
 
1573
        case FSK: case FSKR:
 
1574
                if (val > 256) break;
 
1575
                lo = val;
 
1576
                if (lo >= sizeof(TS990_CAT_FSK_filt) / sizeof(*TS990_CAT_FSK_filt))
 
1577
                        A.iBW = A_default_FSK;
 
1578
                else
 
1579
                        A.iBW = val;
 
1580
                cmd = "SL0";
 
1581
                cmd += TS990_CAT_FSK_filt[A.iBW];
 
1582
                sendCommand(cmd,0);
 
1583
                showresp(INFO, ASC, "set FSK bw", cmd, replystr);
 
1584
                break;
 
1585
 
 
1586
        case PSK: case PSKR:
 
1587
                if (val > 256) break;
 
1588
                lo = val;
 
1589
                if (lo >= sizeof(TS990_CAT_PSK_filt) / sizeof(*TS990_CAT_PSK_filt))
 
1590
                        A.iBW = A_default_PSK;
 
1591
                else
 
1592
                        A.iBW = val;
 
1593
                cmd = "SL0";
 
1594
                cmd += TS990_CAT_PSK_filt[A.iBW];
 
1595
                sendCommand(cmd,0);
 
1596
                showresp(INFO, ASC, "set PSK bw", cmd, replystr);
 
1597
                break;
 
1598
        }
 
1599
}
 
1600
 
 
1601
void RIG_TS990::set_bwB(int val)
 
1602
{
 
1603
        size_t lo = 0, hi = 0;
 
1604
        switch (B.imode) {
 
1605
        case LSB: case USB:
 
1606
                if (val < 256) break;
 
1607
                if (menu_0607) {
 
1608
                        lo = val & 0x7F;
 
1609
                        hi = (val >> 8) & 0x7F;
 
1610
                        if (hi >= sizeof(TS990_CAT_filt_width)/sizeof(*TS990_CAT_filt_width) ||
 
1611
                                 lo >= sizeof(TS990_CAT_filt_shift)/sizeof(*TS990_CAT_filt_shift) )
 
1612
                                B.iBW = B_default_SH_WI;
 
1613
                        else
 
1614
                                B.iBW = val;
 
1615
                        cmd = "SL1";
 
1616
                        cmd += TS990_CAT_filt_width[(B.iBW >> 8) & 0x7F];
 
1617
                        sendCommand(cmd,0);
 
1618
                        showresp(INFO, ASC, "set filter width", cmd, replystr);
 
1619
                        cmd = "SH1";
 
1620
                        cmd += TS990_CAT_filt_shift[B.iBW & 0x7F];
 
1621
                        sendCommand(cmd,0);
 
1622
                        showresp(INFO, ASC, "set filter shift", cmd, replystr);
 
1623
                } else {
 
1624
                        lo = val & 0x7F;
 
1625
                        hi = (val >> 8) & 0x7F;
 
1626
                        if (hi >= sizeof(TS990_CAT_filt_hi)/sizeof(*TS990_CAT_filt_lo) ||
 
1627
                                 lo >= sizeof(TS990_CAT_filt_lo)/sizeof(*TS990_CAT_filt_lo) )
 
1628
                                B.iBW = B_default_HI_LO;
 
1629
                        else
 
1630
                                B.iBW = val;
 
1631
                        cmd = "SL1";
 
1632
                        cmd += TS990_CAT_filt_lo[B.iBW  & 0x7F];
 
1633
                        sendCommand(cmd,0);
 
1634
                        showresp(INFO, ASC, "set filter lower cutoff", cmd, replystr);
 
1635
                        cmd = "SH1";
 
1636
                        cmd += TS990_CAT_filt_hi[(B.iBW >> 8) & 0x7F];
 
1637
                        sendCommand(cmd,0);
 
1638
                        showresp(INFO, ASC, "set filter upper cutoff", cmd, replystr);
 
1639
                }
 
1640
                break;
 
1641
 
 
1642
        case LSBD1: case LSBD2: case LSBD3:
 
1643
        case USBD1: case USBD2: case USBD3:
 
1644
                if (val < 256) break;
 
1645
                if (menu_0608) {
 
1646
                        lo = val & 0x7F;
 
1647
                        hi = (val >> 8) & 0x7F;
 
1648
                        if (hi >= sizeof(TS990_CAT_filt_width)/sizeof(*TS990_CAT_filt_width) ||
 
1649
                                 lo >= sizeof(TS990_CAT_filt_shift)/sizeof(*TS990_CAT_filt_shift) )
 
1650
                                B.iBW = B_default_SH_WI;
 
1651
                        else
 
1652
                                B.iBW = val;
 
1653
                        cmd = "SL1";
 
1654
                        cmd += TS990_CAT_filt_width[(B.iBW >> 8) & 0x7F];
 
1655
                        sendCommand(cmd,0);
 
1656
                        showresp(INFO, ASC, "set data width", cmd, replystr);
 
1657
                        cmd = "SH1";
 
1658
                        cmd += TS990_CAT_filt_shift[B.iBW & 0x7F];
 
1659
                        sendCommand(cmd,0);
 
1660
                        showresp(INFO, ASC, "set data shift", cmd, replystr);
 
1661
                } else {
 
1662
                        lo = val & 0x7F;
 
1663
                        hi = (val >> 8) & 0x7F;
 
1664
                        if (hi >= sizeof(TS990_CAT_filt_hi)/sizeof(*TS990_CAT_filt_lo) ||
 
1665
                                 lo >= sizeof(TS990_CAT_filt_lo)/sizeof(*TS990_CAT_filt_lo) )
 
1666
                                B.iBW = B_default_HI_LO;
 
1667
                        else
 
1668
                                B.iBW = val;
 
1669
                        cmd = "SL1";
 
1670
                        cmd += TS990_CAT_filt_lo[B.iBW & 0x7F];
 
1671
                        sendCommand(cmd,0);
 
1672
                        showresp(INFO, ASC, "set data lower cutoff", cmd, replystr);
 
1673
                        cmd = "SH1";
 
1674
                        cmd += TS990_CAT_filt_hi[(B.iBW >> 8) & 0x7F];
 
1675
                        sendCommand(cmd,0);
 
1676
                        showresp(INFO, ASC, "set data upper cutoff", cmd, replystr);
 
1677
                }
 
1678
                break;
 
1679
 
 
1680
        case AM: case AMD1: case AMD2: case AMD3:
 
1681
                if (val < 256) break;
 
1682
                lo = val & 0x7F;
 
1683
                hi = (val >> 8) & 0x7F;
 
1684
                if (hi >= sizeof(TS990_CAT_AM_hi) / sizeof(*TS990_CAT_AM_hi) ||
 
1685
                        lo >= sizeof(TS990_CAT_AM_lo) / sizeof(*TS990_CAT_AM_lo) )
 
1686
                        B.iBW = B_default_AM;
 
1687
                else
 
1688
                        B.iBW = val;
 
1689
                cmd = "SL1";
 
1690
                cmd += TS990_CAT_AM_lo[B.iBW & 0x7F];
 
1691
                sendCommand(cmd,0);
 
1692
                showresp(INFO, ASC, "set AM lower", cmd, replystr);
 
1693
                cmd = "SH1";
 
1694
                cmd += TS990_CAT_AM_hi[(B.iBW >> 8) & 0x7F];
 
1695
                sendCommand(cmd,0);
 
1696
                showresp(INFO, ASC, "set AM upper", cmd, replystr);
 
1697
                break;
 
1698
 
 
1699
        case FM: case FMD1: case FMD2: case FMD3:
 
1700
                if (val < 256) break;
 
1701
                lo = val & 0x7F;
 
1702
                hi = (val >> 8) & 0x7F;
 
1703
                if (hi >= sizeof(TS990_CAT_filt_hi) / sizeof(*TS990_CAT_filt_hi) ||
 
1704
                        lo >= sizeof(TS990_CAT_filt_lo) / sizeof(*TS990_CAT_filt_lo) )
 
1705
                        B.iBW = B_default_FM;
 
1706
                else
 
1707
                        B.iBW = val;
 
1708
                cmd = "SL1";
 
1709
                cmd += TS990_CAT_filt_lo[B.iBW & 0x7F];
 
1710
                sendCommand(cmd,0);
 
1711
                showresp(INFO, ASC, "set FM lower", cmd, replystr);
 
1712
                cmd = "SH1";
 
1713
                cmd += TS990_CAT_filt_hi[(B.iBW >> 8) & 0x7F];
 
1714
                sendCommand(cmd,0);
 
1715
                showresp(INFO, ASC, "set FM upper", cmd, replystr);
 
1716
                break;
 
1717
 
 
1718
        case CW: case CWR:
 
1719
                if (val < 256) break;
 
1720
                lo = val & 0x7F;
 
1721
                hi = (val >> 8) & 0x7F;
 
1722
                if (hi >= sizeof(TS990_CAT_CW_width) / sizeof(*TS990_CAT_CW_width) ||
 
1723
                        lo >= sizeof(TS990_CAT_CW_shift) / sizeof(*TS990_CAT_CW_shift) )
 
1724
                        B.iBW = B_default_CW;
 
1725
                else
 
1726
                        B.iBW = val;
 
1727
                cmd = "SL1";
 
1728
                cmd += TS990_CAT_CW_width[(B.iBW >> 8) & 0x7F];
 
1729
                sendCommand(cmd,0);
 
1730
                showresp(INFO, ASC, "set cw width", cmd, replystr);
 
1731
                cmd = "SH1";
 
1732
                cmd += TS990_CAT_CW_shift[B.iBW & 0x7F];
 
1733
                sendCommand(cmd,0);
 
1734
                showresp(INFO, ASC, "set cw shift", cmd, replystr);
 
1735
                break;
 
1736
 
 
1737
        case FSK: case FSKR:
 
1738
                if (val > 256) break;
 
1739
                lo = val;
 
1740
                if (lo >= sizeof(TS990_CAT_FSK_filt) / sizeof(*TS990_CAT_FSK_filt))
 
1741
                        B.iBW = B_default_FSK;
 
1742
                else
 
1743
                        B.iBW = val;
 
1744
                cmd = "SL1";
 
1745
                cmd += TS990_CAT_FSK_filt[B.iBW];
 
1746
                sendCommand(cmd,0);
 
1747
                showresp(INFO, ASC, "set FSK bw", cmd, replystr);
 
1748
                break;
 
1749
 
 
1750
        case PSK: case PSKR:
 
1751
                if (val > 256) break;
 
1752
                lo = val;
 
1753
                if (lo >= sizeof(TS990_CAT_PSK_filt) / sizeof(*TS990_CAT_PSK_filt))
 
1754
                        B.iBW = B_default_PSK;
 
1755
                else
 
1756
                        B.iBW = val;
 
1757
                cmd = "SL1";
 
1758
                cmd += TS990_CAT_PSK_filt[B.iBW];
 
1759
                sendCommand(cmd,0);
 
1760
                showresp(INFO, ASC, "set PSK bw", cmd, replystr);
 
1761
                break;
 
1762
        }
 
1763
}
 
1764
 
 
1765
int RIG_TS990::get_bwA()
 
1766
{
 
1767
        size_t p;
 
1768
        int lo, hi;
 
1769
 
 
1770
        switch (A.imode) {
 
1771
        case CW: case CWR:
 
1772
                A.iBW = A_default_CW;
 
1773
                lo = A.iBW & 0x7F;
 
1774
                hi = (A.iBW >> 8) & 0x7F;
 
1775
                cmd = "SL0;";
 
1776
                waitN(6, 20, "get CW width", ASC);
 
1777
                p = replystr.rfind("SL");
 
1778
                if (p == string::npos) break;
 
1779
                hi = fm_decimal(&replystr[3], 2); //2 2
 
1780
                cmd = "SH0;";
 
1781
                waitN(6, 20, "get CW shift", ASC);
 
1782
                p = replystr.rfind("SH");
 
1783
                if (p == string::npos) break;
 
1784
                lo = fm_decimal(&replystr[3], 2); //2 2
 
1785
                A_default_CW = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1786
                break;
 
1787
 
 
1788
        case FSK: case FSKR:
 
1789
                A.iBW = A_default_FSK;
 
1790
                lo = A.iBW & 0x7F;
 
1791
                cmd = "SL0;";
 
1792
                waitN(6, 20, "get FSK Width", ASC);
 
1793
                p = replystr.rfind("SL");
 
1794
                if (p == string::npos) break;
 
1795
                lo = fm_decimal(&replystr[3], 2); //2 2
 
1796
                A_default_FSK = A.iBW = (lo & 0x7F);
 
1797
                break;
 
1798
 
 
1799
        case PSK: case PSKR:
 
1800
                A.iBW = A_default_PSK;
 
1801
                lo = A.iBW & 0x7F;
 
1802
                cmd = "SL0;";
 
1803
                waitN(6, 20, "get PSK Width", ASC);
 
1804
                p = replystr.rfind("SL");
 
1805
                if (p == string::npos) break;
 
1806
                lo = fm_decimal(&replystr[3], 2); //2 2
 
1807
                A_default_PSK = A.iBW = (lo & 0x7F);
 
1808
                break;
 
1809
 
 
1810
        case LSB: case USB:
 
1811
                lo = A.iBW & 0x7F;
 
1812
                hi = (A.iBW >> 8) & 0x7F;
 
1813
                if (menu_0607) {
 
1814
                        A.iBW = A_default_SH_WI;
 
1815
                        cmd = "SL0;";
 
1816
                        waitN(6, 20, "get filter width", ASC);
 
1817
                        p = replystr.rfind("SL");
 
1818
                        if (p == string::npos) break;
 
1819
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1820
                        cmd = "SH0;";
 
1821
                        waitN(6, 20, "get filter shift", ASC);
 
1822
                        p = replystr.rfind("SH");
 
1823
                        if (p == string::npos) break;
 
1824
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
1825
                        A_default_SH_WI = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1826
                } else {
 
1827
                        A.iBW = A_default_HI_LO;
 
1828
                        cmd = "SL0;";
 
1829
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
1830
                        p = replystr.rfind("SL");
 
1831
                        if (p == string::npos) break;
 
1832
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
1833
                        cmd = "SH0;";
 
1834
                        waitN(6, 20, "get filter upper cutoff", ASC);
 
1835
                        p = replystr.rfind("SH");
 
1836
                        if (p == string::npos) break;
 
1837
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1838
                        A_default_HI_LO = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1839
                }
 
1840
                break;
 
1841
 
 
1842
        case LSBD1: case USBD1: 
 
1843
                        lo = A.iBW & 0x7F;
 
1844
                        hi = (A.iBW >> 8) & 0x7F;
 
1845
                if (menu_0608) {
 
1846
                        A.iBW = A_default_SH_WI_D1;
 
1847
                        cmd = "SL0;";
 
1848
                        waitN(6, 20, "get filter width", ASC);
 
1849
                        p = replystr.rfind("SL");
 
1850
                        if (p == string::npos) break;
 
1851
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1852
                        cmd = "SH0;";
 
1853
                        waitN(6, 20, "get filter shift", ASC);
 
1854
                        p = replystr.rfind("SH");
 
1855
                        if (p == string::npos) break;
 
1856
                        lo = fm_decimal(&replystr[3], 2); //2 
 
1857
                        A_default_SH_WI_D1 = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1858
                } else {
 
1859
                        
 
1860
                        A.iBW = A_default_HI_LO;
 
1861
                        cmd = "SL0;";
 
1862
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
1863
                        p = replystr.rfind("SL");
 
1864
                        if (p == string::npos) break;
 
1865
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
1866
                        cmd = "SH0;";
 
1867
                        waitN(6, 20, "get filter upper cutoff", ASC);
 
1868
                        p = replystr.rfind("SH");
 
1869
                        if (p == string::npos) break;
 
1870
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1871
                        A_default_HI_LO = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1872
                }
 
1873
                break;
 
1874
                
 
1875
        case LSBD2: case USBD2:
 
1876
                        lo = A.iBW & 0x7F;
 
1877
                        hi = (A.iBW >> 8) & 0x7F;
 
1878
                if (menu_0608) {
 
1879
                        A.iBW = A_default_SH_WI_D2;
 
1880
                        cmd = "SL0;";
 
1881
                        waitN(6, 20, "get filter width", ASC);
 
1882
                        p = replystr.rfind("SL");
 
1883
                        if (p == string::npos) break;
 
1884
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1885
                        cmd = "SH0;";
 
1886
                        waitN(6, 20, "get filter shift", ASC);
 
1887
                        p = replystr.rfind("SH");
 
1888
                        if (p == string::npos) break;
 
1889
                        lo = fm_decimal(&replystr[3], 2); //2 
 
1890
                        A_default_SH_WI_D2 = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1891
                } else {
 
1892
                        
 
1893
                        A.iBW = A_default_HI_LO;
 
1894
                        cmd = "SL0;";
 
1895
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
1896
                        p = replystr.rfind("SL");
 
1897
                        if (p == string::npos) break;
 
1898
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
1899
                        cmd = "SH0;";
 
1900
                        waitN(6, 20, "get filter upper cutoff", ASC);
 
1901
                        p = replystr.rfind("SH");
 
1902
                        if (p == string::npos) break;
 
1903
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1904
                        A_default_HI_LO = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1905
                }
 
1906
                break;
 
1907
                
 
1908
        case LSBD3: case USBD3:
 
1909
                        lo = A.iBW & 0x7F;
 
1910
                        hi = (A.iBW >> 8) & 0x7F;
 
1911
                if (menu_0608) {
 
1912
                        A.iBW = A_default_SH_WI_D3;
 
1913
                        cmd = "SL0;";
 
1914
                        waitN(6, 20, "get filter width", ASC);
 
1915
                        p = replystr.rfind("SL");
 
1916
                        if (p == string::npos) break;
 
1917
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1918
                        cmd = "SH0;";
 
1919
                        waitN(6, 20, "get filter shift", ASC);
 
1920
                        p = replystr.rfind("SH");
 
1921
                        if (p == string::npos) break;
 
1922
                        lo = fm_decimal(&replystr[3], 2); //2 
 
1923
                        A_default_SH_WI_D3 = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1924
                } else {
 
1925
                        
 
1926
                        A.iBW = A_default_HI_LO;
 
1927
                        cmd = "SL0;";
 
1928
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
1929
                        p = replystr.rfind("SL");
 
1930
                        if (p == string::npos) break;
 
1931
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
1932
                        cmd = "SH0;";
 
1933
                        waitN(6, 20, "get filter upper cutoff", ASC);
 
1934
                        p = replystr.rfind("SH");
 
1935
                        if (p == string::npos) break;
 
1936
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
1937
                        A_default_HI_LO = A.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
1938
                }
 
1939
                break;
 
1940
 
 
1941
        case AM:
 
1942
                A.iBW = A_default_AM;
 
1943
                lo = A.iBW & 0x7F;
 
1944
                hi = (A.iBW >> 8) & 0x7F;
 
1945
                cmd = "SL0;";
 
1946
                waitN(6, 20, "get AM lo", ASC);
 
1947
                p = replystr.rfind("SL");
 
1948
                if (p == string::npos) break;
 
1949
                lo = fm_decimal(&replystr[3], 2); //2 2
 
1950
                cmd = "SH0;";
 
1951
                waitN(6, 20, "get AM hi", ASC);
 
1952
                p = replystr.rfind("SH");
 
1953
                if (p == string::npos) break;
 
1954
                hi = fm_decimal(&replystr[3], 2); //2 2
 
1955
                A_default_AM = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
1956
                break;
 
1957
                
 
1958
        case AMD1:
 
1959
                A.iBW = A_default_AM_D1;
 
1960
                lo = A.iBW & 0x7F;
 
1961
                hi = (A.iBW >> 8) & 0x7F;
 
1962
                cmd = "SL0;";
 
1963
                waitN(6, 20, "get AM lo", ASC);
 
1964
                p = replystr.rfind("SL");
 
1965
                if (p == string::npos) break;
 
1966
                lo = fm_decimal(&replystr[3], 2); //2 2
 
1967
                cmd = "SH0;";
 
1968
                waitN(6, 20, "get AM hi", ASC);
 
1969
                p = replystr.rfind("SH");
 
1970
                if (p == string::npos) break;
 
1971
                hi = fm_decimal(&replystr[3], 2); //2 2
 
1972
                A_default_AM_D1 = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
1973
                break;
 
1974
                
 
1975
        case AMD2:
 
1976
                A.iBW = A_default_AM_D2;
 
1977
                lo = A.iBW & 0x7F;
 
1978
                hi = (A.iBW >> 8) & 0x7F;
 
1979
                cmd = "SL0;";
 
1980
                waitN(6, 20, "get AM lo", ASC);
 
1981
                p = replystr.rfind("SL");
 
1982
                if (p == string::npos) break;
 
1983
                lo = fm_decimal(&replystr[3], 2); //2 2
 
1984
                cmd = "SH0;";
 
1985
                waitN(6, 20, "get AM hi", ASC);
 
1986
                p = replystr.rfind("SH");
 
1987
                if (p == string::npos) break;
 
1988
                hi = fm_decimal(&replystr[3], 2); //2 2
 
1989
                A_default_AM_D2 = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
1990
                break;
 
1991
        
 
1992
        case AMD3:
 
1993
                A.iBW = A_default_AM_D3;
 
1994
                lo = A.iBW & 0x7F;
 
1995
                hi = (A.iBW >> 8) & 0x7F;
 
1996
                cmd = "SL0;";
 
1997
                waitN(6, 20, "get AM lo", ASC);
 
1998
                p = replystr.rfind("SL");
 
1999
                if (p == string::npos) break;
 
2000
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2001
                cmd = "SH0;";
 
2002
                waitN(6, 20, "get AM hi", ASC);
 
2003
                p = replystr.rfind("SH");
 
2004
                if (p == string::npos) break;
 
2005
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2006
                A_default_AM_D3 = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2007
                break;
 
2008
 
 
2009
        case FM:
 
2010
                A.iBW = A_default_FM;
 
2011
                lo = A.iBW & 0x7F;
 
2012
                hi = (A.iBW >> 8) & 0x7F;
 
2013
                cmd = "SL0;";
 
2014
                waitN(6, 20, "get FM lo", ASC);
 
2015
                p = replystr.rfind("SL");
 
2016
                if (p == string::npos) break;
 
2017
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2018
                cmd = "SH0;";
 
2019
                waitN(6, 20, "get FM hi", ASC);
 
2020
                p = replystr.rfind("SH");
 
2021
                if (p == string::npos) break;
 
2022
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2023
                A_default_FM = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2024
                break;
 
2025
                
 
2026
        case FMD1:
 
2027
                A.iBW = A_default_FM_D1;
 
2028
                lo = A.iBW & 0x7F;
 
2029
                hi = (A.iBW >> 8) & 0x7F;
 
2030
                cmd = "SL0;";
 
2031
                waitN(6, 20, "get FM lo", ASC);
 
2032
                p = replystr.rfind("SL");
 
2033
                if (p == string::npos) break;
 
2034
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2035
                cmd = "SH0;";
 
2036
                waitN(6, 20, "get FM hi", ASC);
 
2037
                p = replystr.rfind("SH");
 
2038
                if (p == string::npos) break;
 
2039
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2040
                A_default_FM_D1 = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2041
                break;
 
2042
                
 
2043
        case FMD2 :
 
2044
                A.iBW = A_default_FM_D2;
 
2045
                lo = A.iBW & 0x7F;
 
2046
                hi = (A.iBW >> 8) & 0x7F;
 
2047
                cmd = "SL0;";
 
2048
                waitN(6, 20, "get FM lo", ASC);
 
2049
                p = replystr.rfind("SL");
 
2050
                if (p == string::npos) break;
 
2051
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2052
                cmd = "SH0;";
 
2053
                waitN(6, 20, "get FM hi", ASC);
 
2054
                p = replystr.rfind("SH");
 
2055
                if (p == string::npos) break;
 
2056
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2057
                A_default_FM_D2 = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2058
                break;
 
2059
                
 
2060
        case FMD3:
 
2061
                A.iBW = A_default_FM_D3;
 
2062
                lo = A.iBW & 0x7F;
 
2063
                hi = (A.iBW >> 8) & 0x7F;
 
2064
                cmd = "SL0;";
 
2065
                waitN(6, 20, "get FM lo", ASC);
 
2066
                p = replystr.rfind("SL");
 
2067
                if (p == string::npos) break;
 
2068
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2069
                cmd = "SH0;";
 
2070
                waitN(6, 20, "get FM hi", ASC);
 
2071
                p = replystr.rfind("SH");
 
2072
                if (p == string::npos) break;
 
2073
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2074
                A_default_FM_D3 = A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2075
                return A.iBW;                   
 
2076
        }
 
2077
        return A.iBW;
 
2078
}
 
2079
 
 
2080
int RIG_TS990::get_bwB()
 
2081
{
 
2082
        size_t p;
 
2083
        int hi, lo;
 
2084
 
 
2085
        switch (B.imode) {
 
2086
        case CW: case CWR:
 
2087
                B.iBW = B_default_CW;
 
2088
                lo = B.iBW & 0x7F;
 
2089
                hi = (B.iBW >> 8) & 0x7F;
 
2090
                cmd = "SL1;";
 
2091
                waitN(6, 20, "get CW lower", ASC);
 
2092
                p = replystr.rfind("SL");
 
2093
                if (p == string::npos) break;
 
2094
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2095
                cmd = "SH1;";
 
2096
                waitN(6, 20, "get CW upper", ASC);
 
2097
                p = replystr.rfind("SH");
 
2098
                if (p == string::npos) break;
 
2099
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2100
                B_default_CW = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2101
                break;
 
2102
 
 
2103
        case FSK: case FSKR:
 
2104
                B.iBW = B_default_FSK;
 
2105
                lo = B.iBW & 0x7F;
 
2106
                cmd = "SL1;";
 
2107
                waitN(6, 20, "get FSK Width", ASC);
 
2108
                p = replystr.rfind("SL");
 
2109
                if (p == string::npos) break;
 
2110
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2111
                B_default_FSK = B.iBW = (lo & 0x7F);
 
2112
                break;
 
2113
 
 
2114
        case PSK: case PSKR:
 
2115
                B.iBW = B_default_PSK;
 
2116
                lo = B.iBW & 0x7F;
 
2117
                cmd = "SL1;";
 
2118
                waitN(6, 20, "get PSK Width", ASC);
 
2119
                p = replystr.rfind("SL");
 
2120
                if (p == string::npos) break;
 
2121
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2122
                B_default_PSK = B.iBW = (lo & 0x7F);
 
2123
                break;
 
2124
 
 
2125
        case LSB: case USB:
 
2126
                lo = B.iBW & 0x7F;
 
2127
                hi = (B.iBW >> 8) & 0x7F;
 
2128
                if (menu_0607) {
 
2129
                        B.iBW = B_default_SH_WI;
 
2130
                        cmd = "SL1;";
 
2131
                        waitN(6, 20, "get filter width", ASC);
 
2132
                        p = replystr.rfind("SL");
 
2133
                        if (p == string::npos) break;
 
2134
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2135
                        cmd = "SH1;";
 
2136
                        waitN(6, 20, "get filter shift", ASC);
 
2137
                        p = replystr.rfind("SH");
 
2138
                        if (p == string::npos) break;
 
2139
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2140
                        B_default_SH_WI = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2141
                } else {
 
2142
                        B.iBW = B_default_HI_LO;
 
2143
                        cmd = "SL1;";
 
2144
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
2145
                        p = replystr.rfind("SL");
 
2146
                        if (p == string::npos) break;
 
2147
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2148
                        cmd = "SH1;";
 
2149
                        waitN(6, 20, "get filter upper cutoff", ASC);
 
2150
                        p = replystr.rfind("SH");
 
2151
                        if (p == string::npos) break;
 
2152
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2153
                        B_default_HI_LO = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2154
                }
 
2155
                break;
 
2156
 
 
2157
        case LSBD1: case USBD1:
 
2158
                lo = B.iBW & 0x7F;
 
2159
                hi = (B.iBW >> 8) & 0x7F;
 
2160
                if (menu_0608) {
 
2161
                        B.iBW = B_default_SH_WI_D1;
 
2162
                        cmd = "SL1;";
 
2163
                        waitN(6, 20, "get filter width", ASC);
 
2164
                        p = replystr.rfind("SL");
 
2165
                        if (p == string::npos) break;
 
2166
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2167
                        cmd = "SH1;";
 
2168
                        waitN(6, 20, "get filter shift", ASC);
 
2169
                        p = replystr.rfind("SH");
 
2170
                        if (p == string::npos) break;
 
2171
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2172
                        B_default_SH_WI_D1 = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2173
                } else {
 
2174
                        B.iBW = B_default_HI_LO;
 
2175
                        cmd = "SL1;";
 
2176
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
2177
                        p = replystr.rfind("SL");
 
2178
                        if (p == string::npos) break;
 
2179
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2180
                        cmd = "SH1;";
 
2181
                        waitN(6, 20, "get fiter upper cutoff", ASC);
 
2182
                        p = replystr.rfind("SH");
 
2183
                        if (p == string::npos) break;
 
2184
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2185
                        B_default_HI_LO = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2186
                }
 
2187
                break;
 
2188
                
 
2189
        case LSBD2: case USBD2:
 
2190
                lo = B.iBW & 0x7F;
 
2191
                hi = (B.iBW >> 8) & 0x7F;
 
2192
                if (menu_0608) {
 
2193
                        B.iBW = B_default_SH_WI_D2;
 
2194
                        cmd = "SL1;";
 
2195
                        waitN(6, 20, "get filter width", ASC);
 
2196
                        p = replystr.rfind("SL");
 
2197
                        if (p == string::npos) break;
 
2198
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2199
                        cmd = "SH1;";
 
2200
                        waitN(6, 20, "get filter shift", ASC);
 
2201
                        p = replystr.rfind("SH");
 
2202
                        if (p == string::npos) break;
 
2203
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2204
                        B_default_SH_WI_D2 = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2205
                } else {
 
2206
                        B.iBW = B_default_HI_LO;
 
2207
                        cmd = "SL1;";
 
2208
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
2209
                        p = replystr.rfind("SL");
 
2210
                        if (p == string::npos) break;
 
2211
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2212
                        cmd = "SH1;";
 
2213
                        waitN(6, 20, "get fiter upper cutoff", ASC);
 
2214
                        p = replystr.rfind("SH");
 
2215
                        if (p == string::npos) break;
 
2216
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2217
                        B_default_HI_LO = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2218
                }
 
2219
                break;
 
2220
                
 
2221
        case LSBD3: case USBD3:
 
2222
                lo = B.iBW & 0x7F;
 
2223
                hi = (B.iBW >> 8) & 0x7F;
 
2224
                if (menu_0608) {
 
2225
                        B.iBW = B_default_SH_WI_D3;
 
2226
                        cmd = "SL1;";
 
2227
                        waitN(6, 20, "get filter width", ASC);
 
2228
                        p = replystr.rfind("SL");
 
2229
                        if (p == string::npos) break;
 
2230
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2231
                        cmd = "SH1;";
 
2232
                        waitN(6, 20, "get filter shift", ASC);
 
2233
                        p = replystr.rfind("SH");
 
2234
                        if (p == string::npos) break;
 
2235
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2236
                        B_default_SH_WI_D3 = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2237
                } else {
 
2238
                        B.iBW = B_default_HI_LO;
 
2239
                        cmd = "SL1;";
 
2240
                        waitN(6, 20, "get filter lower cutoff", ASC);
 
2241
                        p = replystr.rfind("SL");
 
2242
                        if (p == string::npos) break;
 
2243
                        lo = fm_decimal(&replystr[3], 2); //2 2
 
2244
                        cmd = "SH1;";
 
2245
                        waitN(6, 20, "get fiter upper cutoff", ASC);
 
2246
                        p = replystr.rfind("SH");
 
2247
                        if (p == string::npos) break;
 
2248
                        hi = fm_decimal(&replystr[3], 2); //2 2
 
2249
                        B_default_HI_LO = B.iBW = ((hi << 8) | (lo & 0x7F )) | 0x8000;
 
2250
                }
 
2251
                break;          
 
2252
 
 
2253
        case AM:
 
2254
                B.iBW = B_default_AM;
 
2255
                lo = B.iBW & 0x7F;
 
2256
                hi = (B.iBW >> 8) & 0x7F;
 
2257
                cmd = "SL1;";
 
2258
                waitN(6, 20, "get AM lo", ASC);
 
2259
                p = replystr.rfind("SL");
 
2260
                if (p == string::npos) break;
 
2261
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2262
                cmd = "SH1;";
 
2263
                waitN(6, 20, "get AM hi", ASC);
 
2264
                p = replystr.rfind("SH");
 
2265
                if (p == string::npos) break;
 
2266
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2267
                B_default_AM = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2268
                break;
 
2269
                
 
2270
        case AMD1:
 
2271
                B.iBW = B_default_AM_D1;
 
2272
                lo = B.iBW & 0x7F;
 
2273
                hi = (B.iBW >> 8) & 0x7F;
 
2274
                cmd = "SL1;";
 
2275
                waitN(6, 20, "get AM lo", ASC);
 
2276
                p = replystr.rfind("SL");
 
2277
                if (p == string::npos) break;
 
2278
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2279
                cmd = "SH1;";
 
2280
                waitN(6, 20, "get AM hi", ASC);
 
2281
                p = replystr.rfind("SH");
 
2282
                if (p == string::npos) break;
 
2283
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2284
                B_default_AM_D1 = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2285
                break;
 
2286
                
 
2287
        case AMD2:
 
2288
                B.iBW = B_default_AM_D2;
 
2289
                lo = B.iBW & 0x7F;
 
2290
                hi = (B.iBW >> 8) & 0x7F;
 
2291
                cmd = "SL1;";
 
2292
                waitN(6, 20, "get AM lo", ASC);
 
2293
                p = replystr.rfind("SL");
 
2294
                if (p == string::npos) break;
 
2295
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2296
                cmd = "SH1;";
 
2297
                waitN(6, 20, "get AM hi", ASC);
 
2298
                p = replystr.rfind("SH");
 
2299
                if (p == string::npos) break;
 
2300
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2301
                B_default_AM_D2 = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2302
                break;
 
2303
                
 
2304
        case AMD3:
 
2305
                B.iBW = B_default_AM_D3;
 
2306
                lo = B.iBW & 0x7F;
 
2307
                hi = (B.iBW >> 8) & 0x7F;
 
2308
                cmd = "SL1;";
 
2309
                waitN(6, 20, "get AM lo", ASC);
 
2310
                p = replystr.rfind("SL");
 
2311
                if (p == string::npos) break;
 
2312
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2313
                cmd = "SH1;";
 
2314
                waitN(6, 20, "get AM hi", ASC);
 
2315
                p = replystr.rfind("SH");
 
2316
                if (p == string::npos) break;
 
2317
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2318
                B_default_AM_D3 = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2319
                break;                  
 
2320
 
 
2321
        case FM:
 
2322
                B.iBW = B_default_FM;
 
2323
                lo = B.iBW & 0x7F;
 
2324
                hi = (B.iBW >> 8) & 0x7F;
 
2325
                cmd = "SL1;";
 
2326
                waitN(6, 20, "get FM lo", ASC);
 
2327
                p = replystr.rfind("SL");
 
2328
                if (p == string::npos) break;
 
2329
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2330
                cmd = "SH1;";
 
2331
                waitN(6, 20, "get FM hi", ASC);
 
2332
                p = replystr.rfind("SH");
 
2333
                if (p == string::npos) break;
 
2334
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2335
                B_default_FM = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2336
                break;
 
2337
                
 
2338
        case FMD1:
 
2339
                B.iBW = B_default_FM_D1;
 
2340
                lo = B.iBW & 0x7F;
 
2341
                hi = (B.iBW >> 8) & 0x7F;
 
2342
                cmd = "SL1;";
 
2343
                waitN(6, 20, "get FM lo", ASC);
 
2344
                p = replystr.rfind("SL");
 
2345
                if (p == string::npos) break;
 
2346
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2347
                cmd = "SH1;";
 
2348
                waitN(6, 20, "get FM hi", ASC);
 
2349
                p = replystr.rfind("SH");
 
2350
                if (p == string::npos) break;
 
2351
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2352
                B_default_FM_D1 = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2353
                break;
 
2354
                
 
2355
        case FMD2:
 
2356
                B.iBW = B_default_FM_D2;
 
2357
                lo = B.iBW & 0x7F;
 
2358
                hi = (B.iBW >> 8) & 0x7F;
 
2359
                cmd = "SL1;";
 
2360
                waitN(6, 20, "get FM lo", ASC);
 
2361
                p = replystr.rfind("SL");
 
2362
                if (p == string::npos) break;
 
2363
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2364
                cmd = "SH1;";
 
2365
                waitN(6, 20, "get FM hi", ASC);
 
2366
                p = replystr.rfind("SH");
 
2367
                if (p == string::npos) break;
 
2368
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2369
                B_default_FM_D2 = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2370
                break;
 
2371
                
 
2372
        case FMD3:
 
2373
                B.iBW = B_default_FM_D3;
 
2374
                lo = B.iBW & 0x7F;
 
2375
                hi = (B.iBW >> 8) & 0x7F;
 
2376
                cmd = "SL1;";
 
2377
                waitN(6, 20, "get FM lo", ASC);
 
2378
                p = replystr.rfind("SL");
 
2379
                if (p == string::npos) break;
 
2380
                lo = fm_decimal(&replystr[3], 2); //2 2
 
2381
                cmd = "SH1;";
 
2382
                waitN(6, 20, "get FM hi", ASC);
 
2383
                p = replystr.rfind("SH");
 
2384
                if (p == string::npos) break;
 
2385
                hi = fm_decimal(&replystr[3], 2); //2 2
 
2386
                B_default_FM_D3 = B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
 
2387
                return B.iBW;                   
 
2388
        }
 
2389
        return B.iBW;
 
2390
}
 
2391
 
 
2392
int RIG_TS990::get_modetype(int n)
 
2393
{
 
2394
        return TS990_mode_type[n];
 
2395
}
 
2396
 
 
2397
void RIG_TS990::set_noise(bool val) //Now Setting AGC
 
2398
{
 
2399
        if (useB) {
 
2400
                if (nb_level == 2) {
 
2401
                        nb_level = 3;
 
2402
                        nb_label("AGC F", false);
 
2403
                        cmd = "GC13;";
 
2404
                        sendCommand(cmd, 0);
 
2405
                } else if (nb_level == 3) {
 
2406
                        nb_level = 1;
 
2407
                        nb_label("AGC S", false);
 
2408
                        cmd = "GC11;";
 
2409
                        sendCommand(cmd, 0);
 
2410
                } else if (nb_level == 1) {
 
2411
                        nb_level = 2;
 
2412
                        nb_label("AGC M", false);
 
2413
                        cmd = "GC12;";
 
2414
                        sendCommand(cmd, 0);
 
2415
                }
 
2416
        } else {
 
2417
                if (nb_level == 2) {
 
2418
                        nb_level = 3;
 
2419
                        nb_label("AGC F", false);
 
2420
                        cmd = "GC03;";
 
2421
                        sendCommand(cmd, 0);
 
2422
                } else if (nb_level == 3) {
 
2423
                        nb_level = 1;
 
2424
                        nb_label("AGC S", false);
 
2425
                        cmd = "GC01;";
 
2426
                        sendCommand(cmd, 0);
 
2427
                } else if (nb_level == 1) {
 
2428
                        nb_level = 2;
 
2429
                        nb_label("AGC M", false);
 
2430
                        cmd = "GC02;";
 
2431
                        sendCommand(cmd, 0);
 
2432
                }
 
2433
        }
 
2434
}
 
2435
 
 
2436
//----------------------------------------------------------------------
 
2437
int  RIG_TS990::get_agc()
 
2438
{
 
2439
        int val = 0;
 
2440
        if (useB) {
 
2441
                cmd = "GC1;";
 
2442
                int ret = sendCommand(cmd);
 
2443
                showresp(INFO, ASC, "get AGC", cmd, replystr);
 
2444
                if (ret < 5) return val;
 
2445
                size_t p = replystr.rfind("GC");
 
2446
                if (p == string::npos) return val;
 
2447
                if (replystr[p + 3] == '1' ) {
 
2448
                        nb_label("AGC S", false);
 
2449
                } else if (replystr[p + 3] == '2' ) {
 
2450
                        nb_label("AGC M", false);
 
2451
                } else if (replystr[p + 3] == '3' ) {
 
2452
                        nb_label("AGC F", false);
 
2453
                }
 
2454
        } else {
 
2455
                cmd = "GC0;";
 
2456
                int ret = sendCommand(cmd);
 
2457
                showresp(INFO, ASC, "get AGC", cmd, replystr);
 
2458
                if (ret < 5) return val;
 
2459
                size_t p = replystr.rfind("GC");
 
2460
                if (p == string::npos) return val;
 
2461
                if (replystr[p + 3] == '1' ) {
 
2462
                        nb_label("AGC S", false);
 
2463
                } else if (replystr[p + 3] == '2' ) {
 
2464
                        nb_label("AGC M", false);
 
2465
                } else if (replystr[p + 3] == '3' ) {
 
2466
                        nb_label("AGC F", false);
 
2467
                }
 
2468
        }
 
2469
        return val;
 
2470
}
 
2471
 
 
2472
//==============================================================================
 
2473
 
 
2474
void RIG_TS990::set_squelch(int val)
 
2475
{
 
2476
        if (useB) {
 
2477
                cmd = "SQ1";
 
2478
                cmd.append(to_decimal(abs(val),3)).append(";");
 
2479
                sendCommand(cmd,0);
 
2480
                showresp(INFO, ASC, "set squelch", cmd, replystr);
 
2481
        } else {
 
2482
                cmd = "SQ0";
 
2483
                cmd.append(to_decimal(abs(val),3)).append(";");
 
2484
                sendCommand(cmd,0);
 
2485
                showresp(INFO, ASC, "set squelch", cmd, replystr);
 
2486
        }
 
2487
}
 
2488
 
 
2489
int  RIG_TS990::get_squelch()
 
2490
{
 
2491
        int val = 0;
 
2492
        if (useB) {
 
2493
                cmd = "SQ1;";
 
2494
                int ret = waitN(7, 20, "get squelch", ASC);
 
2495
                if (ret >= 7) {
 
2496
                        size_t p = replystr.rfind("SQ1");
 
2497
                        if (p == string::npos) return val;
 
2498
                        replystr[p + 6] = 0;
 
2499
                        val = atoi(&replystr[p + 3]);
 
2500
                }
 
2501
        } else {
 
2502
                cmd = "SQ0;";
 
2503
                int ret = waitN(7, 20, "get squelch", ASC);
 
2504
                if (ret >= 7) {
 
2505
                        size_t p = replystr.rfind("SQ0");
 
2506
                        if (p == string::npos) return val;
 
2507
                        replystr[p + 6] = 0;
 
2508
                        val = atoi(&replystr[p + 3]);
 
2509
                }
 
2510
        }
 
2511
        return val;
 
2512
}
 
2513
 
 
2514
void RIG_TS990::get_squelch_min_max_step(int &min, int &max, int &step)
 
2515
{
 
2516
        min = 0; max = 255; step = 1;
 
2517
}
 
2518
 
 
2519
void RIG_TS990::set_rf_gain(int val)
 
2520
{
 
2521
        if (useB) {
 
2522
                cmd = "RG1";
 
2523
                cmd.append(to_decimal(val,3)).append(";");
 
2524
                sendCommand(cmd,0);
 
2525
                showresp(INFO, ASC, "set rf gain", cmd, replystr);
 
2526
        } else {
 
2527
                cmd = "RG0";
 
2528
                cmd.append(to_decimal(val,3)).append(";");
 
2529
                sendCommand(cmd,0);
 
2530
                showresp(INFO, ASC, "set rf gain", cmd, replystr);
 
2531
        }
 
2532
}
 
2533
 
 
2534
int  RIG_TS990::get_rf_gain()
 
2535
{
 
2536
        int val = progStatus.rfgain;
 
2537
        if (useB) {
 
2538
                cmd = "RG1;";
 
2539
                int ret = waitN(7, 20, "get rf gain", ASC);
 
2540
                if (ret < 7) return val;
 
2541
                size_t p = replystr.rfind("RG");
 
2542
                if (p != string::npos)
 
2543
                        val = fm_decimal(&replystr[p+3], 3);
 
2544
        } else {
 
2545
                cmd = "RG0;";
 
2546
                int ret = waitN(7, 20, "get rf gain", ASC);
 
2547
                if (ret < 7) return val;
 
2548
                size_t p = replystr.rfind("RG");
 
2549
                if (p != string::npos)
 
2550
                        val = fm_decimal(&replystr[p+3], 3);
 
2551
        }
 
2552
        return val;
 
2553
}
 
2554
 
 
2555
void RIG_TS990::get_rf_min_max_step(int &min, int &max, int &step)
 
2556
{
 
2557
        min = 0;
 
2558
        max = 255;
 
2559
        step = 1;
 
2560
}
 
2561
 
 
2562
static bool nr_on = false;
 
2563
 
 
2564
void RIG_TS990::set_noise_reduction(int val)
 
2565
{
 
2566
        if (useB) {
 
2567
                cmd.assign("NR1").append(val ? "1" : "0" ).append(";");
 
2568
                sendCommand(cmd);
 
2569
                showresp(INFO, ASC, "SET noise reduction", cmd, replystr);
 
2570
                if (val) nr_on = true;
 
2571
                else nr_on = false;
 
2572
        } else {
 
2573
                cmd.assign("NR0").append(val ? "1" : "0" ).append(";");
 
2574
                sendCommand(cmd);
 
2575
                showresp(INFO, ASC, "SET noise reduction", cmd, replystr);
 
2576
                if (val) nr_on = true;
 
2577
                else nr_on = false;
 
2578
        }
 
2579
}
 
2580
 
 
2581
int  RIG_TS990::get_noise_reduction()
 
2582
{
 
2583
        int val = 0;
 
2584
        if (useB) {
 
2585
                cmd = rsp = "NR1";
 
2586
                cmd.append(";");
 
2587
                waitN(5, 20, "GET noise reduction", ASC);
 
2588
                size_t p = replystr.rfind(rsp);
 
2589
                if (p == string::npos) return val;
 
2590
                val = replystr[p+3] - '0';
 
2591
                if (val == 1) nr_on = true;
 
2592
                else nr_on = false;
 
2593
                return val;
 
2594
        } else {
 
2595
                cmd = rsp = "NR0";
 
2596
                cmd.append(";");
 
2597
                waitN(5, 20, "GET noise reduction", ASC);
 
2598
                size_t p = replystr.rfind(rsp);
 
2599
                if (p == string::npos) return val;
 
2600
                val = replystr[p+3] - '0';
 
2601
                if (val == 1) nr_on = true;
 
2602
                else nr_on = false;
 
2603
        }
 
2604
        return val;
 
2605
}
 
2606
 
 
2607
void RIG_TS990::set_noise_reduction_val(int val)
 
2608
{
 
2609
        if (useB) {
 
2610
                cmd.assign("RL11").append(to_decimal(val, 2)).append(";");
 
2611
                sendCommand(cmd);
 
2612
                showresp(INFO, ASC, "SET_noise_reduction_val", cmd, replystr);
 
2613
        } else {
 
2614
                cmd.assign("RL10").append(to_decimal(val, 2)).append(";");
 
2615
                sendCommand(cmd);
 
2616
                showresp(INFO, ASC, "SET_noise_reduction_val", cmd, replystr);
 
2617
        }
 
2618
}
 
2619
 
 
2620
int  RIG_TS990::get_noise_reduction_val()
 
2621
{
 
2622
        int val = 0;
 
2623
        if (useB) {
 
2624
                if (!nr_on) return val;
 
2625
                cmd = rsp = "RL11";
 
2626
                cmd.append(";");
 
2627
                waitN(7, 20, "GET noise reduction val", ASC);
 
2628
                size_t p = replystr.rfind(rsp);
 
2629
                if (p == string::npos) return val;
 
2630
                val = fm_decimal(&replystr[p+4], 2);
 
2631
        } else {
 
2632
                if (!nr_on) return val;
 
2633
                cmd = rsp = "RL10";
 
2634
                cmd.append(";");
 
2635
                waitN(7, 20, "GET noise reduction val", ASC);
 
2636
                size_t p = replystr.rfind(rsp);
 
2637
                if (p == string::npos) return val;
 
2638
                val = fm_decimal(&replystr[p+4], 2);
 
2639
        }
 
2640
        return val;
 
2641
}
 
2642
 
 
2643
void RIG_TS990::set_auto_notch(int v)
 
2644
{
 
2645
        if (useB) {
 
2646
                cmd.assign("NT1").append(v ? "1" : "0" ).append(";");
 
2647
                sendCommand(cmd);
 
2648
                showresp(INFO, ASC, "SET Auto Notch", cmd, replystr);
 
2649
        } else {
 
2650
                cmd.assign("NT0").append(v ? "1" : "0" ).append(";");
 
2651
                sendCommand(cmd);
 
2652
                showresp(INFO, ASC, "SET Auto Notch", cmd, replystr);
 
2653
        }
 
2654
}
 
2655
 
 
2656
int  RIG_TS990::get_auto_notch()
 
2657
{
 
2658
        int val = 0;
 
2659
        if (useB) {
 
2660
                cmd = "NT1;";
 
2661
                waitN(5, 20, "get auto notch", ASC);
 
2662
                size_t p = replystr.rfind("NT");
 
2663
                if (p == string::npos) return val;
 
2664
                if (replystr[p+3] == '1') val = 1;
 
2665
        } else {
 
2666
                cmd = "NT0;";
 
2667
                waitN(5, 20, "get auto notch", ASC);
 
2668
                size_t p = replystr.rfind("NT");
 
2669
                if (p == string::npos) return val;
 
2670
                if (replystr[p+3] == '1') val = 1;
 
2671
        }
 
2672
        return val;
 
2673
}
 
2674
 
 
2675
void RIG_TS990::set_notch(bool on, int val)
 
2676
{
 
2677
        if (useB) {
 
2678
                if (on) {
 
2679
                        cmd.assign("NT12;");
 
2680
                        sendCommand(cmd);
 
2681
                        showresp(INFO, ASC, "Set notch ON", cmd, replystr);
 
2682
                        int bp = (int)(val * 127.0 / 3000);
 
2683
                        if (bp == 0) bp = 1;
 
2684
                        cmd.assign("BP1").append(to_decimal(bp, 3)).append(";");
 
2685
                        sendCommand(cmd);
 
2686
                        showresp(INFO, ASC, "set notch freq", cmd, replystr);
 
2687
                } else {
 
2688
                        cmd.assign("NT10;");
 
2689
                        sendCommand(cmd);
 
2690
                        showresp(INFO, ASC, "Set notch OFF", cmd, replystr);
 
2691
                }
 
2692
        } else {
 
2693
                if (on) {
 
2694
                        cmd.assign("NT02;");
 
2695
                        sendCommand(cmd);
 
2696
                        showresp(INFO, ASC, "Set notch ON", cmd, replystr);
 
2697
                        int bp = (int)(val * 127.0 / 3000);
 
2698
                        if (bp == 0) bp = 1;
 
2699
                        cmd.assign("BP0").append(to_decimal(bp, 3)).append(";");
 
2700
                        sendCommand(cmd);
 
2701
                        showresp(INFO, ASC, "set notch freq", cmd, replystr);
 
2702
                } else {
 
2703
                        cmd.assign("NT00;");
 
2704
                        sendCommand(cmd);
 
2705
                        showresp(INFO, ASC, "Set notch OFF", cmd, replystr);
 
2706
                }
 
2707
        }
 
2708
}
 
2709
 
 
2710
bool  RIG_TS990::get_notch(int &val)
 
2711
{
 
2712
        if (useB) {
 
2713
                val = 1500;
 
2714
                cmd = "NT1;";
 
2715
                waitN(5, 20, "get notch state", ASC);
 
2716
                size_t p = replystr.rfind("NT");
 
2717
                if (p == string::npos)
 
2718
                        return 0;
 
2719
                if (replystr[p+3] == '2') {
 
2720
                        cmd.assign("BP1;");
 
2721
                        waitN(7, 20, "get notch freq", ASC);
 
2722
                        size_t p = replystr.rfind("BP1");
 
2723
                        if (p != string::npos)
 
2724
                                val = (int)(atoi(&replystr[p+3]) * 3000 / 127.0);
 
2725
                        return 1;
 
2726
                }
 
2727
                return 0;
 
2728
        } else {
 
2729
                val = 1500;
 
2730
                cmd = "NT0;";
 
2731
                waitN(5, 20, "get notch state", ASC);
 
2732
                size_t p = replystr.rfind("NT");
 
2733
                if (p == string::npos)
 
2734
                        return 0;
 
2735
                if (replystr[p+3] == '2') {
 
2736
                        cmd.assign("BP0;");
 
2737
                        waitN(7, 20, "get notch freq", ASC);
 
2738
                        size_t p = replystr.rfind("BP0");
 
2739
                        if (p != string::npos)
 
2740
                                val = (int)(atoi(&replystr[p+3]) * 3000.0 / 127.0);
 
2741
                        return 1;
 
2742
                }
 
2743
                return 0;
 
2744
        }
 
2745
        return 0;
 
2746
}
 
2747
 
 
2748
void RIG_TS990::get_notch_min_max_step(int &min, int &max, int &step)
 
2749
{
 
2750
        min = 20;
 
2751
        max = 3000;
 
2752
        step = 10;
 
2753
}
 
2754
 
 
2755
 
 
2756
//==============================================================================
 
2757
 
 
2758
void RIG_TS990::set_if_shift(int val)  //Now doing Monitor
 
2759
{
 
2760
        progStatus.shift_val = val;
 
2761
        cmd = "ML";
 
2762
        cmd.append(to_decimal(val,3)).append(";");
 
2763
        sendCommand(cmd,0);
 
2764
        showresp(INFO, ASC, "set Mon Level", cmd, replystr);
 
2765
}
 
2766
 
 
2767
bool RIG_TS990::get_if_shift(int &val)
 
2768
{
 
2769
        cmd = "ML;";
 
2770
        waitN(6, 20, "get Mon Level", ASC);
 
2771
        size_t p = replystr.rfind("ML");
 
2772
        if (p != string::npos) {
 
2773
                val = fm_decimal(&replystr[p+2], 3);
 
2774
                return true;
 
2775
        }
 
2776
        val = progStatus.shift_val;
 
2777
        return false;
 
2778
}
 
2779
 
 
2780
 
 
2781
void RIG_TS990::get_if_min_max_step(int &min, int &max, int &step)
 
2782
{
 
2783
        if_shift_min = min = 0;
 
2784
        if_shift_max = max = 255;
 
2785
        if_shift_step = step = 1;
 
2786
        if_shift_mid = 10;
 
2787
}
 
2788