« back to all changes in this revision
Viewing changes to src/rigs/TS590S.cxx
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Package Import Robot
- Author(s): Kamal Mostafa
- Date: 2014-06-07 11:28:52 UTC
- Revision ID: package-import@ubuntu.com-20140607112852-v4d5tb1m3h3vi0dl
Tags: upstream-1.3.15
Import upstream version 1.3.15
- files added:
- build-aux
- data
- data/mac
- data/win32
- m4
- scripts
- src
- src/UI
- src/UI/fluid-designs
- src/images
- src/include
- src/rigs
- src/xmlrpcpp
added
removed
src/rigs/TS590S.cxx
1
/*
2
* Kenwood TS590S driver
3
*
4
* a part of flrig
5
*
6
* Copyright 2009, Dave Freese, W1HKJ
7
*
8
*/
9
10
#include "config.h"
11
12
#include "TS590S.h"
13
#include "support.h"
14
15
static const char TS590Sname_[] = "TS-590S";
16
17
static const char *TS590Smodes_[] = {
18
"LSB", "USB", "CW", "FM", "AM", "FSK", "CW-R", "FSK-R",
19
"LSB-D", "USB-D", "FM-D", NULL};
20
21
static const char TS590S_mode_chr[] = {
22
'1', '2', '3', '4', '5', '6', '7', '9',
23
'1', '2', '4' };
24
static const char TS590S_mode_type[] = {
25
'L', 'U', 'U', 'U', 'U', 'L', 'L', 'U',
26
'L', 'U', 'U' };
27
28
//----------------------------------------------------------------------
29
static const char *TS590S_empty[] = { "N/A", NULL };
30
31
//----------------------------------------------------------------------
32
static int DEF_lo_hi = 0x8A03;
33
static const char *TS590S_SSB_lo[] = {
34
"0", "50", "100", "200", "300",
35
"400", "500", "600", "700", "800",
36
"900", "1000", NULL };
37
38
static const char *TS590S_CAT_ssb_lo[] = {
39
"SL00;", "SL01;", "SL02;", "SL03;", "SL04;",
40
"SL05;", "SL06;", "SL07;", "SL08;", "SL09;",
41
"SL10;", "SL11;", NULL };
42
static const char *TS590S_SSB_lo_tooltip = "lo cutoff";
43
static const char *TS590S_SSB_btn_lo_label = "L";
44
45
static const char *TS590S_SSB_hi[] = {
46
"1000", "1200", "1400", "1600", "1800",
47
"2000", "2200", "2400", "2600", "2800",
48
"3000", "3400", "4000", "5000", NULL };
49
50
static const char *TS590S_CAT_ssb_hi[] = {
51
"SH00;", "SH01;", "SH02;", "SH03;", "SH04;",
52
"SH05;", "SH06;", "SH07;", "SH08;", "SH09;",
53
"SH10;", "SH11;", "SH12;", "SH13;", NULL };
54
static const char *TS590S_SSB_hi_tooltip = "hi cutoff";
55
static const char *TS590S_SSB_btn_hi_label = "H";
56
57
//----------------------------------------------------------------------
58
static int DEF_width_shift = 0x8D05;
59
static const char *TS590S_DATA_width[] = {
60
"50", "80", "100", "150", "200",
61
"250", "300", "400", "500", "600",
62
"1000", "1500", "2000", "2500", NULL };
63
64
static const char *TS590S_CAT_data_width[] = {
65
"SL00;", "SL01;", "SL02;", "SL03;", "SL04;",
66
"SL05;", "SL06;", "SL07;", "SL08;", "SL09;",
67
"SL10;", "SL11;", "SL12;", "SL13;", NULL };
68
static const char *TS590S_DATA_W_tooltip = "filter width";
69
static const char *TS590S_DATA_W_btn_label = "W";
70
71
static const char *TS590S_DATA_shift[] = {
72
"1000", "1100", "1200", "1300", "1400",
73
"1500", "1600", "1700", "1800", "1900",
74
"2000", "2100", "2210", NULL };
75
76
static const char *TS590S_CAT_data_shift[] = {
77
"SH00;", "SH01;", "SH02;", "SH03;", "SH04;",
78
"SH05;", "SH06;", "SH07;", "SH08;", "SH09;",
79
"SH10;", "SH11;", "SH12;", NULL };
80
static const char *TS590S_DATA_S_tooltip = "shift frequency";
81
static const char *TS590S_DATA_S_btn_label = "S";
82
83
//----------------------------------------------------------------------
84
static int DEF_am = 0x8201;
85
static const char *TS590S_AM_lo[] = {
86
"10", "100", "200", "500", NULL };
87
88
static const char *TS590S_CAT_am_lo[] = {
89
"SL00;", "SL01;", "SL02;", "SL03;", NULL};
90
static const char *TS590S_AM_lo_tooltip = "lo cutoff";
91
static const char *TS590S_AM_btn_lo_label = "L";
92
93
static const char *TS590S_AM_hi[] = {
94
"2500", "3000", "4000", "5000", NULL };
95
96
static const char *TS590S_CAT_am_hi[] = {
97
"SH00;", "SH01;", "SH02;", "SH03;", NULL};
98
static const char *TS590S_AM_hi_tooltip = "hi cutoff";
99
static const char *TS590S_AM_btn_hi_label = "H";
100
101
//----------------------------------------------------------------------
102
static int DEF_cw = 7;
103
static const char *TS590S_CWwidths[] = {
104
"50", "80", "100", "150", "200",
105
"250", "300", "400", "500", "600",
106
"1000", "1500", "2000", "2500", NULL};
107
108
static const char *TS590S_CWbw[] = {
109
"FW0050;", "FW0080;", "FW0100;", "FW0150;", "FW0200;",
110
"FW0250;", "FW0300;", "FW0400;", "FW0500;", "FW0600;",
111
"FW1000;", "FW1500;", "FW2000;", "FW2500;", NULL};
112
113
//----------------------------------------------------------------------
114
static int DEF_fsk = 1;
115
static const char *TS590S_FSKwidths[] = {
116
"250", "500", "1000", "1500", NULL};
117
118
static const char *TS590S_FSKbw[] = {
119
"FW0250;", "FW0500;", "FW1000;", "FW1500;", NULL };
120
121
//----------------------------------------------------------------------
122
123
static GUI rig_widgets[]= {
124
{ (Fl_Widget *)btnVol, 2, 125, 50 },
125
{ (Fl_Widget *)sldrVOLUME, 54, 125, 156 },
126
{ (Fl_Widget *)sldrRFGAIN, 54, 145, 156 },
127
{ (Fl_Widget *)btnIFsh, 214, 105, 50 },
128
{ (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 },
129
{ (Fl_Widget *)btnNotch, 214, 125, 50 },
130
{ (Fl_Widget *)sldrNOTCH, 266, 125, 156 },
131
{ (Fl_Widget *)sldrMICGAIN, 266, 145, 156 },
132
{ (Fl_Widget *)sldrPOWER, 266, 165, 156 },
133
{ (Fl_Widget *)btnNR, 2, 165, 50 },
134
{ (Fl_Widget *)sldrNR, 54, 165, 156 },
135
{ (Fl_Widget *)NULL, 0, 0, 0 }
136
};
137
138
static string menu003;
139
140
void RIG_TS590S::initialize()
141
{
142
rig_widgets[0].W = btnVol;
143
rig_widgets[1].W = sldrVOLUME;
144
rig_widgets[2].W = sldrRFGAIN;
145
rig_widgets[3].W = btnIFsh;
146
rig_widgets[4].W = sldrIFSHIFT;
147
rig_widgets[5].W = btnNotch;
148
rig_widgets[6].W = sldrNOTCH;
149
rig_widgets[7].W = sldrMICGAIN;
150
rig_widgets[8].W = sldrPOWER;
151
rig_widgets[9].W = btnNR;
152
rig_widgets[10].W = sldrNR;
153
154
cmd = "EX0030000;";
155
if (waitN(11, 100, "read ex 003", ASC) == 11)
156
menu003 = replystr;
157
cmd = "EX003000000;";
158
sendCommand(cmd);
159
160
RIG_DEBUG = true;
161
cmd = "AC000;"; sendCommand(cmd);
162
selectA();
163
get_preamp();
164
get_attenuator();
165
}
166
167
void RIG_TS590S::shutdown()
168
{
169
// restore state of xcvr beeps
170
cmd = menu003;
171
sendCommand(cmd);
172
}
173
174
175
RIG_TS590S::RIG_TS590S() {
176
177
name_ = TS590Sname_;
178
modes_ = TS590Smodes_;
179
bandwidths_ = TS590S_SSB_hi;
180
181
dsp_lo = TS590S_SSB_lo;
182
lo_tooltip = TS590S_SSB_lo_tooltip;
183
lo_label = TS590S_SSB_btn_lo_label;
184
185
dsp_hi = TS590S_SSB_hi;
186
hi_tooltip = TS590S_SSB_hi_tooltip;
187
hi_label = TS590S_SSB_btn_hi_label;
188
189
widgets = rig_widgets;
190
191
comm_baudrate = BR115200;
192
stopbits = 1;
193
comm_retries = 2;
194
comm_wait = 5;
195
comm_timeout = 50;
196
comm_rtscts = true;
197
comm_rtsplus = false;
198
comm_dtrplus = false;
199
comm_catptt = true;
200
comm_rtsptt = false;
201
comm_dtrptt = false;
202
203
B.imode = A.imode = USB;
204
B.iBW = A.iBW = DEF_lo_hi;
205
B.freq = A.freq = 14070000;
206
can_change_alt_vfo = true;
207
208
nb_level = 2;
209
210
has_micgain_control =
211
has_ifshift_control = false;
212
213
has_auto_notch =
214
has_notch_control =
215
has_sql_control =
216
has_swr_control =
217
has_noise_reduction =
218
has_noise_reduction_control =
219
has_alc_control =
220
has_dsp_controls =
221
has_smeter =
222
has_power_out =
223
has_split =
224
has_split_AB =
225
has_noise_control =
226
has_micgain_control =
227
has_rf_control =
228
has_volume_control =
229
has_power_control =
230
has_tune_control =
231
has_attenuator_control =
232
has_preamp_control =
233
has_mode_control =
234
has_bandwidth_control =
235
has_ifshift_control =
236
has_ptt_control = true;
237
238
rxtxa = true;
239
240
precision = 1;
241
ndigits = 8;
242
243
att_level = 0;
244
preamp_level = 0;
245
noise_reduction_level = 0;
246
}
247
248
const char * RIG_TS590S::get_bwname_(int n, int md)
249
{
250
static char bwname[20];
251
if (n > 256) {
252
int hi = (n >> 8) & 0x7F;
253
int lo = n & 0xFF;
254
snprintf(bwname, sizeof(bwname), "%s/%s",
255
(md == LSB || md == USB || md == FM) ? TS590S_SSB_lo[lo] :
256
(md == AM) ? TS590S_AM_lo[lo] :
257
TS590S_DATA_width[lo],
258
(md == LSB || md == USB || md == FM) ? TS590S_SSB_hi[hi] :
259
(md == AM) ? TS590S_AM_hi[hi] :
260
TS590S_DATA_shift[hi] );
261
} else {
262
snprintf(bwname, sizeof(bwname), "%s",
263
(md == CW || md == CWR) ? TS590S_CWwidths[n] : TS590S_FSKwidths[n]);
264
}
265
return bwname;
266
}
267
268
void RIG_TS590S::selectA()
269
{
270
cmd = "FR0;";
271
sendCommand(cmd, 0);
272
showresp(WARN, ASC, "Rx A", cmd, replystr);
273
cmd = "FT0;";
274
sendCommand(cmd, 0);
275
showresp(WARN, ASC, "Tx A", cmd, replystr);
276
rxtxa = true;
277
}
278
279
void RIG_TS590S::selectB()
280
{
281
cmd = "FR1;";
282
sendCommand(cmd, 0);
283
showresp(WARN, ASC, "Rx B", cmd, replystr);
284
cmd = "FT1;";
285
sendCommand(cmd, 0);
286
showresp(WARN, ASC, "Tx B", cmd, replystr);
287
rxtxa = false;
288
}
289
290
void RIG_TS590S::set_split(bool val)
291
{
292
split = val;
293
if (useB) {
294
if (val) {
295
cmd = "FR1;FT0;";
296
sendCommand(cmd);
297
showresp(WARN, ASC, "Rx on B, Tx on A", cmd, replystr);
298
} else {
299
cmd = "FR1;FT1;";
300
sendCommand(cmd);
301
showresp(WARN, ASC, "Rx on B, Tx on B", cmd, replystr);
302
}
303
} else {
304
if (val) {
305
cmd = "FR0;FT1;";
306
sendCommand(cmd);
307
showresp(WARN, ASC, "Rx on A, Tx on B", cmd, replystr);
308
} else {
309
cmd = "FR0;FT0;";
310
sendCommand(cmd);
311
showresp(WARN, ASC, "Rx on A, Tx on A", cmd, replystr);
312
}
313
}
314
Fl::awake(highlight_vfo, (void *)0);
315
}
316
317
int RIG_TS590S::get_split()
318
{
319
size_t p;
320
int split = 0;
321
char rx, tx;
322
// tx vfo
323
cmd = rsp = "FT";
324
cmd.append(";");
325
waitN(4, 100, "get split tx vfo", ASC);
326
p = replystr.rfind(rsp);
327
if (p == string::npos) return split;
328
tx = replystr[p+2];
329
330
// rx vfo
331
cmd = rsp = "FR";
332
cmd.append(";");
333
waitN(4, 100, "get split rx vfo", ASC);
334
335
p = replystr.rfind(rsp);
336
if (p == string::npos) return split;
337
rx = replystr[p+2];
338
// split test
339
split = (tx == '1' ? 2 : 0) + (rx == '1' ? 1 : 0);
340
341
return split;
342
}
343
344
long RIG_TS590S::get_vfoA ()
345
{
346
cmd = "FA;";
347
int ret = waitN(14, 100, "get vfoA", ASC);
348
349
if (ret < 14) return A.freq;
350
size_t p = replystr.rfind("FA");
351
if (p == string::npos) return A.freq;
352
353
long f = 0L;
354
long mul = 1L;
355
for (size_t n = 12; n > 1; n--) {
356
f += (replystr[p + n] - '0') * mul;
357
mul *= 10;
358
}
359
A.freq = f;
360
return A.freq;
361
}
362
363
void RIG_TS590S::set_vfoA (long freq)
364
{
365
A.freq = freq;
366
cmd = "FA00000000000;";
367
for (int i = 12; i > 1; i--) {
368
cmd[i] += freq % 10;
369
freq /= 10;
370
}
371
sendCommand(cmd, 0);
372
showresp(WARN, ASC, "set vfo A", cmd, replystr);
373
}
374
375
long RIG_TS590S::get_vfoB ()
376
{
377
cmd = "FB;";
378
int ret = waitN(14, 100, "get vfoB", ASC);
379
380
if (ret < 14) return B.freq;
381
size_t p = replystr.rfind("FB");
382
if (p == string::npos) return B.freq;
383
384
long f = 0L;
385
long mul = 1L;
386
for (size_t n = 12; n > 1; n--) {
387
f += (replystr[p + n] - '0') * mul;
388
mul *= 10;
389
}
390
B.freq = f;
391
392
return B.freq;
393
}
394
395
void RIG_TS590S::set_vfoB (long freq)
396
{
397
B.freq = freq;
398
cmd = "FB00000000000;";
399
for (int i = 12; i > 1; i--) {
400
cmd[i] += freq % 10;
401
freq /= 10;
402
}
403
sendCommand(cmd, 0);
404
showresp(WARN, ASC, "set vfo B", cmd, replystr);
405
}
406
407
int RIG_TS590S::get_smeter()
408
{
409
int mtr = 0;
410
cmd = "SM0;";
411
int ret = waitN(8, 100, "get", ASC);
412
if (ret < 8) return 0;
413
size_t p = replystr.find("SM0");
414
if (p == string::npos) return 0;
415
416
replystr[p + 7] = 0;
417
mtr = atoi(&replystr[p + 3]);
418
mtr *= 50;
419
mtr /= 15;
420
if (mtr > 100) mtr = 100;
421
return mtr;
422
}
423
424
int RIG_TS590S::get_power_out()
425
{
426
int mtr = 0;
427
cmd = "SM0;";
428
int ret = waitN(8, 100, "get power", ASC);
429
430
if (ret < 8) return mtr;
431
size_t p = replystr.rfind("SM0");
432
if (p == string::npos) return mtr;
433
434
mtr = atoi(&replystr[p + 3]);
435
mtr *= 50;
436
mtr /= 18;
437
if (mtr > 100) mtr = 100;
438
439
return mtr;
440
}
441
442
static bool read_alc = false;
443
static int alc_val = 0;
444
445
int RIG_TS590S::get_swr(void)
446
{
447
int mtr = 0;
448
449
read_alc = false;
450
451
cmd = "RM;";
452
int ret = waitN(8, 100, "get swr/alc", ASC);
453
if (ret < 24) return 0;
454
455
size_t p = replystr.find("RM3");
456
if (p != string::npos) {
457
replystr[p + 7] = 0;
458
alc_val = atoi(&replystr[p + 3]);
459
alc_val *= 100;
460
alc_val /= 15;
461
if (alc_val > 100) alc_val = 100;
462
read_alc = true;
463
}
464
465
p = replystr.find("RM1");
466
if (p == string::npos) return 0;
467
468
replystr[p + 7] = 0;
469
mtr = atoi(&replystr[p + 3]);
470
mtr *= 50;
471
mtr /= 15;
472
if (mtr > 100) mtr = 100;
473
474
return mtr;
475
}
476
477
int RIG_TS590S::get_alc(void)
478
{
479
if (read_alc) {
480
read_alc = false;
481
return alc_val;
482
}
483
cmd = "RM;";
484
int ret = waitN(8, 100, "get alc", ASC);
485
if (ret < 24) return 0;
486
487
size_t p = replystr.find("RM3");
488
if (p == string::npos) return 0;
489
490
replystr[p + 7] = 0;
491
alc_val = atoi(&replystr[p + 3]);
492
alc_val *= 100;
493
alc_val /= 15;
494
if (alc_val > 100) alc_val = 100;
495
return alc_val;
496
}
497
498
// Transceiver power level
499
void RIG_TS590S::set_power_control(double val)
500
{
501
int ival = (int)val;
502
cmd = "PC000;";
503
for (int i = 4; i > 1; i--) {
504
cmd[i] += ival % 10;
505
ival /= 10;
506
}
507
sendCommand(cmd, 0);
508
}
509
510
int RIG_TS590S::get_power_control()
511
{
512
cmd = "PC;";
513
int ret = waitN(6, 100, "get pwr ctrl", ASC);
514
515
if (ret < 6) return 0;
516
size_t p = replystr.rfind("PC");
517
if (p == string::npos) return 0;
518
int mtr = 0;
519
if (ret >= 6) {
520
replystr[p + 5] = 0;
521
mtr = atoi(&replystr[p + 2]);
522
}
523
return mtr;
524
}
525
526
// Volume control return 0 ... 100
527
int RIG_TS590S::get_volume_control()
528
{
529
cmd = "AG0;";
530
int ret = waitN(7, 100, "get vol ctrl", ASC);
531
532
if (ret < 7) return 0;
533
size_t p = replystr.rfind("AG");
534
if (p == string::npos) return 0;
535
536
replystr[p + 6] = 0;
537
int val = atoi(&replystr[p + 3]);
538
return (int)(val / 2.55);
539
}
540
541
void RIG_TS590S::set_volume_control(int val)
542
{
543
int ivol = (int)(val * 2.55);
544
cmd = "AG0000;";
545
for (int i = 5; i > 2; i--) {
546
cmd[i] += ivol % 10;
547
ivol /= 10;
548
}
549
sendCommand(cmd, 0);
550
}
551
552
// Tranceiver PTT on/off
553
void RIG_TS590S::set_PTT_control(int val)
554
{
555
if (val) {
556
if (data_mode)
557
cmd = "TX1;";
558
else
559
cmd = "TX0;";
560
} else
561
cmd = "RX;";
562
sendCommand(cmd, 0);
563
}
564
565
void RIG_TS590S::tune_rig()
566
{
567
cmd = "AC111;";
568
sendCommand(cmd, 0);
569
}
570
571
void RIG_TS590S::set_attenuator(int val)
572
{
573
att_level = val;
574
if (val) cmd = "RA01;";
575
else cmd = "RA00;";
576
sendCommand(cmd, 0);
577
}
578
579
int RIG_TS590S::get_attenuator()
580
{
581
cmd = "RA;";
582
int ret = waitN(7, 100, "get att", ASC);
583
584
if (ret < 7) return 0;
585
size_t p = replystr.rfind("RA");
586
if (p == string::npos) return 0;
587
588
if (replystr[p + 2] == '0' &&
589
replystr[p + 3] == '0')
590
att_level = 0;
591
else
592
att_level = 1;
593
594
return att_level;
595
}
596
597
void RIG_TS590S::set_preamp(int val)
598
{
599
preamp_level = val;
600
if (val) cmd = "PA1;";
601
else cmd = "PA0;";
602
sendCommand(cmd, 0);
603
}
604
605
int RIG_TS590S::get_preamp()
606
{
607
cmd = "PA;";
608
int ret = waitN(5, 100, "get preamp", ASC);
609
610
if (ret < 5) return 0;
611
size_t p = replystr.rfind("PA");
612
if (p == string::npos) return 0;
613
614
if (replystr[p + 2] == '1')
615
preamp_level = 1;
616
else
617
preamp_level = 0;
618
return preamp_level;
619
}
620
621
//======================================================================
622
// mode commands
623
//======================================================================
624
625
void RIG_TS590S::set_modeA(int val)
626
{
627
active_mode = A.imode = val;
628
cmd = "MD";
629
cmd += TS590S_mode_chr[val];
630
cmd += ';';
631
sendCommand(cmd, 0);
632
showresp(ERR, ASC, "set mode A", cmd, replystr);
633
if ( val == LSBD || val == USBD || val == FMD) {
634
data_mode = true;
635
cmd = "DA1;";
636
sendCommand(cmd, 0);
637
showresp(WARN, ASC, "set data A", cmd, replystr);
638
} else if (val == LSB || val == USB || val == FM) {
639
data_mode = false;
640
cmd = "DA0;";
641
sendCommand(cmd, 0);
642
showresp(WARN, ASC, "set data A", cmd, replystr);
643
}
644
set_widths(val);
645
}
646
647
int RIG_TS590S::get_modeA()
648
{
649
int md = A.imode;
650
cmd = "MD;";
651
int ret = waitN(4, 100, "get mode A", ASC);
652
653
if (ret < 4) return A.imode;
654
655
size_t p = replystr.rfind("MD");
656
if (p == string::npos) return A.imode;
657
658
switch (replystr[p + 2]) {
659
case '1' : md = LSB; break;
660
case '2' : md = USB; break;
661
case '3' : md = CW; break;
662
case '4' : md = FM; break;
663
case '5' : md = AM; break;
664
case '6' : md = FSK; break;
665
case '7' : md = CWR; break;
666
case '9' : md = FSKR; break;
667
default : md = A.imode;
668
}
669
670
if (md == LSB || md == USB || md == FM) {
671
cmd = "DA;";
672
ret = waitN(4, 100, "get data A", ASC);
673
674
if (ret < 4) return A.imode;
675
p = replystr.rfind("DA");
676
if (p == string::npos) return A.imode;
677
if (replystr[p + 2] == '1') {
678
data_mode = true;
679
if (md == LSB) md = LSBD;
680
else if (md == USB) md = USBD;
681
else if (md == FM) md = FMD;
682
}
683
}
684
if (md != A.imode) {
685
active_mode = A.imode = md;
686
set_widths(md);
687
}
688
return A.imode;
689
}
690
691
void RIG_TS590S::set_modeB(int val)
692
{
693
active_mode = B.imode = val;
694
cmd = "MD";
695
cmd += TS590S_mode_chr[val];
696
cmd += ';';
697
sendCommand(cmd, 0);
698
showresp(WARN, ASC, "set mode B", cmd, replystr);
699
if ( val == LSBD || val == USBD || val == FMD) {
700
data_mode = true;
701
cmd = "DA1;";
702
sendCommand(cmd, 0);
703
showresp(WARN, ASC, "set data B", cmd, replystr);
704
} else if (val == LSB || val == USB || val == FM) {
705
cmd = "DA0;";
706
sendCommand(cmd, 0);
707
showresp(WARN, ASC, "set data B", cmd, replystr);
708
}
709
set_widths(val);
710
}
711
712
int RIG_TS590S::get_modeB()
713
{
714
int md = B.imode;
715
cmd = "MD;";
716
int ret = waitN(4, 100, "get mode B", ASC);
717
718
if (ret < 4) return B.imode;
719
size_t p = replystr.rfind("MD");
720
if (p == string::npos) return B.imode;
721
722
switch (replystr[p + 2]) {
723
case '1' : md = LSB; break;
724
case '2' : md = USB; break;
725
case '3' : md = CW; break;
726
case '4' : md = FM; break;
727
case '5' : md = AM; break;
728
case '6' : md = FSK; break;
729
case '7' : md = CWR; break;
730
case '9' : md = FSKR; break;
731
default : md = B.imode;
732
}
733
734
if (md == LSB || md == USB || md == FM) {
735
cmd = "DA;";
736
ret = waitN(4, 100, "get dat B", ASC);
737
738
if (ret < 4) return B.imode;
739
p = replystr.rfind("DA");
740
if (p == string::npos) return B.imode;
741
if (replystr[p + 2] == '1') {
742
data_mode = true;
743
if (md == LSB) md = LSBD;
744
else if (md == USB) md = USBD;
745
else if (md == FM) md = FMD;
746
}
747
}
748
if (md != B.imode) {
749
active_mode = B.imode = md;
750
set_widths(md);
751
}
752
return B.imode;
753
}
754
755
//======================================================================
756
// Bandpass filter commands
757
//======================================================================
758
759
int RIG_TS590S::set_widths(int val)
760
{
761
int bw = 0;
762
if (val == LSB || val == USB || val == FM || val == FMD) {
763
bandwidths_ = TS590S_SSB_hi;
764
dsp_lo = TS590S_SSB_lo;
765
dsp_hi = TS590S_SSB_hi;
766
lo_tooltip = TS590S_SSB_lo_tooltip;
767
lo_label = TS590S_SSB_btn_lo_label;
768
hi_tooltip = TS590S_SSB_hi_tooltip;
769
hi_label = TS590S_SSB_btn_hi_label;
770
bw = DEF_lo_hi; // 200 lower, 3000 upper
771
} else if (val == CW || val == CWR) {
772
bandwidths_ = TS590S_CWwidths;
773
dsp_lo = TS590S_empty;
774
dsp_hi = TS590S_empty;
775
bw = DEF_cw;
776
} else if (val == FSK || val == FSKR) {
777
bandwidths_ = TS590S_FSKwidths;
778
dsp_lo = TS590S_empty;
779
dsp_hi = TS590S_empty;
780
bw = 1;
781
} else if (val == AM) { // val == 4 ==> AM
782
bandwidths_ = TS590S_AM_hi;
783
dsp_lo = TS590S_AM_lo;
784
dsp_hi = TS590S_AM_hi;
785
lo_tooltip = TS590S_AM_lo_tooltip;
786
lo_label = TS590S_AM_btn_lo_label;
787
hi_tooltip = TS590S_AM_hi_tooltip;
788
hi_label = TS590S_AM_btn_hi_label;
789
bw = DEF_am;
790
} else if (val == LSBD || val == USBD) {
791
bandwidths_ = TS590S_DATA_width;
792
793
dsp_lo = TS590S_DATA_shift;
794
lo_tooltip = TS590S_DATA_S_tooltip;
795
lo_label = TS590S_DATA_S_btn_label;
796
797
dsp_hi = TS590S_DATA_width;
798
hi_tooltip = TS590S_DATA_W_tooltip;
799
hi_label = TS590S_DATA_W_btn_label;
800
bw = DEF_width_shift;
801
}
802
return bw;
803
}
804
805
const char **RIG_TS590S::bwtable(int m)
806
{
807
if (m == LSB || m == USB || m == FM || m == FMD)
808
return TS590S_SSB_hi;
809
else if (m == CW || m == CWR)
810
return TS590S_CWwidths;
811
else if (m == FSK || m == FSKR)
812
return TS590S_FSKwidths;
813
else if (m == AM)
814
return TS590S_AM_hi;
815
else
816
return TS590S_DATA_width;
817
}
818
819
const char **RIG_TS590S::lotable(int m)
820
{
821
if (m == LSB || m == USB || m == FM || m == FMD)
822
return TS590S_SSB_lo;
823
else if (m == AM)
824
return TS590S_AM_lo;
825
else if (m == LSBD || m == USBD)
826
return TS590S_DATA_shift;
827
// CW CWR FSK FSKR
828
return NULL;
829
}
830
831
const char **RIG_TS590S::hitable(int m)
832
{
833
if (m == LSB || m == USB || m == FM || m == FMD)
834
return TS590S_SSB_hi;
835
else if (m == AM)
836
return TS590S_AM_hi;
837
else if (m == LSBD || m == USBD)
838
return TS590S_DATA_width;
839
// CW CWR FSK FSKR
840
return NULL;
841
}
842
843
int RIG_TS590S::adjust_bandwidth(int val)
844
{
845
if (val == LSB || val == USB || val == FM || val == FMD)
846
return DEF_lo_hi;
847
else if (val == LSBD || val == USBD)
848
return DEF_width_shift;
849
else if (val == CW || val == CWR)
850
return DEF_cw;
851
else if (val == FSK || val == FSKR)
852
return DEF_fsk;
853
// else if (val == AM)
854
return DEF_am;
855
}
856
857
int RIG_TS590S::def_bandwidth(int val)
858
{
859
return adjust_bandwidth(val);
860
}
861
862
void RIG_TS590S::set_bwA(int val)
863
{
864
// LSB, USB, FM, FM-D
865
if (A.imode == LSB || A.imode == USB || A.imode == FM || A.imode == FMD) {
866
if (val < 256) return;
867
A.iBW = val;
868
cmd = TS590S_CAT_ssb_lo[A.iBW & 0x7F];
869
sendCommand(cmd,0);
870
showresp(WARN, ASC, "set lower", cmd, replystr);
871
cmd = TS590S_CAT_ssb_hi[(A.iBW >> 8) & 0x7F];
872
sendCommand(cmd,0);
873
showresp(WARN, ASC, "set upper", cmd, replystr);
874
return;
875
}
876
// LSB-D, USB-D
877
if (A.imode == LSBD || A.imode == USBD) {
878
if (val < 256) return;
879
A.iBW = val;
880
cmd = TS590S_CAT_data_shift[A.iBW & 0x7F];
881
sendCommand(cmd,0);
882
showresp(WARN, ASC, "set shift", cmd, replystr);
883
cmd = TS590S_CAT_data_width[(A.iBW >> 8) & 0x7F];
884
sendCommand(cmd,0);
885
showresp(WARN, ASC, "set width", cmd, replystr);
886
return;
887
}
888
// AM
889
if (A.imode == AM) {
890
if (val < 256) return;
891
A.iBW = val;
892
cmd = TS590S_CAT_am_lo[A.iBW & 0x7F];
893
sendCommand(cmd,0);
894
showresp(WARN, ASC, "set lower", cmd, replystr);
895
cmd = TS590S_CAT_am_hi[(A.iBW >> 8) & 0x7F];
896
sendCommand(cmd,0);
897
showresp(WARN, ASC, "set upper", cmd, replystr);
898
return;
899
}
900
if (val > 256) return;
901
// CW
902
if (A.imode == CW || A.imode == CWR) {
903
A.iBW = val;
904
cmd = TS590S_CWbw[A.iBW];
905
sendCommand(cmd,0);
906
showresp(WARN, ASC, "set CW bw", cmd, replystr);
907
return;
908
}
909
// FSK
910
if (A.imode == FSK || A.imode == FSKR) {
911
A.iBW = val;
912
cmd = TS590S_FSKbw[A.iBW];
913
sendCommand(cmd,0);
914
showresp(WARN, ASC, "set FSK bw", cmd, replystr);
915
return;
916
}
917
}
918
919
void RIG_TS590S::set_bwB(int val)
920
{
921
if (B.imode == LSB || B.imode == USB || B.imode == FM || B.imode == FMD) {
922
if (val < 256) return;
923
B.iBW = val;
924
cmd = TS590S_CAT_ssb_lo[B.iBW & 0x7F];
925
sendCommand(cmd,0);
926
showresp(WARN, ASC, "set lower", cmd, replystr);
927
cmd = TS590S_CAT_ssb_hi[(B.iBW >> 8) & 0x7F];
928
sendCommand(cmd,0);
929
showresp(WARN, ASC, "set upper", cmd, replystr);
930
return;
931
}
932
if (B.imode == LSBD || B.imode == USBD) { // SSB data mode
933
if (val < 256) return;
934
B.iBW = val;
935
cmd = TS590S_CAT_data_shift[B.iBW & 0x7F];
936
sendCommand(cmd,0);
937
showresp(WARN, ASC, "set shift", cmd, replystr);
938
cmd = TS590S_CAT_data_width[(B.iBW >> 8) & 0x7F];
939
sendCommand(cmd,0);
940
showresp(WARN, ASC, "set width", cmd, replystr);
941
return;
942
}
943
if (B.imode == AM) {
944
if (val < 256) return;
945
B.iBW = val;
946
cmd = TS590S_AM_lo[B.iBW & 0x7F];
947
sendCommand(cmd,0);
948
showresp(WARN, ASC, "set lower", cmd, replystr);
949
cmd = TS590S_AM_hi[(B.iBW >> 8) & 0x7F];
950
sendCommand(cmd,0);
951
showresp(WARN, ASC, "set upper", cmd, replystr);
952
return;
953
}
954
955
if (val > 256) return;
956
if (B.imode == CW || B.imode == CWR) {
957
B.iBW = val;
958
cmd = TS590S_CWbw[B.iBW];
959
sendCommand(cmd,0);
960
showresp(WARN, ASC, "set CW bw", cmd, replystr);
961
return;
962
}
963
964
if (B.imode == FSK || B.imode == FSKR) {
965
B.iBW = val;
966
cmd = TS590S_FSKbw[B.iBW];
967
sendCommand(cmd,0);
968
showresp(WARN, ASC, "set FSK bw", cmd, replystr);
969
return;
970
}
971
}
972
973
int RIG_TS590S::get_bwA()
974
{
975
int i = 0, lo = 0, hi = 0;
976
size_t p;
977
switch (A.imode) {
978
case CW: case CWR:
979
A.iBW = DEF_cw;
980
cmd = "FW;";
981
waitN(7, 100, "get CW width", ASC);
982
p = replystr.rfind("FW");
983
if (p != string::npos) {
984
for (i = 0; i < 14; i++)
985
if (replystr.find(TS590S_CWbw[i]) == p)
986
break;
987
if (i == 14) i = 13;
988
A.iBW = i;
989
}
990
break;
991
case FSK: case FSKR:
992
A.iBW = DEF_fsk;
993
cmd = "FW;";
994
waitN(7, 100, "get FSK width", ASC);
995
p = replystr.rfind("FW");
996
if (p != string::npos) {
997
for (i = 0; i < 4; i++)
998
if (replystr.find(TS590S_FSKbw[i]) == p)
999
break;
1000
if (i == 4) i = 3;
1001
A.iBW = i;
1002
}
1003
break;
1004
case LSB: case USB: case FM:
1005
A.iBW = DEF_lo_hi;
1006
lo = A.iBW & 0x7F;
1007
hi = (A.iBW >> 8) & 0x7F;
1008
cmd = "SL;";
1009
waitN(5, 100, "get lower", ASC);
1010
p = replystr.rfind("SL");
1011
if (p == string::npos) break;
1012
lo = fm_decimal(&replystr[2], 2);
1013
cmd = "SH;";
1014
waitN(5, 100, "get upper", ASC);
1015
p = replystr.rfind("SH");
1016
if (p == string::npos) break;
1017
hi = fm_decimal(&replystr[2], 2);
1018
A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
1019
break;
1020
case LSBD: case USBD: case FMD:
1021
A.iBW = DEF_width_shift;
1022
lo = A.iBW & 0x7F;
1023
hi = (A.iBW >> 8) & 0x7F;
1024
cmd = "SL;";
1025
waitN(5, 100, "get width", ASC);
1026
p = replystr.rfind("SL");
1027
if (p == string::npos) break;
1028
hi = fm_decimal(&replystr[2], 2);
1029
cmd = "SH;";
1030
waitN(5, 100, "get shift", ASC);
1031
p = replystr.rfind("SH");
1032
if (p == string::npos) break;
1033
lo = fm_decimal(&replystr[2], 2);
1034
A.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
1035
break;
1036
}
1037
return A.iBW;
1038
}
1039
1040
int RIG_TS590S::get_bwB()
1041
{
1042
int i = 0, lo = 0, hi = 0;
1043
size_t p;
1044
switch (B.imode) {
1045
case CW: case CWR:
1046
B.iBW = DEF_cw;
1047
cmd = "FW;";
1048
waitN(7, 100, "get CW width", ASC);
1049
p = replystr.rfind("FW");
1050
if (p != string::npos) {
1051
for (i = 0; i < 14; i++)
1052
if (replystr.find(TS590S_CWbw[i]) == p)
1053
break;
1054
if (i == 14) i = 13;
1055
B.iBW = i;
1056
}
1057
break;
1058
case FSK: case FSKR:
1059
B.iBW = DEF_fsk;
1060
cmd = "FW;";
1061
waitN(7, 100, "get FSK width", ASC);
1062
p = replystr.rfind("FW");
1063
if (p != string::npos) {
1064
for (i = 0; i < 4; i++)
1065
if (replystr.find(TS590S_FSKbw[i]) == p)
1066
break;
1067
if (i == 4) i = 3;
1068
B.iBW = i;
1069
}
1070
break;
1071
case LSB: case USB: case FM:
1072
B.iBW = DEF_lo_hi;
1073
lo = B.iBW & 0xFF;
1074
hi = (B.iBW >> 8) & 0x7F;
1075
cmd = "SL;";
1076
waitN(5, 100, "get lower", ASC);
1077
p = replystr.rfind("SL");
1078
if (p == string::npos) break;
1079
lo = fm_decimal(&replystr[2], 2);
1080
cmd = "SH;";
1081
waitN(5, 100, "get upper", ASC);
1082
p = replystr.rfind("SH");
1083
if (p == string::npos) break;
1084
hi = fm_decimal(&replystr[2], 2);
1085
B.iBW = ((hi << 8) | (lo & 0x7F)) | 0x8000;
1086
break;
1087
case LSBD: case USBD: case FMD:
1088
B.iBW = DEF_width_shift;
1089
lo = B.iBW & 0x7F;
1090
hi = (B.iBW >> 8) & 0x7F;
1091
cmd = "SL;";
1092
waitN(5, 100, "get width", ASC);
1093
p = replystr.rfind("SL");
1094
if (p == string::npos) break;
1095
hi = fm_decimal(&replystr[2], 2);
1096
cmd = "SH;";
1097
waitN(5, 100, "get shift", ASC);
1098
p = replystr.rfind("SH");
1099
if (p == string::npos) break;
1100
lo = fm_decimal(&replystr[2], 2);
1101
B.iBW = ((hi << 8) | (lo & 0xFF)) | 0x8000;
1102
break;
1103
}
1104
return B.iBW;
1105
}
1106
1107
int RIG_TS590S::get_modetype(int n)
1108
{
1109
return TS590S_mode_type[n];
1110
}
1111
1112
// val 0 .. 100
1113
void RIG_TS590S::set_mic_gain(int val)
1114
{
1115
cmd = "MG000;";
1116
for (int i = 3; i > 0; i--) {
1117
cmd[1+i] += val % 10;
1118
val /= 10;
1119
}
1120
sendCommand(cmd, 0);
1121
}
1122
1123
int RIG_TS590S::get_mic_gain()
1124
{
1125
int val = 0;
1126
cmd = "MG;";
1127
int ret = waitN(6, 100, "get mic ctrl", ASC);
1128
1129
if (ret >= 6) {
1130
size_t p = replystr.rfind("MG");
1131
if (p == string::npos) return val;
1132
replystr[p + 5] = 0;
1133
val = atoi(&replystr[p + 2]);
1134
}
1135
return val;
1136
}
1137
1138
void RIG_TS590S::get_mic_min_max_step(int &min, int &max, int &step)
1139
{
1140
min = 0;
1141
max = 100;
1142
step = 1;
1143
}
1144
1145
void RIG_TS590S::set_noise(bool val)
1146
{
1147
if (nb_level == 0) {
1148
nb_level = 1;
1149
nb_label("NB 1", true);
1150
} else if (nb_level == 1) {
1151
nb_level = 2;
1152
nb_label("NB 2", true);
1153
} else if (nb_level == 2) {
1154
nb_level = 0;
1155
nb_label("NB", false);
1156
}
1157
cmd = "NB0;";
1158
cmd[2] += nb_level;
1159
LOG_INFO("%s", cmd.c_str());
1160
sendCommand(cmd, 0);
1161
}
1162
1163
//======================================================================
1164
// IF shift command only available if the transceiver is in the CW mode
1165
// step size is 50 Hz
1166
//======================================================================
1167
void RIG_TS590S::set_if_shift(int val)
1168
{
1169
if (active_mode == CW || active_mode == CWR) { // cw modes
1170
progStatus.shift_val = val;
1171
cmd = "IS ";
1172
cmd.append(to_decimal(abs(val),4)).append(";");
1173
sendCommand(cmd,0);
1174
showresp(WARN, ASC, "set IF shift", cmd, replystr);
1175
}
1176
}
1177
1178
bool RIG_TS590S::get_if_shift(int &val)
1179
{
1180
if (active_mode == CW || active_mode == CWR) { // cw modes
1181
cmd = "IS;";
1182
waitN(8, 100, "get IF shift", ASC);
1183
size_t p = replystr.rfind("IS");
1184
if (p != string::npos) {
1185
val = fm_decimal(&replystr[p+3], 4);
1186
} else
1187
val = progStatus.shift_val;
1188
return true;
1189
}
1190
val = progStatus.shift_val;
1191
return false;
1192
}
1193
1194
void RIG_TS590S::get_if_min_max_step(int &min, int &max, int &step)
1195
{
1196
if_shift_min = min = 300;
1197
if_shift_max = max = 1000;
1198
if_shift_step = step = 50;
1199
if_shift_mid = 800;
1200
}
1201
1202
void RIG_TS590S::set_squelch(int val)
1203
{
1204
cmd = "SQ0";
1205
cmd.append(to_decimal(abs(val),3)).append(";");
1206
sendCommand(cmd,0);
1207
showresp(WARN, ASC, "set squelch", cmd, replystr);
1208
}
1209
1210
int RIG_TS590S::get_squelch()
1211
{
1212
int val = 0;
1213
cmd = "SQ0;";
1214
int ret = waitN(7, 100, "get squelch", ASC);
1215
1216
if (ret >= 7) {
1217
size_t p = replystr.rfind("SQ0");
1218
if (p == string::npos) return val;
1219
replystr[p + 6] = 0;
1220
val = atoi(&replystr[p + 3]);
1221
}
1222
return val;
1223
}
1224
1225
void RIG_TS590S::get_squelch_min_max_step(int &min, int &max, int &step)
1226
{
1227
min = 0; max = 255; step = 1;
1228
}
1229
1230
void RIG_TS590S::set_rf_gain(int val)
1231
{
1232
cmd = "RG000;";
1233
int rfval = 255 - val;
1234
for (int i = 4; i > 1; i--) {
1235
cmd[i] = rfval % 10 + '0';
1236
rfval /= 10;
1237
}
1238
sendCommand(cmd);
1239
showresp(WARN, ASC, "SET rfgain", cmd, replystr);
1240
}
1241
1242
int RIG_TS590S::get_rf_gain()
1243
{
1244
int rfval = 0;
1245
cmd = rsp = "RG";
1246
cmd += ';';
1247
waitN(6, 100, "get rfgain", ASC);
1248
1249
size_t p = replystr.rfind(rsp);
1250
if (p == string::npos) return progStatus.rfgain;
1251
for (int i = 2; i < 5; i++) {
1252
rfval *= 10;
1253
rfval += replystr[p+i] - '0';
1254
}
1255
return 255 - rfval;
1256
}
1257
1258
void RIG_TS590S::get_rf_min_max_step(int &min, int &max, int &step)
1259
{
1260
min = 0;
1261
max = 255;
1262
step = 1;
1263
}
1264
1265
void RIG_TS590S::set_noise_reduction(int val)
1266
{
1267
if (val == -1) {
1268
if (noise_reduction_level == 1) {
1269
nr_label("NR1", true);
1270
} else if (noise_reduction_level == 2) {
1271
nr_label("NR2", true);
1272
}
1273
return;
1274
}
1275
if (noise_reduction_level == 0) {
1276
noise_reduction_level = 1;
1277
nr_label("NR1", true);
1278
} else if (noise_reduction_level == 1) {
1279
noise_reduction_level = 2;
1280
nr_label("NR2", true);
1281
} else if (noise_reduction_level == 2) {
1282
noise_reduction_level = 0;
1283
nr_label("NR", false);
1284
}
1285
cmd.assign("NR");
1286
cmd += '0' + noise_reduction_level;
1287
sendCommand (cmd);
1288
showresp(WARN, ASC, "SET noise reduction", cmd, replystr);
1289
}
1290
1291
int RIG_TS590S::get_noise_reduction()
1292
{
1293
cmd = rsp = "NR";
1294
cmd.append(";");
1295
waitN(4, 100, "GET noise reduction", ASC);
1296
size_t p = replystr.rfind(rsp);
1297
if (p == string::npos) return noise_reduction_level;
1298
noise_reduction_level = replystr[p+2] - '0';
1299
1300
if (noise_reduction_level == 1) {
1301
nr_label("NR1", true);
1302
} else if (noise_reduction_level == 2) {
1303
nr_label("NR2", true);
1304
} else {
1305
nr_label("NR", false);
1306
}
1307
1308
return noise_reduction_level;
1309
}
1310
1311
void RIG_TS590S::set_noise_reduction_val(int val)
1312
{
1313
cmd.assign("RL").append(to_decimal(val, 2)).append(";");
1314
sendCommand(cmd);
1315
showresp(WARN, ASC, "SET_noise_reduction_val", cmd, replystr);
1316
}
1317
1318
int RIG_TS590S::get_noise_reduction_val()
1319
{
1320
if (noise_reduction_level == 0) return 0;
1321
int val = 1;
1322
cmd = rsp = "RL";
1323
cmd.append(";");
1324
waitN(5, 100, "GET noise reduction val", ASC);
1325
size_t p = replystr.rfind(rsp);
1326
if (p == string::npos) return progStatus.noise_reduction_val;
1327
val = atoi(&replystr[p+2]);
1328
return val;
1329
}
1330
1331
void RIG_TS590S::set_auto_notch(int v)
1332
{
1333
cmd.assign("NT").append(v ? "1" : "0" ).append("0;");
1334
sendCommand(cmd);
1335
showresp(WARN, ASC, "SET Auto Notch", cmd, replystr);
1336
}
1337
1338
int RIG_TS590S::get_auto_notch()
1339
{
1340
cmd = "NT;";
1341
waitN(5, 100, "get auto notch", ASC);
1342
size_t p = replystr.rfind("NT");
1343
if (p == string::npos) return 0;
1344
if (replystr[p+2] == '1') return 1;
1345
return 0;
1346
}
1347
1348
void RIG_TS590S::set_notch(bool on, int val)
1349
{
1350
if (on) {
1351
cmd.assign("NT20;");
1352
sendCommand(cmd);
1353
showresp(WARN, ASC, "Set notch ON", cmd, replystr);
1354
int bp = (int)((val - 300.0) * 128.0 / 2700.0);
1355
cmd.assign("BP").append(to_decimal(bp, 3)).append(";");
1356
sendCommand(cmd);
1357
showresp(WARN, ASC, "set notch freq", cmd, replystr);
1358
} else {
1359
cmd.assign("NT00;");
1360
sendCommand(cmd);
1361
showresp(WARN, ASC, "Set notch OFF", cmd, replystr);
1362
}
1363
}
1364
1365
bool RIG_TS590S::get_notch(int &val)
1366
{
1367
val = 300;
1368
cmd = "NT;";
1369
waitN(5, 100, "get notch state", ASC);
1370
size_t p = replystr.rfind("NT");
1371
if (p == string::npos)
1372
return 0;
1373
if (replystr[p+2] == '2') {
1374
cmd.assign("BP;");
1375
waitN(6, 100, "get notch freq", ASC);
1376
size_t p = replystr.rfind("BP");
1377
if (p != string::npos)
1378
val = (int)((atoi(&replystr[p+2]) * 2700.0 / 128.0) + 300.0);
1379
return 1;
1380
}
1381
return 0;
1382
}
1383
1384
void RIG_TS590S::get_notch_min_max_step(int &min, int &max, int &step)
1385
{
1386
min = 300;
1387
max = 3000;
1388
step = 20;
1389
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1